namespace OpenTK.OpenGL
{
    using System;
    using System.Runtime.InteropServices;

    public static partial class GL
    {

        [System.CLSCompliant(false)]
        public static 
        void NewList(UInt32 list, OpenTK.OpenGL.Enums.ListMode mode)
        {
            Delegates.glNewList((UInt32)list, (OpenTK.OpenGL.Enums.ListMode)mode);
        }

        public static 
        void NewList(Int32 list, OpenTK.OpenGL.Enums.ListMode mode)
        {
            Delegates.glNewList((UInt32)list, (OpenTK.OpenGL.Enums.ListMode)mode);
        }

        public static 
        void EndList()
        {
            Delegates.glEndList();
        }

        [System.CLSCompliant(false)]
        public static 
        void CallList(UInt32 list)
        {
            Delegates.glCallList((UInt32)list);
        }

        public static 
        void CallList(Int32 list)
        {
            Delegates.glCallList((UInt32)list);
        }

        public static 
        void CallLists(Int32 n, OpenTK.OpenGL.Enums.ListNameType type, IntPtr lists)
        {
            Delegates.glCallLists((Int32)n, (OpenTK.OpenGL.Enums.ListNameType)type, (IntPtr)lists);
        }

        public static 
        void CallLists(Int32 n, OpenTK.OpenGL.Enums.ListNameType type, [In, Out] object lists)
        {
            System.Runtime.InteropServices.GCHandle lists_ptr = System.Runtime.InteropServices.GCHandle.Alloc(lists, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glCallLists((Int32)n, (OpenTK.OpenGL.Enums.ListNameType)type, (IntPtr)lists_ptr.AddrOfPinnedObject());
            }
            finally
            {
                lists_ptr.Free();
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteLists(UInt32 list, Int32 range)
        {
            Delegates.glDeleteLists((UInt32)list, (Int32)range);
        }

        public static 
        void DeleteLists(Int32 list, Int32 range)
        {
            Delegates.glDeleteLists((UInt32)list, (Int32)range);
        }

        public static 
        Int32 GenLists(Int32 range)
        {
            return Delegates.glGenLists((Int32)range);
        }

        [System.CLSCompliant(false)]
        public static 
        void ListBase(UInt32 @base)
        {
            Delegates.glListBase((UInt32)@base);
        }

        public static 
        void ListBase(Int32 @base)
        {
            Delegates.glListBase((UInt32)@base);
        }

        public static 
        void Begin(OpenTK.OpenGL.Enums.BeginMode mode)
        {
            Delegates.glBegin((OpenTK.OpenGL.Enums.BeginMode)mode);
        }

        public static 
        void Bitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, Byte[] bitmap)
        {
            unsafe
            {
                fixed (Byte* bitmap_ptr = bitmap)
                {
                    Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap_ptr);
                }
            }
        }

        public static 
        void Bitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, ref Byte bitmap)
        {
            unsafe
            {
                fixed (Byte* bitmap_ptr = &bitmap)
                {
                    Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Bitmap(Int32 width, Int32 height, Single xorig, Single yorig, Single xmove, Single ymove, Byte* bitmap)
        {
            Delegates.glBitmap((Int32)width, (Int32)height, (Single)xorig, (Single)yorig, (Single)xmove, (Single)ymove, (Byte*)bitmap);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(SByte red, SByte green, SByte blue)
        {
            Delegates.glColor3b((SByte)red, (SByte)green, (SByte)blue);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glColor3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glColor3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(SByte* v)
        {
            Delegates.glColor3bv((SByte*)v);
        }

        public static 
        void Color3(Double red, Double green, Double blue)
        {
            Delegates.glColor3d((Double)red, (Double)green, (Double)blue);
        }

        public static 
        void Color3(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glColor3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void Color3(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glColor3dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(Double* v)
        {
            Delegates.glColor3dv((Double*)v);
        }

        public static 
        void Color3(Single red, Single green, Single blue)
        {
            Delegates.glColor3f((Single)red, (Single)green, (Single)blue);
        }

        public static 
        void Color3(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void Color3(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor3fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(Single* v)
        {
            Delegates.glColor3fv((Single*)v);
        }

        public static 
        void Color3(Byte red, Byte green, Byte blue)
        {
            Delegates.glColor3ub((Byte)red, (Byte)green, (Byte)blue);
        }

        public static 
        void Color3(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor3ubv((Byte*)v_ptr);
                }
            }
        }

        public static 
        void Color3(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor3ubv((Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(Byte* v)
        {
            Delegates.glColor3ubv((Byte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(UInt32 red, UInt32 green, UInt32 blue)
        {
            Delegates.glColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void Color3(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void Color3(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void Color3(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(UInt32* v)
        {
            Delegates.glColor3uiv((UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(Int32* v)
        {
            Delegates.glColor3uiv((UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(UInt16 red, UInt16 green, UInt16 blue)
        {
            Delegates.glColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void Color3(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void Color3(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void Color3(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void Color3(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor3usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(UInt16* v)
        {
            Delegates.glColor3usv((UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color3(Int16* v)
        {
            Delegates.glColor3usv((UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(SByte red, SByte green, SByte blue, SByte alpha)
        {
            Delegates.glColor4b((SByte)red, (SByte)green, (SByte)blue, (SByte)alpha);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glColor4bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glColor4bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(SByte* v)
        {
            Delegates.glColor4bv((SByte*)v);
        }

        public static 
        void Color4(Double red, Double green, Double blue, Double alpha)
        {
            Delegates.glColor4d((Double)red, (Double)green, (Double)blue, (Double)alpha);
        }

        public static 
        void Color4(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glColor4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void Color4(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glColor4dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(Double* v)
        {
            Delegates.glColor4dv((Double*)v);
        }

        public static 
        void Color4(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glColor4f((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void Color4(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glColor4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void Color4(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glColor4fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(Single* v)
        {
            Delegates.glColor4fv((Single*)v);
        }

        public static 
        void Color4(Byte red, Byte green, Byte blue, Byte alpha)
        {
            Delegates.glColor4ub((Byte)red, (Byte)green, (Byte)blue, (Byte)alpha);
        }

        public static 
        void Color4(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glColor4ubv((Byte*)v_ptr);
                }
            }
        }

        public static 
        void Color4(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glColor4ubv((Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(Byte* v)
        {
            Delegates.glColor4ubv((Byte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
        {
            Delegates.glColor4ui((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
        }

        public static 
        void Color4(Int32 red, Int32 green, Int32 blue, Int32 alpha)
        {
            Delegates.glColor4ui((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void Color4(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void Color4(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glColor4uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(UInt32* v)
        {
            Delegates.glColor4uiv((UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(Int32* v)
        {
            Delegates.glColor4uiv((UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(UInt16 red, UInt16 green, UInt16 blue, UInt16 alpha)
        {
            Delegates.glColor4us((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
        }

        public static 
        void Color4(Int16 red, Int16 green, Int16 blue, Int16 alpha)
        {
            Delegates.glColor4us((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void Color4(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void Color4(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void Color4(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glColor4usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(UInt16* v)
        {
            Delegates.glColor4usv((UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Color4(Int16* v)
        {
            Delegates.glColor4usv((UInt16*)v);
        }

        public static 
        void EdgeFlag(bool flag)
        {
            Delegates.glEdgeFlag((bool)flag);
        }

        public static 
        void EdgeFlag(bool[] flag)
        {
            unsafe
            {
                fixed (bool* flag_ptr = flag)
                {
                    Delegates.glEdgeFlagv((bool*)flag_ptr);
                }
            }
        }

        public static 
        void EdgeFlag(ref bool flag)
        {
            unsafe
            {
                fixed (bool* flag_ptr = &flag)
                {
                    Delegates.glEdgeFlagv((bool*)flag_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void EdgeFlag(bool* flag)
        {
            Delegates.glEdgeFlagv((bool*)flag);
        }

        public static 
        void End()
        {
            Delegates.glEnd();
        }

        public static 
        void Index(Double c)
        {
            Delegates.glIndexd((Double)c);
        }

        public static 
        void Indexv(Double[] c)
        {
            unsafe
            {
                fixed (Double* c_ptr = c)
                {
                    Delegates.glIndexdv((Double*)c_ptr);
                }
            }
        }

        public static 
        void Indexv(ref Double c)
        {
            unsafe
            {
                fixed (Double* c_ptr = &c)
                {
                    Delegates.glIndexdv((Double*)c_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexv(Double* c)
        {
            Delegates.glIndexdv((Double*)c);
        }

        public static 
        void Index(Single c)
        {
            Delegates.glIndexf((Single)c);
        }

        public static 
        void Indexv(Single[] c)
        {
            unsafe
            {
                fixed (Single* c_ptr = c)
                {
                    Delegates.glIndexfv((Single*)c_ptr);
                }
            }
        }

        public static 
        void Indexv(ref Single c)
        {
            unsafe
            {
                fixed (Single* c_ptr = &c)
                {
                    Delegates.glIndexfv((Single*)c_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexv(Single* c)
        {
            Delegates.glIndexfv((Single*)c);
        }

        public static 
        void Index(Int32 c)
        {
            Delegates.glIndexi((Int32)c);
        }

        public static 
        void Indexv(Int32[] c)
        {
            unsafe
            {
                fixed (Int32* c_ptr = c)
                {
                    Delegates.glIndexiv((Int32*)c_ptr);
                }
            }
        }

        public static 
        void Indexv(ref Int32 c)
        {
            unsafe
            {
                fixed (Int32* c_ptr = &c)
                {
                    Delegates.glIndexiv((Int32*)c_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexv(Int32* c)
        {
            Delegates.glIndexiv((Int32*)c);
        }

        public static 
        void Index(Int16 c)
        {
            Delegates.glIndexs((Int16)c);
        }

        public static 
        void Indexv(Int16[] c)
        {
            unsafe
            {
                fixed (Int16* c_ptr = c)
                {
                    Delegates.glIndexsv((Int16*)c_ptr);
                }
            }
        }

        public static 
        void Indexv(ref Int16 c)
        {
            unsafe
            {
                fixed (Int16* c_ptr = &c)
                {
                    Delegates.glIndexsv((Int16*)c_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexv(Int16* c)
        {
            Delegates.glIndexsv((Int16*)c);
        }

        [System.CLSCompliant(false)]
        public static 
        void Normal3(SByte nx, SByte ny, SByte nz)
        {
            Delegates.glNormal3b((SByte)nx, (SByte)ny, (SByte)nz);
        }

        public static 
        void Normal3(Byte nx, Byte ny, Byte nz)
        {
            Delegates.glNormal3b((SByte)nx, (SByte)ny, (SByte)nz);
        }

        [System.CLSCompliant(false)]
        public static 
        void Normal3(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void Normal3(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void Normal3(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        public static 
        void Normal3(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glNormal3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3(SByte* v)
        {
            Delegates.glNormal3bv((SByte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3(Byte* v)
        {
            Delegates.glNormal3bv((SByte*)v);
        }

        public static 
        void Normal3(Double nx, Double ny, Double nz)
        {
            Delegates.glNormal3d((Double)nx, (Double)ny, (Double)nz);
        }

        public static 
        void Normal3(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glNormal3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void Normal3(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glNormal3dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3(Double* v)
        {
            Delegates.glNormal3dv((Double*)v);
        }

        public static 
        void Normal3(Single nx, Single ny, Single nz)
        {
            Delegates.glNormal3f((Single)nx, (Single)ny, (Single)nz);
        }

        public static 
        void Normal3(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glNormal3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void Normal3(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glNormal3fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3(Single* v)
        {
            Delegates.glNormal3fv((Single*)v);
        }

        public static 
        void Normal3(Int32 nx, Int32 ny, Int32 nz)
        {
            Delegates.glNormal3i((Int32)nx, (Int32)ny, (Int32)nz);
        }

        public static 
        void Normal3(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glNormal3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void Normal3(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glNormal3iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3(Int32* v)
        {
            Delegates.glNormal3iv((Int32*)v);
        }

        public static 
        void Normal3(Int16 nx, Int16 ny, Int16 nz)
        {
            Delegates.glNormal3s((Int16)nx, (Int16)ny, (Int16)nz);
        }

        public static 
        void Normal3(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glNormal3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void Normal3(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glNormal3sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Normal3(Int16* v)
        {
            Delegates.glNormal3sv((Int16*)v);
        }

        public static 
        void RasterPos2(Double x, Double y)
        {
            Delegates.glRasterPos2d((Double)x, (Double)y);
        }

        public static 
        void RasterPos2(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glRasterPos2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos2(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glRasterPos2dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2(Double* v)
        {
            Delegates.glRasterPos2dv((Double*)v);
        }

        public static 
        void RasterPos2(Single x, Single y)
        {
            Delegates.glRasterPos2f((Single)x, (Single)y);
        }

        public static 
        void RasterPos2(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glRasterPos2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos2(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glRasterPos2fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2(Single* v)
        {
            Delegates.glRasterPos2fv((Single*)v);
        }

        public static 
        void RasterPos2(Int32 x, Int32 y)
        {
            Delegates.glRasterPos2i((Int32)x, (Int32)y);
        }

        public static 
        void RasterPos2(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glRasterPos2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos2(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glRasterPos2iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2(Int32* v)
        {
            Delegates.glRasterPos2iv((Int32*)v);
        }

        public static 
        void RasterPos2(Int16 x, Int16 y)
        {
            Delegates.glRasterPos2s((Int16)x, (Int16)y);
        }

        public static 
        void RasterPos2(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glRasterPos2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos2(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glRasterPos2sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos2(Int16* v)
        {
            Delegates.glRasterPos2sv((Int16*)v);
        }

        public static 
        void RasterPos3(Double x, Double y, Double z)
        {
            Delegates.glRasterPos3d((Double)x, (Double)y, (Double)z);
        }

        public static 
        void RasterPos3(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glRasterPos3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos3(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glRasterPos3dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3(Double* v)
        {
            Delegates.glRasterPos3dv((Double*)v);
        }

        public static 
        void RasterPos3(Single x, Single y, Single z)
        {
            Delegates.glRasterPos3f((Single)x, (Single)y, (Single)z);
        }

        public static 
        void RasterPos3(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glRasterPos3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos3(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glRasterPos3fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3(Single* v)
        {
            Delegates.glRasterPos3fv((Single*)v);
        }

        public static 
        void RasterPos3(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glRasterPos3i((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void RasterPos3(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glRasterPos3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos3(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glRasterPos3iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3(Int32* v)
        {
            Delegates.glRasterPos3iv((Int32*)v);
        }

        public static 
        void RasterPos3(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glRasterPos3s((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void RasterPos3(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glRasterPos3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos3(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glRasterPos3sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos3(Int16* v)
        {
            Delegates.glRasterPos3sv((Int16*)v);
        }

        public static 
        void RasterPos4(Double x, Double y, Double z, Double w)
        {
            Delegates.glRasterPos4d((Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void RasterPos4(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glRasterPos4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos4(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glRasterPos4dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4(Double* v)
        {
            Delegates.glRasterPos4dv((Double*)v);
        }

        public static 
        void RasterPos4(Single x, Single y, Single z, Single w)
        {
            Delegates.glRasterPos4f((Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void RasterPos4(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glRasterPos4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos4(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glRasterPos4fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4(Single* v)
        {
            Delegates.glRasterPos4fv((Single*)v);
        }

        public static 
        void RasterPos4(Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glRasterPos4i((Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void RasterPos4(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glRasterPos4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos4(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glRasterPos4iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4(Int32* v)
        {
            Delegates.glRasterPos4iv((Int32*)v);
        }

        public static 
        void RasterPos4(Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glRasterPos4s((Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void RasterPos4(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glRasterPos4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void RasterPos4(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glRasterPos4sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void RasterPos4(Int16* v)
        {
            Delegates.glRasterPos4sv((Int16*)v);
        }

        public static 
        void Rect(Double x1, Double y1, Double x2, Double y2)
        {
            Delegates.glRectd((Double)x1, (Double)y1, (Double)x2, (Double)y2);
        }

        public static 
        void Rect(Double[] v1, Double[] v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = v1)
                fixed (Double* v2_ptr = v2)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
                }
            }
        }

        public static 
        void Rect(ref Double v1, ref Double v2)
        {
            unsafe
            {
                fixed (Double* v1_ptr = &v1)
                fixed (Double* v2_ptr = &v2)
                {
                    Delegates.glRectdv((Double*)v1_ptr, (Double*)v2_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Rect(Double* v1, Double* v2)
        {
            Delegates.glRectdv((Double*)v1, (Double*)v2);
        }

        public static 
        void Rect(Single x1, Single y1, Single x2, Single y2)
        {
            Delegates.glRectf((Single)x1, (Single)y1, (Single)x2, (Single)y2);
        }

        public static 
        void Rect(Single[] v1, Single[] v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = v1)
                fixed (Single* v2_ptr = v2)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
                }
            }
        }

        public static 
        void Rect(ref Single v1, ref Single v2)
        {
            unsafe
            {
                fixed (Single* v1_ptr = &v1)
                fixed (Single* v2_ptr = &v2)
                {
                    Delegates.glRectfv((Single*)v1_ptr, (Single*)v2_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Rect(Single* v1, Single* v2)
        {
            Delegates.glRectfv((Single*)v1, (Single*)v2);
        }

        public static 
        void Rect(Int32 x1, Int32 y1, Int32 x2, Int32 y2)
        {
            Delegates.glRecti((Int32)x1, (Int32)y1, (Int32)x2, (Int32)y2);
        }

        public static 
        void Rect(Int32[] v1, Int32[] v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = v1)
                fixed (Int32* v2_ptr = v2)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
                }
            }
        }

        public static 
        void Rect(ref Int32 v1, ref Int32 v2)
        {
            unsafe
            {
                fixed (Int32* v1_ptr = &v1)
                fixed (Int32* v2_ptr = &v2)
                {
                    Delegates.glRectiv((Int32*)v1_ptr, (Int32*)v2_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Rect(Int32* v1, Int32* v2)
        {
            Delegates.glRectiv((Int32*)v1, (Int32*)v2);
        }

        public static 
        void Rects(Int16 x1, Int16 y1, Int16 x2, Int16 y2)
        {
            Delegates.glRects((Int16)x1, (Int16)y1, (Int16)x2, (Int16)y2);
        }

        public static 
        void Rect(Int16[] v1, Int16[] v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = v1)
                fixed (Int16* v2_ptr = v2)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
                }
            }
        }

        public static 
        void Rect(ref Int16 v1, ref Int16 v2)
        {
            unsafe
            {
                fixed (Int16* v1_ptr = &v1)
                fixed (Int16* v2_ptr = &v2)
                {
                    Delegates.glRectsv((Int16*)v1_ptr, (Int16*)v2_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Rect(Int16* v1, Int16* v2)
        {
            Delegates.glRectsv((Int16*)v1, (Int16*)v2);
        }

        public static 
        void TexCoord1(Double s)
        {
            Delegates.glTexCoord1d((Double)s);
        }

        public static 
        void TexCoord1v(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord1dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord1v(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord1dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1v(Double* v)
        {
            Delegates.glTexCoord1dv((Double*)v);
        }

        public static 
        void TexCoord1(Single s)
        {
            Delegates.glTexCoord1f((Single)s);
        }

        public static 
        void TexCoord1v(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord1fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord1v(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord1fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1v(Single* v)
        {
            Delegates.glTexCoord1fv((Single*)v);
        }

        public static 
        void TexCoord1(Int32 s)
        {
            Delegates.glTexCoord1i((Int32)s);
        }

        public static 
        void TexCoord1v(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord1iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord1v(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord1iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1v(Int32* v)
        {
            Delegates.glTexCoord1iv((Int32*)v);
        }

        public static 
        void TexCoord1(Int16 s)
        {
            Delegates.glTexCoord1s((Int16)s);
        }

        public static 
        void TexCoord1v(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord1sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord1v(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord1sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord1v(Int16* v)
        {
            Delegates.glTexCoord1sv((Int16*)v);
        }

        public static 
        void TexCoord2(Double s, Double t)
        {
            Delegates.glTexCoord2d((Double)s, (Double)t);
        }

        public static 
        void TexCoord2(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord2(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord2dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2(Double* v)
        {
            Delegates.glTexCoord2dv((Double*)v);
        }

        public static 
        void TexCoord2(Single s, Single t)
        {
            Delegates.glTexCoord2f((Single)s, (Single)t);
        }

        public static 
        void TexCoord2(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord2(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord2fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2(Single* v)
        {
            Delegates.glTexCoord2fv((Single*)v);
        }

        public static 
        void TexCoord2(Int32 s, Int32 t)
        {
            Delegates.glTexCoord2i((Int32)s, (Int32)t);
        }

        public static 
        void TexCoord2(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord2(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord2iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2(Int32* v)
        {
            Delegates.glTexCoord2iv((Int32*)v);
        }

        public static 
        void TexCoord2(Int16 s, Int16 t)
        {
            Delegates.glTexCoord2s((Int16)s, (Int16)t);
        }

        public static 
        void TexCoord2(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord2(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord2sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord2(Int16* v)
        {
            Delegates.glTexCoord2sv((Int16*)v);
        }

        public static 
        void TexCoord3(Double s, Double t, Double r)
        {
            Delegates.glTexCoord3d((Double)s, (Double)t, (Double)r);
        }

        public static 
        void TexCoord3(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord3(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord3dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3(Double* v)
        {
            Delegates.glTexCoord3dv((Double*)v);
        }

        public static 
        void TexCoord3(Single s, Single t, Single r)
        {
            Delegates.glTexCoord3f((Single)s, (Single)t, (Single)r);
        }

        public static 
        void TexCoord3(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord3(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord3fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3(Single* v)
        {
            Delegates.glTexCoord3fv((Single*)v);
        }

        public static 
        void TexCoord3(Int32 s, Int32 t, Int32 r)
        {
            Delegates.glTexCoord3i((Int32)s, (Int32)t, (Int32)r);
        }

        public static 
        void TexCoord3(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord3(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord3iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3(Int32* v)
        {
            Delegates.glTexCoord3iv((Int32*)v);
        }

        public static 
        void TexCoord3(Int16 s, Int16 t, Int16 r)
        {
            Delegates.glTexCoord3s((Int16)s, (Int16)t, (Int16)r);
        }

        public static 
        void TexCoord3(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord3(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord3sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord3(Int16* v)
        {
            Delegates.glTexCoord3sv((Int16*)v);
        }

        public static 
        void TexCoord4(Double s, Double t, Double r, Double q)
        {
            Delegates.glTexCoord4d((Double)s, (Double)t, (Double)r, (Double)q);
        }

        public static 
        void TexCoord4(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glTexCoord4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord4(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glTexCoord4dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4(Double* v)
        {
            Delegates.glTexCoord4dv((Double*)v);
        }

        public static 
        void TexCoord4(Single s, Single t, Single r, Single q)
        {
            Delegates.glTexCoord4f((Single)s, (Single)t, (Single)r, (Single)q);
        }

        public static 
        void TexCoord4(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glTexCoord4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord4(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glTexCoord4fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4(Single* v)
        {
            Delegates.glTexCoord4fv((Single*)v);
        }

        public static 
        void TexCoord4(Int32 s, Int32 t, Int32 r, Int32 q)
        {
            Delegates.glTexCoord4i((Int32)s, (Int32)t, (Int32)r, (Int32)q);
        }

        public static 
        void TexCoord4(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glTexCoord4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord4(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glTexCoord4iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4(Int32* v)
        {
            Delegates.glTexCoord4iv((Int32*)v);
        }

        public static 
        void TexCoord4(Int16 s, Int16 t, Int16 r, Int16 q)
        {
            Delegates.glTexCoord4s((Int16)s, (Int16)t, (Int16)r, (Int16)q);
        }

        public static 
        void TexCoord4(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glTexCoord4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void TexCoord4(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glTexCoord4sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexCoord4(Int16* v)
        {
            Delegates.glTexCoord4sv((Int16*)v);
        }

        public static 
        void Vertex2(Double x, Double y)
        {
            Delegates.glVertex2d((Double)x, (Double)y);
        }

        public static 
        void Vertex2(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertex2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void Vertex2(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertex2dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2(Double* v)
        {
            Delegates.glVertex2dv((Double*)v);
        }

        public static 
        void Vertex2(Single x, Single y)
        {
            Delegates.glVertex2f((Single)x, (Single)y);
        }

        public static 
        void Vertex2(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertex2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void Vertex2(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertex2fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2(Single* v)
        {
            Delegates.glVertex2fv((Single*)v);
        }

        public static 
        void Vertex2(Int32 x, Int32 y)
        {
            Delegates.glVertex2i((Int32)x, (Int32)y);
        }

        public static 
        void Vertex2(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertex2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void Vertex2(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertex2iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2(Int32* v)
        {
            Delegates.glVertex2iv((Int32*)v);
        }

        public static 
        void Vertex2(Int16 x, Int16 y)
        {
            Delegates.glVertex2s((Int16)x, (Int16)y);
        }

        public static 
        void Vertex2(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void Vertex2(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex2sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex2(Int16* v)
        {
            Delegates.glVertex2sv((Int16*)v);
        }

        public static 
        void Vertex3(Double x, Double y, Double z)
        {
            Delegates.glVertex3d((Double)x, (Double)y, (Double)z);
        }

        public static 
        void Vertex3(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertex3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void Vertex3(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertex3dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3(Double* v)
        {
            Delegates.glVertex3dv((Double*)v);
        }

        public static 
        void Vertex3(Single x, Single y, Single z)
        {
            Delegates.glVertex3f((Single)x, (Single)y, (Single)z);
        }

        public static 
        void Vertex3(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertex3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void Vertex3(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertex3fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3(Single* v)
        {
            Delegates.glVertex3fv((Single*)v);
        }

        public static 
        void Vertex3(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glVertex3i((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void Vertex3(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertex3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void Vertex3(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertex3iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3(Int32* v)
        {
            Delegates.glVertex3iv((Int32*)v);
        }

        public static 
        void Vertex3(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertex3s((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void Vertex3(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void Vertex3(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex3sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex3(Int16* v)
        {
            Delegates.glVertex3sv((Int16*)v);
        }

        public static 
        void Vertex4(Double x, Double y, Double z, Double w)
        {
            Delegates.glVertex4d((Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void Vertex4(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertex4dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void Vertex4(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertex4dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4(Double* v)
        {
            Delegates.glVertex4dv((Double*)v);
        }

        public static 
        void Vertex4(Single x, Single y, Single z, Single w)
        {
            Delegates.glVertex4f((Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void Vertex4(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertex4fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void Vertex4(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertex4fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4(Single* v)
        {
            Delegates.glVertex4fv((Single*)v);
        }

        public static 
        void Vertex4(Int32 x, Int32 y, Int32 z, Int32 w)
        {
            Delegates.glVertex4i((Int32)x, (Int32)y, (Int32)z, (Int32)w);
        }

        public static 
        void Vertex4(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertex4iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void Vertex4(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertex4iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4(Int32* v)
        {
            Delegates.glVertex4iv((Int32*)v);
        }

        public static 
        void Vertex4(Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertex4s((Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void Vertex4(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertex4sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void Vertex4(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertex4sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Vertex4(Int16* v)
        {
            Delegates.glVertex4sv((Int16*)v);
        }

        public static 
        void ClipPlane(OpenTK.OpenGL.Enums.ClipPlaneName plane, Double[] equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = equation)
                {
                    Delegates.glClipPlane((OpenTK.OpenGL.Enums.ClipPlaneName)plane, (Double*)equation_ptr);
                }
            }
        }

        public static 
        void ClipPlane(OpenTK.OpenGL.Enums.ClipPlaneName plane, ref Double equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = &equation)
                {
                    Delegates.glClipPlane((OpenTK.OpenGL.Enums.ClipPlaneName)plane, (Double*)equation_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void ClipPlane(OpenTK.OpenGL.Enums.ClipPlaneName plane, Double* equation)
        {
            Delegates.glClipPlane((OpenTK.OpenGL.Enums.ClipPlaneName)plane, (Double*)equation);
        }

        public static 
        void ColorMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.ColorMaterialParameter mode)
        {
            Delegates.glColorMaterial((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.ColorMaterialParameter)mode);
        }

        public static 
        void CullFace(OpenTK.OpenGL.Enums.CullFaceMode mode)
        {
            Delegates.glCullFace((OpenTK.OpenGL.Enums.CullFaceMode)mode);
        }

        public static 
        void Fog(OpenTK.OpenGL.Enums.FogParameter pname, Single param)
        {
            Delegates.glFogf((OpenTK.OpenGL.Enums.FogParameter)pname, (Single)param);
        }

        public static 
        void Fogv(OpenTK.OpenGL.Enums.FogParameter pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glFogfv((OpenTK.OpenGL.Enums.FogParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void Fogv(OpenTK.OpenGL.Enums.FogParameter pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glFogfv((OpenTK.OpenGL.Enums.FogParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Fogv(OpenTK.OpenGL.Enums.FogParameter pname, Single* @params)
        {
            Delegates.glFogfv((OpenTK.OpenGL.Enums.FogParameter)pname, (Single*)@params);
        }

        public static 
        void Fog(OpenTK.OpenGL.Enums.FogParameter pname, Int32 param)
        {
            Delegates.glFogi((OpenTK.OpenGL.Enums.FogParameter)pname, (Int32)param);
        }

        public static 
        void Fogv(OpenTK.OpenGL.Enums.FogParameter pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glFogiv((OpenTK.OpenGL.Enums.FogParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void Fogv(OpenTK.OpenGL.Enums.FogParameter pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glFogiv((OpenTK.OpenGL.Enums.FogParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Fogv(OpenTK.OpenGL.Enums.FogParameter pname, Int32* @params)
        {
            Delegates.glFogiv((OpenTK.OpenGL.Enums.FogParameter)pname, (Int32*)@params);
        }

        public static 
        void FrontFace(OpenTK.OpenGL.Enums.FrontFaceDirection mode)
        {
            Delegates.glFrontFace((OpenTK.OpenGL.Enums.FrontFaceDirection)mode);
        }

        public static 
        void Hint(OpenTK.OpenGL.Enums.HintTarget target, OpenTK.OpenGL.Enums.HintMode mode)
        {
            Delegates.glHint((OpenTK.OpenGL.Enums.HintTarget)target, (OpenTK.OpenGL.Enums.HintMode)mode);
        }

        public static 
        void Light(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, Single param)
        {
            Delegates.glLightf((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Single)param);
        }

        public static 
        void Lightv(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glLightfv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void Lightv(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glLightfv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Lightv(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, Single* @params)
        {
            Delegates.glLightfv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Single*)@params);
        }

        public static 
        void Light(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, Int32 param)
        {
            Delegates.glLighti((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Int32)param);
        }

        public static 
        void Lightv(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glLightiv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void Lightv(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glLightiv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Lightv(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, Int32* @params)
        {
            Delegates.glLightiv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Int32*)@params);
        }

        public static 
        void LightModel(OpenTK.OpenGL.Enums.LightModelParameter pname, Single param)
        {
            Delegates.glLightModelf((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Single)param);
        }

        public static 
        void LightModelv(OpenTK.OpenGL.Enums.LightModelParameter pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glLightModelfv((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void LightModelv(OpenTK.OpenGL.Enums.LightModelParameter pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glLightModelfv((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void LightModelv(OpenTK.OpenGL.Enums.LightModelParameter pname, Single* @params)
        {
            Delegates.glLightModelfv((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Single*)@params);
        }

        public static 
        void LightModel(OpenTK.OpenGL.Enums.LightModelParameter pname, Int32 param)
        {
            Delegates.glLightModeli((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Int32)param);
        }

        public static 
        void LightModelv(OpenTK.OpenGL.Enums.LightModelParameter pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glLightModeliv((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void LightModelv(OpenTK.OpenGL.Enums.LightModelParameter pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glLightModeliv((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void LightModelv(OpenTK.OpenGL.Enums.LightModelParameter pname, Int32* @params)
        {
            Delegates.glLightModeliv((OpenTK.OpenGL.Enums.LightModelParameter)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void LineStipple(Int32 factor, UInt16 pattern)
        {
            Delegates.glLineStipple((Int32)factor, (UInt16)pattern);
        }

        public static 
        void LineStipple(Int32 factor, Int16 pattern)
        {
            Delegates.glLineStipple((Int32)factor, (UInt16)pattern);
        }

        public static 
        void LineWidth(Single width)
        {
            Delegates.glLineWidth((Single)width);
        }

        public static 
        void Material(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Single param)
        {
            Delegates.glMaterialf((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single)param);
        }

        public static 
        void Materialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glMaterialfv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void Materialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glMaterialfv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Materialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Single* @params)
        {
            Delegates.glMaterialfv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params);
        }

        public static 
        void Material(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Int32 param)
        {
            Delegates.glMateriali((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32)param);
        }

        public static 
        void Materialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glMaterialiv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void Materialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glMaterialiv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Materialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Int32* @params)
        {
            Delegates.glMaterialiv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params);
        }

        public static 
        void PointSize(Single size)
        {
            Delegates.glPointSize((Single)size);
        }

        public static 
        void PolygonMode(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.PolygonMode mode)
        {
            Delegates.glPolygonMode((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.PolygonMode)mode);
        }

        public static 
        void PolygonStipple(Byte[] mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = mask)
                {
                    Delegates.glPolygonStipple((Byte*)mask_ptr);
                }
            }
        }

        public static 
        void PolygonStipple(ref Byte mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = &mask)
                {
                    Delegates.glPolygonStipple((Byte*)mask_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PolygonStipple(Byte* mask)
        {
            Delegates.glPolygonStipple((Byte*)mask);
        }

        public static 
        void Scissor(Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glScissor((Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void ShadeModel(OpenTK.OpenGL.Enums.ShadingModel mode)
        {
            Delegates.glShadeModel((OpenTK.OpenGL.Enums.ShadingModel)mode);
        }

        public static 
        void TexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Single param)
        {
            Delegates.glTexParameterf((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Single)param);
        }

        public static 
        void TexParameterv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glTexParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void TexParameterv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glTexParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexParameterv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Single* @params)
        {
            Delegates.glTexParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Single*)@params);
        }

        public static 
        void TexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Int32 param)
        {
            Delegates.glTexParameteri((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Int32)param);
        }

        public static 
        void TexParameterv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void TexParameterv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexParameterv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Int32* @params)
        {
            Delegates.glTexParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (Int32*)@params);
        }

        public static 
        void TexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
        {
            Delegates.glTexImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void TexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glTexImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void TexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
        {
            Delegates.glTexImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void TexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glTexImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void TexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, Single param)
        {
            Delegates.glTexEnvf((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Single)param);
        }

        public static 
        void TexEnvv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glTexEnvfv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void TexEnvv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glTexEnvfv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexEnvv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, Single* @params)
        {
            Delegates.glTexEnvfv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Single*)@params);
        }

        public static 
        void TexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, Int32 param)
        {
            Delegates.glTexEnvi((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Int32)param);
        }

        public static 
        void TexEnvv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexEnviv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void TexEnvv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexEnviv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexEnvv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, Int32* @params)
        {
            Delegates.glTexEnviv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Int32*)@params);
        }

        public static 
        void TexGend(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Double param)
        {
            Delegates.glTexGend((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Double)param);
        }

        public static 
        void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glTexGendv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, ref Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glTexGendv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Double* @params)
        {
            Delegates.glTexGendv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Double*)@params);
        }

        public static 
        void TexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Single param)
        {
            Delegates.glTexGenf((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Single)param);
        }

        public static 
        void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glTexGenfv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glTexGenfv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Single* @params)
        {
            Delegates.glTexGenfv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Single*)@params);
        }

        public static 
        void TexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Int32 param)
        {
            Delegates.glTexGeni((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Int32)param);
        }

        public static 
        void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glTexGeniv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glTexGeniv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void TexGenv(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, Int32* @params)
        {
            Delegates.glTexGeniv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Int32*)@params);
        }

        public static 
        void FeedbackBuffer(Int32 size, OpenTK.OpenGL.Enums.FeedbackType type, [Out] Single[] buffer)
        {
            unsafe
            {
                fixed (Single* buffer_ptr = buffer)
                {
                    Delegates.glFeedbackBuffer((Int32)size, (OpenTK.OpenGL.Enums.FeedbackType)type, (Single*)buffer_ptr);
                }
            }
        }

        public static 
        void FeedbackBuffer(Int32 size, OpenTK.OpenGL.Enums.FeedbackType type, [Out] out Single buffer)
        {
            unsafe
            {
                fixed (Single* buffer_ptr = &buffer)
                {
                    Delegates.glFeedbackBuffer((Int32)size, (OpenTK.OpenGL.Enums.FeedbackType)type, (Single*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void FeedbackBuffer(Int32 size, OpenTK.OpenGL.Enums.FeedbackType type, [Out] Single* buffer)
        {
            Delegates.glFeedbackBuffer((Int32)size, (OpenTK.OpenGL.Enums.FeedbackType)type, (Single*)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void SelectBuffer(Int32 size, [Out] UInt32[] buffer)
        {
            unsafe
            {
                fixed (UInt32* buffer_ptr = buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                }
            }
        }

        public static 
        void SelectBuffer(Int32 size, [Out] Int32[] buffer)
        {
            unsafe
            {
                fixed (Int32* buffer_ptr = buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void SelectBuffer(Int32 size, [Out] out UInt32 buffer)
        {
            unsafe
            {
                fixed (UInt32* buffer_ptr = &buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }

        public static 
        void SelectBuffer(Int32 size, [Out] out Int32 buffer)
        {
            unsafe
            {
                fixed (Int32* buffer_ptr = &buffer)
                {
                    Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer_ptr);
                    buffer = *buffer_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SelectBuffer(Int32 size, [Out] UInt32* buffer)
        {
            Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SelectBuffer(Int32 size, [Out] Int32* buffer)
        {
            Delegates.glSelectBuffer((Int32)size, (UInt32*)buffer);
        }

        public static 
        Int32 RenderMode(OpenTK.OpenGL.Enums.RenderingMode mode)
        {
            return Delegates.glRenderMode((OpenTK.OpenGL.Enums.RenderingMode)mode);
        }

        public static 
        void InitNames()
        {
            Delegates.glInitNames();
        }

        [System.CLSCompliant(false)]
        public static 
        void LoadName(UInt32 name)
        {
            Delegates.glLoadName((UInt32)name);
        }

        public static 
        void LoadName(Int32 name)
        {
            Delegates.glLoadName((UInt32)name);
        }

        public static 
        void PassThrough(Single token)
        {
            Delegates.glPassThrough((Single)token);
        }

        public static 
        void PopName()
        {
            Delegates.glPopName();
        }

        [System.CLSCompliant(false)]
        public static 
        void PushName(UInt32 name)
        {
            Delegates.glPushName((UInt32)name);
        }

        public static 
        void PushName(Int32 name)
        {
            Delegates.glPushName((UInt32)name);
        }

        public static 
        void DrawBuffer(OpenTK.OpenGL.Enums.DrawBufferMode mode)
        {
            Delegates.glDrawBuffer((OpenTK.OpenGL.Enums.DrawBufferMode)mode);
        }

        public static 
        void Clear(OpenTK.OpenGL.Enums.ClearBufferMask mask)
        {
            Delegates.glClear((OpenTK.OpenGL.Enums.ClearBufferMask)mask);
        }

        public static 
        void ClearAccum(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glClearAccum((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void ClearIndex(Single c)
        {
            Delegates.glClearIndex((Single)c);
        }

        public static 
        void ClearColor(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glClearColor((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void ClearStencil(Int32 s)
        {
            Delegates.glClearStencil((Int32)s);
        }

        public static 
        void ClearDepth(Double depth)
        {
            Delegates.glClearDepth((Double)depth);
        }

        [System.CLSCompliant(false)]
        public static 
        void StencilMask(UInt32 mask)
        {
            Delegates.glStencilMask((UInt32)mask);
        }

        public static 
        void StencilMask(Int32 mask)
        {
            Delegates.glStencilMask((UInt32)mask);
        }

        public static 
        void ColorMask(bool red, bool green, bool blue, bool alpha)
        {
            Delegates.glColorMask((bool)red, (bool)green, (bool)blue, (bool)alpha);
        }

        public static 
        void DepthMask(bool flag)
        {
            Delegates.glDepthMask((bool)flag);
        }

        [System.CLSCompliant(false)]
        public static 
        void IndexMask(UInt32 mask)
        {
            Delegates.glIndexMask((UInt32)mask);
        }

        public static 
        void IndexMask(Int32 mask)
        {
            Delegates.glIndexMask((UInt32)mask);
        }

        public static 
        void Accum(OpenTK.OpenGL.Enums.AccumOp op, Single value)
        {
            Delegates.glAccum((OpenTK.OpenGL.Enums.AccumOp)op, (Single)value);
        }

        public static 
        void Disable(OpenTK.OpenGL.Enums.EnableCap cap)
        {
            Delegates.glDisable((OpenTK.OpenGL.Enums.EnableCap)cap);
        }

        public static 
        void Enable(OpenTK.OpenGL.Enums.EnableCap cap)
        {
            Delegates.glEnable((OpenTK.OpenGL.Enums.EnableCap)cap);
        }

        public static 
        void Finish()
        {
            Delegates.glFinish();
        }

        public static 
        void Flush()
        {
            Delegates.glFlush();
        }

        public static 
        void PopAttrib()
        {
            Delegates.glPopAttrib();
        }

        public static 
        void PushAttrib(OpenTK.OpenGL.Enums.AttribMask mask)
        {
            Delegates.glPushAttrib((OpenTK.OpenGL.Enums.AttribMask)mask);
        }

        public static 
        void Map1(OpenTK.OpenGL.Enums.MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, Double[] points)
        {
            unsafe
            {
                fixed (Double* points_ptr = points)
                {
                    Delegates.glMap1d((OpenTK.OpenGL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points_ptr);
                }
            }
        }

        public static 
        void Map1(OpenTK.OpenGL.Enums.MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, ref Double points)
        {
            unsafe
            {
                fixed (Double* points_ptr = &points)
                {
                    Delegates.glMap1d((OpenTK.OpenGL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Map1(OpenTK.OpenGL.Enums.MapTarget target, Double u1, Double u2, Int32 stride, Int32 order, Double* points)
        {
            Delegates.glMap1d((OpenTK.OpenGL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)stride, (Int32)order, (Double*)points);
        }

        public static 
        void Map1(OpenTK.OpenGL.Enums.MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glMap1f((OpenTK.OpenGL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points_ptr);
                }
            }
        }

        public static 
        void Map1(OpenTK.OpenGL.Enums.MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glMap1f((OpenTK.OpenGL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Map1(OpenTK.OpenGL.Enums.MapTarget target, Single u1, Single u2, Int32 stride, Int32 order, Single* points)
        {
            Delegates.glMap1f((OpenTK.OpenGL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)stride, (Int32)order, (Single*)points);
        }

        public static 
        void Map2(OpenTK.OpenGL.Enums.MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double[] points)
        {
            unsafe
            {
                fixed (Double* points_ptr = points)
                {
                    Delegates.glMap2d((OpenTK.OpenGL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points_ptr);
                }
            }
        }

        public static 
        void Map2(OpenTK.OpenGL.Enums.MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, ref Double points)
        {
            unsafe
            {
                fixed (Double* points_ptr = &points)
                {
                    Delegates.glMap2d((OpenTK.OpenGL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Map2(OpenTK.OpenGL.Enums.MapTarget target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double* points)
        {
            Delegates.glMap2d((OpenTK.OpenGL.Enums.MapTarget)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double*)points);
        }

        public static 
        void Map2(OpenTK.OpenGL.Enums.MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single[] points)
        {
            unsafe
            {
                fixed (Single* points_ptr = points)
                {
                    Delegates.glMap2f((OpenTK.OpenGL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points_ptr);
                }
            }
        }

        public static 
        void Map2(OpenTK.OpenGL.Enums.MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, ref Single points)
        {
            unsafe
            {
                fixed (Single* points_ptr = &points)
                {
                    Delegates.glMap2f((OpenTK.OpenGL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Map2(OpenTK.OpenGL.Enums.MapTarget target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single* points)
        {
            Delegates.glMap2f((OpenTK.OpenGL.Enums.MapTarget)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single*)points);
        }

        public static 
        void MapGrid1(Int32 un, Double u1, Double u2)
        {
            Delegates.glMapGrid1d((Int32)un, (Double)u1, (Double)u2);
        }

        public static 
        void MapGrid1(Int32 un, Single u1, Single u2)
        {
            Delegates.glMapGrid1f((Int32)un, (Single)u1, (Single)u2);
        }

        public static 
        void MapGrid2(Int32 un, Double u1, Double u2, Int32 vn, Double v1, Double v2)
        {
            Delegates.glMapGrid2d((Int32)un, (Double)u1, (Double)u2, (Int32)vn, (Double)v1, (Double)v2);
        }

        public static 
        void MapGrid2(Int32 un, Single u1, Single u2, Int32 vn, Single v1, Single v2)
        {
            Delegates.glMapGrid2f((Int32)un, (Single)u1, (Single)u2, (Int32)vn, (Single)v1, (Single)v2);
        }

        public static 
        void EvalCoord1(Double u)
        {
            Delegates.glEvalCoord1d((Double)u);
        }

        public static 
        void EvalCoord1v(Double[] u)
        {
            unsafe
            {
                fixed (Double* u_ptr = u)
                {
                    Delegates.glEvalCoord1dv((Double*)u_ptr);
                }
            }
        }

        public static 
        void EvalCoord1v(ref Double u)
        {
            unsafe
            {
                fixed (Double* u_ptr = &u)
                {
                    Delegates.glEvalCoord1dv((Double*)u_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord1v(Double* u)
        {
            Delegates.glEvalCoord1dv((Double*)u);
        }

        public static 
        void EvalCoord1(Single u)
        {
            Delegates.glEvalCoord1f((Single)u);
        }

        public static 
        void EvalCoord1v(Single[] u)
        {
            unsafe
            {
                fixed (Single* u_ptr = u)
                {
                    Delegates.glEvalCoord1fv((Single*)u_ptr);
                }
            }
        }

        public static 
        void EvalCoord1v(ref Single u)
        {
            unsafe
            {
                fixed (Single* u_ptr = &u)
                {
                    Delegates.glEvalCoord1fv((Single*)u_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord1v(Single* u)
        {
            Delegates.glEvalCoord1fv((Single*)u);
        }

        public static 
        void EvalCoord2(Double u, Double v)
        {
            Delegates.glEvalCoord2d((Double)u, (Double)v);
        }

        public static 
        void EvalCoord2(Double[] u)
        {
            unsafe
            {
                fixed (Double* u_ptr = u)
                {
                    Delegates.glEvalCoord2dv((Double*)u_ptr);
                }
            }
        }

        public static 
        void EvalCoord2(ref Double u)
        {
            unsafe
            {
                fixed (Double* u_ptr = &u)
                {
                    Delegates.glEvalCoord2dv((Double*)u_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord2(Double* u)
        {
            Delegates.glEvalCoord2dv((Double*)u);
        }

        public static 
        void EvalCoord2(Single u, Single v)
        {
            Delegates.glEvalCoord2f((Single)u, (Single)v);
        }

        public static 
        void EvalCoord2(Single[] u)
        {
            unsafe
            {
                fixed (Single* u_ptr = u)
                {
                    Delegates.glEvalCoord2fv((Single*)u_ptr);
                }
            }
        }

        public static 
        void EvalCoord2(ref Single u)
        {
            unsafe
            {
                fixed (Single* u_ptr = &u)
                {
                    Delegates.glEvalCoord2fv((Single*)u_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void EvalCoord2(Single* u)
        {
            Delegates.glEvalCoord2fv((Single*)u);
        }

        public static 
        void EvalMesh1(OpenTK.OpenGL.Enums.MeshMode1 mode, Int32 i1, Int32 i2)
        {
            Delegates.glEvalMesh1((OpenTK.OpenGL.Enums.MeshMode1)mode, (Int32)i1, (Int32)i2);
        }

        public static 
        void EvalPoint1(Int32 i)
        {
            Delegates.glEvalPoint1((Int32)i);
        }

        public static 
        void EvalMesh2(OpenTK.OpenGL.Enums.MeshMode2 mode, Int32 i1, Int32 i2, Int32 j1, Int32 j2)
        {
            Delegates.glEvalMesh2((OpenTK.OpenGL.Enums.MeshMode2)mode, (Int32)i1, (Int32)i2, (Int32)j1, (Int32)j2);
        }

        public static 
        void EvalPoint2(Int32 i, Int32 j)
        {
            Delegates.glEvalPoint2((Int32)i, (Int32)j);
        }

        public static 
        void AlphaFunc(OpenTK.OpenGL.Enums.AlphaFunction func, Single @ref)
        {
            Delegates.glAlphaFunc((OpenTK.OpenGL.Enums.AlphaFunction)func, (Single)@ref);
        }

        public static 
        void BlendFunc(OpenTK.OpenGL.Enums.BlendingFactorSrc sfactor, OpenTK.OpenGL.Enums.BlendingFactorDest dfactor)
        {
            Delegates.glBlendFunc((OpenTK.OpenGL.Enums.BlendingFactorSrc)sfactor, (OpenTK.OpenGL.Enums.BlendingFactorDest)dfactor);
        }

        public static 
        void LogicOp(OpenTK.OpenGL.Enums.LogicOp opcode)
        {
            Delegates.glLogicOp((OpenTK.OpenGL.Enums.LogicOp)opcode);
        }

        [System.CLSCompliant(false)]
        public static 
        void StencilFunc(OpenTK.OpenGL.Enums.StencilFunction func, Int32 @ref, UInt32 mask)
        {
            Delegates.glStencilFunc((OpenTK.OpenGL.Enums.StencilFunction)func, (Int32)@ref, (UInt32)mask);
        }

        public static 
        void StencilFunc(OpenTK.OpenGL.Enums.StencilFunction func, Int32 @ref, Int32 mask)
        {
            Delegates.glStencilFunc((OpenTK.OpenGL.Enums.StencilFunction)func, (Int32)@ref, (UInt32)mask);
        }

        public static 
        void StencilOp(OpenTK.OpenGL.Enums.StencilOp fail, OpenTK.OpenGL.Enums.StencilOp zfail, OpenTK.OpenGL.Enums.StencilOp zpass)
        {
            Delegates.glStencilOp((OpenTK.OpenGL.Enums.StencilOp)fail, (OpenTK.OpenGL.Enums.StencilOp)zfail, (OpenTK.OpenGL.Enums.StencilOp)zpass);
        }

        public static 
        void DepthFunc(OpenTK.OpenGL.Enums.DepthFunction func)
        {
            Delegates.glDepthFunc((OpenTK.OpenGL.Enums.DepthFunction)func);
        }

        public static 
        void PixelZoom(Single xfactor, Single yfactor)
        {
            Delegates.glPixelZoom((Single)xfactor, (Single)yfactor);
        }

        public static 
        void PixelTransfer(OpenTK.OpenGL.Enums.PixelTransferParameter pname, Single param)
        {
            Delegates.glPixelTransferf((OpenTK.OpenGL.Enums.PixelTransferParameter)pname, (Single)param);
        }

        public static 
        void PixelTransfer(OpenTK.OpenGL.Enums.PixelTransferParameter pname, Int32 param)
        {
            Delegates.glPixelTransferi((OpenTK.OpenGL.Enums.PixelTransferParameter)pname, (Int32)param);
        }

        public static 
        void PixelStore(OpenTK.OpenGL.Enums.PixelStoreParameter pname, Single param)
        {
            Delegates.glPixelStoref((OpenTK.OpenGL.Enums.PixelStoreParameter)pname, (Single)param);
        }

        public static 
        void PixelStore(OpenTK.OpenGL.Enums.PixelStoreParameter pname, Int32 param)
        {
            Delegates.glPixelStorei((OpenTK.OpenGL.Enums.PixelStoreParameter)pname, (Int32)param);
        }

        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, Single[] values)
        {
            unsafe
            {
                fixed (Single* values_ptr = values)
                {
                    Delegates.glPixelMapfv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (Single*)values_ptr);
                }
            }
        }

        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, ref Single values)
        {
            unsafe
            {
                fixed (Single* values_ptr = &values)
                {
                    Delegates.glPixelMapfv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (Single*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, Single* values)
        {
            Delegates.glPixelMapfv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (Single*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, UInt32[] values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = values)
                {
                    Delegates.glPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, Int32[] values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = values)
                {
                    Delegates.glPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, ref UInt32 values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = &values)
                {
                    Delegates.glPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, ref Int32 values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = &values)
                {
                    Delegates.glPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, UInt32* values)
        {
            Delegates.glPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, Int32* values)
        {
            Delegates.glPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt32*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, UInt16[] values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = values)
                {
                    Delegates.glPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, Int16[] values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = values)
                {
                    Delegates.glPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, ref UInt16 values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = &values)
                {
                    Delegates.glPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        public static 
        void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, ref Int16 values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = &values)
                {
                    Delegates.glPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, UInt16* values)
        {
            Delegates.glPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PixelMap(OpenTK.OpenGL.Enums.PixelMap map, Int32 mapsize, Int16* values)
        {
            Delegates.glPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (Int32)mapsize, (UInt16*)values);
        }

        public static 
        void ReadBuffer(OpenTK.OpenGL.Enums.ReadBufferMode mode)
        {
            Delegates.glReadBuffer((OpenTK.OpenGL.Enums.ReadBufferMode)mode);
        }

        public static 
        void CopyPixel(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelCopyType type)
        {
            Delegates.glCopyPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelCopyType)type);
        }

        public static 
        void ReadPixel(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr pixels)
        {
            Delegates.glReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void ReadPixel(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void DrawPixel(Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
        {
            Delegates.glDrawPixels((Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void DrawPixel(Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glDrawPixels((Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void GetBoolean(OpenTK.OpenGL.Enums.GetPName pname, [Out] bool[] @params)
        {
            unsafe
            {
                fixed (bool* @params_ptr = @params)
                {
                    Delegates.glGetBooleanv((OpenTK.OpenGL.Enums.GetPName)pname, (bool*)@params_ptr);
                }
            }
        }

        public static 
        void GetBoolean(OpenTK.OpenGL.Enums.GetPName pname, [Out] out bool @params)
        {
            unsafe
            {
                fixed (bool* @params_ptr = &@params)
                {
                    Delegates.glGetBooleanv((OpenTK.OpenGL.Enums.GetPName)pname, (bool*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetBoolean(OpenTK.OpenGL.Enums.GetPName pname, [Out] bool* @params)
        {
            Delegates.glGetBooleanv((OpenTK.OpenGL.Enums.GetPName)pname, (bool*)@params);
        }

        public static 
        void GetClipPlane(OpenTK.OpenGL.Enums.ClipPlaneName plane, [Out] Double[] equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = equation)
                {
                    Delegates.glGetClipPlane((OpenTK.OpenGL.Enums.ClipPlaneName)plane, (Double*)equation_ptr);
                }
            }
        }

        public static 
        void GetClipPlane(OpenTK.OpenGL.Enums.ClipPlaneName plane, [Out] out Double equation)
        {
            unsafe
            {
                fixed (Double* equation_ptr = &equation)
                {
                    Delegates.glGetClipPlane((OpenTK.OpenGL.Enums.ClipPlaneName)plane, (Double*)equation_ptr);
                    equation = *equation_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetClipPlane(OpenTK.OpenGL.Enums.ClipPlaneName plane, [Out] Double* equation)
        {
            Delegates.glGetClipPlane((OpenTK.OpenGL.Enums.ClipPlaneName)plane, (Double*)equation);
        }

        public static 
        void GetDouble(OpenTK.OpenGL.Enums.GetPName pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetDoublev((OpenTK.OpenGL.Enums.GetPName)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void GetDouble(OpenTK.OpenGL.Enums.GetPName pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetDoublev((OpenTK.OpenGL.Enums.GetPName)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetDouble(OpenTK.OpenGL.Enums.GetPName pname, [Out] Double* @params)
        {
            Delegates.glGetDoublev((OpenTK.OpenGL.Enums.GetPName)pname, (Double*)@params);
        }

        public static 
        OpenTK.OpenGL.Enums.ErrorCode GetError()
        {
            return Delegates.glGetError();
        }

        public static 
        void GetFloat(OpenTK.OpenGL.Enums.GetPName pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetFloatv((OpenTK.OpenGL.Enums.GetPName)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetFloat(OpenTK.OpenGL.Enums.GetPName pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetFloatv((OpenTK.OpenGL.Enums.GetPName)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetFloat(OpenTK.OpenGL.Enums.GetPName pname, [Out] Single* @params)
        {
            Delegates.glGetFloatv((OpenTK.OpenGL.Enums.GetPName)pname, (Single*)@params);
        }

        public static 
        void GetInteger(OpenTK.OpenGL.Enums.GetPName pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetIntegerv((OpenTK.OpenGL.Enums.GetPName)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetInteger(OpenTK.OpenGL.Enums.GetPName pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetIntegerv((OpenTK.OpenGL.Enums.GetPName)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetInteger(OpenTK.OpenGL.Enums.GetPName pname, [Out] Int32* @params)
        {
            Delegates.glGetIntegerv((OpenTK.OpenGL.Enums.GetPName)pname, (Int32*)@params);
        }

        public static 
        void GetLight(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetLightfv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetLight(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetLightfv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetLight(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, [Out] Single* @params)
        {
            Delegates.glGetLightfv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Single*)@params);
        }

        public static 
        void GetLight(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetLightiv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetLight(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetLightiv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetLight(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter pname, [Out] Int32* @params)
        {
            Delegates.glGetLightiv((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)pname, (Int32*)@params);
        }

        public static 
        void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glGetMapdv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Double*)v_ptr);
                }
            }
        }

        public static 
        void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] out Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glGetMapdv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Double*)v_ptr);
                    v = *v_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] Double* v)
        {
            Delegates.glGetMapdv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Double*)v);
        }

        public static 
        void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glGetMapfv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Single*)v_ptr);
                }
            }
        }

        public static 
        void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] out Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glGetMapfv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Single*)v_ptr);
                    v = *v_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] Single* v)
        {
            Delegates.glGetMapfv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Single*)v);
        }

        public static 
        void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glGetMapiv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] out Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glGetMapiv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Int32*)v_ptr);
                    v = *v_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMap(OpenTK.OpenGL.Enums.MapTarget target, OpenTK.OpenGL.Enums.GetMapQuery query, [Out] Int32* v)
        {
            Delegates.glGetMapiv((OpenTK.OpenGL.Enums.MapTarget)target, (OpenTK.OpenGL.Enums.GetMapQuery)query, (Int32*)v);
        }

        public static 
        void GetMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMaterialfv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMaterialfv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Single* @params)
        {
            Delegates.glGetMaterialfv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params);
        }

        public static 
        void GetMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMaterialiv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMaterialiv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Int32* @params)
        {
            Delegates.glGetMaterialiv((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params);
        }

        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] Single[] values)
        {
            unsafe
            {
                fixed (Single* values_ptr = values)
                {
                    Delegates.glGetPixelMapfv((OpenTK.OpenGL.Enums.PixelMap)map, (Single*)values_ptr);
                }
            }
        }

        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] out Single values)
        {
            unsafe
            {
                fixed (Single* values_ptr = &values)
                {
                    Delegates.glGetPixelMapfv((OpenTK.OpenGL.Enums.PixelMap)map, (Single*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] Single* values)
        {
            Delegates.glGetPixelMapfv((OpenTK.OpenGL.Enums.PixelMap)map, (Single*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] UInt32[] values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = values)
                {
                    Delegates.glGetPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt32*)values_ptr);
                }
            }
        }

        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] Int32[] values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = values)
                {
                    Delegates.glGetPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt32*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] out UInt32 values)
        {
            unsafe
            {
                fixed (UInt32* values_ptr = &values)
                {
                    Delegates.glGetPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt32*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] out Int32 values)
        {
            unsafe
            {
                fixed (Int32* values_ptr = &values)
                {
                    Delegates.glGetPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt32*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] UInt32* values)
        {
            Delegates.glGetPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt32*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] Int32* values)
        {
            Delegates.glGetPixelMapuiv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt32*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] UInt16[] values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = values)
                {
                    Delegates.glGetPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt16*)values_ptr);
                }
            }
        }

        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] Int16[] values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = values)
                {
                    Delegates.glGetPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt16*)values_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] out UInt16 values)
        {
            unsafe
            {
                fixed (UInt16* values_ptr = &values)
                {
                    Delegates.glGetPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt16*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        public static 
        void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] out Int16 values)
        {
            unsafe
            {
                fixed (Int16* values_ptr = &values)
                {
                    Delegates.glGetPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt16*)values_ptr);
                    values = *values_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] UInt16* values)
        {
            Delegates.glGetPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt16*)values);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPixelMap(OpenTK.OpenGL.Enums.PixelMap map, [Out] Int16* values)
        {
            Delegates.glGetPixelMapusv((OpenTK.OpenGL.Enums.PixelMap)map, (UInt16*)values);
        }

        public static 
        void GetPolygonStipple([Out] Byte[] mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = mask)
                {
                    Delegates.glGetPolygonStipple((Byte*)mask_ptr);
                }
            }
        }

        public static 
        void GetPolygonStipple([Out] out Byte mask)
        {
            unsafe
            {
                fixed (Byte* mask_ptr = &mask)
                {
                    Delegates.glGetPolygonStipple((Byte*)mask_ptr);
                    mask = *mask_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetPolygonStipple([Out] Byte* mask)
        {
            Delegates.glGetPolygonStipple((Byte*)mask);
        }

        public static 
        string GetString(OpenTK.OpenGL.Enums.StringName name)
        {
            return System.Runtime.InteropServices.Marshal.PtrToStringAnsi(Delegates.glGetString((OpenTK.OpenGL.Enums.StringName)name));
        }

        public static 
        void GetTexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexEnvfv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexEnvfv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, [Out] Single* @params)
        {
            Delegates.glGetTexEnvfv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Single*)@params);
        }

        public static 
        void GetTexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexEnviv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexEnviv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexEnv(OpenTK.OpenGL.Enums.TextureEnvTarget target, OpenTK.OpenGL.Enums.TextureEnvParameter pname, [Out] Int32* @params)
        {
            Delegates.glGetTexEnviv((OpenTK.OpenGL.Enums.TextureEnvTarget)target, (OpenTK.OpenGL.Enums.TextureEnvParameter)pname, (Int32*)@params);
        }

        public static 
        void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetTexGendv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetTexGendv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] Double* @params)
        {
            Delegates.glGetTexGendv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Double*)@params);
        }

        public static 
        void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexGenfv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexGenfv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] Single* @params)
        {
            Delegates.glGetTexGenfv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Single*)@params);
        }

        public static 
        void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexGeniv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexGeniv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexGen(OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter pname, [Out] Int32* @params)
        {
            Delegates.glGetTexGeniv((OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)pname, (Int32*)@params);
        }

        public static 
        void GetTexImage(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr pixels)
        {
            Delegates.glGetTexImage((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void GetTexImage(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetTexImage((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void GetTexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Single* @params)
        {
            Delegates.glGetTexParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Single*)@params);
        }

        public static 
        void GetTexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexParameter(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Int32* @params)
        {
            Delegates.glGetTexParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Int32*)@params);
        }

        public static 
        void GetTexLevelParameter(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetTexLevelParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexLevelParameter(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetTexLevelParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexLevelParameter(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Single* @params)
        {
            Delegates.glGetTexLevelParameterfv((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Single*)@params);
        }

        public static 
        void GetTexLevelParameter(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetTexLevelParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetTexLevelParameter(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetTexLevelParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetTexLevelParameter(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Int32* @params)
        {
            Delegates.glGetTexLevelParameteriv((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (Int32*)@params);
        }

        public static 
        bool IsEnabled(OpenTK.OpenGL.Enums.EnableCap cap)
        {
            return Delegates.glIsEnabled((OpenTK.OpenGL.Enums.EnableCap)cap);
        }

        [System.CLSCompliant(false)]
        public static 
        bool IsList(UInt32 list)
        {
            return Delegates.glIsList((UInt32)list);
        }

        public static 
        bool IsList(Int32 list)
        {
            return Delegates.glIsList((UInt32)list);
        }

        public static 
        void DepthRange(Double near, Double far)
        {
            Delegates.glDepthRange((Double)near, (Double)far);
        }

        public static 
        void Frustum(Double left, Double right, Double bottom, Double top, Double zNear, Double zFar)
        {
            Delegates.glFrustum((Double)left, (Double)right, (Double)bottom, (Double)top, (Double)zNear, (Double)zFar);
        }

        public static 
        void LoadIdentity()
        {
            Delegates.glLoadIdentity();
        }

        public static 
        void LoadMatrix(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glLoadMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void LoadMatrix(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glLoadMatrixf((Single*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadMatrix(Single* m)
        {
            Delegates.glLoadMatrixf((Single*)m);
        }

        public static 
        void LoadMatrix(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glLoadMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void LoadMatrix(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glLoadMatrixd((Double*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadMatrix(Double* m)
        {
            Delegates.glLoadMatrixd((Double*)m);
        }

        public static 
        void MatrixMode(OpenTK.OpenGL.Enums.MatrixMode mode)
        {
            Delegates.glMatrixMode((OpenTK.OpenGL.Enums.MatrixMode)mode);
        }

        public static 
        void MultMatrix(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glMultMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void MultMatrix(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glMultMatrixf((Single*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultMatrix(Single* m)
        {
            Delegates.glMultMatrixf((Single*)m);
        }

        public static 
        void MultMatrix(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glMultMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void MultMatrix(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glMultMatrixd((Double*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultMatrix(Double* m)
        {
            Delegates.glMultMatrixd((Double*)m);
        }

        public static 
        void Ortho(Double left, Double right, Double bottom, Double top, Double zNear, Double zFar)
        {
            Delegates.glOrtho((Double)left, (Double)right, (Double)bottom, (Double)top, (Double)zNear, (Double)zFar);
        }

        public static 
        void PopMatrix()
        {
            Delegates.glPopMatrix();
        }

        public static 
        void PushMatrix()
        {
            Delegates.glPushMatrix();
        }

        public static 
        void Rotate(Double angle, Double x, Double y, Double z)
        {
            Delegates.glRotated((Double)angle, (Double)x, (Double)y, (Double)z);
        }

        public static 
        void Rotate(Single angle, Single x, Single y, Single z)
        {
            Delegates.glRotatef((Single)angle, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void Scaled(Double x, Double y, Double z)
        {
            Delegates.glScaled((Double)x, (Double)y, (Double)z);
        }

        public static 
        void Scale(Single x, Single y, Single z)
        {
            Delegates.glScalef((Single)x, (Single)y, (Single)z);
        }

        public static 
        void Translate(Double x, Double y, Double z)
        {
            Delegates.glTranslated((Double)x, (Double)y, (Double)z);
        }

        public static 
        void Translate(Single x, Single y, Single z)
        {
            Delegates.glTranslatef((Single)x, (Single)y, (Single)z);
        }

        public static 
        void Viewport(Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glViewport((Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void ArrayElement(Int32 i)
        {
            Delegates.glArrayElement((Int32)i);
        }

        public static 
        void ColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, IntPtr pointer)
        {
            Delegates.glColorPointer((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void ColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glColorPointer((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void DisableClientState(OpenTK.OpenGL.Enums.EnableCap array)
        {
            Delegates.glDisableClientState((OpenTK.OpenGL.Enums.EnableCap)array);
        }

        public static 
        void DrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, Int32 first, Int32 count)
        {
            Delegates.glDrawArrays((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)first, (Int32)count);
        }

        public static 
        void DrawElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32 count, OpenTK.OpenGL.Enums.All type, IntPtr indices)
        {
            Delegates.glDrawElements((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)count, (OpenTK.OpenGL.Enums.All)type, (IntPtr)indices);
        }

        public static 
        void DrawElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32 count, OpenTK.OpenGL.Enums.All type, [In, Out] object indices)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glDrawElements((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)count, (OpenTK.OpenGL.Enums.All)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
            }
            finally
            {
                indices_ptr.Free();
            }
        }

        public static 
        void EdgeFlagPointer(Int32 stride, IntPtr pointer)
        {
            Delegates.glEdgeFlagPointer((Int32)stride, (IntPtr)pointer);
        }

        public static 
        void EdgeFlagPointer(Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glEdgeFlagPointer((Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void EnableClientState(OpenTK.OpenGL.Enums.EnableCap array)
        {
            Delegates.glEnableClientState((OpenTK.OpenGL.Enums.EnableCap)array);
        }

        public static 
        void GetPointer(OpenTK.OpenGL.Enums.GetPointervPName pname, [Out] IntPtr @params)
        {
            Delegates.glGetPointerv((OpenTK.OpenGL.Enums.GetPointervPName)pname, (IntPtr)@params);
        }

        public static 
        void GetPointer(OpenTK.OpenGL.Enums.GetPointervPName pname, [In, Out] object @params)
        {
            System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetPointerv((OpenTK.OpenGL.Enums.GetPointervPName)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
            }
            finally
            {
                @params_ptr.Free();
            }
        }

        public static 
        void IndexPointer(OpenTK.OpenGL.Enums.IndexPointerType type, Int32 stride, IntPtr pointer)
        {
            Delegates.glIndexPointer((OpenTK.OpenGL.Enums.IndexPointerType)type, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void IndexPointer(OpenTK.OpenGL.Enums.IndexPointerType type, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glIndexPointer((OpenTK.OpenGL.Enums.IndexPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void InterleavedArrays(OpenTK.OpenGL.Enums.InterleavedArrayFormat format, Int32 stride, IntPtr pointer)
        {
            Delegates.glInterleavedArrays((OpenTK.OpenGL.Enums.InterleavedArrayFormat)format, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void InterleavedArrays(OpenTK.OpenGL.Enums.InterleavedArrayFormat format, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glInterleavedArrays((OpenTK.OpenGL.Enums.InterleavedArrayFormat)format, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void NormalPointer(OpenTK.OpenGL.Enums.NormalPointerType type, Int32 stride, IntPtr pointer)
        {
            Delegates.glNormalPointer((OpenTK.OpenGL.Enums.NormalPointerType)type, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void NormalPointer(OpenTK.OpenGL.Enums.NormalPointerType type, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glNormalPointer((OpenTK.OpenGL.Enums.NormalPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void TexCoordPointer(Int32 size, OpenTK.OpenGL.Enums.TexCoordPointerType type, Int32 stride, IntPtr pointer)
        {
            Delegates.glTexCoordPointer((Int32)size, (OpenTK.OpenGL.Enums.TexCoordPointerType)type, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void TexCoordPointer(Int32 size, OpenTK.OpenGL.Enums.TexCoordPointerType type, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glTexCoordPointer((Int32)size, (OpenTK.OpenGL.Enums.TexCoordPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void VertexPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, Int32 stride, IntPtr pointer)
        {
            Delegates.glVertexPointer((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void VertexPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glVertexPointer((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void PolygonOffset(Single factor, Single units)
        {
            Delegates.glPolygonOffset((Single)factor, (Single)units);
        }

        public static 
        void CopyTexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
        {
            Delegates.glCopyTexImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)border);
        }

        public static 
        void CopyTexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
        {
            Delegates.glCopyTexImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height, (Int32)border);
        }

        public static 
        void CopyTexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyTexSubImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void CopyTexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyTexSubImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void TexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
        {
            Delegates.glTexSubImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void TexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glTexSubImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void TexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
        {
            Delegates.glTexSubImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void TexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glTexSubImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        [System.CLSCompliant(false)]
        public static 
        bool AreTexturesResident(Int32 n, UInt32[] textures, [Out] bool[] residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (bool* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                }
            }
        }

        public static 
        bool AreTexturesResident(Int32 n, Int32[] textures, [Out] bool[] residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (bool* residences_ptr = residences)
                {
                    return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        bool AreTexturesResident(Int32 n, ref UInt32 textures, [Out] out bool residences)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (bool* residences_ptr = &residences)
                {
                    bool retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        public static 
        bool AreTexturesResident(Int32 n, ref Int32 textures, [Out] out bool residences)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (bool* residences_ptr = &residences)
                {
                    bool retval = Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                    residences = *residences_ptr;
                    return retval;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe bool AreTexturesResident(Int32 n, UInt32* textures, [Out] bool* residences)
        {
            return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures, (bool*)residences);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe bool AreTexturesResident(Int32 n, Int32* textures, [Out] bool* residences)
        {
            return Delegates.glAreTexturesResident((Int32)n, (UInt32*)textures, (bool*)residences);
        }

        [System.CLSCompliant(false)]
        public static 
        void BindTexture(OpenTK.OpenGL.Enums.TextureTarget target, UInt32 texture)
        {
            Delegates.glBindTexture((OpenTK.OpenGL.Enums.TextureTarget)target, (UInt32)texture);
        }

        public static 
        void BindTexture(OpenTK.OpenGL.Enums.TextureTarget target, Int32 texture)
        {
            Delegates.glBindTexture((OpenTK.OpenGL.Enums.TextureTarget)target, (UInt32)texture);
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteTextures(Int32 n, UInt32[] textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void DeleteTextures(Int32 n, Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteTextures(Int32 n, ref UInt32 textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void DeleteTextures(Int32 n, ref Int32 textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glDeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteTextures(Int32 n, UInt32* textures)
        {
            Delegates.glDeleteTextures((Int32)n, (UInt32*)textures);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteTextures(Int32 n, Int32* textures)
        {
            Delegates.glDeleteTextures((Int32)n, (UInt32*)textures);
        }

        [System.CLSCompliant(false)]
        public static 
        void GenTextures(Int32 n, [Out] UInt32[] textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        public static 
        void GenTextures(Int32 n, [Out] Int32[] textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GenTextures(Int32 n, [Out] out UInt32 textures)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }

        public static 
        void GenTextures(Int32 n, [Out] out Int32 textures)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Delegates.glGenTextures((Int32)n, (UInt32*)textures_ptr);
                    textures = *textures_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GenTextures(Int32 n, [Out] UInt32* textures)
        {
            Delegates.glGenTextures((Int32)n, (UInt32*)textures);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GenTextures(Int32 n, [Out] Int32* textures)
        {
            Delegates.glGenTextures((Int32)n, (UInt32*)textures);
        }

        [System.CLSCompliant(false)]
        public static 
        bool IsTexture(UInt32 texture)
        {
            return Delegates.glIsTexture((UInt32)texture);
        }

        public static 
        bool IsTexture(Int32 texture)
        {
            return Delegates.glIsTexture((UInt32)texture);
        }

        [System.CLSCompliant(false)]
        public static 
        void PrioritizeTextures(Int32 n, UInt32[] textures, Single[] priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void PrioritizeTextures(Int32 n, Int32[] textures, Single[] priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                fixed (Single* priorities_ptr = priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void PrioritizeTextures(Int32 n, ref UInt32 textures, ref Single priorities)
        {
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        public static 
        void PrioritizeTextures(Int32 n, ref Int32 textures, ref Single priorities)
        {
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                fixed (Single* priorities_ptr = &priorities)
                {
                    Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(Int32 n, UInt32* textures, Single* priorities)
        {
            Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PrioritizeTextures(Int32 n, Int32* textures, Single* priorities)
        {
            Delegates.glPrioritizeTextures((Int32)n, (UInt32*)textures, (Single*)priorities);
        }

        public static 
        void Index(Byte c)
        {
            Delegates.glIndexub((Byte)c);
        }

        public static 
        void Indexv(Byte[] c)
        {
            unsafe
            {
                fixed (Byte* c_ptr = c)
                {
                    Delegates.glIndexubv((Byte*)c_ptr);
                }
            }
        }

        public static 
        void Indexv(ref Byte c)
        {
            unsafe
            {
                fixed (Byte* c_ptr = &c)
                {
                    Delegates.glIndexubv((Byte*)c_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Indexv(Byte* c)
        {
            Delegates.glIndexubv((Byte*)c);
        }

        public static 
        void PopClientAttrib()
        {
            Delegates.glPopClientAttrib();
        }

        public static 
        void PushClientAttrib(OpenTK.OpenGL.Enums.ClientAttribMask mask)
        {
            Delegates.glPushClientAttrib((OpenTK.OpenGL.Enums.ClientAttribMask)mask);
        }

        public static 
        void BlendColor(Single red, Single green, Single blue, Single alpha)
        {
            Delegates.glBlendColor((Single)red, (Single)green, (Single)blue, (Single)alpha);
        }

        public static 
        void BlendEquation(OpenTK.OpenGL.Enums.Version12 mode)
        {
            Delegates.glBlendEquation((OpenTK.OpenGL.Enums.Version12)mode);
        }

        [System.CLSCompliant(false)]
        public static 
        void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count, OpenTK.OpenGL.Enums.Version12 type, IntPtr indices)
        {
            Delegates.glDrawRangeElements((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.Version12)type, (IntPtr)indices);
        }

        public static 
        void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, OpenTK.OpenGL.Enums.Version12 type, IntPtr indices)
        {
            Delegates.glDrawRangeElements((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.Version12)type, (IntPtr)indices);
        }

        [System.CLSCompliant(false)]
        public static 
        void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count, OpenTK.OpenGL.Enums.Version12 type, [In, Out] object indices)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glDrawRangeElements((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.Version12)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
            }
            finally
            {
                indices_ptr.Free();
            }
        }

        public static 
        void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, OpenTK.OpenGL.Enums.Version12 type, [In, Out] object indices)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glDrawRangeElements((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.Version12)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
            }
            finally
            {
                indices_ptr.Free();
            }
        }

        public static 
        void ColorTable(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr table)
        {
            Delegates.glColorTable((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table);
        }

        public static 
        void ColorTable(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object table)
        {
            System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glColorTable((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table_ptr.AddrOfPinnedObject());
            }
            finally
            {
                table_ptr.Free();
            }
        }

        public static 
        void ColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glColorTableParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void ColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Single* @params)
        {
            Delegates.glColorTableParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params);
        }

        public static 
        void ColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glColorTableParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void ColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glColorTableParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void ColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Int32* @params)
        {
            Delegates.glColorTableParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params);
        }

        public static 
        void CopyColorTable(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyColorTable((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void GetColorTable(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr table)
        {
            Delegates.glGetColorTable((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table);
        }

        public static 
        void GetColorTable(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object table)
        {
            System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetColorTable((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table_ptr.AddrOfPinnedObject());
            }
            finally
            {
                table_ptr.Free();
            }
        }

        public static 
        void GetColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single* @params)
        {
            Delegates.glGetColorTableParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params);
        }

        public static 
        void GetColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetColorTableParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetColorTableParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetColorTableParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32* @params)
        {
            Delegates.glGetColorTableParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params);
        }

        public static 
        void ColorSubTable(OpenTK.OpenGL.Enums.Version12 target, Int32 start, Int32 count, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr data)
        {
            Delegates.glColorSubTable((OpenTK.OpenGL.Enums.Version12)target, (Int32)start, (Int32)count, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)data);
        }

        public static 
        void ColorSubTable(OpenTK.OpenGL.Enums.Version12 target, Int32 start, Int32 count, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glColorSubTable((OpenTK.OpenGL.Enums.Version12)target, (Int32)start, (Int32)count, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void CopyColorSubTable(OpenTK.OpenGL.Enums.Version12 target, Int32 start, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyColorSubTable((OpenTK.OpenGL.Enums.Version12)target, (Int32)start, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void ConvolutionFilter1D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr image)
        {
            Delegates.glConvolutionFilter1D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image);
        }

        public static 
        void ConvolutionFilter1D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object image)
        {
            System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glConvolutionFilter1D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image_ptr.AddrOfPinnedObject());
            }
            finally
            {
                image_ptr.Free();
            }
        }

        public static 
        void ConvolutionFilter2D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr image)
        {
            Delegates.glConvolutionFilter2D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image);
        }

        public static 
        void ConvolutionFilter2D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object image)
        {
            System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glConvolutionFilter2D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image_ptr.AddrOfPinnedObject());
            }
            finally
            {
                image_ptr.Free();
            }
        }

        public static 
        void ConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Single @params)
        {
            Delegates.glConvolutionParameterf((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single)@params);
        }

        public static 
        void ConvolutionParameterv(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void ConvolutionParameterv(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void ConvolutionParameterv(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Single* @params)
        {
            Delegates.glConvolutionParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params);
        }

        public static 
        void ConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Int32 @params)
        {
            Delegates.glConvolutionParameteri((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32)@params);
        }

        public static 
        void ConvolutionParameterv(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glConvolutionParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void ConvolutionParameterv(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glConvolutionParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void ConvolutionParameterv(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, Int32* @params)
        {
            Delegates.glConvolutionParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params);
        }

        public static 
        void CopyConvolutionFilter1D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
        {
            Delegates.glCopyConvolutionFilter1D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
        }

        public static 
        void CopyConvolutionFilter2D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyConvolutionFilter2D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void GetConvolutionFilter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr image)
        {
            Delegates.glGetConvolutionFilter((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image);
        }

        public static 
        void GetConvolutionFilter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object image)
        {
            System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetConvolutionFilter((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image_ptr.AddrOfPinnedObject());
            }
            finally
            {
                image_ptr.Free();
            }
        }

        public static 
        void GetConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single* @params)
        {
            Delegates.glGetConvolutionParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params);
        }

        public static 
        void GetConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetConvolutionParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetConvolutionParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetConvolutionParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32* @params)
        {
            Delegates.glGetConvolutionParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params);
        }

        public static 
        void GetSeparableFilter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr row, [Out] IntPtr column, [Out] IntPtr span)
        {
            Delegates.glGetSeparableFilter((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row, (IntPtr)column, (IntPtr)span);
        }

        public static 
        void GetSeparableFilter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object row, [In, Out] object column, [In, Out] object span)
        {
            System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
            System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
            System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetSeparableFilter((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
            }
            finally
            {
                row_ptr.Free();
                column_ptr.Free();
                span_ptr.Free();
            }
        }

        public static 
        void GetSeparableFilter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr row, [In, Out] object column, [In, Out] object span)
        {
            System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
            System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetSeparableFilter((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
            }
            finally
            {
                column_ptr.Free();
                span_ptr.Free();
            }
        }

        public static 
        void SeparableFilter2D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr row, IntPtr column)
        {
            Delegates.glSeparableFilter2D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row, (IntPtr)column);
        }

        public static 
        void SeparableFilter2D(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object row, [In, Out] object column)
        {
            System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
            System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glSeparableFilter2D((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject());
            }
            finally
            {
                row_ptr.Free();
                column_ptr.Free();
            }
        }

        public static 
        void GetHistogram(OpenTK.OpenGL.Enums.Version12 target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr values)
        {
            Delegates.glGetHistogram((OpenTK.OpenGL.Enums.Version12)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values);
        }

        public static 
        void GetHistogram(OpenTK.OpenGL.Enums.Version12 target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object values)
        {
            System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetHistogram((OpenTK.OpenGL.Enums.Version12)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values_ptr.AddrOfPinnedObject());
            }
            finally
            {
                values_ptr.Free();
            }
        }

        public static 
        void GetHistogramParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetHistogramParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetHistogramParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single* @params)
        {
            Delegates.glGetHistogramParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params);
        }

        public static 
        void GetHistogramParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetHistogramParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetHistogramParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetHistogramParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetHistogramParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32* @params)
        {
            Delegates.glGetHistogramParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params);
        }

        public static 
        void GetMinmax(OpenTK.OpenGL.Enums.Version12 target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr values)
        {
            Delegates.glGetMinmax((OpenTK.OpenGL.Enums.Version12)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values);
        }

        public static 
        void GetMinmax(OpenTK.OpenGL.Enums.Version12 target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object values)
        {
            System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetMinmax((OpenTK.OpenGL.Enums.Version12)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values_ptr.AddrOfPinnedObject());
            }
            finally
            {
                values_ptr.Free();
            }
        }

        public static 
        void GetMinmaxParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetMinmaxParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMinmaxParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Single* @params)
        {
            Delegates.glGetMinmaxParameterfv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Single*)@params);
        }

        public static 
        void GetMinmaxParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetMinmaxParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetMinmaxParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetMinmaxParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetMinmaxParameter(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.Version12 pname, [Out] Int32* @params)
        {
            Delegates.glGetMinmaxParameteriv((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.Version12)pname, (Int32*)@params);
        }

        public static 
        void Histogram(OpenTK.OpenGL.Enums.Version12 target, Int32 width, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, bool sink)
        {
            Delegates.glHistogram((OpenTK.OpenGL.Enums.Version12)target, (Int32)width, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (bool)sink);
        }

        public static 
        void Minmax(OpenTK.OpenGL.Enums.Version12 target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, bool sink)
        {
            Delegates.glMinmax((OpenTK.OpenGL.Enums.Version12)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (bool)sink);
        }

        public static 
        void ResetHistogram(OpenTK.OpenGL.Enums.Version12 target)
        {
            Delegates.glResetHistogram((OpenTK.OpenGL.Enums.Version12)target);
        }

        public static 
        void ResetMinmax(OpenTK.OpenGL.Enums.Version12 target)
        {
            Delegates.glResetMinmax((OpenTK.OpenGL.Enums.Version12)target);
        }

        public static 
        void TexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
        {
            Delegates.glTexImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void TexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glTexImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void TexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
        {
            Delegates.glTexSubImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
        }

        public static 
        void TexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
        {
            System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glTexSubImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
        }

        public static 
        void CopyTexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            Delegates.glCopyTexSubImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
        }

        public static 
        void ActiveTexture(OpenTK.OpenGL.Enums.Version13 texture)
        {
            Delegates.glActiveTexture((OpenTK.OpenGL.Enums.Version13)texture);
        }

        public static 
        void ClientActiveTexture(OpenTK.OpenGL.Enums.Version13 texture)
        {
            Delegates.glClientActiveTexture((OpenTK.OpenGL.Enums.Version13)texture);
        }

        public static 
        void MultiTexCoord1(OpenTK.OpenGL.Enums.Version13 target, Double s)
        {
            Delegates.glMultiTexCoord1d((OpenTK.OpenGL.Enums.Version13)target, (Double)s);
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Double* v)
        {
            Delegates.glMultiTexCoord1dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v);
        }

        public static 
        void MultiTexCoord1(OpenTK.OpenGL.Enums.Version13 target, Single s)
        {
            Delegates.glMultiTexCoord1f((OpenTK.OpenGL.Enums.Version13)target, (Single)s);
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Single* v)
        {
            Delegates.glMultiTexCoord1fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v);
        }

        public static 
        void MultiTexCoord1(OpenTK.OpenGL.Enums.Version13 target, Int32 s)
        {
            Delegates.glMultiTexCoord1i((OpenTK.OpenGL.Enums.Version13)target, (Int32)s);
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Int32* v)
        {
            Delegates.glMultiTexCoord1iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v);
        }

        public static 
        void MultiTexCoord1(OpenTK.OpenGL.Enums.Version13 target, Int16 s)
        {
            Delegates.glMultiTexCoord1s((OpenTK.OpenGL.Enums.Version13)target, (Int16)s);
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord1sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord1sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.Version13 target, Int16* v)
        {
            Delegates.glMultiTexCoord1sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Double s, Double t)
        {
            Delegates.glMultiTexCoord2d((OpenTK.OpenGL.Enums.Version13)target, (Double)s, (Double)t);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Double* v)
        {
            Delegates.glMultiTexCoord2dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Single s, Single t)
        {
            Delegates.glMultiTexCoord2f((OpenTK.OpenGL.Enums.Version13)target, (Single)s, (Single)t);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Single* v)
        {
            Delegates.glMultiTexCoord2fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Int32 s, Int32 t)
        {
            Delegates.glMultiTexCoord2i((OpenTK.OpenGL.Enums.Version13)target, (Int32)s, (Int32)t);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Int32* v)
        {
            Delegates.glMultiTexCoord2iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Int16 s, Int16 t)
        {
            Delegates.glMultiTexCoord2s((OpenTK.OpenGL.Enums.Version13)target, (Int16)s, (Int16)t);
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord2sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord2sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.Version13 target, Int16* v)
        {
            Delegates.glMultiTexCoord2sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Double s, Double t, Double r)
        {
            Delegates.glMultiTexCoord3d((OpenTK.OpenGL.Enums.Version13)target, (Double)s, (Double)t, (Double)r);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Double* v)
        {
            Delegates.glMultiTexCoord3dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Single s, Single t, Single r)
        {
            Delegates.glMultiTexCoord3f((OpenTK.OpenGL.Enums.Version13)target, (Single)s, (Single)t, (Single)r);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Single* v)
        {
            Delegates.glMultiTexCoord3fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Int32 s, Int32 t, Int32 r)
        {
            Delegates.glMultiTexCoord3i((OpenTK.OpenGL.Enums.Version13)target, (Int32)s, (Int32)t, (Int32)r);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Int32* v)
        {
            Delegates.glMultiTexCoord3iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Int16 s, Int16 t, Int16 r)
        {
            Delegates.glMultiTexCoord3s((OpenTK.OpenGL.Enums.Version13)target, (Int16)s, (Int16)t, (Int16)r);
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord3sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord3sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.Version13 target, Int16* v)
        {
            Delegates.glMultiTexCoord3sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Double s, Double t, Double r, Double q)
        {
            Delegates.glMultiTexCoord4d((OpenTK.OpenGL.Enums.Version13)target, (Double)s, (Double)t, (Double)r, (Double)q);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Double* v)
        {
            Delegates.glMultiTexCoord4dv((OpenTK.OpenGL.Enums.Version13)target, (Double*)v);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Single s, Single t, Single r, Single q)
        {
            Delegates.glMultiTexCoord4f((OpenTK.OpenGL.Enums.Version13)target, (Single)s, (Single)t, (Single)r, (Single)q);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Single* v)
        {
            Delegates.glMultiTexCoord4fv((OpenTK.OpenGL.Enums.Version13)target, (Single*)v);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Int32 s, Int32 t, Int32 r, Int32 q)
        {
            Delegates.glMultiTexCoord4i((OpenTK.OpenGL.Enums.Version13)target, (Int32)s, (Int32)t, (Int32)r, (Int32)q);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Int32* v)
        {
            Delegates.glMultiTexCoord4iv((OpenTK.OpenGL.Enums.Version13)target, (Int32*)v);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Int16 s, Int16 t, Int16 r, Int16 q)
        {
            Delegates.glMultiTexCoord4s((OpenTK.OpenGL.Enums.Version13)target, (Int16)s, (Int16)t, (Int16)r, (Int16)q);
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glMultiTexCoord4sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glMultiTexCoord4sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.Version13 target, Int16* v)
        {
            Delegates.glMultiTexCoord4sv((OpenTK.OpenGL.Enums.Version13)target, (Int16*)v);
        }

        public static 
        void LoadTransposeMatrix(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void LoadTransposeMatrix(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadTransposeMatrix(Single* m)
        {
            Delegates.glLoadTransposeMatrixf((Single*)m);
        }

        public static 
        void LoadTransposeMatrix(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glLoadTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void LoadTransposeMatrix(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glLoadTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void LoadTransposeMatrix(Double* m)
        {
            Delegates.glLoadTransposeMatrixd((Double*)m);
        }

        public static 
        void MultTransposeMatrix(Single[] m)
        {
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        public static 
        void MultTransposeMatrix(ref Single m)
        {
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixf((Single*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultTransposeMatrix(Single* m)
        {
            Delegates.glMultTransposeMatrixf((Single*)m);
        }

        public static 
        void MultTransposeMatrix(Double[] m)
        {
            unsafe
            {
                fixed (Double* m_ptr = m)
                {
                    Delegates.glMultTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        public static 
        void MultTransposeMatrix(ref Double m)
        {
            unsafe
            {
                fixed (Double* m_ptr = &m)
                {
                    Delegates.glMultTransposeMatrixd((Double*)m_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultTransposeMatrix(Double* m)
        {
            Delegates.glMultTransposeMatrixd((Double*)m);
        }

        public static 
        void SampleCoverage(Single value, bool invert)
        {
            Delegates.glSampleCoverage((Single)value, (bool)invert);
        }

        public static 
        void CompressedTexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr data)
        {
            Delegates.glCompressedTexImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data);
        }

        public static 
        void CompressedTexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glCompressedTexImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void CompressedTexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr data)
        {
            Delegates.glCompressedTexImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data);
        }

        public static 
        void CompressedTexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glCompressedTexImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void CompressedTexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr data)
        {
            Delegates.glCompressedTexImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data);
        }

        public static 
        void CompressedTexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glCompressedTexImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void CompressedTexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, IntPtr data)
        {
            Delegates.glCompressedTexSubImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data);
        }

        public static 
        void CompressedTexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glCompressedTexSubImage3D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void CompressedTexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, IntPtr data)
        {
            Delegates.glCompressedTexSubImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data);
        }

        public static 
        void CompressedTexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glCompressedTexSubImage2D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void CompressedTexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, IntPtr data)
        {
            Delegates.glCompressedTexSubImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data);
        }

        public static 
        void CompressedTexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glCompressedTexSubImage1D((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void GetCompressedTexImage(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, [Out] IntPtr img)
        {
            Delegates.glGetCompressedTexImage((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (IntPtr)img);
        }

        public static 
        void GetCompressedTexImage(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, [In, Out] object img)
        {
            System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetCompressedTexImage((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (IntPtr)img_ptr.AddrOfPinnedObject());
            }
            finally
            {
                img_ptr.Free();
            }
        }

        public static 
        void BlendFuncSeparate(OpenTK.OpenGL.Enums.Version14 sfactorRGB, OpenTK.OpenGL.Enums.Version14 dfactorRGB, OpenTK.OpenGL.Enums.Version14 sfactorAlpha, OpenTK.OpenGL.Enums.Version14 dfactorAlpha)
        {
            Delegates.glBlendFuncSeparate((OpenTK.OpenGL.Enums.Version14)sfactorRGB, (OpenTK.OpenGL.Enums.Version14)dfactorRGB, (OpenTK.OpenGL.Enums.Version14)sfactorAlpha, (OpenTK.OpenGL.Enums.Version14)dfactorAlpha);
        }

        public static 
        void FogCoord(Single coord)
        {
            Delegates.glFogCoordf((Single)coord);
        }

        public static 
        void FogCoordv(Single[] coord)
        {
            unsafe
            {
                fixed (Single* coord_ptr = coord)
                {
                    Delegates.glFogCoordfv((Single*)coord_ptr);
                }
            }
        }

        public static 
        void FogCoordv(ref Single coord)
        {
            unsafe
            {
                fixed (Single* coord_ptr = &coord)
                {
                    Delegates.glFogCoordfv((Single*)coord_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void FogCoordv(Single* coord)
        {
            Delegates.glFogCoordfv((Single*)coord);
        }

        public static 
        void FogCoord(Double coord)
        {
            Delegates.glFogCoordd((Double)coord);
        }

        public static 
        void FogCoordv(Double[] coord)
        {
            unsafe
            {
                fixed (Double* coord_ptr = coord)
                {
                    Delegates.glFogCoorddv((Double*)coord_ptr);
                }
            }
        }

        public static 
        void FogCoordv(ref Double coord)
        {
            unsafe
            {
                fixed (Double* coord_ptr = &coord)
                {
                    Delegates.glFogCoorddv((Double*)coord_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void FogCoordv(Double* coord)
        {
            Delegates.glFogCoorddv((Double*)coord);
        }

        public static 
        void FogCoordPointer(OpenTK.OpenGL.Enums.Version14 type, Int32 stride, IntPtr pointer)
        {
            Delegates.glFogCoordPointer((OpenTK.OpenGL.Enums.Version14)type, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void FogCoordPointer(OpenTK.OpenGL.Enums.Version14 type, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glFogCoordPointer((OpenTK.OpenGL.Enums.Version14)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void MultiDrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, [Out] Int32[] first, [Out] Int32[] count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = first)
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawArrays((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                }
            }
        }

        public static 
        void MultiDrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, [Out] out Int32 first, [Out] out Int32 count, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* first_ptr = &first)
                fixed (Int32* count_ptr = &count)
                {
                    Delegates.glMultiDrawArrays((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    first = *first_ptr;
                    count = *count_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, [Out] Int32* first, [Out] Int32* count, Int32 primcount)
        {
            Delegates.glMultiDrawArrays((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count, (Int32)primcount);
        }

        public static 
        void MultiDrawElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32[] count, OpenTK.OpenGL.Enums.Version14 type, IntPtr indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                {
                    Delegates.glMultiDrawElements((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)count_ptr, (OpenTK.OpenGL.Enums.Version14)type, (IntPtr)indices, (Int32)primcount);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void MultiDrawElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32* count, OpenTK.OpenGL.Enums.Version14 type, [In, Out] object indices, Int32 primcount)
        {
            System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glMultiDrawElements((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)count, (OpenTK.OpenGL.Enums.Version14)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
            }
            finally
            {
                indices_ptr.Free();
            }
        }

        public static 
        void MultiDrawElements(OpenTK.OpenGL.Enums.BeginMode mode, ref Int32 count, OpenTK.OpenGL.Enums.Version14 type, [In, Out] object indices, Int32 primcount)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                {
                    System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                    try
                    {
                        Delegates.glMultiDrawElements((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)count_ptr, (OpenTK.OpenGL.Enums.Version14)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                    }
                    finally
                    {
                        indices_ptr.Free();
                    }
                }
            }
        }

        public static 
        void PointParameter(OpenTK.OpenGL.Enums.Version14 pname, Single param)
        {
            Delegates.glPointParameterf((OpenTK.OpenGL.Enums.Version14)pname, (Single)param);
        }

        public static 
        void PointParameterv(OpenTK.OpenGL.Enums.Version14 pname, Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glPointParameterfv((OpenTK.OpenGL.Enums.Version14)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void PointParameterv(OpenTK.OpenGL.Enums.Version14 pname, ref Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glPointParameterfv((OpenTK.OpenGL.Enums.Version14)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PointParameterv(OpenTK.OpenGL.Enums.Version14 pname, Single* @params)
        {
            Delegates.glPointParameterfv((OpenTK.OpenGL.Enums.Version14)pname, (Single*)@params);
        }

        public static 
        void PointParameter(OpenTK.OpenGL.Enums.Version14 pname, Int32 param)
        {
            Delegates.glPointParameteri((OpenTK.OpenGL.Enums.Version14)pname, (Int32)param);
        }

        public static 
        void PointParameterv(OpenTK.OpenGL.Enums.Version14 pname, Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glPointParameteriv((OpenTK.OpenGL.Enums.Version14)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void PointParameterv(OpenTK.OpenGL.Enums.Version14 pname, ref Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glPointParameteriv((OpenTK.OpenGL.Enums.Version14)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void PointParameterv(OpenTK.OpenGL.Enums.Version14 pname, Int32* @params)
        {
            Delegates.glPointParameteriv((OpenTK.OpenGL.Enums.Version14)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(SByte red, SByte green, SByte blue)
        {
            Delegates.glSecondaryColor3b((SByte)red, (SByte)green, (SByte)blue);
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3bv((SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(SByte* v)
        {
            Delegates.glSecondaryColor3bv((SByte*)v);
        }

        public static 
        void SecondaryColor3(Double red, Double green, Double blue)
        {
            Delegates.glSecondaryColor3d((Double)red, (Double)green, (Double)blue);
        }

        public static 
        void SecondaryColor3(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glSecondaryColor3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void SecondaryColor3(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(Double* v)
        {
            Delegates.glSecondaryColor3dv((Double*)v);
        }

        public static 
        void SecondaryColor3(Single red, Single green, Single blue)
        {
            Delegates.glSecondaryColor3f((Single)red, (Single)green, (Single)blue);
        }

        public static 
        void SecondaryColor3(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glSecondaryColor3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void SecondaryColor3(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(Single* v)
        {
            Delegates.glSecondaryColor3fv((Single*)v);
        }

        public static 
        void SecondaryColor3(Byte red, Byte green, Byte blue)
        {
            Delegates.glSecondaryColor3ub((Byte)red, (Byte)green, (Byte)blue);
        }

        public static 
        void SecondaryColor3(Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glSecondaryColor3ubv((Byte*)v_ptr);
                }
            }
        }

        public static 
        void SecondaryColor3(ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3ubv((Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(Byte* v)
        {
            Delegates.glSecondaryColor3ubv((Byte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(UInt32 red, UInt32 green, UInt32 blue)
        {
            Delegates.glSecondaryColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        public static 
        void SecondaryColor3(Int32 red, Int32 green, Int32 blue)
        {
            Delegates.glSecondaryColor3ui((UInt32)red, (UInt32)green, (UInt32)blue);
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void SecondaryColor3(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        public static 
        void SecondaryColor3(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3uiv((UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(UInt32* v)
        {
            Delegates.glSecondaryColor3uiv((UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(Int32* v)
        {
            Delegates.glSecondaryColor3uiv((UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(UInt16 red, UInt16 green, UInt16 blue)
        {
            Delegates.glSecondaryColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        public static 
        void SecondaryColor3(Int16 red, Int16 green, Int16 blue)
        {
            Delegates.glSecondaryColor3us((UInt16)red, (UInt16)green, (UInt16)blue);
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void SecondaryColor3(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void SecondaryColor3(ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        public static 
        void SecondaryColor3(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glSecondaryColor3usv((UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(UInt16* v)
        {
            Delegates.glSecondaryColor3usv((UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void SecondaryColor3(Int16* v)
        {
            Delegates.glSecondaryColor3usv((UInt16*)v);
        }

        public static 
        void SecondaryColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, IntPtr pointer)
        {
            Delegates.glSecondaryColorPointer((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void SecondaryColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glSecondaryColorPointer((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void WindowPos2(Double x, Double y)
        {
            Delegates.glWindowPos2d((Double)x, (Double)y);
        }

        public static 
        void WindowPos2(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos2dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos2(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos2dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2(Double* v)
        {
            Delegates.glWindowPos2dv((Double*)v);
        }

        public static 
        void WindowPos2(Single x, Single y)
        {
            Delegates.glWindowPos2f((Single)x, (Single)y);
        }

        public static 
        void WindowPos2(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos2fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos2(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos2fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2(Single* v)
        {
            Delegates.glWindowPos2fv((Single*)v);
        }

        public static 
        void WindowPos2(Int32 x, Int32 y)
        {
            Delegates.glWindowPos2i((Int32)x, (Int32)y);
        }

        public static 
        void WindowPos2(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos2iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos2(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos2iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2(Int32* v)
        {
            Delegates.glWindowPos2iv((Int32*)v);
        }

        public static 
        void WindowPos2(Int16 x, Int16 y)
        {
            Delegates.glWindowPos2s((Int16)x, (Int16)y);
        }

        public static 
        void WindowPos2(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos2sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos2(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos2sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos2(Int16* v)
        {
            Delegates.glWindowPos2sv((Int16*)v);
        }

        public static 
        void WindowPos3(Double x, Double y, Double z)
        {
            Delegates.glWindowPos3d((Double)x, (Double)y, (Double)z);
        }

        public static 
        void WindowPos3(Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glWindowPos3dv((Double*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos3(ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glWindowPos3dv((Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3(Double* v)
        {
            Delegates.glWindowPos3dv((Double*)v);
        }

        public static 
        void WindowPos3(Single x, Single y, Single z)
        {
            Delegates.glWindowPos3f((Single)x, (Single)y, (Single)z);
        }

        public static 
        void WindowPos3(Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glWindowPos3fv((Single*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos3(ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glWindowPos3fv((Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3(Single* v)
        {
            Delegates.glWindowPos3fv((Single*)v);
        }

        public static 
        void WindowPos3(Int32 x, Int32 y, Int32 z)
        {
            Delegates.glWindowPos3i((Int32)x, (Int32)y, (Int32)z);
        }

        public static 
        void WindowPos3(Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glWindowPos3iv((Int32*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos3(ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glWindowPos3iv((Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3(Int32* v)
        {
            Delegates.glWindowPos3iv((Int32*)v);
        }

        public static 
        void WindowPos3(Int16 x, Int16 y, Int16 z)
        {
            Delegates.glWindowPos3s((Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void WindowPos3(Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glWindowPos3sv((Int16*)v_ptr);
                }
            }
        }

        public static 
        void WindowPos3(ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glWindowPos3sv((Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void WindowPos3(Int16* v)
        {
            Delegates.glWindowPos3sv((Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void GenQueries(Int32 n, [Out] UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void GenQueries(Int32 n, [Out] Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GenQueries(Int32 n, [Out] out UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        public static 
        void GenQueries(Int32 n, [Out] out Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glGenQueries((Int32)n, (UInt32*)ids_ptr);
                    ids = *ids_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GenQueries(Int32 n, [Out] UInt32* ids)
        {
            Delegates.glGenQueries((Int32)n, (UInt32*)ids);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GenQueries(Int32 n, [Out] Int32* ids)
        {
            Delegates.glGenQueries((Int32)n, (UInt32*)ids);
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteQueries(Int32 n, UInt32[] ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void DeleteQueries(Int32 n, Int32[] ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteQueries(Int32 n, ref UInt32 ids)
        {
            unsafe
            {
                fixed (UInt32* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        public static 
        void DeleteQueries(Int32 n, ref Int32 ids)
        {
            unsafe
            {
                fixed (Int32* ids_ptr = &ids)
                {
                    Delegates.glDeleteQueries((Int32)n, (UInt32*)ids_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteQueries(Int32 n, UInt32* ids)
        {
            Delegates.glDeleteQueries((Int32)n, (UInt32*)ids);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteQueries(Int32 n, Int32* ids)
        {
            Delegates.glDeleteQueries((Int32)n, (UInt32*)ids);
        }

        [System.CLSCompliant(false)]
        public static 
        bool IsQuery(UInt32 id)
        {
            return Delegates.glIsQuery((UInt32)id);
        }

        public static 
        bool IsQuery(Int32 id)
        {
            return Delegates.glIsQuery((UInt32)id);
        }

        [System.CLSCompliant(false)]
        public static 
        void BeginQuery(OpenTK.OpenGL.Enums.Version15 target, UInt32 id)
        {
            Delegates.glBeginQuery((OpenTK.OpenGL.Enums.Version15)target, (UInt32)id);
        }

        public static 
        void BeginQuery(OpenTK.OpenGL.Enums.Version15 target, Int32 id)
        {
            Delegates.glBeginQuery((OpenTK.OpenGL.Enums.Version15)target, (UInt32)id);
        }

        public static 
        void EndQuery(OpenTK.OpenGL.Enums.Version15 target)
        {
            Delegates.glEndQuery((OpenTK.OpenGL.Enums.Version15)target);
        }

        public static 
        void GetQuery(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryiv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetQuery(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryiv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQuery(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32* @params)
        {
            Delegates.glGetQueryiv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32* @params)
        {
            Delegates.glGetQueryObjectiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] UInt32[] @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (UInt32*)@params_ptr);
                }
            }
        }

        public static 
        void GetQueryObject(Int32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (UInt32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] out UInt32 @params)
        {
            unsafe
            {
                fixed (UInt32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetQueryObject(Int32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetQueryObjectuiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (UInt32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] UInt32* @params)
        {
            Delegates.glGetQueryObjectuiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (UInt32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetQueryObject(Int32 id, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32* @params)
        {
            Delegates.glGetQueryObjectuiv((UInt32)id, (OpenTK.OpenGL.Enums.Version15)pname, (UInt32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void BindBuffer(OpenTK.OpenGL.Enums.Version15 target, UInt32 buffer)
        {
            Delegates.glBindBuffer((OpenTK.OpenGL.Enums.Version15)target, (UInt32)buffer);
        }

        public static 
        void BindBuffer(OpenTK.OpenGL.Enums.Version15 target, Int32 buffer)
        {
            Delegates.glBindBuffer((OpenTK.OpenGL.Enums.Version15)target, (UInt32)buffer);
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteBuffers(Int32 n, UInt32[] buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void DeleteBuffers(Int32 n, Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteBuffers(Int32 n, ref UInt32 buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void DeleteBuffers(Int32 n, ref Int32 buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteBuffers(Int32 n, UInt32* buffers)
        {
            Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void DeleteBuffers(Int32 n, Int32* buffers)
        {
            Delegates.glDeleteBuffers((Int32)n, (UInt32*)buffers);
        }

        [System.CLSCompliant(false)]
        public static 
        void GenBuffers(Int32 n, [Out] UInt32[] buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        public static 
        void GenBuffers(Int32 n, [Out] Int32[] buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GenBuffers(Int32 n, [Out] out UInt32 buffers)
        {
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }

        public static 
        void GenBuffers(Int32 n, [Out] out Int32 buffers)
        {
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Delegates.glGenBuffers((Int32)n, (UInt32*)buffers_ptr);
                    buffers = *buffers_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GenBuffers(Int32 n, [Out] UInt32* buffers)
        {
            Delegates.glGenBuffers((Int32)n, (UInt32*)buffers);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GenBuffers(Int32 n, [Out] Int32* buffers)
        {
            Delegates.glGenBuffers((Int32)n, (UInt32*)buffers);
        }

        [System.CLSCompliant(false)]
        public static 
        bool IsBuffer(UInt32 buffer)
        {
            return Delegates.glIsBuffer((UInt32)buffer);
        }

        public static 
        bool IsBuffer(Int32 buffer)
        {
            return Delegates.glIsBuffer((UInt32)buffer);
        }

        public static 
        void BufferData(OpenTK.OpenGL.Enums.Version15 target, IntPtr size, IntPtr data, OpenTK.OpenGL.Enums.Version15 usage)
        {
            Delegates.glBufferData((OpenTK.OpenGL.Enums.Version15)target, (IntPtr)size, (IntPtr)data, (OpenTK.OpenGL.Enums.Version15)usage);
        }

        public static 
        void BufferData(OpenTK.OpenGL.Enums.Version15 target, IntPtr size, [In, Out] object data, OpenTK.OpenGL.Enums.Version15 usage)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glBufferData((OpenTK.OpenGL.Enums.Version15)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (OpenTK.OpenGL.Enums.Version15)usage);
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void BufferSubData(OpenTK.OpenGL.Enums.Version15 target, IntPtr offset, IntPtr size, IntPtr data)
        {
            Delegates.glBufferSubData((OpenTK.OpenGL.Enums.Version15)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
        }

        public static 
        void BufferSubData(OpenTK.OpenGL.Enums.Version15 target, IntPtr offset, IntPtr size, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glBufferSubData((OpenTK.OpenGL.Enums.Version15)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        public static 
        void GetBufferSubData(OpenTK.OpenGL.Enums.Version15 target, IntPtr offset, IntPtr size, [Out] IntPtr data)
        {
            Delegates.glGetBufferSubData((OpenTK.OpenGL.Enums.Version15)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
        }

        public static 
        void GetBufferSubData(OpenTK.OpenGL.Enums.Version15 target, IntPtr offset, IntPtr size, [In, Out] object data)
        {
            System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetBufferSubData((OpenTK.OpenGL.Enums.Version15)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe IntPtr MapBuffer(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 access)
        {
            return Delegates.glMapBuffer((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)access);
        }

        public static 
        bool UnmapBuffer(OpenTK.OpenGL.Enums.Version15 target)
        {
            return Delegates.glUnmapBuffer((OpenTK.OpenGL.Enums.Version15)target);
        }

        public static 
        void GetBufferParameter(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetBufferParameteriv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetBufferParameter(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetBufferParameteriv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetBufferParameter(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [Out] Int32* @params)
        {
            Delegates.glGetBufferParameteriv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (Int32*)@params);
        }

        public static 
        void GetBufferPointer(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [Out] IntPtr @params)
        {
            Delegates.glGetBufferPointerv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (IntPtr)@params);
        }

        public static 
        void GetBufferPointer(OpenTK.OpenGL.Enums.Version15 target, OpenTK.OpenGL.Enums.Version15 pname, [In, Out] object @params)
        {
            System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetBufferPointerv((OpenTK.OpenGL.Enums.Version15)target, (OpenTK.OpenGL.Enums.Version15)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
            }
            finally
            {
                @params_ptr.Free();
            }
        }

        public static 
        void BlendEquationSeparate(OpenTK.OpenGL.Enums.BlendEquationModeExt modeRGB, OpenTK.OpenGL.Enums.BlendEquationModeExt modeAlpha)
        {
            Delegates.glBlendEquationSeparate((OpenTK.OpenGL.Enums.BlendEquationModeExt)modeRGB, (OpenTK.OpenGL.Enums.BlendEquationModeExt)modeAlpha);
        }

        public static 
        void DrawBuffers(Int32 n, OpenTK.OpenGL.Enums.Version20[] bufs)
        {
            unsafe
            {
                fixed (OpenTK.OpenGL.Enums.Version20* bufs_ptr = bufs)
                {
                    Delegates.glDrawBuffers((Int32)n, (OpenTK.OpenGL.Enums.Version20*)bufs_ptr);
                }
            }
        }

        public static 
        void DrawBuffers(Int32 n, ref OpenTK.OpenGL.Enums.Version20 bufs)
        {
            unsafe
            {
                fixed (OpenTK.OpenGL.Enums.Version20* bufs_ptr = &bufs)
                {
                    Delegates.glDrawBuffers((Int32)n, (OpenTK.OpenGL.Enums.Version20*)bufs_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void DrawBuffers(Int32 n, OpenTK.OpenGL.Enums.Version20* bufs)
        {
            Delegates.glDrawBuffers((Int32)n, (OpenTK.OpenGL.Enums.Version20*)bufs);
        }

        public static 
        void StencilOpSeparate(OpenTK.OpenGL.Enums.Version20 face, OpenTK.OpenGL.Enums.StencilOp sfail, OpenTK.OpenGL.Enums.StencilOp dpfail, OpenTK.OpenGL.Enums.StencilOp dppass)
        {
            Delegates.glStencilOpSeparate((OpenTK.OpenGL.Enums.Version20)face, (OpenTK.OpenGL.Enums.StencilOp)sfail, (OpenTK.OpenGL.Enums.StencilOp)dpfail, (OpenTK.OpenGL.Enums.StencilOp)dppass);
        }

        [System.CLSCompliant(false)]
        public static 
        void StencilFuncSeparate(OpenTK.OpenGL.Enums.StencilFunction frontfunc, OpenTK.OpenGL.Enums.StencilFunction backfunc, Int32 @ref, UInt32 mask)
        {
            Delegates.glStencilFuncSeparate((OpenTK.OpenGL.Enums.StencilFunction)frontfunc, (OpenTK.OpenGL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
        }

        public static 
        void StencilFuncSeparate(OpenTK.OpenGL.Enums.StencilFunction frontfunc, OpenTK.OpenGL.Enums.StencilFunction backfunc, Int32 @ref, Int32 mask)
        {
            Delegates.glStencilFuncSeparate((OpenTK.OpenGL.Enums.StencilFunction)frontfunc, (OpenTK.OpenGL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
        }

        [System.CLSCompliant(false)]
        public static 
        void StencilMaskSeparate(OpenTK.OpenGL.Enums.Version20 face, UInt32 mask)
        {
            Delegates.glStencilMaskSeparate((OpenTK.OpenGL.Enums.Version20)face, (UInt32)mask);
        }

        public static 
        void StencilMaskSeparate(OpenTK.OpenGL.Enums.Version20 face, Int32 mask)
        {
            Delegates.glStencilMaskSeparate((OpenTK.OpenGL.Enums.Version20)face, (UInt32)mask);
        }

        [System.CLSCompliant(false)]
        public static 
        void AttachShader(UInt32 program, UInt32 shader)
        {
            Delegates.glAttachShader((UInt32)program, (UInt32)shader);
        }

        public static 
        void AttachShader(Int32 program, Int32 shader)
        {
            Delegates.glAttachShader((UInt32)program, (UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void BindAttribLocation(UInt32 program, UInt32 index, System.String name)
        {
            Delegates.glBindAttribLocation((UInt32)program, (UInt32)index, (System.String)name);
        }

        public static 
        void BindAttribLocation(Int32 program, Int32 index, System.String name)
        {
            Delegates.glBindAttribLocation((UInt32)program, (UInt32)index, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void CompileShader(UInt32 shader)
        {
            Delegates.glCompileShader((UInt32)shader);
        }

        public static 
        void CompileShader(Int32 shader)
        {
            Delegates.glCompileShader((UInt32)shader);
        }

        public static 
        Int32 CreateProgram()
        {
            return Delegates.glCreateProgram();
        }

        public static 
        Int32 CreateShader(OpenTK.OpenGL.Enums.Version20 type)
        {
            return Delegates.glCreateShader((OpenTK.OpenGL.Enums.Version20)type);
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteProgram(UInt32 program)
        {
            Delegates.glDeleteProgram((UInt32)program);
        }

        public static 
        void DeleteProgram(Int32 program)
        {
            Delegates.glDeleteProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        void DeleteShader(UInt32 shader)
        {
            Delegates.glDeleteShader((UInt32)shader);
        }

        public static 
        void DeleteShader(Int32 shader)
        {
            Delegates.glDeleteShader((UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void DetachShader(UInt32 program, UInt32 shader)
        {
            Delegates.glDetachShader((UInt32)program, (UInt32)shader);
        }

        public static 
        void DetachShader(Int32 program, Int32 shader)
        {
            Delegates.glDetachShader((UInt32)program, (UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void DisableVertexAttribArray(UInt32 index)
        {
            Delegates.glDisableVertexAttribArray((UInt32)index);
        }

        public static 
        void DisableVertexAttribArray(Int32 index)
        {
            Delegates.glDisableVertexAttribArray((UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void EnableVertexAttribArray(UInt32 index)
        {
            Delegates.glEnableVertexAttribArray((UInt32)index);
        }

        public static 
        void EnableVertexAttribArray(Int32 index)
        {
            Delegates.glEnableVertexAttribArray((UInt32)index);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.Version20[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.Version20[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.Version20 type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.Version20 type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = &type)
                {
                    Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.Version20* type, [Out] System.Text.StringBuilder name)
        {
            Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.Version20*)type, (System.Text.StringBuilder)name);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveAttrib(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.Version20* type, [Out] System.Text.StringBuilder name)
        {
            Delegates.glGetActiveAttrib((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.Version20*)type, (System.Text.StringBuilder)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.Version20[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        public static 
        void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.Version20[] type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                fixed (Int32* size_ptr = size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.Version20 type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        public static 
        void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.Version20 type, [Out] System.Text.StringBuilder name)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                fixed (Int32* size_ptr = &size)
                fixed (OpenTK.OpenGL.Enums.Version20* type_ptr = &type)
                {
                    Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.Version20*)type_ptr, (System.Text.StringBuilder)name);
                    length = *length_ptr;
                    size = *size_ptr;
                    type = *type_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.Version20* type, [Out] System.Text.StringBuilder name)
        {
            Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.Version20*)type, (System.Text.StringBuilder)name);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetActiveUniform(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.Version20* type, [Out] System.Text.StringBuilder name)
        {
            Delegates.glGetActiveUniform((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.Version20*)type, (System.Text.StringBuilder)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] Int32[] count, [Out] UInt32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (UInt32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                }
            }
        }

        public static 
        void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32[] count, [Out] Int32[] obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = count)
                fixed (Int32* obj_ptr = obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] out Int32 count, [Out] out UInt32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (UInt32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }

        public static 
        void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] out Int32 count, [Out] out Int32 obj)
        {
            unsafe
            {
                fixed (Int32* count_ptr = &count)
                fixed (Int32* obj_ptr = &obj)
                {
                    Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    count = *count_ptr;
                    obj = *obj_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(UInt32 program, Int32 maxCount, [Out] Int32* count, [Out] UInt32* obj)
        {
            Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetAttachedShaders(Int32 program, Int32 maxCount, [Out] Int32* count, [Out] Int32* obj)
        {
            Delegates.glGetAttachedShaders((UInt32)program, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 GetAttribLocation(UInt32 program, System.String name)
        {
            return Delegates.glGetAttribLocation((UInt32)program, (System.String)name);
        }

        public static 
        Int32 GetAttribLocation(Int32 program, System.String name)
        {
            return Delegates.glGetAttribLocation((UInt32)program, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetProgram(UInt32 program, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetProgram(Int32 program, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetProgram(UInt32 program, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetProgram(Int32 program, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetProgramiv((UInt32)program, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgram(UInt32 program, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32* @params)
        {
            Delegates.glGetProgramiv((UInt32)program, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgram(Int32 program, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32* @params)
        {
            Delegates.glGetProgramiv((UInt32)program, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        public static 
        void GetProgramInfoLog(Int32 program, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void GetProgramInfoLog(Int32 program, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgramInfoLog(UInt32 program, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
        {
            Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetProgramInfoLog(Int32 program, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
        {
            Delegates.glGetProgramInfoLog((UInt32)program, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetShader(UInt32 shader, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetShader(Int32 shader, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetShader(UInt32 shader, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetShader(Int32 shader, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetShaderiv((UInt32)shader, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShader(UInt32 shader, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32* @params)
        {
            Delegates.glGetShaderiv((UInt32)shader, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShader(Int32 shader, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32* @params)
        {
            Delegates.glGetShaderiv((UInt32)shader, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        public static 
        void GetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void GetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderInfoLog(UInt32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
        {
            Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderInfoLog(Int32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
        {
            Delegates.glGetShaderInfoLog((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder)infoLog);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetShaderSource(UInt32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }

        public static 
        void GetShaderSource(Int32 shader, Int32 bufSize, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetShaderSource(UInt32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }

        public static 
        void GetShaderSource(Int32 shader, Int32 bufSize, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    length = *length_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderSource(UInt32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
        {
            Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder[])source);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetShaderSource(Int32 shader, Int32 bufSize, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
        {
            Delegates.glGetShaderSource((UInt32)shader, (Int32)bufSize, (Int32*)length, (System.Text.StringBuilder[])source);
        }

        [System.CLSCompliant(false)]
        public static 
        Int32 GetUniformLocation(UInt32 program, System.String name)
        {
            return Delegates.glGetUniformLocation((UInt32)program, (System.String)name);
        }

        public static 
        Int32 GetUniformLocation(Int32 program, System.String name)
        {
            return Delegates.glGetUniformLocation((UInt32)program, (System.String)name);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetUniform(UInt32 program, Int32 location, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetUniform(Int32 program, Int32 location, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetUniform(UInt32 program, Int32 location, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetUniform(Int32 program, Int32 location, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniform(UInt32 program, Int32 location, [Out] Single* @params)
        {
            Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniform(Int32 program, Int32 location, [Out] Single* @params)
        {
            Delegates.glGetUniformfv((UInt32)program, (Int32)location, (Single*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetUniform(UInt32 program, Int32 location, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetUniform(Int32 program, Int32 location, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetUniform(UInt32 program, Int32 location, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetUniform(Int32 program, Int32 location, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniform(UInt32 program, Int32 location, [Out] Int32* @params)
        {
            Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetUniform(Int32 program, Int32 location, [Out] Int32* @params)
        {
            Delegates.glGetUniformiv((UInt32)program, (Int32)location, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Double*)@params_ptr);
                }
            }
        }

        public static 
        void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Double[] @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Double*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Double @params)
        {
            unsafe
            {
                fixed (Double* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribdv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Double*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Double* @params)
        {
            Delegates.glGetVertexAttribdv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Double*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Double* @params)
        {
            Delegates.glGetVertexAttribdv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Double*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Single*)@params_ptr);
                }
            }
        }

        public static 
        void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Single[] @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Single*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Single @params)
        {
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribfv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Single*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Single* @params)
        {
            Delegates.glGetVertexAttribfv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Single*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Single* @params)
        {
            Delegates.glGetVertexAttribfv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Single*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                }
            }
        }

        public static 
        void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32[] @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        public static 
        void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] out Int32 @params)
        {
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Delegates.glGetVertexAttribiv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params_ptr);
                    @params = *@params_ptr;
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32* @params)
        {
            Delegates.glGetVertexAttribiv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] Int32* @params)
        {
            Delegates.glGetVertexAttribiv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (Int32*)@params);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribPointer(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] IntPtr pointer)
        {
            Delegates.glGetVertexAttribPointerv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (IntPtr)pointer);
        }

        public static 
        void GetVertexAttribPointer(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [Out] IntPtr pointer)
        {
            Delegates.glGetVertexAttribPointerv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (IntPtr)pointer);
        }

        [System.CLSCompliant(false)]
        public static 
        void GetVertexAttribPointer(UInt32 index, OpenTK.OpenGL.Enums.Version20 pname, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetVertexAttribPointerv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void GetVertexAttribPointer(Int32 index, OpenTK.OpenGL.Enums.Version20 pname, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glGetVertexAttribPointerv((UInt32)index, (OpenTK.OpenGL.Enums.Version20)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        [System.CLSCompliant(false)]
        public static 
        bool IsProgram(UInt32 program)
        {
            return Delegates.glIsProgram((UInt32)program);
        }

        public static 
        bool IsProgram(Int32 program)
        {
            return Delegates.glIsProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        bool IsShader(UInt32 shader)
        {
            return Delegates.glIsShader((UInt32)shader);
        }

        public static 
        bool IsShader(Int32 shader)
        {
            return Delegates.glIsShader((UInt32)shader);
        }

        [System.CLSCompliant(false)]
        public static 
        void LinkProgram(UInt32 program)
        {
            Delegates.glLinkProgram((UInt32)program);
        }

        public static 
        void LinkProgram(Int32 program)
        {
            Delegates.glLinkProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        void ShaderSource(UInt32 shader, Int32 count, System.String[] @string, Int32[] length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        public static 
        void ShaderSource(Int32 shader, Int32 count, System.String[] @string, Int32[] length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void ShaderSource(UInt32 shader, Int32 count, System.String[] @string, ref Int32 length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        public static 
        void ShaderSource(Int32 shader, Int32 count, System.String[] @string, ref Int32 length)
        {
            unsafe
            {
                fixed (Int32* length_ptr = &length)
                {
                    Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void ShaderSource(UInt32 shader, Int32 count, System.String[] @string, Int32* length)
        {
            Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void ShaderSource(Int32 shader, Int32 count, System.String[] @string, Int32* length)
        {
            Delegates.glShaderSource((UInt32)shader, (Int32)count, (System.String[])@string, (Int32*)length);
        }

        [System.CLSCompliant(false)]
        public static 
        void UseProgram(UInt32 program)
        {
            Delegates.glUseProgram((UInt32)program);
        }

        public static 
        void UseProgram(Int32 program)
        {
            Delegates.glUseProgram((UInt32)program);
        }

        public static 
        void Uniform1(Int32 location, Single v0)
        {
            Delegates.glUniform1f((Int32)location, (Single)v0);
        }

        public static 
        void Uniform2(Int32 location, Single v0, Single v1)
        {
            Delegates.glUniform2f((Int32)location, (Single)v0, (Single)v1);
        }

        public static 
        void Uniform3(Int32 location, Single v0, Single v1, Single v2)
        {
            Delegates.glUniform3f((Int32)location, (Single)v0, (Single)v1, (Single)v2);
        }

        public static 
        void Uniform4(Int32 location, Single v0, Single v1, Single v2, Single v3)
        {
            Delegates.glUniform4f((Int32)location, (Single)v0, (Single)v1, (Single)v2, (Single)v3);
        }

        public static 
        void Uniform1(Int32 location, Int32 v0)
        {
            Delegates.glUniform1i((Int32)location, (Int32)v0);
        }

        public static 
        void Uniform2(Int32 location, Int32 v0, Int32 v1)
        {
            Delegates.glUniform2i((Int32)location, (Int32)v0, (Int32)v1);
        }

        public static 
        void Uniform3(Int32 location, Int32 v0, Int32 v1, Int32 v2)
        {
            Delegates.glUniform3i((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2);
        }

        public static 
        void Uniform4(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
        {
            Delegates.glUniform4i((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2, (Int32)v3);
        }

        public static 
        void Uniform1(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void Uniform1(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform1(Int32 location, Int32 count, Single* value)
        {
            Delegates.glUniform1fv((Int32)location, (Int32)count, (Single*)value);
        }

        public static 
        void Uniform2v(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void Uniform2v(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform2v(Int32 location, Int32 count, Single* value)
        {
            Delegates.glUniform2fv((Int32)location, (Int32)count, (Single*)value);
        }

        public static 
        void Uniform3(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void Uniform3(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform3(Int32 location, Int32 count, Single* value)
        {
            Delegates.glUniform3fv((Int32)location, (Int32)count, (Single*)value);
        }

        public static 
        void Uniform4(Int32 location, Int32 count, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        public static 
        void Uniform4(Int32 location, Int32 count, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform4(Int32 location, Int32 count, Single* value)
        {
            Delegates.glUniform4fv((Int32)location, (Int32)count, (Single*)value);
        }

        public static 
        void Uniform1(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void Uniform1(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform1(Int32 location, Int32 count, Int32* value)
        {
            Delegates.glUniform1iv((Int32)location, (Int32)count, (Int32*)value);
        }

        public static 
        void Uniform2v(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void Uniform2v(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform2v(Int32 location, Int32 count, Int32* value)
        {
            Delegates.glUniform2iv((Int32)location, (Int32)count, (Int32*)value);
        }

        public static 
        void Uniform3(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void Uniform3(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform3(Int32 location, Int32 count, Int32* value)
        {
            Delegates.glUniform3iv((Int32)location, (Int32)count, (Int32*)value);
        }

        public static 
        void Uniform4(Int32 location, Int32 count, Int32[] value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = value)
                {
                    Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        public static 
        void Uniform4(Int32 location, Int32 count, ref Int32 value)
        {
            unsafe
            {
                fixed (Int32* value_ptr = &value)
                {
                    Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void Uniform4(Int32 location, Int32 count, Int32* value)
        {
            Delegates.glUniform4iv((Int32)location, (Int32)count, (Int32*)value);
        }

        public static 
        void UniformMatrix2(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix2(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix2(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static 
        void UniformMatrix3(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix3(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix3(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static 
        void UniformMatrix4(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix4(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix4(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        [System.CLSCompliant(false)]
        public static 
        void ValidateProgram(UInt32 program)
        {
            Delegates.glValidateProgram((UInt32)program);
        }

        public static 
        void ValidateProgram(Int32 program)
        {
            Delegates.glValidateProgram((UInt32)program);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1(UInt32 index, Double x)
        {
            Delegates.glVertexAttrib1d((UInt32)index, (Double)x);
        }

        public static 
        void VertexAttrib1(Int32 index, Double x)
        {
            Delegates.glVertexAttrib1d((UInt32)index, (Double)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1v(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib1v(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1v(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib1v(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1v(UInt32 index, Double* v)
        {
            Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1v(Int32 index, Double* v)
        {
            Delegates.glVertexAttrib1dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1(UInt32 index, Single x)
        {
            Delegates.glVertexAttrib1f((UInt32)index, (Single)x);
        }

        public static 
        void VertexAttrib1(Int32 index, Single x)
        {
            Delegates.glVertexAttrib1f((UInt32)index, (Single)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1v(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib1v(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1v(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib1v(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1v(UInt32 index, Single* v)
        {
            Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1v(Int32 index, Single* v)
        {
            Delegates.glVertexAttrib1fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1(UInt32 index, Int16 x)
        {
            Delegates.glVertexAttrib1s((UInt32)index, (Int16)x);
        }

        public static 
        void VertexAttrib1(Int32 index, Int16 x)
        {
            Delegates.glVertexAttrib1s((UInt32)index, (Int16)x);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1v(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib1v(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib1v(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib1v(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1v(UInt32 index, Int16* v)
        {
            Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib1v(Int32 index, Int16* v)
        {
            Delegates.glVertexAttrib1sv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2d((UInt32)index, (Double)x, (Double)y);
        }

        public static 
        void VertexAttrib2(Int32 index, Double x, Double y)
        {
            Delegates.glVertexAttrib2d((UInt32)index, (Double)x, (Double)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib2(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib2(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2(UInt32 index, Double* v)
        {
            Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2(Int32 index, Double* v)
        {
            Delegates.glVertexAttrib2dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2f((UInt32)index, (Single)x, (Single)y);
        }

        public static 
        void VertexAttrib2(Int32 index, Single x, Single y)
        {
            Delegates.glVertexAttrib2f((UInt32)index, (Single)x, (Single)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib2(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib2(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2(UInt32 index, Single* v)
        {
            Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2(Int32 index, Single* v)
        {
            Delegates.glVertexAttrib2fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2s((UInt32)index, (Int16)x, (Int16)y);
        }

        public static 
        void VertexAttrib2(Int32 index, Int16 x, Int16 y)
        {
            Delegates.glVertexAttrib2s((UInt32)index, (Int16)x, (Int16)y);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib2(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib2(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib2(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2(UInt32 index, Int16* v)
        {
            Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib2(Int32 index, Int16* v)
        {
            Delegates.glVertexAttrib2sv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3d((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        public static 
        void VertexAttrib3(Int32 index, Double x, Double y, Double z)
        {
            Delegates.glVertexAttrib3d((UInt32)index, (Double)x, (Double)y, (Double)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib3(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib3(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3(UInt32 index, Double* v)
        {
            Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3(Int32 index, Double* v)
        {
            Delegates.glVertexAttrib3dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3f((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        public static 
        void VertexAttrib3(Int32 index, Single x, Single y, Single z)
        {
            Delegates.glVertexAttrib3f((UInt32)index, (Single)x, (Single)y, (Single)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib3(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib3(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3(UInt32 index, Single* v)
        {
            Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3(Int32 index, Single* v)
        {
            Delegates.glVertexAttrib3fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3s((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        public static 
        void VertexAttrib3(Int32 index, Int16 x, Int16 y, Int16 z)
        {
            Delegates.glVertexAttrib3s((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib3(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib3(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib3(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3(UInt32 index, Int16* v)
        {
            Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib3(Int32 index, Int16* v)
        {
            Delegates.glVertexAttrib3sv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(UInt32 index, SByte* v)
        {
            Delegates.glVertexAttrib4Nbv((UInt32)index, (SByte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(UInt32 index, Int32* v)
        {
            Delegates.glVertexAttrib4Niv((UInt32)index, (Int32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(UInt32 index, Int16* v)
        {
            Delegates.glVertexAttrib4Nsv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4Nub((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        public static 
        void VertexAttrib4N(Int32 index, Byte x, Byte y, Byte z, Byte w)
        {
            Delegates.glVertexAttrib4Nub((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4N(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4N(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(UInt32 index, Byte* v)
        {
            Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(Int32 index, Byte* v)
        {
            Delegates.glVertexAttrib4Nubv((UInt32)index, (Byte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4N(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4N(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(UInt32 index, UInt32* v)
        {
            Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(Int32 index, Int32* v)
        {
            Delegates.glVertexAttrib4Nuiv((UInt32)index, (UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4N(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4N(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4N(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(UInt32 index, UInt16* v)
        {
            Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4N(Int32 index, Int16* v)
        {
            Delegates.glVertexAttrib4Nusv((UInt32)index, (UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, SByte[] v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref SByte v)
        {
            unsafe
            {
                fixed (SByte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, SByte* v)
        {
            Delegates.glVertexAttrib4bv((UInt32)index, (SByte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4d((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        public static 
        void VertexAttrib4(Int32 index, Double x, Double y, Double z, Double w)
        {
            Delegates.glVertexAttrib4d((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, Double[] v)
        {
            unsafe
            {
                fixed (Double* v_ptr = v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, ref Double v)
        {
            unsafe
            {
                fixed (Double* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, Double* v)
        {
            Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(Int32 index, Double* v)
        {
            Delegates.glVertexAttrib4dv((UInt32)index, (Double*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4f((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        public static 
        void VertexAttrib4(Int32 index, Single x, Single y, Single z, Single w)
        {
            Delegates.glVertexAttrib4f((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, Single[] v)
        {
            unsafe
            {
                fixed (Single* v_ptr = v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, ref Single v)
        {
            unsafe
            {
                fixed (Single* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, Single* v)
        {
            Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(Int32 index, Single* v)
        {
            Delegates.glVertexAttrib4fv((UInt32)index, (Single*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, Int32* v)
        {
            Delegates.glVertexAttrib4iv((UInt32)index, (Int32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4s((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        public static 
        void VertexAttrib4(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
        {
            Delegates.glVertexAttrib4s((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, Int16* v)
        {
            Delegates.glVertexAttrib4sv((UInt32)index, (Int16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, Byte[] v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, ref Byte v)
        {
            unsafe
            {
                fixed (Byte* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, Byte* v)
        {
            Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(Int32 index, Byte* v)
        {
            Delegates.glVertexAttrib4ubv((UInt32)index, (Byte*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, UInt32[] v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, Int32[] v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref UInt32 v)
        {
            unsafe
            {
                fixed (UInt32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, ref Int32 v)
        {
            unsafe
            {
                fixed (Int32* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, UInt32* v)
        {
            Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(Int32 index, Int32* v)
        {
            Delegates.glVertexAttrib4uiv((UInt32)index, (UInt32*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, UInt16[] v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, Int16[] v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttrib4(UInt32 index, ref UInt16 v)
        {
            unsafe
            {
                fixed (UInt16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        public static 
        void VertexAttrib4(Int32 index, ref Int16 v)
        {
            unsafe
            {
                fixed (Int16* v_ptr = &v)
                {
                    Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(UInt32 index, UInt16* v)
        {
            Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void VertexAttrib4(Int32 index, Int16* v)
        {
            Delegates.glVertexAttrib4usv((UInt32)index, (UInt16*)v);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttribPointer(UInt32 index, Int32 size, OpenTK.OpenGL.Enums.Version20 type, bool normalized, Int32 stride, IntPtr pointer)
        {
            Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.Version20)type, (bool)normalized, (Int32)stride, (IntPtr)pointer);
        }

        public static 
        void VertexAttribPointer(Int32 index, Int32 size, OpenTK.OpenGL.Enums.Version20 type, bool normalized, Int32 stride, IntPtr pointer)
        {
            Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.Version20)type, (bool)normalized, (Int32)stride, (IntPtr)pointer);
        }

        [System.CLSCompliant(false)]
        public static 
        void VertexAttribPointer(UInt32 index, Int32 size, OpenTK.OpenGL.Enums.Version20 type, bool normalized, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.Version20)type, (bool)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void VertexAttribPointer(Int32 index, Int32 size, OpenTK.OpenGL.Enums.Version20 type, bool normalized, Int32 stride, [In, Out] object pointer)
        {
            System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
            try
            {
                Delegates.glVertexAttribPointer((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.Version20)type, (bool)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
        }

        public static 
        void UniformMatrix2x3(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix2x3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix2x3(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix2x3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix2x3(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix2x3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static 
        void UniformMatrix3x2(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix3x2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix3x2(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix3x2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix3x2(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix3x2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static 
        void UniformMatrix2x4(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix2x4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix2x4(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix2x4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix2x4(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix2x4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static 
        void UniformMatrix4x2(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix4x2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix4x2(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix4x2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix4x2(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix4x2fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static 
        void UniformMatrix3x4(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix3x4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix3x4(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix3x4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix3x4(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix3x4fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static 
        void UniformMatrix4x3(Int32 location, Int32 count, bool transpose, Single[] value)
        {
            unsafe
            {
                fixed (Single* value_ptr = value)
                {
                    Delegates.glUniformMatrix4x3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        public static 
        void UniformMatrix4x3(Int32 location, Int32 count, bool transpose, ref Single value)
        {
            unsafe
            {
                fixed (Single* value_ptr = &value)
                {
                    Delegates.glUniformMatrix4x3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                }
            }
        }

        [System.CLSCompliant(false)]
        public static 
        unsafe void UniformMatrix4x3(Int32 location, Int32 count, bool transpose, Single* value)
        {
            Delegates.glUniformMatrix4x3fv((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
        }

        public static partial class Arb
        {
            public static 
            void ActiveTexture(OpenTK.OpenGL.Enums.ArbMultitexture texture)
            {
                Delegates.glActiveTextureARB((OpenTK.OpenGL.Enums.ArbMultitexture)texture);
            }

            public static 
            void ClientActiveTexture(OpenTK.OpenGL.Enums.ArbMultitexture texture)
            {
                Delegates.glClientActiveTextureARB((OpenTK.OpenGL.Enums.ArbMultitexture)texture);
            }

            public static 
            void MultiTexCoord1(OpenTK.OpenGL.Enums.ArbMultitexture target, Double s)
            {
                Delegates.glMultiTexCoord1dARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double)s);
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Double* v)
            {
                Delegates.glMultiTexCoord1dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v);
            }

            public static 
            void MultiTexCoord1(OpenTK.OpenGL.Enums.ArbMultitexture target, Single s)
            {
                Delegates.glMultiTexCoord1fARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single)s);
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Single* v)
            {
                Delegates.glMultiTexCoord1fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v);
            }

            public static 
            void MultiTexCoord1(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32 s)
            {
                Delegates.glMultiTexCoord1iARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32)s);
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32* v)
            {
                Delegates.glMultiTexCoord1ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v);
            }

            public static 
            void MultiTexCoord1(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16 s)
            {
                Delegates.glMultiTexCoord1sARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16)s);
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1v(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16* v)
            {
                Delegates.glMultiTexCoord1svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Double s, Double t)
            {
                Delegates.glMultiTexCoord2dARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double)s, (Double)t);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Double* v)
            {
                Delegates.glMultiTexCoord2dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Single s, Single t)
            {
                Delegates.glMultiTexCoord2fARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single)s, (Single)t);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Single* v)
            {
                Delegates.glMultiTexCoord2fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32 s, Int32 t)
            {
                Delegates.glMultiTexCoord2iARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32)s, (Int32)t);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32* v)
            {
                Delegates.glMultiTexCoord2ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16 s, Int16 t)
            {
                Delegates.glMultiTexCoord2sARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16)s, (Int16)t);
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16* v)
            {
                Delegates.glMultiTexCoord2svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Double s, Double t, Double r)
            {
                Delegates.glMultiTexCoord3dARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double)s, (Double)t, (Double)r);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Double* v)
            {
                Delegates.glMultiTexCoord3dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Single s, Single t, Single r)
            {
                Delegates.glMultiTexCoord3fARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single)s, (Single)t, (Single)r);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Single* v)
            {
                Delegates.glMultiTexCoord3fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32 s, Int32 t, Int32 r)
            {
                Delegates.glMultiTexCoord3iARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32)s, (Int32)t, (Int32)r);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32* v)
            {
                Delegates.glMultiTexCoord3ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16 s, Int16 t, Int16 r)
            {
                Delegates.glMultiTexCoord3sARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16)s, (Int16)t, (Int16)r);
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16* v)
            {
                Delegates.glMultiTexCoord3svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Double s, Double t, Double r, Double q)
            {
                Delegates.glMultiTexCoord4dARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double)s, (Double)t, (Double)r, (Double)q);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Double* v)
            {
                Delegates.glMultiTexCoord4dvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Double*)v);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Single s, Single t, Single r, Single q)
            {
                Delegates.glMultiTexCoord4fARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single)s, (Single)t, (Single)r, (Single)q);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Single* v)
            {
                Delegates.glMultiTexCoord4fvARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Single*)v);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32 s, Int32 t, Int32 r, Int32 q)
            {
                Delegates.glMultiTexCoord4iARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32)s, (Int32)t, (Int32)r, (Int32)q);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Int32* v)
            {
                Delegates.glMultiTexCoord4ivARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int32*)v);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16 s, Int16 t, Int16 r, Int16 q)
            {
                Delegates.glMultiTexCoord4sARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16)s, (Int16)t, (Int16)r, (Int16)q);
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4(OpenTK.OpenGL.Enums.ArbMultitexture target, Int16* v)
            {
                Delegates.glMultiTexCoord4svARB((OpenTK.OpenGL.Enums.ArbMultitexture)target, (Int16*)v);
            }

            public static 
            void LoadTransposeMatrix(Single[] m)
            {
                unsafe
                {
                    fixed (Single* m_ptr = m)
                    {
                        Delegates.glLoadTransposeMatrixfARB((Single*)m_ptr);
                    }
                }
            }

            public static 
            void LoadTransposeMatrix(ref Single m)
            {
                unsafe
                {
                    fixed (Single* m_ptr = &m)
                    {
                        Delegates.glLoadTransposeMatrixfARB((Single*)m_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadTransposeMatrix(Single* m)
            {
                Delegates.glLoadTransposeMatrixfARB((Single*)m);
            }

            public static 
            void LoadTransposeMatrix(Double[] m)
            {
                unsafe
                {
                    fixed (Double* m_ptr = m)
                    {
                        Delegates.glLoadTransposeMatrixdARB((Double*)m_ptr);
                    }
                }
            }

            public static 
            void LoadTransposeMatrix(ref Double m)
            {
                unsafe
                {
                    fixed (Double* m_ptr = &m)
                    {
                        Delegates.glLoadTransposeMatrixdARB((Double*)m_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadTransposeMatrix(Double* m)
            {
                Delegates.glLoadTransposeMatrixdARB((Double*)m);
            }

            public static 
            void MultTransposeMatrix(Single[] m)
            {
                unsafe
                {
                    fixed (Single* m_ptr = m)
                    {
                        Delegates.glMultTransposeMatrixfARB((Single*)m_ptr);
                    }
                }
            }

            public static 
            void MultTransposeMatrix(ref Single m)
            {
                unsafe
                {
                    fixed (Single* m_ptr = &m)
                    {
                        Delegates.glMultTransposeMatrixfARB((Single*)m_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultTransposeMatrix(Single* m)
            {
                Delegates.glMultTransposeMatrixfARB((Single*)m);
            }

            public static 
            void MultTransposeMatrix(Double[] m)
            {
                unsafe
                {
                    fixed (Double* m_ptr = m)
                    {
                        Delegates.glMultTransposeMatrixdARB((Double*)m_ptr);
                    }
                }
            }

            public static 
            void MultTransposeMatrix(ref Double m)
            {
                unsafe
                {
                    fixed (Double* m_ptr = &m)
                    {
                        Delegates.glMultTransposeMatrixdARB((Double*)m_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultTransposeMatrix(Double* m)
            {
                Delegates.glMultTransposeMatrixdARB((Double*)m);
            }

            public static 
            void SampleCoverage(Single value, bool invert)
            {
                Delegates.glSampleCoverageARB((Single)value, (bool)invert);
            }

            public static 
            void CompressedTexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, IntPtr data)
            {
                Delegates.glCompressedTexImage3DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }

            public static 
            void CompressedTexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, Int32 imageSize, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage3DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void CompressedTexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr data)
            {
                Delegates.glCompressedTexImage2DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }

            public static 
            void CompressedTexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage2DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void CompressedTexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, IntPtr data)
            {
                Delegates.glCompressedTexImage1DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data);
            }

            public static 
            void CompressedTexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 border, Int32 imageSize, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexImage1DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void CompressedTexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, IntPtr data)
            {
                Delegates.glCompressedTexSubImage3DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data);
            }

            public static 
            void CompressedTexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage3DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void CompressedTexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, IntPtr data)
            {
                Delegates.glCompressedTexSubImage2DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data);
            }

            public static 
            void CompressedTexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage2DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void CompressedTexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, IntPtr data)
            {
                Delegates.glCompressedTexSubImage1DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data);
            }

            public static 
            void CompressedTexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, Int32 imageSize, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glCompressedTexSubImage1DARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void GetCompressedTexImage(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, [Out] IntPtr img)
            {
                Delegates.glGetCompressedTexImageARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (IntPtr)img);
            }

            public static 
            void GetCompressedTexImage(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, [In, Out] object img)
            {
                System.Runtime.InteropServices.GCHandle img_ptr = System.Runtime.InteropServices.GCHandle.Alloc(img, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetCompressedTexImageARB((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (IntPtr)img_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    img_ptr.Free();
                }
            }

            public static 
            void PointParameter(OpenTK.OpenGL.Enums.ArbPointParameters pname, Single param)
            {
                Delegates.glPointParameterfARB((OpenTK.OpenGL.Enums.ArbPointParameters)pname, (Single)param);
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.ArbPointParameters pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glPointParameterfvARB((OpenTK.OpenGL.Enums.ArbPointParameters)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.ArbPointParameters pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterfvARB((OpenTK.OpenGL.Enums.ArbPointParameters)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameterv(OpenTK.OpenGL.Enums.ArbPointParameters pname, Single* @params)
            {
                Delegates.glPointParameterfvARB((OpenTK.OpenGL.Enums.ArbPointParameters)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void Weight(Int32 size, SByte[] weights)
            {
                unsafe
                {
                    fixed (SByte* weights_ptr = weights)
                    {
                        Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Weight(Int32 size, ref SByte weights)
            {
                unsafe
                {
                    fixed (SByte* weights_ptr = &weights)
                    {
                        Delegates.glWeightbvARB((Int32)size, (SByte*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, SByte* weights)
            {
                Delegates.glWeightbvARB((Int32)size, (SByte*)weights);
            }

            public static 
            void Weight(Int32 size, Single[] weights)
            {
                unsafe
                {
                    fixed (Single* weights_ptr = weights)
                    {
                        Delegates.glWeightfvARB((Int32)size, (Single*)weights_ptr);
                    }
                }
            }

            public static 
            void Weight(Int32 size, ref Single weights)
            {
                unsafe
                {
                    fixed (Single* weights_ptr = &weights)
                    {
                        Delegates.glWeightfvARB((Int32)size, (Single*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, Single* weights)
            {
                Delegates.glWeightfvARB((Int32)size, (Single*)weights);
            }

            public static 
            void Weight(Int32 size, Double[] weights)
            {
                unsafe
                {
                    fixed (Double* weights_ptr = weights)
                    {
                        Delegates.glWeightdvARB((Int32)size, (Double*)weights_ptr);
                    }
                }
            }

            public static 
            void Weight(Int32 size, ref Double weights)
            {
                unsafe
                {
                    fixed (Double* weights_ptr = &weights)
                    {
                        Delegates.glWeightdvARB((Int32)size, (Double*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, Double* weights)
            {
                Delegates.glWeightdvARB((Int32)size, (Double*)weights);
            }

            public static 
            void Weight(Int32 size, Byte[] weights)
            {
                unsafe
                {
                    fixed (Byte* weights_ptr = weights)
                    {
                        Delegates.glWeightubvARB((Int32)size, (Byte*)weights_ptr);
                    }
                }
            }

            public static 
            void Weight(Int32 size, ref Byte weights)
            {
                unsafe
                {
                    fixed (Byte* weights_ptr = &weights)
                    {
                        Delegates.glWeightubvARB((Int32)size, (Byte*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, Byte* weights)
            {
                Delegates.glWeightubvARB((Int32)size, (Byte*)weights);
            }

            [System.CLSCompliant(false)]
            public static 
            void Weight(Int32 size, UInt16[] weights)
            {
                unsafe
                {
                    fixed (UInt16* weights_ptr = weights)
                    {
                        Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                    }
                }
            }

            public static 
            void Weight(Int32 size, Int16[] weights)
            {
                unsafe
                {
                    fixed (Int16* weights_ptr = weights)
                    {
                        Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Weight(Int32 size, ref UInt16 weights)
            {
                unsafe
                {
                    fixed (UInt16* weights_ptr = &weights)
                    {
                        Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                    }
                }
            }

            public static 
            void Weight(Int32 size, ref Int16 weights)
            {
                unsafe
                {
                    fixed (Int16* weights_ptr = &weights)
                    {
                        Delegates.glWeightusvARB((Int32)size, (UInt16*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, UInt16* weights)
            {
                Delegates.glWeightusvARB((Int32)size, (UInt16*)weights);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, Int16* weights)
            {
                Delegates.glWeightusvARB((Int32)size, (UInt16*)weights);
            }

            [System.CLSCompliant(false)]
            public static 
            void Weight(Int32 size, UInt32[] weights)
            {
                unsafe
                {
                    fixed (UInt32* weights_ptr = weights)
                    {
                        Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                    }
                }
            }

            public static 
            void Weight(Int32 size, Int32[] weights)
            {
                unsafe
                {
                    fixed (Int32* weights_ptr = weights)
                    {
                        Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Weight(Int32 size, ref UInt32 weights)
            {
                unsafe
                {
                    fixed (UInt32* weights_ptr = &weights)
                    {
                        Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                    }
                }
            }

            public static 
            void Weight(Int32 size, ref Int32 weights)
            {
                unsafe
                {
                    fixed (Int32* weights_ptr = &weights)
                    {
                        Delegates.glWeightuivARB((Int32)size, (UInt32*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, UInt32* weights)
            {
                Delegates.glWeightuivARB((Int32)size, (UInt32*)weights);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Weight(Int32 size, Int32* weights)
            {
                Delegates.glWeightuivARB((Int32)size, (UInt32*)weights);
            }

            public static 
            void WeightPointer(Int32 size, OpenTK.OpenGL.Enums.ArbVertexBlend type, Int32 stride, IntPtr pointer)
            {
                Delegates.glWeightPointerARB((Int32)size, (OpenTK.OpenGL.Enums.ArbVertexBlend)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void WeightPointer(Int32 size, OpenTK.OpenGL.Enums.ArbVertexBlend type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glWeightPointerARB((Int32)size, (OpenTK.OpenGL.Enums.ArbVertexBlend)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void VertexBlend(Int32 count)
            {
                Delegates.glVertexBlendARB((Int32)count);
            }

            public static 
            void CurrentPaletteMatrix(Int32 index)
            {
                Delegates.glCurrentPaletteMatrixARB((Int32)index);
            }

            public static 
            void MatrixIndex(Int32 size, Byte[] indices)
            {
                unsafe
                {
                    fixed (Byte* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices_ptr);
                    }
                }
            }

            public static 
            void MatrixIndex(Int32 size, ref Byte indices)
            {
                unsafe
                {
                    fixed (Byte* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndex(Int32 size, Byte* indices)
            {
                Delegates.glMatrixIndexubvARB((Int32)size, (Byte*)indices);
            }

            [System.CLSCompliant(false)]
            public static 
            void MatrixIndex(Int32 size, UInt16[] indices)
            {
                unsafe
                {
                    fixed (UInt16* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                    }
                }
            }

            public static 
            void MatrixIndex(Int32 size, Int16[] indices)
            {
                unsafe
                {
                    fixed (Int16* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void MatrixIndex(Int32 size, ref UInt16 indices)
            {
                unsafe
                {
                    fixed (UInt16* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                    }
                }
            }

            public static 
            void MatrixIndex(Int32 size, ref Int16 indices)
            {
                unsafe
                {
                    fixed (Int16* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndex(Int32 size, UInt16* indices)
            {
                Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndex(Int32 size, Int16* indices)
            {
                Delegates.glMatrixIndexusvARB((Int32)size, (UInt16*)indices);
            }

            [System.CLSCompliant(false)]
            public static 
            void MatrixIndex(Int32 size, UInt32[] indices)
            {
                unsafe
                {
                    fixed (UInt32* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                    }
                }
            }

            public static 
            void MatrixIndex(Int32 size, Int32[] indices)
            {
                unsafe
                {
                    fixed (Int32* indices_ptr = indices)
                    {
                        Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void MatrixIndex(Int32 size, ref UInt32 indices)
            {
                unsafe
                {
                    fixed (UInt32* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                    }
                }
            }

            public static 
            void MatrixIndex(Int32 size, ref Int32 indices)
            {
                unsafe
                {
                    fixed (Int32* indices_ptr = &indices)
                    {
                        Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndex(Int32 size, UInt32* indices)
            {
                Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MatrixIndex(Int32 size, Int32* indices)
            {
                Delegates.glMatrixIndexuivARB((Int32)size, (UInt32*)indices);
            }

            public static 
            void MatrixIndexPointer(Int32 size, OpenTK.OpenGL.Enums.ArbMatrixPalette type, Int32 stride, IntPtr pointer)
            {
                Delegates.glMatrixIndexPointerARB((Int32)size, (OpenTK.OpenGL.Enums.ArbMatrixPalette)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void MatrixIndexPointer(Int32 size, OpenTK.OpenGL.Enums.ArbMatrixPalette type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMatrixIndexPointerARB((Int32)size, (OpenTK.OpenGL.Enums.ArbMatrixPalette)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void WindowPos2(Double x, Double y)
            {
                Delegates.glWindowPos2dARB((Double)x, (Double)y);
            }

            public static 
            void WindowPos2(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glWindowPos2dvARB((Double*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glWindowPos2dvARB((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Double* v)
            {
                Delegates.glWindowPos2dvARB((Double*)v);
            }

            public static 
            void WindowPos2(Single x, Single y)
            {
                Delegates.glWindowPos2fARB((Single)x, (Single)y);
            }

            public static 
            void WindowPos2(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glWindowPos2fvARB((Single*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glWindowPos2fvARB((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Single* v)
            {
                Delegates.glWindowPos2fvARB((Single*)v);
            }

            public static 
            void WindowPos2(Int32 x, Int32 y)
            {
                Delegates.glWindowPos2iARB((Int32)x, (Int32)y);
            }

            public static 
            void WindowPos2(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glWindowPos2ivARB((Int32*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glWindowPos2ivARB((Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Int32* v)
            {
                Delegates.glWindowPos2ivARB((Int32*)v);
            }

            public static 
            void WindowPos2(Int16 x, Int16 y)
            {
                Delegates.glWindowPos2sARB((Int16)x, (Int16)y);
            }

            public static 
            void WindowPos2(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glWindowPos2svARB((Int16*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glWindowPos2svARB((Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Int16* v)
            {
                Delegates.glWindowPos2svARB((Int16*)v);
            }

            public static 
            void WindowPos3(Double x, Double y, Double z)
            {
                Delegates.glWindowPos3dARB((Double)x, (Double)y, (Double)z);
            }

            public static 
            void WindowPos3(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glWindowPos3dvARB((Double*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glWindowPos3dvARB((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Double* v)
            {
                Delegates.glWindowPos3dvARB((Double*)v);
            }

            public static 
            void WindowPos3(Single x, Single y, Single z)
            {
                Delegates.glWindowPos3fARB((Single)x, (Single)y, (Single)z);
            }

            public static 
            void WindowPos3(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glWindowPos3fvARB((Single*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glWindowPos3fvARB((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Single* v)
            {
                Delegates.glWindowPos3fvARB((Single*)v);
            }

            public static 
            void WindowPos3(Int32 x, Int32 y, Int32 z)
            {
                Delegates.glWindowPos3iARB((Int32)x, (Int32)y, (Int32)z);
            }

            public static 
            void WindowPos3(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glWindowPos3ivARB((Int32*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glWindowPos3ivARB((Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Int32* v)
            {
                Delegates.glWindowPos3ivARB((Int32*)v);
            }

            public static 
            void WindowPos3(Int16 x, Int16 y, Int16 z)
            {
                Delegates.glWindowPos3sARB((Int16)x, (Int16)y, (Int16)z);
            }

            public static 
            void WindowPos3(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glWindowPos3svARB((Int16*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glWindowPos3svARB((Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Int16* v)
            {
                Delegates.glWindowPos3svARB((Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1(UInt32 index, Double x)
            {
                Delegates.glVertexAttrib1dARB((UInt32)index, (Double)x);
            }

            public static 
            void VertexAttrib1(Int32 index, Double x)
            {
                Delegates.glVertexAttrib1dARB((UInt32)index, (Double)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib1dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1(UInt32 index, Single x)
            {
                Delegates.glVertexAttrib1fARB((UInt32)index, (Single)x);
            }

            public static 
            void VertexAttrib1(Int32 index, Single x)
            {
                Delegates.glVertexAttrib1fARB((UInt32)index, (Single)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib1fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1(UInt32 index, Int16 x)
            {
                Delegates.glVertexAttrib1sARB((UInt32)index, (Int16)x);
            }

            public static 
            void VertexAttrib1(Int32 index, Int16 x)
            {
                Delegates.glVertexAttrib1sARB((UInt32)index, (Int16)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib1svARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Double x, Double y)
            {
                Delegates.glVertexAttrib2dARB((UInt32)index, (Double)x, (Double)y);
            }

            public static 
            void VertexAttrib2(Int32 index, Double x, Double y)
            {
                Delegates.glVertexAttrib2dARB((UInt32)index, (Double)x, (Double)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib2dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Single x, Single y)
            {
                Delegates.glVertexAttrib2fARB((UInt32)index, (Single)x, (Single)y);
            }

            public static 
            void VertexAttrib2(Int32 index, Single x, Single y)
            {
                Delegates.glVertexAttrib2fARB((UInt32)index, (Single)x, (Single)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib2fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Int16 x, Int16 y)
            {
                Delegates.glVertexAttrib2sARB((UInt32)index, (Int16)x, (Int16)y);
            }

            public static 
            void VertexAttrib2(Int32 index, Int16 x, Int16 y)
            {
                Delegates.glVertexAttrib2sARB((UInt32)index, (Int16)x, (Int16)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib2svARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Double x, Double y, Double z)
            {
                Delegates.glVertexAttrib3dARB((UInt32)index, (Double)x, (Double)y, (Double)z);
            }

            public static 
            void VertexAttrib3(Int32 index, Double x, Double y, Double z)
            {
                Delegates.glVertexAttrib3dARB((UInt32)index, (Double)x, (Double)y, (Double)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib3dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Single x, Single y, Single z)
            {
                Delegates.glVertexAttrib3fARB((UInt32)index, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void VertexAttrib3(Int32 index, Single x, Single y, Single z)
            {
                Delegates.glVertexAttrib3fARB((UInt32)index, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib3fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertexAttrib3sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
            }

            public static 
            void VertexAttrib3(Int32 index, Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertexAttrib3sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib3svARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, SByte[] v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, ref SByte v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(UInt32 index, SByte* v)
            {
                Delegates.glVertexAttrib4NbvARB((UInt32)index, (SByte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(UInt32 index, Int32* v)
            {
                Delegates.glVertexAttrib4NivARB((UInt32)index, (Int32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib4NsvARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, Byte x, Byte y, Byte z, Byte w)
            {
                Delegates.glVertexAttrib4NubARB((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
            }

            public static 
            void VertexAttrib4N(Int32 index, Byte x, Byte y, Byte z, Byte w)
            {
                Delegates.glVertexAttrib4NubARB((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4N(Int32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4N(Int32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(UInt32 index, Byte* v)
            {
                Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(Int32 index, Byte* v)
            {
                Delegates.glVertexAttrib4NubvARB((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, UInt32[] v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4N(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, ref UInt32 v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4N(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(UInt32 index, UInt32* v)
            {
                Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(Int32 index, Int32* v)
            {
                Delegates.glVertexAttrib4NuivARB((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4N(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4N(UInt32 index, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4N(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(UInt32 index, UInt16* v)
            {
                Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4N(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib4NusvARB((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, SByte[] v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref SByte v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, SByte* v)
            {
                Delegates.glVertexAttrib4bvARB((UInt32)index, (SByte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glVertexAttrib4dARB((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            public static 
            void VertexAttrib4(Int32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glVertexAttrib4dARB((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib4dvARB((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glVertexAttrib4fARB((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void VertexAttrib4(Int32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glVertexAttrib4fARB((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib4fvARB((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Int32* v)
            {
                Delegates.glVertexAttrib4ivARB((UInt32)index, (Int32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertexAttrib4sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
            }

            public static 
            void VertexAttrib4(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertexAttrib4sARB((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib4svARB((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Byte* v)
            {
                Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Byte* v)
            {
                Delegates.glVertexAttrib4ubvARB((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, UInt32[] v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref UInt32 v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, UInt32* v)
            {
                Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Int32* v)
            {
                Delegates.glVertexAttrib4uivARB((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, UInt16* v)
            {
                Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib4usvARB((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribPointer(UInt32 index, Int32 size, OpenTK.OpenGL.Enums.ArbVertexProgram type, bool normalized, Int32 stride, IntPtr pointer)
            {
                Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.ArbVertexProgram)type, (bool)normalized, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void VertexAttribPointer(Int32 index, Int32 size, OpenTK.OpenGL.Enums.ArbVertexProgram type, bool normalized, Int32 stride, IntPtr pointer)
            {
                Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.ArbVertexProgram)type, (bool)normalized, (Int32)stride, (IntPtr)pointer);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribPointer(UInt32 index, Int32 size, OpenTK.OpenGL.Enums.ArbVertexProgram type, bool normalized, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.ArbVertexProgram)type, (bool)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void VertexAttribPointer(Int32 index, Int32 size, OpenTK.OpenGL.Enums.ArbVertexProgram type, bool normalized, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerARB((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.ArbVertexProgram)type, (bool)normalized, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void EnableVertexAttribArray(UInt32 index)
            {
                Delegates.glEnableVertexAttribArrayARB((UInt32)index);
            }

            public static 
            void EnableVertexAttribArray(Int32 index)
            {
                Delegates.glEnableVertexAttribArrayARB((UInt32)index);
            }

            [System.CLSCompliant(false)]
            public static 
            void DisableVertexAttribArray(UInt32 index)
            {
                Delegates.glDisableVertexAttribArrayARB((UInt32)index);
            }

            public static 
            void DisableVertexAttribArray(Int32 index)
            {
                Delegates.glDisableVertexAttribArrayARB((UInt32)index);
            }

            public static 
            void ProgramString(OpenTK.OpenGL.Enums.ArbVertexProgram target, OpenTK.OpenGL.Enums.ArbVertexProgram format, Int32 len, IntPtr @string)
            {
                Delegates.glProgramStringARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (OpenTK.OpenGL.Enums.ArbVertexProgram)format, (Int32)len, (IntPtr)@string);
            }

            public static 
            void ProgramString(OpenTK.OpenGL.Enums.ArbVertexProgram target, OpenTK.OpenGL.Enums.ArbVertexProgram format, Int32 len, [In, Out] object @string)
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glProgramStringARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (OpenTK.OpenGL.Enums.ArbVertexProgram)format, (Int32)len, (IntPtr)@string_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @string_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void BindProgram(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 program)
            {
                Delegates.glBindProgramARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)program);
            }

            public static 
            void BindProgram(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 program)
            {
                Delegates.glBindProgramARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)program);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteProgram(Int32 n, UInt32[] programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void DeleteProgram(Int32 n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteProgram(Int32 n, ref UInt32 programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void DeleteProgram(Int32 n, ref Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteProgram(Int32 n, UInt32* programs)
            {
                Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteProgram(Int32 n, Int32* programs)
            {
                Delegates.glDeleteProgramsARB((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenProgram(Int32 n, [Out] UInt32[] programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void GenProgram(Int32 n, [Out] Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenProgram(Int32 n, [Out] out UInt32 programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }

            public static 
            void GenProgram(Int32 n, [Out] out Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenProgram(Int32 n, [Out] UInt32* programs)
            {
                Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenProgram(Int32 n, [Out] Int32* programs)
            {
                Delegates.glGenProgramsARB((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramEnvParameter4dARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramEnvParameter4dARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, ref Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, ref Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Double* @params)
            {
                Delegates.glProgramEnvParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Double* @params)
            {
                Delegates.glProgramEnvParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramEnvParameter4fARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramEnvParameter4fARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Single* @params)
            {
                Delegates.glProgramEnvParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Single* @params)
            {
                Delegates.glProgramEnvParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramLocalParameter4dARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramLocalParameter4dARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, ref Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, ref Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Double* @params)
            {
                Delegates.glProgramLocalParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Double* @params)
            {
                Delegates.glProgramLocalParameter4dvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramLocalParameter4fARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramLocalParameter4fARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, Single* @params)
            {
                Delegates.glProgramLocalParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameter4(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, Single* @params)
            {
                Delegates.glProgramLocalParameter4fvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Double* @params)
            {
                Delegates.glGetProgramEnvParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Double* @params)
            {
                Delegates.glGetProgramEnvParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Single* @params)
            {
                Delegates.glGetProgramEnvParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Single* @params)
            {
                Delegates.glGetProgramEnvParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Double* @params)
            {
                Delegates.glGetProgramLocalParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Double* @params)
            {
                Delegates.glGetProgramLocalParameterdvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, UInt32 index, [Out] Single* @params)
            {
                Delegates.glGetProgramLocalParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameter(OpenTK.OpenGL.Enums.ArbVertexProgram target, Int32 index, [Out] Single* @params)
            {
                Delegates.glGetProgramLocalParameterfvARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (UInt32)index, (Single*)@params);
            }

            public static 
            void GetProgram(OpenTK.OpenGL.Enums.ArbVertexProgram target, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramivARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgram(OpenTK.OpenGL.Enums.ArbVertexProgram target, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramivARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgram(OpenTK.OpenGL.Enums.ArbVertexProgram target, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetProgramivARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params);
            }

            public static 
            void GetProgramString(OpenTK.OpenGL.Enums.ArbVertexProgram target, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] IntPtr @string)
            {
                Delegates.glGetProgramStringARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (IntPtr)@string);
            }

            public static 
            void GetProgramString(OpenTK.OpenGL.Enums.ArbVertexProgram target, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [In, Out] object @string)
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetProgramStringARB((OpenTK.OpenGL.Enums.ArbVertexProgram)target, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (IntPtr)@string_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @string_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Double* @params)
            {
                Delegates.glGetVertexAttribdvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Double* @params)
            {
                Delegates.glGetVertexAttribdvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Single* @params)
            {
                Delegates.glGetVertexAttribfvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Single* @params)
            {
                Delegates.glGetVertexAttribfvARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribivARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribivARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribPointer(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] IntPtr pointer)
            {
                Delegates.glGetVertexAttribPointervARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (IntPtr)pointer);
            }

            public static 
            void GetVertexAttribPointer(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [Out] IntPtr pointer)
            {
                Delegates.glGetVertexAttribPointervARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (IntPtr)pointer);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribPointer(UInt32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void GetVertexAttribPointer(Int32 index, OpenTK.OpenGL.Enums.ArbVertexProgram pname, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervARB((UInt32)index, (OpenTK.OpenGL.Enums.ArbVertexProgram)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsProgram(UInt32 program)
            {
                return Delegates.glIsProgramARB((UInt32)program);
            }

            public static 
            bool IsProgram(Int32 program)
            {
                return Delegates.glIsProgramARB((UInt32)program);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindBuffer(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, UInt32 buffer)
            {
                Delegates.glBindBufferARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (UInt32)buffer);
            }

            public static 
            void BindBuffer(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, Int32 buffer)
            {
                Delegates.glBindBufferARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteBuffers(Int32 n, UInt32[] buffers)
            {
                unsafe
                {
                    fixed (UInt32* buffers_ptr = buffers)
                    {
                        Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    }
                }
            }

            public static 
            void DeleteBuffers(Int32 n, Int32[] buffers)
            {
                unsafe
                {
                    fixed (Int32* buffers_ptr = buffers)
                    {
                        Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteBuffers(Int32 n, ref UInt32 buffers)
            {
                unsafe
                {
                    fixed (UInt32* buffers_ptr = &buffers)
                    {
                        Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    }
                }
            }

            public static 
            void DeleteBuffers(Int32 n, ref Int32 buffers)
            {
                unsafe
                {
                    fixed (Int32* buffers_ptr = &buffers)
                    {
                        Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteBuffers(Int32 n, UInt32* buffers)
            {
                Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteBuffers(Int32 n, Int32* buffers)
            {
                Delegates.glDeleteBuffersARB((Int32)n, (UInt32*)buffers);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenBuffers(Int32 n, [Out] UInt32[] buffers)
            {
                unsafe
                {
                    fixed (UInt32* buffers_ptr = buffers)
                    {
                        Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    }
                }
            }

            public static 
            void GenBuffers(Int32 n, [Out] Int32[] buffers)
            {
                unsafe
                {
                    fixed (Int32* buffers_ptr = buffers)
                    {
                        Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenBuffers(Int32 n, [Out] out UInt32 buffers)
            {
                unsafe
                {
                    fixed (UInt32* buffers_ptr = &buffers)
                    {
                        Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                        buffers = *buffers_ptr;
                    }
                }
            }

            public static 
            void GenBuffers(Int32 n, [Out] out Int32 buffers)
            {
                unsafe
                {
                    fixed (Int32* buffers_ptr = &buffers)
                    {
                        Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers_ptr);
                        buffers = *buffers_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenBuffers(Int32 n, [Out] UInt32* buffers)
            {
                Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenBuffers(Int32 n, [Out] Int32* buffers)
            {
                Delegates.glGenBuffersARB((Int32)n, (UInt32*)buffers);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsBuffer(UInt32 buffer)
            {
                return Delegates.glIsBufferARB((UInt32)buffer);
            }

            public static 
            bool IsBuffer(Int32 buffer)
            {
                return Delegates.glIsBufferARB((UInt32)buffer);
            }

            public static 
            void BufferData(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, IntPtr size, IntPtr data, OpenTK.OpenGL.Enums.ArbVertexBufferObject usage)
            {
                Delegates.glBufferDataARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (IntPtr)size, (IntPtr)data, (OpenTK.OpenGL.Enums.ArbVertexBufferObject)usage);
            }

            public static 
            void BufferData(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, IntPtr size, [In, Out] object data, OpenTK.OpenGL.Enums.ArbVertexBufferObject usage)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBufferDataARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (OpenTK.OpenGL.Enums.ArbVertexBufferObject)usage);
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void BufferSubData(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, IntPtr offset, IntPtr size, IntPtr data)
            {
                Delegates.glBufferSubDataARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
            }

            public static 
            void BufferSubData(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, IntPtr offset, IntPtr size, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBufferSubDataARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void GetBufferSubData(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, IntPtr offset, IntPtr size, [Out] IntPtr data)
            {
                Delegates.glGetBufferSubDataARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
            }

            public static 
            void GetBufferSubData(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, IntPtr offset, IntPtr size, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetBufferSubDataARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe IntPtr MapBuffer(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, OpenTK.OpenGL.Enums.ArbVertexBufferObject access)
            {
                return Delegates.glMapBufferARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (OpenTK.OpenGL.Enums.ArbVertexBufferObject)access);
            }

            public static 
            bool UnmapBuffer(OpenTK.OpenGL.Enums.ArbVertexBufferObject target)
            {
                return Delegates.glUnmapBufferARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target);
            }

            public static 
            void GetBufferParameter(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, OpenTK.OpenGL.Enums.ArbVertexBufferObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetBufferParameterivARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (OpenTK.OpenGL.Enums.ArbVertexBufferObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetBufferParameter(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, OpenTK.OpenGL.Enums.ArbVertexBufferObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetBufferParameterivARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (OpenTK.OpenGL.Enums.ArbVertexBufferObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBufferParameter(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, OpenTK.OpenGL.Enums.ArbVertexBufferObject pname, [Out] Int32* @params)
            {
                Delegates.glGetBufferParameterivARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (OpenTK.OpenGL.Enums.ArbVertexBufferObject)pname, (Int32*)@params);
            }

            public static 
            void GetBufferPointer(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, OpenTK.OpenGL.Enums.ArbVertexBufferObject pname, [Out] IntPtr @params)
            {
                Delegates.glGetBufferPointervARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (OpenTK.OpenGL.Enums.ArbVertexBufferObject)pname, (IntPtr)@params);
            }

            public static 
            void GetBufferPointer(OpenTK.OpenGL.Enums.ArbVertexBufferObject target, OpenTK.OpenGL.Enums.ArbVertexBufferObject pname, [In, Out] object @params)
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetBufferPointervARB((OpenTK.OpenGL.Enums.ArbVertexBufferObject)target, (OpenTK.OpenGL.Enums.ArbVertexBufferObject)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenQueries(Int32 n, [Out] UInt32[] ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = ids)
                    {
                        Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            public static 
            void GenQueries(Int32 n, [Out] Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenQueries(Int32 n, [Out] out UInt32 ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = &ids)
                    {
                        Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }

            public static 
            void GenQueries(Int32 n, [Out] out Int32 ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenQueries(Int32 n, [Out] UInt32* ids)
            {
                Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenQueries(Int32 n, [Out] Int32* ids)
            {
                Delegates.glGenQueriesARB((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteQueries(Int32 n, UInt32[] ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = ids)
                    {
                        Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            public static 
            void DeleteQueries(Int32 n, Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteQueries(Int32 n, ref UInt32 ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = &ids)
                    {
                        Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            public static 
            void DeleteQueries(Int32 n, ref Int32 ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteQueries(Int32 n, UInt32* ids)
            {
                Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteQueries(Int32 n, Int32* ids)
            {
                Delegates.glDeleteQueriesARB((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsQuery(UInt32 id)
            {
                return Delegates.glIsQueryARB((UInt32)id);
            }

            public static 
            bool IsQuery(Int32 id)
            {
                return Delegates.glIsQueryARB((UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            void BeginQuery(OpenTK.OpenGL.Enums.ArbOcclusionQuery target, UInt32 id)
            {
                Delegates.glBeginQueryARB((OpenTK.OpenGL.Enums.ArbOcclusionQuery)target, (UInt32)id);
            }

            public static 
            void BeginQuery(OpenTK.OpenGL.Enums.ArbOcclusionQuery target, Int32 id)
            {
                Delegates.glBeginQueryARB((OpenTK.OpenGL.Enums.ArbOcclusionQuery)target, (UInt32)id);
            }

            public static 
            void EndQuery(OpenTK.OpenGL.Enums.ArbOcclusionQuery target)
            {
                Delegates.glEndQueryARB((OpenTK.OpenGL.Enums.ArbOcclusionQuery)target);
            }

            public static 
            void GetQuery(OpenTK.OpenGL.Enums.ArbOcclusionQuery target, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetQueryivARB((OpenTK.OpenGL.Enums.ArbOcclusionQuery)target, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetQuery(OpenTK.OpenGL.Enums.ArbOcclusionQuery target, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryivARB((OpenTK.OpenGL.Enums.ArbOcclusionQuery)target, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQuery(OpenTK.OpenGL.Enums.ArbOcclusionQuery target, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] Int32* @params)
            {
                Delegates.glGetQueryivARB((OpenTK.OpenGL.Enums.ArbOcclusionQuery)target, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] Int32* @params)
            {
                Delegates.glGetQueryObjectivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectuivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetQueryObject(Int32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectuivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] out UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectuivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetQueryObject(Int32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectuivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObject(UInt32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] UInt32* @params)
            {
                Delegates.glGetQueryObjectuivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObject(Int32 id, OpenTK.OpenGL.Enums.ArbOcclusionQuery pname, [Out] Int32* @params)
            {
                Delegates.glGetQueryObjectuivARB((UInt32)id, (OpenTK.OpenGL.Enums.ArbOcclusionQuery)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteObject(UInt32 obj)
            {
                Delegates.glDeleteObjectARB((UInt32)obj);
            }

            public static 
            void DeleteObject(Int32 obj)
            {
                Delegates.glDeleteObjectARB((UInt32)obj);
            }

            public static 
            Int32 GetHandle(OpenTK.OpenGL.Enums.ArbShaderObjects pname)
            {
                return Delegates.glGetHandleARB((OpenTK.OpenGL.Enums.ArbShaderObjects)pname);
            }

            [System.CLSCompliant(false)]
            public static 
            void DetachObject(UInt32 containerObj, UInt32 attachedObj)
            {
                Delegates.glDetachObjectARB((UInt32)containerObj, (UInt32)attachedObj);
            }

            public static 
            void DetachObject(Int32 containerObj, Int32 attachedObj)
            {
                Delegates.glDetachObjectARB((UInt32)containerObj, (UInt32)attachedObj);
            }

            public static 
            Int32 CreateShaderObject(OpenTK.OpenGL.Enums.ArbShaderObjects shaderType)
            {
                return Delegates.glCreateShaderObjectARB((OpenTK.OpenGL.Enums.ArbShaderObjects)shaderType);
            }

            [System.CLSCompliant(false)]
            public static 
            void ShaderSource(UInt32 shaderObj, Int32 count, System.String[] @string, Int32[] length)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    {
                        Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                    }
                }
            }

            public static 
            void ShaderSource(Int32 shaderObj, Int32 count, System.String[] @string, Int32[] length)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    {
                        Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ShaderSource(UInt32 shaderObj, Int32 count, System.String[] @string, ref Int32 length)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    {
                        Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                    }
                }
            }

            public static 
            void ShaderSource(Int32 shaderObj, Int32 count, System.String[] @string, ref Int32 length)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    {
                        Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ShaderSource(UInt32 shaderObj, Int32 count, System.String[] @string, Int32* length)
            {
                Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ShaderSource(Int32 shaderObj, Int32 count, System.String[] @string, Int32* length)
            {
                Delegates.glShaderSourceARB((UInt32)shaderObj, (Int32)count, (System.String[])@string, (Int32*)length);
            }

            [System.CLSCompliant(false)]
            public static 
            void CompileShader(UInt32 shaderObj)
            {
                Delegates.glCompileShaderARB((UInt32)shaderObj);
            }

            public static 
            void CompileShader(Int32 shaderObj)
            {
                Delegates.glCompileShaderARB((UInt32)shaderObj);
            }

            public static 
            Int32 CreateProgramObject()
            {
                return Delegates.glCreateProgramObjectARB();
            }

            [System.CLSCompliant(false)]
            public static 
            void AttachObject(UInt32 containerObj, UInt32 obj)
            {
                Delegates.glAttachObjectARB((UInt32)containerObj, (UInt32)obj);
            }

            public static 
            void AttachObject(Int32 containerObj, Int32 obj)
            {
                Delegates.glAttachObjectARB((UInt32)containerObj, (UInt32)obj);
            }

            [System.CLSCompliant(false)]
            public static 
            void LinkProgram(UInt32 programObj)
            {
                Delegates.glLinkProgramARB((UInt32)programObj);
            }

            public static 
            void LinkProgram(Int32 programObj)
            {
                Delegates.glLinkProgramARB((UInt32)programObj);
            }

            [System.CLSCompliant(false)]
            public static 
            void UseProgramObject(UInt32 programObj)
            {
                Delegates.glUseProgramObjectARB((UInt32)programObj);
            }

            public static 
            void UseProgramObject(Int32 programObj)
            {
                Delegates.glUseProgramObjectARB((UInt32)programObj);
            }

            [System.CLSCompliant(false)]
            public static 
            void ValidateProgram(UInt32 programObj)
            {
                Delegates.glValidateProgramARB((UInt32)programObj);
            }

            public static 
            void ValidateProgram(Int32 programObj)
            {
                Delegates.glValidateProgramARB((UInt32)programObj);
            }

            public static 
            void Uniform1(Int32 location, Single v0)
            {
                Delegates.glUniform1fARB((Int32)location, (Single)v0);
            }

            public static 
            void Uniform2(Int32 location, Single v0, Single v1)
            {
                Delegates.glUniform2fARB((Int32)location, (Single)v0, (Single)v1);
            }

            public static 
            void Uniform3(Int32 location, Single v0, Single v1, Single v2)
            {
                Delegates.glUniform3fARB((Int32)location, (Single)v0, (Single)v1, (Single)v2);
            }

            public static 
            void Uniform4(Int32 location, Single v0, Single v1, Single v2, Single v3)
            {
                Delegates.glUniform4fARB((Int32)location, (Single)v0, (Single)v1, (Single)v2, (Single)v3);
            }

            public static 
            void Uniform1(Int32 location, Int32 v0)
            {
                Delegates.glUniform1iARB((Int32)location, (Int32)v0);
            }

            public static 
            void Uniform2(Int32 location, Int32 v0, Int32 v1)
            {
                Delegates.glUniform2iARB((Int32)location, (Int32)v0, (Int32)v1);
            }

            public static 
            void Uniform3(Int32 location, Int32 v0, Int32 v1, Int32 v2)
            {
                Delegates.glUniform3iARB((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2);
            }

            public static 
            void Uniform4(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
            {
                Delegates.glUniform4iARB((Int32)location, (Int32)v0, (Int32)v1, (Int32)v2, (Int32)v3);
            }

            public static 
            void Uniform1(Int32 location, Int32 count, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform1(Int32 location, Int32 count, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1(Int32 location, Int32 count, Single* value)
            {
                Delegates.glUniform1fvARB((Int32)location, (Int32)count, (Single*)value);
            }

            public static 
            void Uniform2v(Int32 location, Int32 count, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform2v(Int32 location, Int32 count, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2v(Int32 location, Int32 count, Single* value)
            {
                Delegates.glUniform2fvARB((Int32)location, (Int32)count, (Single*)value);
            }

            public static 
            void Uniform3(Int32 location, Int32 count, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform3(Int32 location, Int32 count, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3(Int32 location, Int32 count, Single* value)
            {
                Delegates.glUniform3fvARB((Int32)location, (Int32)count, (Single*)value);
            }

            public static 
            void Uniform4(Int32 location, Int32 count, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform4(Int32 location, Int32 count, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4(Int32 location, Int32 count, Single* value)
            {
                Delegates.glUniform4fvARB((Int32)location, (Int32)count, (Single*)value);
            }

            public static 
            void Uniform1(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform1(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform1ivARB((Int32)location, (Int32)count, (Int32*)value);
            }

            public static 
            void Uniform2v(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform2v(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2v(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform2ivARB((Int32)location, (Int32)count, (Int32*)value);
            }

            public static 
            void Uniform3(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform3(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform3ivARB((Int32)location, (Int32)count, (Int32*)value);
            }

            public static 
            void Uniform4(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform4(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform4ivARB((Int32)location, (Int32)count, (Int32*)value);
            }

            public static 
            void UniformMatrix2(Int32 location, Int32 count, bool transpose, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glUniformMatrix2fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void UniformMatrix2(Int32 location, Int32 count, bool transpose, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glUniformMatrix2fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void UniformMatrix2(Int32 location, Int32 count, bool transpose, Single* value)
            {
                Delegates.glUniformMatrix2fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
            }

            public static 
            void UniformMatrix3(Int32 location, Int32 count, bool transpose, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glUniformMatrix3fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void UniformMatrix3(Int32 location, Int32 count, bool transpose, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glUniformMatrix3fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void UniformMatrix3(Int32 location, Int32 count, bool transpose, Single* value)
            {
                Delegates.glUniformMatrix3fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
            }

            public static 
            void UniformMatrix4(Int32 location, Int32 count, bool transpose, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glUniformMatrix4fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void UniformMatrix4(Int32 location, Int32 count, bool transpose, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glUniformMatrix4fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void UniformMatrix4(Int32 location, Int32 count, bool transpose, Single* value)
            {
                Delegates.glUniformMatrix4fvARB((Int32)location, (Int32)count, (bool)transpose, (Single*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameter(UInt32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterfvARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetObjectParameter(Int32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterfvARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameter(UInt32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterfvARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetObjectParameter(Int32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterfvARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameter(UInt32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Single* @params)
            {
                Delegates.glGetObjectParameterfvARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameter(Int32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Single* @params)
            {
                Delegates.glGetObjectParameterfvARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameter(UInt32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterivARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetObjectParameter(Int32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetObjectParameterivARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectParameter(UInt32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterivARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetObjectParameter(Int32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectParameterivARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameter(UInt32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Int32* @params)
            {
                Delegates.glGetObjectParameterivARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectParameter(Int32 obj, OpenTK.OpenGL.Enums.ArbShaderObjects pname, [Out] Int32* @params)
            {
                Delegates.glGetObjectParameterivARB((UInt32)obj, (OpenTK.OpenGL.Enums.ArbShaderObjects)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInfoLog(UInt32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    {
                        Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    }
                }
            }

            public static 
            void GetInfoLog(Int32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder infoLog)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    {
                        Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInfoLog(UInt32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    {
                        Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                        length = *length_ptr;
                    }
                }
            }

            public static 
            void GetInfoLog(Int32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder infoLog)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    {
                        Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder)infoLog);
                        length = *length_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInfoLog(UInt32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
            {
                Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInfoLog(Int32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder infoLog)
            {
                Delegates.glGetInfoLogARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder)infoLog);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetAttachedObjects(UInt32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] UInt32[] obj)
            {
                unsafe
                {
                    fixed (Int32* count_ptr = count)
                    fixed (UInt32* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    }
                }
            }

            public static 
            void GetAttachedObjects(Int32 containerObj, Int32 maxCount, [Out] Int32[] count, [Out] Int32[] obj)
            {
                unsafe
                {
                    fixed (Int32* count_ptr = count)
                    fixed (Int32* obj_ptr = obj)
                    {
                        Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetAttachedObjects(UInt32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] out UInt32 obj)
            {
                unsafe
                {
                    fixed (Int32* count_ptr = &count)
                    fixed (UInt32* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                        count = *count_ptr;
                        obj = *obj_ptr;
                    }
                }
            }

            public static 
            void GetAttachedObjects(Int32 containerObj, Int32 maxCount, [Out] out Int32 count, [Out] out Int32 obj)
            {
                unsafe
                {
                    fixed (Int32* count_ptr = &count)
                    fixed (Int32* obj_ptr = &obj)
                    {
                        Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count_ptr, (UInt32*)obj_ptr);
                        count = *count_ptr;
                        obj = *obj_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(UInt32 containerObj, Int32 maxCount, [Out] Int32* count, [Out] UInt32* obj)
            {
                Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetAttachedObjects(Int32 containerObj, Int32 maxCount, [Out] Int32* count, [Out] Int32* obj)
            {
                Delegates.glGetAttachedObjectsARB((UInt32)containerObj, (Int32)maxCount, (Int32*)count, (UInt32*)obj);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GetUniformLocation(UInt32 programObj, System.String name)
            {
                return Delegates.glGetUniformLocationARB((UInt32)programObj, (System.String)name);
            }

            public static 
            Int32 GetUniformLocation(Int32 programObj, System.String name)
            {
                return Delegates.glGetUniformLocationARB((UInt32)programObj, (System.String)name);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.ArbShaderObjects[] type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    fixed (Int32* size_ptr = size)
                    fixed (OpenTK.OpenGL.Enums.ArbShaderObjects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbShaderObjects*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }

            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.ArbShaderObjects[] type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    fixed (Int32* size_ptr = size)
                    fixed (OpenTK.OpenGL.Enums.ArbShaderObjects* type_ptr = type)
                    {
                        Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbShaderObjects*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetActiveUniform(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.ArbShaderObjects type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    fixed (Int32* size_ptr = &size)
                    fixed (OpenTK.OpenGL.Enums.ArbShaderObjects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbShaderObjects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }

            public static 
            void GetActiveUniform(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.ArbShaderObjects type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    fixed (Int32* size_ptr = &size)
                    fixed (OpenTK.OpenGL.Enums.ArbShaderObjects* type_ptr = &type)
                    {
                        Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbShaderObjects*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.ArbShaderObjects* type, [Out] System.Text.StringBuilder name)
            {
                Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.ArbShaderObjects*)type, (System.Text.StringBuilder)name);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveUniform(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.ArbShaderObjects* type, [Out] System.Text.StringBuilder name)
            {
                Delegates.glGetActiveUniformARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.ArbShaderObjects*)type, (System.Text.StringBuilder)name);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetUniform(UInt32 programObj, Int32 location, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetUniform(Int32 programObj, Int32 location, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetUniform(UInt32 programObj, Int32 location, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetUniform(Int32 programObj, Int32 location, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniform(UInt32 programObj, Int32 location, [Out] Single* @params)
            {
                Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniform(Int32 programObj, Int32 location, [Out] Single* @params)
            {
                Delegates.glGetUniformfvARB((UInt32)programObj, (Int32)location, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetUniform(UInt32 programObj, Int32 location, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetUniform(Int32 programObj, Int32 location, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetUniform(UInt32 programObj, Int32 location, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetUniform(Int32 programObj, Int32 location, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniform(UInt32 programObj, Int32 location, [Out] Int32* @params)
            {
                Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniform(Int32 programObj, Int32 location, [Out] Int32* @params)
            {
                Delegates.glGetUniformivARB((UInt32)programObj, (Int32)location, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetShaderSource(UInt32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    {
                        Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    }
                }
            }

            public static 
            void GetShaderSource(Int32 obj, Int32 maxLength, [Out] Int32[] length, [Out] System.Text.StringBuilder[] source)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    {
                        Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetShaderSource(UInt32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    {
                        Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                        length = *length_ptr;
                    }
                }
            }

            public static 
            void GetShaderSource(Int32 obj, Int32 maxLength, [Out] out Int32 length, [Out] System.Text.StringBuilder[] source)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    {
                        Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length_ptr, (System.Text.StringBuilder[])source);
                        length = *length_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetShaderSource(UInt32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
            {
                Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder[])source);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetShaderSource(Int32 obj, Int32 maxLength, [Out] Int32* length, [Out] System.Text.StringBuilder[] source)
            {
                Delegates.glGetShaderSourceARB((UInt32)obj, (Int32)maxLength, (Int32*)length, (System.Text.StringBuilder[])source);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindAttribLocation(UInt32 programObj, UInt32 index, System.String name)
            {
                Delegates.glBindAttribLocationARB((UInt32)programObj, (UInt32)index, (System.String)name);
            }

            public static 
            void BindAttribLocation(Int32 programObj, Int32 index, System.String name)
            {
                Delegates.glBindAttribLocationARB((UInt32)programObj, (UInt32)index, (System.String)name);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.ArbVertexShader[] type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    fixed (Int32* size_ptr = size)
                    fixed (OpenTK.OpenGL.Enums.ArbVertexShader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbVertexShader*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }

            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.ArbVertexShader[] type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    fixed (Int32* size_ptr = size)
                    fixed (OpenTK.OpenGL.Enums.ArbVertexShader* type_ptr = type)
                    {
                        Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbVertexShader*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetActiveAttrib(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.ArbVertexShader type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    fixed (Int32* size_ptr = &size)
                    fixed (OpenTK.OpenGL.Enums.ArbVertexShader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbVertexShader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }

            public static 
            void GetActiveAttrib(Int32 programObj, Int32 index, Int32 maxLength, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.ArbVertexShader type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    fixed (Int32* size_ptr = &size)
                    fixed (OpenTK.OpenGL.Enums.ArbVertexShader* type_ptr = &type)
                    {
                        Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.ArbVertexShader*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(UInt32 programObj, UInt32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.ArbVertexShader* type, [Out] System.Text.StringBuilder name)
            {
                Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.ArbVertexShader*)type, (System.Text.StringBuilder)name);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveAttrib(Int32 programObj, Int32 index, Int32 maxLength, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.ArbVertexShader* type, [Out] System.Text.StringBuilder name)
            {
                Delegates.glGetActiveAttribARB((UInt32)programObj, (UInt32)index, (Int32)maxLength, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.ArbVertexShader*)type, (System.Text.StringBuilder)name);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GetAttribLocation(UInt32 programObj, System.String name)
            {
                return Delegates.glGetAttribLocationARB((UInt32)programObj, (System.String)name);
            }

            public static 
            Int32 GetAttribLocation(Int32 programObj, System.String name)
            {
                return Delegates.glGetAttribLocationARB((UInt32)programObj, (System.String)name);
            }

            public static 
            void DrawBuffers(Int32 n, OpenTK.OpenGL.Enums.ArbDrawBuffers[] bufs)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.ArbDrawBuffers* bufs_ptr = bufs)
                    {
                        Delegates.glDrawBuffersARB((Int32)n, (OpenTK.OpenGL.Enums.ArbDrawBuffers*)bufs_ptr);
                    }
                }
            }

            public static 
            void DrawBuffers(Int32 n, ref OpenTK.OpenGL.Enums.ArbDrawBuffers bufs)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.ArbDrawBuffers* bufs_ptr = &bufs)
                    {
                        Delegates.glDrawBuffersARB((Int32)n, (OpenTK.OpenGL.Enums.ArbDrawBuffers*)bufs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DrawBuffers(Int32 n, OpenTK.OpenGL.Enums.ArbDrawBuffers* bufs)
            {
                Delegates.glDrawBuffersARB((Int32)n, (OpenTK.OpenGL.Enums.ArbDrawBuffers*)bufs);
            }

            public static 
            void ClampColor(OpenTK.OpenGL.Enums.ArbColorBufferFloat target, OpenTK.OpenGL.Enums.ArbColorBufferFloat clamp)
            {
                Delegates.glClampColorARB((OpenTK.OpenGL.Enums.ArbColorBufferFloat)target, (OpenTK.OpenGL.Enums.ArbColorBufferFloat)clamp);
            }

        }

        public static partial class Ext
        {
            public static 
            void BlendColor(Single red, Single green, Single blue, Single alpha)
            {
                Delegates.glBlendColorEXT((Single)red, (Single)green, (Single)blue, (Single)alpha);
            }

            public static 
            void PolygonOffset(Single factor, Single bias)
            {
                Delegates.glPolygonOffsetEXT((Single)factor, (Single)bias);
            }

            public static 
            void TexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
            {
                Delegates.glTexImage3DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
            }

            public static 
            void TexImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexImage3DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }

            public static 
            void TexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
            {
                Delegates.glTexSubImage3DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
            }

            public static 
            void TexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 width, Int32 height, Int32 depth, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage3DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)width, (Int32)height, (Int32)depth, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }

            public static 
            void TexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
            {
                Delegates.glTexSubImage1DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
            }

            public static 
            void TexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage1DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }

            public static 
            void TexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
            {
                Delegates.glTexSubImage2DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
            }

            public static 
            void TexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage2DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }

            public static 
            void CopyTexImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 border)
            {
                Delegates.glCopyTexImage1DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)border);
            }

            public static 
            void CopyTexImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
            {
                Delegates.glCopyTexImage2DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height, (Int32)border);
            }

            public static 
            void CopyTexSubImage1D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 x, Int32 y, Int32 width)
            {
                Delegates.glCopyTexSubImage1DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)x, (Int32)y, (Int32)width);
            }

            public static 
            void CopyTexSubImage2D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
            {
                Delegates.glCopyTexSubImage2DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
            }

            public static 
            void CopyTexSubImage3D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 x, Int32 y, Int32 width, Int32 height)
            {
                Delegates.glCopyTexSubImage3DEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
            }

            public static 
            void GetHistogram(OpenTK.OpenGL.Enums.HistogramTargetExt target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr values)
            {
                Delegates.glGetHistogramEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values);
            }

            public static 
            void GetHistogram(OpenTK.OpenGL.Enums.HistogramTargetExt target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object values)
            {
                System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetHistogramEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    values_ptr.Free();
                }
            }

            public static 
            void GetHistogramParameter(OpenTK.OpenGL.Enums.HistogramTargetExt target, OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetHistogramParameterfvEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetHistogramParameter(OpenTK.OpenGL.Enums.HistogramTargetExt target, OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetHistogramParameterfvEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetHistogramParameter(OpenTK.OpenGL.Enums.HistogramTargetExt target, OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt pname, [Out] Single* @params)
            {
                Delegates.glGetHistogramParameterfvEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt)pname, (Single*)@params);
            }

            public static 
            void GetHistogramParameter(OpenTK.OpenGL.Enums.HistogramTargetExt target, OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetHistogramParameterivEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetHistogramParameter(OpenTK.OpenGL.Enums.HistogramTargetExt target, OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetHistogramParameterivEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetHistogramParameter(OpenTK.OpenGL.Enums.HistogramTargetExt target, OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt pname, [Out] Int32* @params)
            {
                Delegates.glGetHistogramParameterivEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (OpenTK.OpenGL.Enums.GetHistogramParameterPNameExt)pname, (Int32*)@params);
            }

            public static 
            void GetMinmax(OpenTK.OpenGL.Enums.MinmaxTargetExt target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr values)
            {
                Delegates.glGetMinmaxEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values);
            }

            public static 
            void GetMinmax(OpenTK.OpenGL.Enums.MinmaxTargetExt target, bool reset, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object values)
            {
                System.Runtime.InteropServices.GCHandle values_ptr = System.Runtime.InteropServices.GCHandle.Alloc(values, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetMinmaxEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (bool)reset, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)values_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    values_ptr.Free();
                }
            }

            public static 
            void GetMinmaxParameter(OpenTK.OpenGL.Enums.MinmaxTargetExt target, OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetMinmaxParameterfvEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetMinmaxParameter(OpenTK.OpenGL.Enums.MinmaxTargetExt target, OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetMinmaxParameterfvEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMinmaxParameter(OpenTK.OpenGL.Enums.MinmaxTargetExt target, OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt pname, [Out] Single* @params)
            {
                Delegates.glGetMinmaxParameterfvEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt)pname, (Single*)@params);
            }

            public static 
            void GetMinmaxParameter(OpenTK.OpenGL.Enums.MinmaxTargetExt target, OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetMinmaxParameterivEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetMinmaxParameter(OpenTK.OpenGL.Enums.MinmaxTargetExt target, OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetMinmaxParameterivEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMinmaxParameter(OpenTK.OpenGL.Enums.MinmaxTargetExt target, OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt pname, [Out] Int32* @params)
            {
                Delegates.glGetMinmaxParameterivEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (OpenTK.OpenGL.Enums.GetMinmaxParameterPNameExt)pname, (Int32*)@params);
            }

            public static 
            void Histogram(OpenTK.OpenGL.Enums.HistogramTargetExt target, Int32 width, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, bool sink)
            {
                Delegates.glHistogramEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target, (Int32)width, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (bool)sink);
            }

            public static 
            void Minmax(OpenTK.OpenGL.Enums.MinmaxTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, bool sink)
            {
                Delegates.glMinmaxEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (bool)sink);
            }

            public static 
            void ResetHistogram(OpenTK.OpenGL.Enums.HistogramTargetExt target)
            {
                Delegates.glResetHistogramEXT((OpenTK.OpenGL.Enums.HistogramTargetExt)target);
            }

            public static 
            void ResetMinmax(OpenTK.OpenGL.Enums.MinmaxTargetExt target)
            {
                Delegates.glResetMinmaxEXT((OpenTK.OpenGL.Enums.MinmaxTargetExt)target);
            }

            public static 
            void ConvolutionFilter1D(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr image)
            {
                Delegates.glConvolutionFilter1DEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image);
            }

            public static 
            void ConvolutionFilter1D(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object image)
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glConvolutionFilter1DEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }

            public static 
            void ConvolutionFilter2D(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr image)
            {
                Delegates.glConvolutionFilter2DEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image);
            }

            public static 
            void ConvolutionFilter2D(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object image)
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glConvolutionFilter2DEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }

            public static 
            void ConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, Single @params)
            {
                Delegates.glConvolutionParameterfEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Single)@params);
            }

            public static 
            void ConvolutionParameterv(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glConvolutionParameterfvEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ConvolutionParameterv(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glConvolutionParameterfvEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ConvolutionParameterv(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, Single* @params)
            {
                Delegates.glConvolutionParameterfvEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Single*)@params);
            }

            public static 
            void ConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, Int32 @params)
            {
                Delegates.glConvolutionParameteriEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Int32)@params);
            }

            public static 
            void ConvolutionParameterv(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glConvolutionParameterivEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void ConvolutionParameterv(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glConvolutionParameterivEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ConvolutionParameterv(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, Int32* @params)
            {
                Delegates.glConvolutionParameterivEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Int32*)@params);
            }

            public static 
            void CopyConvolutionFilter1D(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
            {
                Delegates.glCopyConvolutionFilter1DEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
            }

            public static 
            void CopyConvolutionFilter2D(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width, Int32 height)
            {
                Delegates.glCopyConvolutionFilter2DEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
            }

            public static 
            void GetConvolutionFilter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr image)
            {
                Delegates.glGetConvolutionFilterEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image);
            }

            public static 
            void GetConvolutionFilter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object image)
            {
                System.Runtime.InteropServices.GCHandle image_ptr = System.Runtime.InteropServices.GCHandle.Alloc(image, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetConvolutionFilterEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)image_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    image_ptr.Free();
                }
            }

            public static 
            void GetConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetConvolutionParameterfvEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetConvolutionParameterfvEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, [Out] Single* @params)
            {
                Delegates.glGetConvolutionParameterfvEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Single*)@params);
            }

            public static 
            void GetConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetConvolutionParameterivEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetConvolutionParameterivEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetConvolutionParameter(OpenTK.OpenGL.Enums.ConvolutionTargetExt target, OpenTK.OpenGL.Enums.ConvolutionParameterExt pname, [Out] Int32* @params)
            {
                Delegates.glGetConvolutionParameterivEXT((OpenTK.OpenGL.Enums.ConvolutionTargetExt)target, (OpenTK.OpenGL.Enums.ConvolutionParameterExt)pname, (Int32*)@params);
            }

            public static 
            void GetSeparableFilter(OpenTK.OpenGL.Enums.SeparableTargetExt target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr row, [Out] IntPtr column, [Out] IntPtr span)
            {
                Delegates.glGetSeparableFilterEXT((OpenTK.OpenGL.Enums.SeparableTargetExt)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row, (IntPtr)column, (IntPtr)span);
            }

            public static 
            void GetSeparableFilter(OpenTK.OpenGL.Enums.SeparableTargetExt target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object row, [In, Out] object column, [In, Out] object span)
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((OpenTK.OpenGL.Enums.SeparableTargetExt)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                    span_ptr.Free();
                }
            }

            public static 
            void GetSeparableFilter(OpenTK.OpenGL.Enums.SeparableTargetExt target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr row, [In, Out] object column, [In, Out] object span)
            {
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle span_ptr = System.Runtime.InteropServices.GCHandle.Alloc(span, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetSeparableFilterEXT((OpenTK.OpenGL.Enums.SeparableTargetExt)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row, (IntPtr)column_ptr.AddrOfPinnedObject(), (IntPtr)span_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    column_ptr.Free();
                    span_ptr.Free();
                }
            }

            public static 
            void SeparableFilter2D(OpenTK.OpenGL.Enums.SeparableTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr row, IntPtr column)
            {
                Delegates.glSeparableFilter2DEXT((OpenTK.OpenGL.Enums.SeparableTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row, (IntPtr)column);
            }

            public static 
            void SeparableFilter2D(OpenTK.OpenGL.Enums.SeparableTargetExt target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object row, [In, Out] object column)
            {
                System.Runtime.InteropServices.GCHandle row_ptr = System.Runtime.InteropServices.GCHandle.Alloc(row, System.Runtime.InteropServices.GCHandleType.Pinned);
                System.Runtime.InteropServices.GCHandle column_ptr = System.Runtime.InteropServices.GCHandle.Alloc(column, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSeparableFilter2DEXT((OpenTK.OpenGL.Enums.SeparableTargetExt)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)row_ptr.AddrOfPinnedObject(), (IntPtr)column_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    row_ptr.Free();
                    column_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            bool AreTexturesResident(Int32 n, UInt32[] textures, [Out] bool[] residences)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = textures)
                    fixed (bool* residences_ptr = residences)
                    {
                        return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                    }
                }
            }

            public static 
            bool AreTexturesResident(Int32 n, Int32[] textures, [Out] bool[] residences)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    fixed (bool* residences_ptr = residences)
                    {
                        return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            bool AreTexturesResident(Int32 n, ref UInt32 textures, [Out] out bool residences)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = &textures)
                    fixed (bool* residences_ptr = &residences)
                    {
                        bool retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                        residences = *residences_ptr;
                        return retval;
                    }
                }
            }

            public static 
            bool AreTexturesResident(Int32 n, ref Int32 textures, [Out] out bool residences)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    fixed (bool* residences_ptr = &residences)
                    {
                        bool retval = Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures_ptr, (bool*)residences_ptr);
                        residences = *residences_ptr;
                        return retval;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe bool AreTexturesResident(Int32 n, UInt32* textures, [Out] bool* residences)
            {
                return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures, (bool*)residences);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe bool AreTexturesResident(Int32 n, Int32* textures, [Out] bool* residences)
            {
                return Delegates.glAreTexturesResidentEXT((Int32)n, (UInt32*)textures, (bool*)residences);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindTexture(OpenTK.OpenGL.Enums.TextureTarget target, UInt32 texture)
            {
                Delegates.glBindTextureEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (UInt32)texture);
            }

            public static 
            void BindTexture(OpenTK.OpenGL.Enums.TextureTarget target, Int32 texture)
            {
                Delegates.glBindTextureEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (UInt32)texture);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteTextures(Int32 n, UInt32[] textures)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = textures)
                    {
                        Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    }
                }
            }

            public static 
            void DeleteTextures(Int32 n, Int32[] textures)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    {
                        Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteTextures(Int32 n, ref UInt32 textures)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = &textures)
                    {
                        Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    }
                }
            }

            public static 
            void DeleteTextures(Int32 n, ref Int32 textures)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    {
                        Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteTextures(Int32 n, UInt32* textures)
            {
                Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteTextures(Int32 n, Int32* textures)
            {
                Delegates.glDeleteTexturesEXT((Int32)n, (UInt32*)textures);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenTextures(Int32 n, [Out] UInt32[] textures)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = textures)
                    {
                        Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    }
                }
            }

            public static 
            void GenTextures(Int32 n, [Out] Int32[] textures)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    {
                        Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenTextures(Int32 n, [Out] out UInt32 textures)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = &textures)
                    {
                        Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                        textures = *textures_ptr;
                    }
                }
            }

            public static 
            void GenTextures(Int32 n, [Out] out Int32 textures)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    {
                        Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures_ptr);
                        textures = *textures_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenTextures(Int32 n, [Out] UInt32* textures)
            {
                Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenTextures(Int32 n, [Out] Int32* textures)
            {
                Delegates.glGenTexturesEXT((Int32)n, (UInt32*)textures);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsTexture(UInt32 texture)
            {
                return Delegates.glIsTextureEXT((UInt32)texture);
            }

            public static 
            bool IsTexture(Int32 texture)
            {
                return Delegates.glIsTextureEXT((UInt32)texture);
            }

            [System.CLSCompliant(false)]
            public static 
            void PrioritizeTextures(Int32 n, UInt32[] textures, Single[] priorities)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = textures)
                    fixed (Single* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                    }
                }
            }

            public static 
            void PrioritizeTextures(Int32 n, Int32[] textures, Single[] priorities)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = textures)
                    fixed (Single* priorities_ptr = priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void PrioritizeTextures(Int32 n, ref UInt32 textures, ref Single priorities)
            {
                unsafe
                {
                    fixed (UInt32* textures_ptr = &textures)
                    fixed (Single* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                    }
                }
            }

            public static 
            void PrioritizeTextures(Int32 n, ref Int32 textures, ref Single priorities)
            {
                unsafe
                {
                    fixed (Int32* textures_ptr = &textures)
                    fixed (Single* priorities_ptr = &priorities)
                    {
                        Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures_ptr, (Single*)priorities_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(Int32 n, UInt32* textures, Single* priorities)
            {
                Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PrioritizeTextures(Int32 n, Int32* textures, Single* priorities)
            {
                Delegates.glPrioritizeTexturesEXT((Int32)n, (UInt32*)textures, (Single*)priorities);
            }

            public static 
            void ArrayElement(Int32 i)
            {
                Delegates.glArrayElementEXT((Int32)i);
            }

            public static 
            void ColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, Int32 count, IntPtr pointer)
            {
                Delegates.glColorPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }

            public static 
            void ColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void DrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, Int32 first, Int32 count)
            {
                Delegates.glDrawArraysEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)first, (Int32)count);
            }

            public static 
            void EdgeFlagPointer(Int32 stride, Int32 count, bool[] pointer)
            {
                unsafe
                {
                    fixed (bool* pointer_ptr = pointer)
                    {
                        Delegates.glEdgeFlagPointerEXT((Int32)stride, (Int32)count, (bool*)pointer_ptr);
                    }
                }
            }

            public static 
            void EdgeFlagPointer(Int32 stride, Int32 count, ref bool pointer)
            {
                unsafe
                {
                    fixed (bool* pointer_ptr = &pointer)
                    {
                        Delegates.glEdgeFlagPointerEXT((Int32)stride, (Int32)count, (bool*)pointer_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void EdgeFlagPointer(Int32 stride, Int32 count, bool* pointer)
            {
                Delegates.glEdgeFlagPointerEXT((Int32)stride, (Int32)count, (bool*)pointer);
            }

            public static 
            void GetPointer(OpenTK.OpenGL.Enums.GetPointervPName pname, [Out] IntPtr @params)
            {
                Delegates.glGetPointervEXT((OpenTK.OpenGL.Enums.GetPointervPName)pname, (IntPtr)@params);
            }

            public static 
            void GetPointer(OpenTK.OpenGL.Enums.GetPointervPName pname, [In, Out] object @params)
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetPointervEXT((OpenTK.OpenGL.Enums.GetPointervPName)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }

            public static 
            void IndexPointer(OpenTK.OpenGL.Enums.IndexPointerType type, Int32 stride, Int32 count, IntPtr pointer)
            {
                Delegates.glIndexPointerEXT((OpenTK.OpenGL.Enums.IndexPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }

            public static 
            void IndexPointer(OpenTK.OpenGL.Enums.IndexPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glIndexPointerEXT((OpenTK.OpenGL.Enums.IndexPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void NormalPointer(OpenTK.OpenGL.Enums.NormalPointerType type, Int32 stride, Int32 count, IntPtr pointer)
            {
                Delegates.glNormalPointerEXT((OpenTK.OpenGL.Enums.NormalPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }

            public static 
            void NormalPointer(OpenTK.OpenGL.Enums.NormalPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glNormalPointerEXT((OpenTK.OpenGL.Enums.NormalPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void TexCoordPointer(Int32 size, OpenTK.OpenGL.Enums.TexCoordPointerType type, Int32 stride, Int32 count, IntPtr pointer)
            {
                Delegates.glTexCoordPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.TexCoordPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }

            public static 
            void TexCoordPointer(Int32 size, OpenTK.OpenGL.Enums.TexCoordPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexCoordPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.TexCoordPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void VertexPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, Int32 stride, Int32 count, IntPtr pointer)
            {
                Delegates.glVertexPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer);
            }

            public static 
            void VertexPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, Int32 stride, Int32 count, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (Int32)stride, (Int32)count, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void BlendEquation(OpenTK.OpenGL.Enums.BlendEquationModeExt mode)
            {
                Delegates.glBlendEquationEXT((OpenTK.OpenGL.Enums.BlendEquationModeExt)mode);
            }

            public static 
            void PointParameter(OpenTK.OpenGL.Enums.ExtPointParameters pname, Single param)
            {
                Delegates.glPointParameterfEXT((OpenTK.OpenGL.Enums.ExtPointParameters)pname, (Single)param);
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.ExtPointParameters pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glPointParameterfvEXT((OpenTK.OpenGL.Enums.ExtPointParameters)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.ExtPointParameters pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterfvEXT((OpenTK.OpenGL.Enums.ExtPointParameters)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameterv(OpenTK.OpenGL.Enums.ExtPointParameters pname, Single* @params)
            {
                Delegates.glPointParameterfvEXT((OpenTK.OpenGL.Enums.ExtPointParameters)pname, (Single*)@params);
            }

            public static 
            void ColorSubTable(OpenTK.OpenGL.Enums.ExtColorSubtable target, Int32 start, Int32 count, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr data)
            {
                Delegates.glColorSubTableEXT((OpenTK.OpenGL.Enums.ExtColorSubtable)target, (Int32)start, (Int32)count, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)data);
            }

            public static 
            void ColorSubTable(OpenTK.OpenGL.Enums.ExtColorSubtable target, Int32 start, Int32 count, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorSubTableEXT((OpenTK.OpenGL.Enums.ExtColorSubtable)target, (Int32)start, (Int32)count, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void CopyColorSubTable(OpenTK.OpenGL.Enums.ExtColorSubtable target, Int32 start, Int32 x, Int32 y, Int32 width)
            {
                Delegates.glCopyColorSubTableEXT((OpenTK.OpenGL.Enums.ExtColorSubtable)target, (Int32)start, (Int32)x, (Int32)y, (Int32)width);
            }

            public static 
            void ColorTable(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.PixelInternalFormat internalFormat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr table)
            {
                Delegates.glColorTableEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalFormat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table);
            }

            public static 
            void ColorTable(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.PixelInternalFormat internalFormat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object table)
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorTableEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalFormat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }

            public static 
            void GetColorTable(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr data)
            {
                Delegates.glGetColorTableEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)data);
            }

            public static 
            void GetColorTable(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetColorTableEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.ExtPalettedTexture pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterivEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.ExtPalettedTexture)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.ExtPalettedTexture pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterivEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.ExtPalettedTexture)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameter(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.ExtPalettedTexture pname, [Out] Int32* @params)
            {
                Delegates.glGetColorTableParameterivEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.ExtPalettedTexture)pname, (Int32*)@params);
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.ExtPalettedTexture pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterfvEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.ExtPalettedTexture)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.ExtPalettedTexture pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterfvEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.ExtPalettedTexture)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameter(OpenTK.OpenGL.Enums.ExtPalettedTexture target, OpenTK.OpenGL.Enums.ExtPalettedTexture pname, [Out] Single* @params)
            {
                Delegates.glGetColorTableParameterfvEXT((OpenTK.OpenGL.Enums.ExtPalettedTexture)target, (OpenTK.OpenGL.Enums.ExtPalettedTexture)pname, (Single*)@params);
            }

            public static 
            void IndexMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.ExtIndexMaterial mode)
            {
                Delegates.glIndexMaterialEXT((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.ExtIndexMaterial)mode);
            }

            public static 
            void IndexFunc(OpenTK.OpenGL.Enums.ExtIndexFunc func, Single @ref)
            {
                Delegates.glIndexFuncEXT((OpenTK.OpenGL.Enums.ExtIndexFunc)func, (Single)@ref);
            }

            public static 
            void LockArrays(Int32 first, Int32 count)
            {
                Delegates.glLockArraysEXT((Int32)first, (Int32)count);
            }

            public static 
            void UnlockArrays()
            {
                Delegates.glUnlockArraysEXT();
            }

            public static 
            void CullParameter(OpenTK.OpenGL.Enums.ExtCullVertex pname, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glCullParameterdvEXT((OpenTK.OpenGL.Enums.ExtCullVertex)pname, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void CullParameter(OpenTK.OpenGL.Enums.ExtCullVertex pname, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glCullParameterdvEXT((OpenTK.OpenGL.Enums.ExtCullVertex)pname, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void CullParameter(OpenTK.OpenGL.Enums.ExtCullVertex pname, [Out] Double* @params)
            {
                Delegates.glCullParameterdvEXT((OpenTK.OpenGL.Enums.ExtCullVertex)pname, (Double*)@params);
            }

            public static 
            void CullParameter(OpenTK.OpenGL.Enums.ExtCullVertex pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glCullParameterfvEXT((OpenTK.OpenGL.Enums.ExtCullVertex)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void CullParameter(OpenTK.OpenGL.Enums.ExtCullVertex pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glCullParameterfvEXT((OpenTK.OpenGL.Enums.ExtCullVertex)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void CullParameter(OpenTK.OpenGL.Enums.ExtCullVertex pname, [Out] Single* @params)
            {
                Delegates.glCullParameterfvEXT((OpenTK.OpenGL.Enums.ExtCullVertex)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count, OpenTK.OpenGL.Enums.ExtDrawRangeElements type, IntPtr indices)
            {
                Delegates.glDrawRangeElementsEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.ExtDrawRangeElements)type, (IntPtr)indices);
            }

            public static 
            void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, OpenTK.OpenGL.Enums.ExtDrawRangeElements type, IntPtr indices)
            {
                Delegates.glDrawRangeElementsEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.ExtDrawRangeElements)type, (IntPtr)indices);
            }

            [System.CLSCompliant(false)]
            public static 
            void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count, OpenTK.OpenGL.Enums.ExtDrawRangeElements type, [In, Out] object indices)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawRangeElementsEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.ExtDrawRangeElements)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }

            public static 
            void DrawRangeElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count, OpenTK.OpenGL.Enums.ExtDrawRangeElements type, [In, Out] object indices)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawRangeElementsEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count, (OpenTK.OpenGL.Enums.ExtDrawRangeElements)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    indices_ptr.Free();
                }
            }

            public static 
            void ApplyTexture(OpenTK.OpenGL.Enums.ExtLightTexture mode)
            {
                Delegates.glApplyTextureEXT((OpenTK.OpenGL.Enums.ExtLightTexture)mode);
            }

            public static 
            void TextureLight(OpenTK.OpenGL.Enums.ExtLightTexture pname)
            {
                Delegates.glTextureLightEXT((OpenTK.OpenGL.Enums.ExtLightTexture)pname);
            }

            public static 
            void TextureMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter mode)
            {
                Delegates.glTextureMaterialEXT((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)mode);
            }

            public static 
            void PixelTransformParameter(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, Int32 param)
            {
                Delegates.glPixelTransformParameteriEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Int32)param);
            }

            public static 
            void PixelTransformParameter(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, Single param)
            {
                Delegates.glPixelTransformParameterfEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Single)param);
            }

            public static 
            void PixelTransformParameterv(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glPixelTransformParameterivEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void PixelTransformParameterv(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glPixelTransformParameterivEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTransformParameterv(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, Int32* @params)
            {
                Delegates.glPixelTransformParameterivEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Int32*)@params);
            }

            public static 
            void PixelTransformParameterv(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glPixelTransformParameterfvEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void PixelTransformParameterv(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glPixelTransformParameterfvEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTransformParameterv(OpenTK.OpenGL.Enums.ExtPixelTransform target, OpenTK.OpenGL.Enums.ExtPixelTransform pname, Single* @params)
            {
                Delegates.glPixelTransformParameterfvEXT((OpenTK.OpenGL.Enums.ExtPixelTransform)target, (OpenTK.OpenGL.Enums.ExtPixelTransform)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(SByte red, SByte green, SByte blue)
            {
                Delegates.glSecondaryColor3bEXT((SByte)red, (SByte)green, (SByte)blue);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(SByte[] v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(ref SByte v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(SByte* v)
            {
                Delegates.glSecondaryColor3bvEXT((SByte*)v);
            }

            public static 
            void SecondaryColor3(Double red, Double green, Double blue)
            {
                Delegates.glSecondaryColor3dEXT((Double)red, (Double)green, (Double)blue);
            }

            public static 
            void SecondaryColor3(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3dvEXT((Double*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3dvEXT((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(Double* v)
            {
                Delegates.glSecondaryColor3dvEXT((Double*)v);
            }

            public static 
            void SecondaryColor3(Single red, Single green, Single blue)
            {
                Delegates.glSecondaryColor3fEXT((Single)red, (Single)green, (Single)blue);
            }

            public static 
            void SecondaryColor3(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3fvEXT((Single*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3fvEXT((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(Single* v)
            {
                Delegates.glSecondaryColor3fvEXT((Single*)v);
            }

            public static 
            void SecondaryColor3(Byte red, Byte green, Byte blue)
            {
                Delegates.glSecondaryColor3ubEXT((Byte)red, (Byte)green, (Byte)blue);
            }

            public static 
            void SecondaryColor3(Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3ubvEXT((Byte*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3(ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3ubvEXT((Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(Byte* v)
            {
                Delegates.glSecondaryColor3ubvEXT((Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(UInt32 red, UInt32 green, UInt32 blue)
            {
                Delegates.glSecondaryColor3uiEXT((UInt32)red, (UInt32)green, (UInt32)blue);
            }

            public static 
            void SecondaryColor3(Int32 red, Int32 green, Int32 blue)
            {
                Delegates.glSecondaryColor3uiEXT((UInt32)red, (UInt32)green, (UInt32)blue);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(UInt32[] v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(ref UInt32 v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3uivEXT((UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(UInt32* v)
            {
                Delegates.glSecondaryColor3uivEXT((UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(Int32* v)
            {
                Delegates.glSecondaryColor3uivEXT((UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(UInt16 red, UInt16 green, UInt16 blue)
            {
                Delegates.glSecondaryColor3usEXT((UInt16)red, (UInt16)green, (UInt16)blue);
            }

            public static 
            void SecondaryColor3(Int16 red, Int16 green, Int16 blue)
            {
                Delegates.glSecondaryColor3usEXT((UInt16)red, (UInt16)green, (UInt16)blue);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3usvEXT((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(UInt16* v)
            {
                Delegates.glSecondaryColor3usvEXT((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3(Int16* v)
            {
                Delegates.glSecondaryColor3usvEXT((UInt16*)v);
            }

            public static 
            void SecondaryColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, IntPtr pointer)
            {
                Delegates.glSecondaryColorPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void SecondaryColorPointer(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSecondaryColorPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void TextureNormal(OpenTK.OpenGL.Enums.ExtTexturePerturbNormal mode)
            {
                Delegates.glTextureNormalEXT((OpenTK.OpenGL.Enums.ExtTexturePerturbNormal)mode);
            }

            public static 
            void MultiDrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, [Out] Int32[] first, [Out] Int32[] count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = first)
                    fixed (Int32* count_ptr = count)
                    {
                        Delegates.glMultiDrawArraysEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    }
                }
            }

            public static 
            void MultiDrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, [Out] out Int32 first, [Out] out Int32 count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = &first)
                    fixed (Int32* count_ptr = &count)
                    {
                        Delegates.glMultiDrawArraysEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                        first = *first_ptr;
                        count = *count_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawArrays(OpenTK.OpenGL.Enums.BeginMode mode, [Out] Int32* first, [Out] Int32* count, Int32 primcount)
            {
                Delegates.glMultiDrawArraysEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count, (Int32)primcount);
            }

            public static 
            void MultiDrawElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32[] count, OpenTK.OpenGL.Enums.ExtMultiDrawArrays type, IntPtr indices, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* count_ptr = count)
                    {
                        Delegates.glMultiDrawElementsEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)count_ptr, (OpenTK.OpenGL.Enums.ExtMultiDrawArrays)type, (IntPtr)indices, (Int32)primcount);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElements(OpenTK.OpenGL.Enums.BeginMode mode, Int32* count, OpenTK.OpenGL.Enums.ExtMultiDrawArrays type, [In, Out] object indices, Int32 primcount)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMultiDrawElementsEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)count, (OpenTK.OpenGL.Enums.ExtMultiDrawArrays)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }

            public static 
            void MultiDrawElements(OpenTK.OpenGL.Enums.BeginMode mode, ref Int32 count, OpenTK.OpenGL.Enums.ExtMultiDrawArrays type, [In, Out] object indices, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* count_ptr = &count)
                    {
                        System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                        try
                        {
                            Delegates.glMultiDrawElementsEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)count_ptr, (OpenTK.OpenGL.Enums.ExtMultiDrawArrays)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                        }
                        finally
                        {
                            indices_ptr.Free();
                        }
                    }
                }
            }

            public static 
            void FogCoord(Single coord)
            {
                Delegates.glFogCoordfEXT((Single)coord);
            }

            public static 
            void FogCoordv(Single[] coord)
            {
                unsafe
                {
                    fixed (Single* coord_ptr = coord)
                    {
                        Delegates.glFogCoordfvEXT((Single*)coord_ptr);
                    }
                }
            }

            public static 
            void FogCoordv(ref Single coord)
            {
                unsafe
                {
                    fixed (Single* coord_ptr = &coord)
                    {
                        Delegates.glFogCoordfvEXT((Single*)coord_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordv(Single* coord)
            {
                Delegates.glFogCoordfvEXT((Single*)coord);
            }

            public static 
            void FogCoord(Double coord)
            {
                Delegates.glFogCoorddEXT((Double)coord);
            }

            public static 
            void FogCoordv(Double[] coord)
            {
                unsafe
                {
                    fixed (Double* coord_ptr = coord)
                    {
                        Delegates.glFogCoorddvEXT((Double*)coord_ptr);
                    }
                }
            }

            public static 
            void FogCoordv(ref Double coord)
            {
                unsafe
                {
                    fixed (Double* coord_ptr = &coord)
                    {
                        Delegates.glFogCoorddvEXT((Double*)coord_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordv(Double* coord)
            {
                Delegates.glFogCoorddvEXT((Double*)coord);
            }

            public static 
            void FogCoordPointer(OpenTK.OpenGL.Enums.ExtFogCoord type, Int32 stride, IntPtr pointer)
            {
                Delegates.glFogCoordPointerEXT((OpenTK.OpenGL.Enums.ExtFogCoord)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void FogCoordPointer(OpenTK.OpenGL.Enums.ExtFogCoord type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glFogCoordPointerEXT((OpenTK.OpenGL.Enums.ExtFogCoord)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Tangent3(SByte tx, SByte ty, SByte tz)
            {
                Delegates.glTangent3bEXT((SByte)tx, (SByte)ty, (SByte)tz);
            }

            public static 
            void Tangent3(Byte tx, Byte ty, Byte tz)
            {
                Delegates.glTangent3bEXT((SByte)tx, (SByte)ty, (SByte)tz);
            }

            [System.CLSCompliant(false)]
            public static 
            void Tangent3(SByte[] v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = v)
                    {
                        Delegates.glTangent3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            public static 
            void Tangent3(Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glTangent3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Tangent3(ref SByte v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = &v)
                    {
                        Delegates.glTangent3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            public static 
            void Tangent3(ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glTangent3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3(SByte* v)
            {
                Delegates.glTangent3bvEXT((SByte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3(Byte* v)
            {
                Delegates.glTangent3bvEXT((SByte*)v);
            }

            public static 
            void Tangent3(Double tx, Double ty, Double tz)
            {
                Delegates.glTangent3dEXT((Double)tx, (Double)ty, (Double)tz);
            }

            public static 
            void Tangent3(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glTangent3dvEXT((Double*)v_ptr);
                    }
                }
            }

            public static 
            void Tangent3(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glTangent3dvEXT((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3(Double* v)
            {
                Delegates.glTangent3dvEXT((Double*)v);
            }

            public static 
            void Tangent3(Single tx, Single ty, Single tz)
            {
                Delegates.glTangent3fEXT((Single)tx, (Single)ty, (Single)tz);
            }

            public static 
            void Tangent3(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTangent3fvEXT((Single*)v_ptr);
                    }
                }
            }

            public static 
            void Tangent3(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTangent3fvEXT((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3(Single* v)
            {
                Delegates.glTangent3fvEXT((Single*)v);
            }

            public static 
            void Tangent3(Int32 tx, Int32 ty, Int32 tz)
            {
                Delegates.glTangent3iEXT((Int32)tx, (Int32)ty, (Int32)tz);
            }

            public static 
            void Tangent3(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glTangent3ivEXT((Int32*)v_ptr);
                    }
                }
            }

            public static 
            void Tangent3(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glTangent3ivEXT((Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3(Int32* v)
            {
                Delegates.glTangent3ivEXT((Int32*)v);
            }

            public static 
            void Tangent3(Int16 tx, Int16 ty, Int16 tz)
            {
                Delegates.glTangent3sEXT((Int16)tx, (Int16)ty, (Int16)tz);
            }

            public static 
            void Tangent3(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTangent3svEXT((Int16*)v_ptr);
                    }
                }
            }

            public static 
            void Tangent3(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTangent3svEXT((Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Tangent3(Int16* v)
            {
                Delegates.glTangent3svEXT((Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void Binormal3(SByte bx, SByte by, SByte bz)
            {
                Delegates.glBinormal3bEXT((SByte)bx, (SByte)by, (SByte)bz);
            }

            public static 
            void Binormal3(Byte bx, Byte by, Byte bz)
            {
                Delegates.glBinormal3bEXT((SByte)bx, (SByte)by, (SByte)bz);
            }

            [System.CLSCompliant(false)]
            public static 
            void Binormal3(SByte[] v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = v)
                    {
                        Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            public static 
            void Binormal3(Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Binormal3(ref SByte v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = &v)
                    {
                        Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            public static 
            void Binormal3(ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glBinormal3bvEXT((SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3(SByte* v)
            {
                Delegates.glBinormal3bvEXT((SByte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3(Byte* v)
            {
                Delegates.glBinormal3bvEXT((SByte*)v);
            }

            public static 
            void Binormal3(Double bx, Double by, Double bz)
            {
                Delegates.glBinormal3dEXT((Double)bx, (Double)by, (Double)bz);
            }

            public static 
            void Binormal3(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glBinormal3dvEXT((Double*)v_ptr);
                    }
                }
            }

            public static 
            void Binormal3(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glBinormal3dvEXT((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3(Double* v)
            {
                Delegates.glBinormal3dvEXT((Double*)v);
            }

            public static 
            void Binormal3(Single bx, Single by, Single bz)
            {
                Delegates.glBinormal3fEXT((Single)bx, (Single)by, (Single)bz);
            }

            public static 
            void Binormal3(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glBinormal3fvEXT((Single*)v_ptr);
                    }
                }
            }

            public static 
            void Binormal3(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glBinormal3fvEXT((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3(Single* v)
            {
                Delegates.glBinormal3fvEXT((Single*)v);
            }

            public static 
            void Binormal3(Int32 bx, Int32 by, Int32 bz)
            {
                Delegates.glBinormal3iEXT((Int32)bx, (Int32)by, (Int32)bz);
            }

            public static 
            void Binormal3(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glBinormal3ivEXT((Int32*)v_ptr);
                    }
                }
            }

            public static 
            void Binormal3(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glBinormal3ivEXT((Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3(Int32* v)
            {
                Delegates.glBinormal3ivEXT((Int32*)v);
            }

            public static 
            void Binormal3(Int16 bx, Int16 by, Int16 bz)
            {
                Delegates.glBinormal3sEXT((Int16)bx, (Int16)by, (Int16)bz);
            }

            public static 
            void Binormal3(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glBinormal3svEXT((Int16*)v_ptr);
                    }
                }
            }

            public static 
            void Binormal3(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glBinormal3svEXT((Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Binormal3(Int16* v)
            {
                Delegates.glBinormal3svEXT((Int16*)v);
            }

            public static 
            void TangentPointer(OpenTK.OpenGL.Enums.ExtCoordinateFrame type, Int32 stride, IntPtr pointer)
            {
                Delegates.glTangentPointerEXT((OpenTK.OpenGL.Enums.ExtCoordinateFrame)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void TangentPointer(OpenTK.OpenGL.Enums.ExtCoordinateFrame type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTangentPointerEXT((OpenTK.OpenGL.Enums.ExtCoordinateFrame)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void BinormalPointer(OpenTK.OpenGL.Enums.ExtCoordinateFrame type, Int32 stride, IntPtr pointer)
            {
                Delegates.glBinormalPointerEXT((OpenTK.OpenGL.Enums.ExtCoordinateFrame)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void BinormalPointer(OpenTK.OpenGL.Enums.ExtCoordinateFrame type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glBinormalPointerEXT((OpenTK.OpenGL.Enums.ExtCoordinateFrame)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void BlendFuncSeparate(OpenTK.OpenGL.Enums.ExtBlendFuncSeparate sfactorRGB, OpenTK.OpenGL.Enums.ExtBlendFuncSeparate dfactorRGB, OpenTK.OpenGL.Enums.ExtBlendFuncSeparate sfactorAlpha, OpenTK.OpenGL.Enums.ExtBlendFuncSeparate dfactorAlpha)
            {
                Delegates.glBlendFuncSeparateEXT((OpenTK.OpenGL.Enums.ExtBlendFuncSeparate)sfactorRGB, (OpenTK.OpenGL.Enums.ExtBlendFuncSeparate)dfactorRGB, (OpenTK.OpenGL.Enums.ExtBlendFuncSeparate)sfactorAlpha, (OpenTK.OpenGL.Enums.ExtBlendFuncSeparate)dfactorAlpha);
            }

            public static 
            void VertexWeight(Single weight)
            {
                Delegates.glVertexWeightfEXT((Single)weight);
            }

            public static 
            void VertexWeightv(Single[] weight)
            {
                unsafe
                {
                    fixed (Single* weight_ptr = weight)
                    {
                        Delegates.glVertexWeightfvEXT((Single*)weight_ptr);
                    }
                }
            }

            public static 
            void VertexWeightv(ref Single weight)
            {
                unsafe
                {
                    fixed (Single* weight_ptr = &weight)
                    {
                        Delegates.glVertexWeightfvEXT((Single*)weight_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexWeightv(Single* weight)
            {
                Delegates.glVertexWeightfvEXT((Single*)weight);
            }

            public static 
            void VertexWeightPointer(Int32 size, OpenTK.OpenGL.Enums.ExtVertexWeighting type, Int32 stride, IntPtr pointer)
            {
                Delegates.glVertexWeightPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.ExtVertexWeighting)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void VertexWeightPointer(Int32 size, OpenTK.OpenGL.Enums.ExtVertexWeighting type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexWeightPointerEXT((Int32)size, (OpenTK.OpenGL.Enums.ExtVertexWeighting)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void SampleMask(Single value, bool invert)
            {
                Delegates.glSampleMaskEXT((Single)value, (bool)invert);
            }

            public static 
            void SamplePattern(OpenTK.OpenGL.Enums.ExtMultisample pattern)
            {
                Delegates.glSamplePatternEXT((OpenTK.OpenGL.Enums.ExtMultisample)pattern);
            }

            public static 
            void BeginVertexShader()
            {
                Delegates.glBeginVertexShaderEXT();
            }

            public static 
            void EndVertexShader()
            {
                Delegates.glEndVertexShaderEXT();
            }

            [System.CLSCompliant(false)]
            public static 
            void BindVertexShader(UInt32 id)
            {
                Delegates.glBindVertexShaderEXT((UInt32)id);
            }

            public static 
            void BindVertexShader(Int32 id)
            {
                Delegates.glBindVertexShaderEXT((UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GenVertexShaders(UInt32 range)
            {
                return Delegates.glGenVertexShadersEXT((UInt32)range);
            }

            public static 
            Int32 GenVertexShaders(Int32 range)
            {
                return Delegates.glGenVertexShadersEXT((UInt32)range);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteVertexShader(UInt32 id)
            {
                Delegates.glDeleteVertexShaderEXT((UInt32)id);
            }

            public static 
            void DeleteVertexShader(Int32 id)
            {
                Delegates.glDeleteVertexShaderEXT((UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            void ShaderOp1(OpenTK.OpenGL.Enums.ExtVertexShader op, UInt32 res, UInt32 arg1)
            {
                Delegates.glShaderOp1EXT((OpenTK.OpenGL.Enums.ExtVertexShader)op, (UInt32)res, (UInt32)arg1);
            }

            public static 
            void ShaderOp1(OpenTK.OpenGL.Enums.ExtVertexShader op, Int32 res, Int32 arg1)
            {
                Delegates.glShaderOp1EXT((OpenTK.OpenGL.Enums.ExtVertexShader)op, (UInt32)res, (UInt32)arg1);
            }

            [System.CLSCompliant(false)]
            public static 
            void ShaderOp2(OpenTK.OpenGL.Enums.ExtVertexShader op, UInt32 res, UInt32 arg1, UInt32 arg2)
            {
                Delegates.glShaderOp2EXT((OpenTK.OpenGL.Enums.ExtVertexShader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2);
            }

            public static 
            void ShaderOp2(OpenTK.OpenGL.Enums.ExtVertexShader op, Int32 res, Int32 arg1, Int32 arg2)
            {
                Delegates.glShaderOp2EXT((OpenTK.OpenGL.Enums.ExtVertexShader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2);
            }

            [System.CLSCompliant(false)]
            public static 
            void ShaderOp3(OpenTK.OpenGL.Enums.ExtVertexShader op, UInt32 res, UInt32 arg1, UInt32 arg2, UInt32 arg3)
            {
                Delegates.glShaderOp3EXT((OpenTK.OpenGL.Enums.ExtVertexShader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2, (UInt32)arg3);
            }

            public static 
            void ShaderOp3(OpenTK.OpenGL.Enums.ExtVertexShader op, Int32 res, Int32 arg1, Int32 arg2, Int32 arg3)
            {
                Delegates.glShaderOp3EXT((OpenTK.OpenGL.Enums.ExtVertexShader)op, (UInt32)res, (UInt32)arg1, (UInt32)arg2, (UInt32)arg3);
            }

            [System.CLSCompliant(false)]
            public static 
            void Swizzle(UInt32 res, UInt32 @in, OpenTK.OpenGL.Enums.ExtVertexShader outX, OpenTK.OpenGL.Enums.ExtVertexShader outY, OpenTK.OpenGL.Enums.ExtVertexShader outZ, OpenTK.OpenGL.Enums.ExtVertexShader outW)
            {
                Delegates.glSwizzleEXT((UInt32)res, (UInt32)@in, (OpenTK.OpenGL.Enums.ExtVertexShader)outX, (OpenTK.OpenGL.Enums.ExtVertexShader)outY, (OpenTK.OpenGL.Enums.ExtVertexShader)outZ, (OpenTK.OpenGL.Enums.ExtVertexShader)outW);
            }

            public static 
            void Swizzle(Int32 res, Int32 @in, OpenTK.OpenGL.Enums.ExtVertexShader outX, OpenTK.OpenGL.Enums.ExtVertexShader outY, OpenTK.OpenGL.Enums.ExtVertexShader outZ, OpenTK.OpenGL.Enums.ExtVertexShader outW)
            {
                Delegates.glSwizzleEXT((UInt32)res, (UInt32)@in, (OpenTK.OpenGL.Enums.ExtVertexShader)outX, (OpenTK.OpenGL.Enums.ExtVertexShader)outY, (OpenTK.OpenGL.Enums.ExtVertexShader)outZ, (OpenTK.OpenGL.Enums.ExtVertexShader)outW);
            }

            [System.CLSCompliant(false)]
            public static 
            void WriteMask(UInt32 res, UInt32 @in, OpenTK.OpenGL.Enums.ExtVertexShader outX, OpenTK.OpenGL.Enums.ExtVertexShader outY, OpenTK.OpenGL.Enums.ExtVertexShader outZ, OpenTK.OpenGL.Enums.ExtVertexShader outW)
            {
                Delegates.glWriteMaskEXT((UInt32)res, (UInt32)@in, (OpenTK.OpenGL.Enums.ExtVertexShader)outX, (OpenTK.OpenGL.Enums.ExtVertexShader)outY, (OpenTK.OpenGL.Enums.ExtVertexShader)outZ, (OpenTK.OpenGL.Enums.ExtVertexShader)outW);
            }

            public static 
            void WriteMask(Int32 res, Int32 @in, OpenTK.OpenGL.Enums.ExtVertexShader outX, OpenTK.OpenGL.Enums.ExtVertexShader outY, OpenTK.OpenGL.Enums.ExtVertexShader outZ, OpenTK.OpenGL.Enums.ExtVertexShader outW)
            {
                Delegates.glWriteMaskEXT((UInt32)res, (UInt32)@in, (OpenTK.OpenGL.Enums.ExtVertexShader)outX, (OpenTK.OpenGL.Enums.ExtVertexShader)outY, (OpenTK.OpenGL.Enums.ExtVertexShader)outZ, (OpenTK.OpenGL.Enums.ExtVertexShader)outW);
            }

            [System.CLSCompliant(false)]
            public static 
            void InsertComponent(UInt32 res, UInt32 src, UInt32 num)
            {
                Delegates.glInsertComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
            }

            public static 
            void InsertComponent(Int32 res, Int32 src, Int32 num)
            {
                Delegates.glInsertComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
            }

            [System.CLSCompliant(false)]
            public static 
            void ExtractComponent(UInt32 res, UInt32 src, UInt32 num)
            {
                Delegates.glExtractComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
            }

            public static 
            void ExtractComponent(Int32 res, Int32 src, Int32 num)
            {
                Delegates.glExtractComponentEXT((UInt32)res, (UInt32)src, (UInt32)num);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GenSymbol(OpenTK.OpenGL.Enums.ExtVertexShader datatype, OpenTK.OpenGL.Enums.ExtVertexShader storagetype, OpenTK.OpenGL.Enums.ExtVertexShader range, UInt32 components)
            {
                return Delegates.glGenSymbolsEXT((OpenTK.OpenGL.Enums.ExtVertexShader)datatype, (OpenTK.OpenGL.Enums.ExtVertexShader)storagetype, (OpenTK.OpenGL.Enums.ExtVertexShader)range, (UInt32)components);
            }

            public static 
            Int32 GenSymbol(OpenTK.OpenGL.Enums.ExtVertexShader datatype, OpenTK.OpenGL.Enums.ExtVertexShader storagetype, OpenTK.OpenGL.Enums.ExtVertexShader range, Int32 components)
            {
                return Delegates.glGenSymbolsEXT((OpenTK.OpenGL.Enums.ExtVertexShader)datatype, (OpenTK.OpenGL.Enums.ExtVertexShader)storagetype, (OpenTK.OpenGL.Enums.ExtVertexShader)range, (UInt32)components);
            }

            [System.CLSCompliant(false)]
            public static 
            void SetInvariant(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, IntPtr addr)
            {
                Delegates.glSetInvariantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr);
            }

            public static 
            void SetInvariant(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, IntPtr addr)
            {
                Delegates.glSetInvariantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void SetInvariant(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, [In, Out] object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetInvariantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }

            public static 
            void SetInvariant(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, [In, Out] object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetInvariantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void SetLocalConstant(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, IntPtr addr)
            {
                Delegates.glSetLocalConstantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr);
            }

            public static 
            void SetLocalConstant(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, IntPtr addr)
            {
                Delegates.glSetLocalConstantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void SetLocalConstant(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, [In, Out] object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetLocalConstantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }

            public static 
            void SetLocalConstant(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, [In, Out] object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSetLocalConstantEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, SByte[] addr)
            {
                unsafe
                {
                    fixed (SByte* addr_ptr = addr)
                    {
                        Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref SByte addr)
            {
                unsafe
                {
                    fixed (SByte* addr_ptr = &addr)
                    {
                        Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, SByte* addr)
            {
                Delegates.glVariantbvEXT((UInt32)id, (SByte*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, Int16[] addr)
            {
                unsafe
                {
                    fixed (Int16* addr_ptr = addr)
                    {
                        Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref Int16 addr)
            {
                unsafe
                {
                    fixed (Int16* addr_ptr = &addr)
                    {
                        Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, Int16* addr)
            {
                Delegates.glVariantsvEXT((UInt32)id, (Int16*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, Int32[] addr)
            {
                unsafe
                {
                    fixed (Int32* addr_ptr = addr)
                    {
                        Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref Int32 addr)
            {
                unsafe
                {
                    fixed (Int32* addr_ptr = &addr)
                    {
                        Delegates.glVariantivEXT((UInt32)id, (Int32*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, Int32* addr)
            {
                Delegates.glVariantivEXT((UInt32)id, (Int32*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, Single[] addr)
            {
                unsafe
                {
                    fixed (Single* addr_ptr = addr)
                    {
                        Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, Single[] addr)
            {
                unsafe
                {
                    fixed (Single* addr_ptr = addr)
                    {
                        Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref Single addr)
            {
                unsafe
                {
                    fixed (Single* addr_ptr = &addr)
                    {
                        Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, ref Single addr)
            {
                unsafe
                {
                    fixed (Single* addr_ptr = &addr)
                    {
                        Delegates.glVariantfvEXT((UInt32)id, (Single*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, Single* addr)
            {
                Delegates.glVariantfvEXT((UInt32)id, (Single*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(Int32 id, Single* addr)
            {
                Delegates.glVariantfvEXT((UInt32)id, (Single*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, Double[] addr)
            {
                unsafe
                {
                    fixed (Double* addr_ptr = addr)
                    {
                        Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, Double[] addr)
            {
                unsafe
                {
                    fixed (Double* addr_ptr = addr)
                    {
                        Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref Double addr)
            {
                unsafe
                {
                    fixed (Double* addr_ptr = &addr)
                    {
                        Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, ref Double addr)
            {
                unsafe
                {
                    fixed (Double* addr_ptr = &addr)
                    {
                        Delegates.glVariantdvEXT((UInt32)id, (Double*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, Double* addr)
            {
                Delegates.glVariantdvEXT((UInt32)id, (Double*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(Int32 id, Double* addr)
            {
                Delegates.glVariantdvEXT((UInt32)id, (Double*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, Byte[] addr)
            {
                unsafe
                {
                    fixed (Byte* addr_ptr = addr)
                    {
                        Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, Byte[] addr)
            {
                unsafe
                {
                    fixed (Byte* addr_ptr = addr)
                    {
                        Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref Byte addr)
            {
                unsafe
                {
                    fixed (Byte* addr_ptr = &addr)
                    {
                        Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, ref Byte addr)
            {
                unsafe
                {
                    fixed (Byte* addr_ptr = &addr)
                    {
                        Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, Byte* addr)
            {
                Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(Int32 id, Byte* addr)
            {
                Delegates.glVariantubvEXT((UInt32)id, (Byte*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, UInt16[] addr)
            {
                unsafe
                {
                    fixed (UInt16* addr_ptr = addr)
                    {
                        Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, Int16[] addr)
            {
                unsafe
                {
                    fixed (Int16* addr_ptr = addr)
                    {
                        Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref UInt16 addr)
            {
                unsafe
                {
                    fixed (UInt16* addr_ptr = &addr)
                    {
                        Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, ref Int16 addr)
            {
                unsafe
                {
                    fixed (Int16* addr_ptr = &addr)
                    {
                        Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, UInt16* addr)
            {
                Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(Int32 id, Int16* addr)
            {
                Delegates.glVariantusvEXT((UInt32)id, (UInt16*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, UInt32[] addr)
            {
                unsafe
                {
                    fixed (UInt32* addr_ptr = addr)
                    {
                        Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, Int32[] addr)
            {
                unsafe
                {
                    fixed (Int32* addr_ptr = addr)
                    {
                        Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Variant(UInt32 id, ref UInt32 addr)
            {
                unsafe
                {
                    fixed (UInt32* addr_ptr = &addr)
                    {
                        Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                    }
                }
            }

            public static 
            void Variant(Int32 id, ref Int32 addr)
            {
                unsafe
                {
                    fixed (Int32* addr_ptr = &addr)
                    {
                        Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(UInt32 id, UInt32* addr)
            {
                Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Variant(Int32 id, Int32* addr)
            {
                Delegates.glVariantuivEXT((UInt32)id, (UInt32*)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void VariantPointer(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, UInt32 stride, IntPtr addr)
            {
                Delegates.glVariantPointerEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (UInt32)stride, (IntPtr)addr);
            }

            public static 
            void VariantPointer(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, Int32 stride, IntPtr addr)
            {
                Delegates.glVariantPointerEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (UInt32)stride, (IntPtr)addr);
            }

            [System.CLSCompliant(false)]
            public static 
            void VariantPointer(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, UInt32 stride, [In, Out] object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVariantPointerEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (UInt32)stride, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }

            public static 
            void VariantPointer(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader type, Int32 stride, [In, Out] object addr)
            {
                System.Runtime.InteropServices.GCHandle addr_ptr = System.Runtime.InteropServices.GCHandle.Alloc(addr, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVariantPointerEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)type, (UInt32)stride, (IntPtr)addr_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    addr_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void EnableVariantClientState(UInt32 id)
            {
                Delegates.glEnableVariantClientStateEXT((UInt32)id);
            }

            public static 
            void EnableVariantClientState(Int32 id)
            {
                Delegates.glEnableVariantClientStateEXT((UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            void DisableVariantClientState(UInt32 id)
            {
                Delegates.glDisableVariantClientStateEXT((UInt32)id);
            }

            public static 
            void DisableVariantClientState(Int32 id)
            {
                Delegates.glDisableVariantClientStateEXT((UInt32)id);
            }

            public static 
            Int32 BindLightParameter(OpenTK.OpenGL.Enums.LightName light, OpenTK.OpenGL.Enums.LightParameter value)
            {
                return Delegates.glBindLightParameterEXT((OpenTK.OpenGL.Enums.LightName)light, (OpenTK.OpenGL.Enums.LightParameter)value);
            }

            public static 
            Int32 BindMaterialParameter(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter value)
            {
                return Delegates.glBindMaterialParameterEXT((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)value);
            }

            public static 
            Int32 BindTexGenParameter(OpenTK.OpenGL.Enums.ExtVertexShader unit, OpenTK.OpenGL.Enums.TextureCoordName coord, OpenTK.OpenGL.Enums.TextureGenParameter value)
            {
                return Delegates.glBindTexGenParameterEXT((OpenTK.OpenGL.Enums.ExtVertexShader)unit, (OpenTK.OpenGL.Enums.TextureCoordName)coord, (OpenTK.OpenGL.Enums.TextureGenParameter)value);
            }

            public static 
            Int32 BindTextureUnitParameter(OpenTK.OpenGL.Enums.ExtVertexShader unit, OpenTK.OpenGL.Enums.ExtVertexShader value)
            {
                return Delegates.glBindTextureUnitParameterEXT((OpenTK.OpenGL.Enums.ExtVertexShader)unit, (OpenTK.OpenGL.Enums.ExtVertexShader)value);
            }

            public static 
            Int32 BindParameter(OpenTK.OpenGL.Enums.ExtVertexShader value)
            {
                return Delegates.glBindParameterEXT((OpenTK.OpenGL.Enums.ExtVertexShader)value);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsVariantEnabled(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader cap)
            {
                return Delegates.glIsVariantEnabledEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)cap);
            }

            public static 
            bool IsVariantEnabled(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader cap)
            {
                return Delegates.glIsVariantEnabledEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)cap);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetVariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                    }
                }
            }

            public static 
            void GetVariantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetVariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetVariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetVariantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetVariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool* data)
            {
                Delegates.glGetVariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool* data)
            {
                Delegates.glGetVariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetVariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                    }
                }
            }

            public static 
            void GetVariantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetVariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetVariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetVariantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetVariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32* data)
            {
                Delegates.glGetVariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32* data)
            {
                Delegates.glGetVariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single[] data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = data)
                    {
                        Delegates.glGetVariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                    }
                }
            }

            public static 
            void GetVariantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single[] data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = data)
                    {
                        Delegates.glGetVariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Single data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = &data)
                    {
                        Delegates.glGetVariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetVariantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Single data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = &data)
                    {
                        Delegates.glGetVariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single* data)
            {
                Delegates.glGetVariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single* data)
            {
                Delegates.glGetVariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantPointer(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] IntPtr data)
            {
                Delegates.glGetVariantPointervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (IntPtr)data);
            }

            public static 
            void GetVariantPointer(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] IntPtr data)
            {
                Delegates.glGetVariantPointervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (IntPtr)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantPointer(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVariantPointervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            public static 
            void GetVariantPointer(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [In, Out] object data)
            {
                System.Runtime.InteropServices.GCHandle data_ptr = System.Runtime.InteropServices.GCHandle.Alloc(data, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVariantPointervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (IntPtr)data_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    data_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInvariantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetInvariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                    }
                }
            }

            public static 
            void GetInvariantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetInvariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInvariantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetInvariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetInvariantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetInvariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool* data)
            {
                Delegates.glGetInvariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool* data)
            {
                Delegates.glGetInvariantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInvariantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetInvariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                    }
                }
            }

            public static 
            void GetInvariantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetInvariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInvariantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetInvariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetInvariantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetInvariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32* data)
            {
                Delegates.glGetInvariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32* data)
            {
                Delegates.glGetInvariantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInvariantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single[] data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = data)
                    {
                        Delegates.glGetInvariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                    }
                }
            }

            public static 
            void GetInvariantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single[] data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = data)
                    {
                        Delegates.glGetInvariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetInvariantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Single data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = &data)
                    {
                        Delegates.glGetInvariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetInvariantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Single data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = &data)
                    {
                        Delegates.glGetInvariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single* data)
            {
                Delegates.glGetInvariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetInvariantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single* data)
            {
                Delegates.glGetInvariantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                    }
                }
            }

            public static 
            void GetLocalConstantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetLocalConstantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantBoolean(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool* data)
            {
                Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantBoolean(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] bool* data)
            {
                Delegates.glGetLocalConstantBooleanvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                    }
                }
            }

            public static 
            void GetLocalConstantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetLocalConstantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantInteger(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32* data)
            {
                Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantInteger(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Int32* data)
            {
                Delegates.glGetLocalConstantIntegervEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single[] data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                    }
                }
            }

            public static 
            void GetLocalConstantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single[] data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetLocalConstantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Single data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetLocalConstantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] out Single data)
            {
                unsafe
                {
                    fixed (Single* data_ptr = &data)
                    {
                        Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantFloat(UInt32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single* data)
            {
                Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetLocalConstantFloat(Int32 id, OpenTK.OpenGL.Enums.ExtVertexShader value, [Out] Single* data)
            {
                Delegates.glGetLocalConstantFloatvEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtVertexShader)value, (Single*)data);
            }

            public static 
            void ActiveStencilFace(OpenTK.OpenGL.Enums.ExtStencilTwoSide face)
            {
                Delegates.glActiveStencilFaceEXT((OpenTK.OpenGL.Enums.ExtStencilTwoSide)face);
            }

            public static 
            void DepthBounds(Double zmin, Double zmax)
            {
                Delegates.glDepthBoundsEXT((Double)zmin, (Double)zmax);
            }

            public static 
            void BlendEquationSeparate(OpenTK.OpenGL.Enums.BlendEquationModeExt modeRGB, OpenTK.OpenGL.Enums.BlendEquationModeExt modeAlpha)
            {
                Delegates.glBlendEquationSeparateEXT((OpenTK.OpenGL.Enums.BlendEquationModeExt)modeRGB, (OpenTK.OpenGL.Enums.BlendEquationModeExt)modeAlpha);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsRenderbuffer(UInt32 renderbuffer)
            {
                return Delegates.glIsRenderbufferEXT((UInt32)renderbuffer);
            }

            public static 
            bool IsRenderbuffer(Int32 renderbuffer)
            {
                return Delegates.glIsRenderbufferEXT((UInt32)renderbuffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindRenderbuffer(OpenTK.OpenGL.Enums.ExtFramebufferObject target, UInt32 renderbuffer)
            {
                Delegates.glBindRenderbufferEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (UInt32)renderbuffer);
            }

            public static 
            void BindRenderbuffer(OpenTK.OpenGL.Enums.ExtFramebufferObject target, Int32 renderbuffer)
            {
                Delegates.glBindRenderbufferEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (UInt32)renderbuffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteRenderbuffers(Int32 n, UInt32[] renderbuffers)
            {
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
            }

            public static 
            void DeleteRenderbuffers(Int32 n, Int32[] renderbuffers)
            {
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteRenderbuffers(Int32 n, ref UInt32 renderbuffers)
            {
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
            }

            public static 
            void DeleteRenderbuffers(Int32 n, ref Int32 renderbuffers)
            {
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteRenderbuffers(Int32 n, UInt32* renderbuffers)
            {
                Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteRenderbuffers(Int32 n, Int32* renderbuffers)
            {
                Delegates.glDeleteRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenRenderbuffers(Int32 n, [Out] UInt32[] renderbuffers)
            {
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
            }

            public static 
            void GenRenderbuffers(Int32 n, [Out] Int32[] renderbuffers)
            {
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenRenderbuffers(Int32 n, [Out] out UInt32 renderbuffers)
            {
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                        renderbuffers = *renderbuffers_ptr;
                    }
                }
            }

            public static 
            void GenRenderbuffers(Int32 n, [Out] out Int32 renderbuffers)
            {
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = &renderbuffers)
                    {
                        Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers_ptr);
                        renderbuffers = *renderbuffers_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenRenderbuffers(Int32 n, [Out] UInt32* renderbuffers)
            {
                Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenRenderbuffers(Int32 n, [Out] Int32* renderbuffers)
            {
                Delegates.glGenRenderbuffersEXT((Int32)n, (UInt32*)renderbuffers);
            }

            public static 
            void RenderbufferStorage(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject internalformat, Int32 width, Int32 height)
            {
                Delegates.glRenderbufferStorageEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)internalformat, (Int32)width, (Int32)height);
            }

            public static 
            void GetRenderbufferParameter(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetRenderbufferParameterivEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetRenderbufferParameter(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetRenderbufferParameterivEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetRenderbufferParameter(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject pname, [Out] Int32* @params)
            {
                Delegates.glGetRenderbufferParameterivEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsFramebuffer(UInt32 framebuffer)
            {
                return Delegates.glIsFramebufferEXT((UInt32)framebuffer);
            }

            public static 
            bool IsFramebuffer(Int32 framebuffer)
            {
                return Delegates.glIsFramebufferEXT((UInt32)framebuffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindFramebuffer(OpenTK.OpenGL.Enums.ExtFramebufferObject target, UInt32 framebuffer)
            {
                Delegates.glBindFramebufferEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (UInt32)framebuffer);
            }

            public static 
            void BindFramebuffer(OpenTK.OpenGL.Enums.ExtFramebufferObject target, Int32 framebuffer)
            {
                Delegates.glBindFramebufferEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (UInt32)framebuffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteFramebuffers(Int32 n, UInt32[] framebuffers)
            {
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
            }

            public static 
            void DeleteFramebuffers(Int32 n, Int32[] framebuffers)
            {
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteFramebuffers(Int32 n, ref UInt32 framebuffers)
            {
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
            }

            public static 
            void DeleteFramebuffers(Int32 n, ref Int32 framebuffers)
            {
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFramebuffers(Int32 n, UInt32* framebuffers)
            {
                Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFramebuffers(Int32 n, Int32* framebuffers)
            {
                Delegates.glDeleteFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenFramebuffers(Int32 n, [Out] UInt32[] framebuffers)
            {
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
            }

            public static 
            void GenFramebuffers(Int32 n, [Out] Int32[] framebuffers)
            {
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenFramebuffers(Int32 n, [Out] out UInt32 framebuffers)
            {
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                        framebuffers = *framebuffers_ptr;
                    }
                }
            }

            public static 
            void GenFramebuffers(Int32 n, [Out] out Int32 framebuffers)
            {
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = &framebuffers)
                    {
                        Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers_ptr);
                        framebuffers = *framebuffers_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFramebuffers(Int32 n, [Out] UInt32* framebuffers)
            {
                Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFramebuffers(Int32 n, [Out] Int32* framebuffers)
            {
                Delegates.glGenFramebuffersEXT((Int32)n, (UInt32*)framebuffers);
            }

            public static 
            IntPtr CheckFramebufferStat(OpenTK.OpenGL.Enums.ExtFramebufferObject target)
            {
                return Delegates.glCheckFramebufferStatusEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target);
            }

            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture1D(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject textarget, UInt32 texture, Int32 level)
            {
                Delegates.glFramebufferTexture1DEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)textarget, (UInt32)texture, (Int32)level);
            }

            public static 
            void FramebufferTexture1D(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject textarget, Int32 texture, Int32 level)
            {
                Delegates.glFramebufferTexture1DEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)textarget, (UInt32)texture, (Int32)level);
            }

            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture2D(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject textarget, UInt32 texture, Int32 level)
            {
                Delegates.glFramebufferTexture2DEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)textarget, (UInt32)texture, (Int32)level);
            }

            public static 
            void FramebufferTexture2D(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject textarget, Int32 texture, Int32 level)
            {
                Delegates.glFramebufferTexture2DEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)textarget, (UInt32)texture, (Int32)level);
            }

            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture3D(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject textarget, UInt32 texture, Int32 level, Int32 zoffset)
            {
                Delegates.glFramebufferTexture3DEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)textarget, (UInt32)texture, (Int32)level, (Int32)zoffset);
            }

            public static 
            void FramebufferTexture3D(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject textarget, Int32 texture, Int32 level, Int32 zoffset)
            {
                Delegates.glFramebufferTexture3DEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)textarget, (UInt32)texture, (Int32)level, (Int32)zoffset);
            }

            [System.CLSCompliant(false)]
            public static 
            void FramebufferRenderbuffer(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject renderbuffertarget, UInt32 renderbuffer)
            {
                Delegates.glFramebufferRenderbufferEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)renderbuffertarget, (UInt32)renderbuffer);
            }

            public static 
            void FramebufferRenderbuffer(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject renderbuffertarget, Int32 renderbuffer)
            {
                Delegates.glFramebufferRenderbufferEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)renderbuffertarget, (UInt32)renderbuffer);
            }

            public static 
            void GetFramebufferAttachmentParameter(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetFramebufferAttachmentParameterivEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFramebufferAttachmentParameter(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetFramebufferAttachmentParameterivEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFramebufferAttachmentParameter(OpenTK.OpenGL.Enums.ExtFramebufferObject target, OpenTK.OpenGL.Enums.ExtFramebufferObject attachment, OpenTK.OpenGL.Enums.ExtFramebufferObject pname, [Out] Int32* @params)
            {
                Delegates.glGetFramebufferAttachmentParameterivEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target, (OpenTK.OpenGL.Enums.ExtFramebufferObject)attachment, (OpenTK.OpenGL.Enums.ExtFramebufferObject)pname, (Int32*)@params);
            }

            public static 
            void GenerateMipmap(OpenTK.OpenGL.Enums.ExtFramebufferObject target)
            {
                Delegates.glGenerateMipmapEXT((OpenTK.OpenGL.Enums.ExtFramebufferObject)target);
            }

            [System.CLSCompliant(false)]
            public static 
            void StencilClearTag(Int32 stencilTagBits, UInt32 stencilClearTag)
            {
                Delegates.glStencilClearTagEXT((Int32)stencilTagBits, (UInt32)stencilClearTag);
            }

            public static 
            void StencilClearTag(Int32 stencilTagBits, Int32 stencilClearTag)
            {
                Delegates.glStencilClearTagEXT((Int32)stencilTagBits, (UInt32)stencilClearTag);
            }

            public static 
            void BlitFramebuffer(Int32 srcX0, Int32 srcY0, Int32 srcX1, Int32 srcY1, Int32 dstX0, Int32 dstY0, Int32 dstX1, Int32 dstY1, OpenTK.OpenGL.Enums.ClearBufferMask mask, OpenTK.OpenGL.Enums.ExtFramebufferBlit filter)
            {
                Delegates.glBlitFramebufferEXT((Int32)srcX0, (Int32)srcY0, (Int32)srcX1, (Int32)srcY1, (Int32)dstX0, (Int32)dstY0, (Int32)dstX1, (Int32)dstY1, (OpenTK.OpenGL.Enums.ClearBufferMask)mask, (OpenTK.OpenGL.Enums.ExtFramebufferBlit)filter);
            }

            public static 
            void RenderbufferStorageMultisample(OpenTK.OpenGL.Enums.ExtFramebufferMultisample target, Int32 samples, OpenTK.OpenGL.Enums.ExtFramebufferMultisample internalformat, Int32 width, Int32 height)
            {
                Delegates.glRenderbufferStorageMultisampleEXT((OpenTK.OpenGL.Enums.ExtFramebufferMultisample)target, (Int32)samples, (OpenTK.OpenGL.Enums.ExtFramebufferMultisample)internalformat, (Int32)width, (Int32)height);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjecti64(UInt32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] Int64[] @params)
            {
                unsafe
                {
                    fixed (Int64* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (Int64*)@params_ptr);
                    }
                }
            }

            public static 
            void GetQueryObjecti64(Int32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] Int64[] @params)
            {
                unsafe
                {
                    fixed (Int64* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (Int64*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjecti64(UInt32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] out Int64 @params)
            {
                unsafe
                {
                    fixed (Int64* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (Int64*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetQueryObjecti64(Int32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] out Int64 @params)
            {
                unsafe
                {
                    fixed (Int64* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjecti64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (Int64*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjecti64(UInt32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] Int64* @params)
            {
                Delegates.glGetQueryObjecti64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (Int64*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjecti64(Int32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] Int64* @params)
            {
                Delegates.glGetQueryObjecti64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (Int64*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectui64(UInt32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] UInt64[] @params)
            {
                unsafe
                {
                    fixed (UInt64* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (UInt64*)@params_ptr);
                    }
                }
            }

            public static 
            void GetQueryObjectui64(Int32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] Int64[] @params)
            {
                unsafe
                {
                    fixed (Int64* @params_ptr = @params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (UInt64*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetQueryObjectui64(UInt32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] out UInt64 @params)
            {
                unsafe
                {
                    fixed (UInt64* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (UInt64*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetQueryObjectui64(Int32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] out Int64 @params)
            {
                unsafe
                {
                    fixed (Int64* @params_ptr = &@params)
                    {
                        Delegates.glGetQueryObjectui64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (UInt64*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectui64(UInt32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] UInt64* @params)
            {
                Delegates.glGetQueryObjectui64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (UInt64*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetQueryObjectui64(Int32 id, OpenTK.OpenGL.Enums.ExtTimerQuery pname, [Out] Int64* @params)
            {
                Delegates.glGetQueryObjectui64vEXT((UInt32)id, (OpenTK.OpenGL.Enums.ExtTimerQuery)pname, (UInt64*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, UInt32 index, Int32 count, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, Int32 index, Int32 count, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, UInt32 index, Int32 count, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, Int32 index, Int32 count, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, UInt32 index, Int32 count, Single* @params)
            {
                Delegates.glProgramEnvParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, Int32 index, Int32 count, Single* @params)
            {
                Delegates.glProgramEnvParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, UInt32 index, Int32 count, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, Int32 index, Int32 count, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, UInt32 index, Int32 count, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, Int32 index, Int32 count, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, UInt32 index, Int32 count, Single* @params)
            {
                Delegates.glProgramLocalParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameters4(OpenTK.OpenGL.Enums.ExtGpuProgramParameters target, Int32 index, Int32 count, Single* @params)
            {
                Delegates.glProgramLocalParameters4fvEXT((OpenTK.OpenGL.Enums.ExtGpuProgramParameters)target, (UInt32)index, (Int32)count, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void FramebufferTexture(OpenTK.OpenGL.Enums.NvGeometryProgram4 target, OpenTK.OpenGL.Enums.NvGeometryProgram4 attachment, UInt32 texture, Int32 level)
            {
                Delegates.glFramebufferTextureEXT((OpenTK.OpenGL.Enums.NvGeometryProgram4)target, (OpenTK.OpenGL.Enums.NvGeometryProgram4)attachment, (UInt32)texture, (Int32)level);
            }

            public static 
            void FramebufferTexture(OpenTK.OpenGL.Enums.NvGeometryProgram4 target, OpenTK.OpenGL.Enums.NvGeometryProgram4 attachment, Int32 texture, Int32 level)
            {
                Delegates.glFramebufferTextureEXT((OpenTK.OpenGL.Enums.NvGeometryProgram4)target, (OpenTK.OpenGL.Enums.NvGeometryProgram4)attachment, (UInt32)texture, (Int32)level);
            }

            [System.CLSCompliant(false)]
            public static 
            void FramebufferTextureLayer(OpenTK.OpenGL.Enums.NvGeometryProgram4 target, OpenTK.OpenGL.Enums.NvGeometryProgram4 attachment, UInt32 texture, Int32 level, Int32 layer)
            {
                Delegates.glFramebufferTextureLayerEXT((OpenTK.OpenGL.Enums.NvGeometryProgram4)target, (OpenTK.OpenGL.Enums.NvGeometryProgram4)attachment, (UInt32)texture, (Int32)level, (Int32)layer);
            }

            public static 
            void FramebufferTextureLayer(OpenTK.OpenGL.Enums.NvGeometryProgram4 target, OpenTK.OpenGL.Enums.NvGeometryProgram4 attachment, Int32 texture, Int32 level, Int32 layer)
            {
                Delegates.glFramebufferTextureLayerEXT((OpenTK.OpenGL.Enums.NvGeometryProgram4)target, (OpenTK.OpenGL.Enums.NvGeometryProgram4)attachment, (UInt32)texture, (Int32)level, (Int32)layer);
            }

            [System.CLSCompliant(false)]
            public static 
            void FramebufferTextureFace(OpenTK.OpenGL.Enums.NvGeometryProgram4 target, OpenTK.OpenGL.Enums.NvGeometryProgram4 attachment, UInt32 texture, Int32 level, OpenTK.OpenGL.Enums.TextureTarget face)
            {
                Delegates.glFramebufferTextureFaceEXT((OpenTK.OpenGL.Enums.NvGeometryProgram4)target, (OpenTK.OpenGL.Enums.NvGeometryProgram4)attachment, (UInt32)texture, (Int32)level, (OpenTK.OpenGL.Enums.TextureTarget)face);
            }

            public static 
            void FramebufferTextureFace(OpenTK.OpenGL.Enums.NvGeometryProgram4 target, OpenTK.OpenGL.Enums.NvGeometryProgram4 attachment, Int32 texture, Int32 level, OpenTK.OpenGL.Enums.TextureTarget face)
            {
                Delegates.glFramebufferTextureFaceEXT((OpenTK.OpenGL.Enums.NvGeometryProgram4)target, (OpenTK.OpenGL.Enums.NvGeometryProgram4)attachment, (UInt32)texture, (Int32)level, (OpenTK.OpenGL.Enums.TextureTarget)face);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter(UInt32 program, OpenTK.OpenGL.Enums.ExtGeometryShader4 pname, Int32 value)
            {
                Delegates.glProgramParameteriEXT((UInt32)program, (OpenTK.OpenGL.Enums.ExtGeometryShader4)pname, (Int32)value);
            }

            public static 
            void ProgramParameter(Int32 program, OpenTK.OpenGL.Enums.ExtGeometryShader4 pname, Int32 value)
            {
                Delegates.glProgramParameteriEXT((UInt32)program, (OpenTK.OpenGL.Enums.ExtGeometryShader4)pname, (Int32)value);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1(UInt32 index, Int32 x)
            {
                Delegates.glVertexAttribI1iEXT((UInt32)index, (Int32)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2(UInt32 index, Int32 x, Int32 y)
            {
                Delegates.glVertexAttribI2iEXT((UInt32)index, (Int32)x, (Int32)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3(UInt32 index, Int32 x, Int32 y, Int32 z)
            {
                Delegates.glVertexAttribI3iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glVertexAttribI4iEXT((UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1(UInt32 index, UInt32 x)
            {
                Delegates.glVertexAttribI1uiEXT((UInt32)index, (UInt32)x);
            }

            public static 
            void VertexAttribI1(Int32 index, Int32 x)
            {
                Delegates.glVertexAttribI1uiEXT((UInt32)index, (UInt32)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2(UInt32 index, UInt32 x, UInt32 y)
            {
                Delegates.glVertexAttribI2uiEXT((UInt32)index, (UInt32)x, (UInt32)y);
            }

            public static 
            void VertexAttribI2(Int32 index, Int32 x, Int32 y)
            {
                Delegates.glVertexAttribI2uiEXT((UInt32)index, (UInt32)x, (UInt32)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3(UInt32 index, UInt32 x, UInt32 y, UInt32 z)
            {
                Delegates.glVertexAttribI3uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z);
            }

            public static 
            void VertexAttribI3(Int32 index, Int32 x, Int32 y, Int32 z)
            {
                Delegates.glVertexAttribI3uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
            {
                Delegates.glVertexAttribI4uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
            }

            public static 
            void VertexAttribI4(Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glVertexAttribI4uiEXT((UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1v(UInt32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1v(UInt32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI1v(UInt32 index, Int32* v)
            {
                Delegates.glVertexAttribI1ivEXT((UInt32)index, (Int32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2(UInt32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2(UInt32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI2(UInt32 index, Int32* v)
            {
                Delegates.glVertexAttribI2ivEXT((UInt32)index, (Int32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3(UInt32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3(UInt32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI3(UInt32 index, Int32* v)
            {
                Delegates.glVertexAttribI3ivEXT((UInt32)index, (Int32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(UInt32 index, Int32* v)
            {
                Delegates.glVertexAttribI4ivEXT((UInt32)index, (Int32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1v(UInt32 index, UInt32[] v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI1v(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI1v(UInt32 index, ref UInt32 v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI1v(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI1v(UInt32 index, UInt32* v)
            {
                Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI1v(Int32 index, Int32* v)
            {
                Delegates.glVertexAttribI1uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2(UInt32 index, UInt32[] v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI2(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI2(UInt32 index, ref UInt32 v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI2(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI2(UInt32 index, UInt32* v)
            {
                Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI2(Int32 index, Int32* v)
            {
                Delegates.glVertexAttribI2uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3(UInt32 index, UInt32[] v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI3(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI3(UInt32 index, ref UInt32 v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI3(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI3(UInt32 index, UInt32* v)
            {
                Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI3(Int32 index, Int32* v)
            {
                Delegates.glVertexAttribI3uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, UInt32[] v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI4(Int32 index, Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, ref UInt32 v)
            {
                unsafe
                {
                    fixed (UInt32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI4(Int32 index, ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(UInt32 index, UInt32* v)
            {
                Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(Int32 index, Int32* v)
            {
                Delegates.glVertexAttribI4uivEXT((UInt32)index, (UInt32*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, SByte[] v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, ref SByte v)
            {
                unsafe
                {
                    fixed (SByte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(UInt32 index, SByte* v)
            {
                Delegates.glVertexAttribI4bvEXT((UInt32)index, (SByte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttribI4svEXT((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI4(Int32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI4(Int32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(UInt32 index, Byte* v)
            {
                Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(Int32 index, Byte* v)
            {
                Delegates.glVertexAttribI4ubvEXT((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI4(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribI4(UInt32 index, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribI4(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(UInt32 index, UInt16* v)
            {
                Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribI4(Int32 index, Int16* v)
            {
                Delegates.glVertexAttribI4usvEXT((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribIPointer(UInt32 index, Int32 size, OpenTK.OpenGL.Enums.NvVertexProgram4 type, Int32 stride, IntPtr pointer)
            {
                Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.NvVertexProgram4)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void VertexAttribIPointer(Int32 index, Int32 size, OpenTK.OpenGL.Enums.NvVertexProgram4 type, Int32 stride, IntPtr pointer)
            {
                Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.NvVertexProgram4)type, (Int32)stride, (IntPtr)pointer);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribIPointer(UInt32 index, Int32 size, OpenTK.OpenGL.Enums.NvVertexProgram4 type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.NvVertexProgram4)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void VertexAttribIPointer(Int32 index, Int32 size, OpenTK.OpenGL.Enums.NvVertexProgram4 type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribIPointerEXT((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.NvVertexProgram4)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribI(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribIivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribI(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribIivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribI(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribIivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribI(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttribI(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribI(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] out UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttribI(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribIuivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribI(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] UInt32* @params)
            {
                Delegates.glGetVertexAttribIuivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribI(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram4 pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribIuivEXT((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram4)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetUniform(UInt32 program, Int32 location, [Out] UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetUniform(Int32 program, Int32 location, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetUniform(UInt32 program, Int32 location, [Out] out UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetUniform(Int32 program, Int32 location, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniform(UInt32 program, Int32 location, [Out] UInt32* @params)
            {
                Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetUniform(Int32 program, Int32 location, [Out] Int32* @params)
            {
                Delegates.glGetUniformuivEXT((UInt32)program, (Int32)location, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindFragDataLocation(UInt32 program, UInt32 color, System.String name)
            {
                Delegates.glBindFragDataLocationEXT((UInt32)program, (UInt32)color, (System.String)name);
            }

            public static 
            void BindFragDataLocation(Int32 program, Int32 color, System.String name)
            {
                Delegates.glBindFragDataLocationEXT((UInt32)program, (UInt32)color, (System.String)name);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GetFragDataLocation(UInt32 program, System.String name)
            {
                return Delegates.glGetFragDataLocationEXT((UInt32)program, (System.String)name);
            }

            public static 
            Int32 GetFragDataLocation(Int32 program, System.String name)
            {
                return Delegates.glGetFragDataLocationEXT((UInt32)program, (System.String)name);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform1(Int32 location, UInt32 v0)
            {
                Delegates.glUniform1uiEXT((Int32)location, (UInt32)v0);
            }

            public static 
            void Uniform1(Int32 location, Int32 v0)
            {
                Delegates.glUniform1uiEXT((Int32)location, (UInt32)v0);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform2(Int32 location, UInt32 v0, UInt32 v1)
            {
                Delegates.glUniform2uiEXT((Int32)location, (UInt32)v0, (UInt32)v1);
            }

            public static 
            void Uniform2(Int32 location, Int32 v0, Int32 v1)
            {
                Delegates.glUniform2uiEXT((Int32)location, (UInt32)v0, (UInt32)v1);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform3(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2)
            {
                Delegates.glUniform3uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2);
            }

            public static 
            void Uniform3(Int32 location, Int32 v0, Int32 v1, Int32 v2)
            {
                Delegates.glUniform3uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform4(Int32 location, UInt32 v0, UInt32 v1, UInt32 v2, UInt32 v3)
            {
                Delegates.glUniform4uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2, (UInt32)v3);
            }

            public static 
            void Uniform4(Int32 location, Int32 v0, Int32 v1, Int32 v2, Int32 v3)
            {
                Delegates.glUniform4uiEXT((Int32)location, (UInt32)v0, (UInt32)v1, (UInt32)v2, (UInt32)v3);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform1(Int32 location, Int32 count, UInt32[] value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = value)
                    {
                        Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform1(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform1(Int32 location, Int32 count, ref UInt32 value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = &value)
                    {
                        Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform1(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1(Int32 location, Int32 count, UInt32* value)
            {
                Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform1(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform1uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform2v(Int32 location, Int32 count, UInt32[] value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = value)
                    {
                        Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform2v(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform2v(Int32 location, Int32 count, ref UInt32 value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = &value)
                    {
                        Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform2v(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2v(Int32 location, Int32 count, UInt32* value)
            {
                Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform2v(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform2uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform3(Int32 location, Int32 count, UInt32[] value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = value)
                    {
                        Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform3(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform3(Int32 location, Int32 count, ref UInt32 value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = &value)
                    {
                        Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform3(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3(Int32 location, Int32 count, UInt32* value)
            {
                Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform3(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform3uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform4(Int32 location, Int32 count, UInt32[] value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = value)
                    {
                        Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform4(Int32 location, Int32 count, Int32[] value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = value)
                    {
                        Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Uniform4(Int32 location, Int32 count, ref UInt32 value)
            {
                unsafe
                {
                    fixed (UInt32* value_ptr = &value)
                    {
                        Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            public static 
            void Uniform4(Int32 location, Int32 count, ref Int32 value)
            {
                unsafe
                {
                    fixed (Int32* value_ptr = &value)
                    {
                        Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4(Int32 location, Int32 count, UInt32* value)
            {
                Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Uniform4(Int32 location, Int32 count, Int32* value)
            {
                Delegates.glUniform4uivEXT((Int32)location, (Int32)count, (UInt32*)value);
            }

            public static 
            void DrawArraysInstance(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 count, Int32 primcount)
            {
                Delegates.glDrawArraysInstancedEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)start, (Int32)count, (Int32)primcount);
            }

            public static 
            void DrawElementsInstance(OpenTK.OpenGL.Enums.BeginMode mode, Int32 count, OpenTK.OpenGL.Enums.ExtDrawInstanced type, IntPtr indices, Int32 primcount)
            {
                Delegates.glDrawElementsInstancedEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)count, (OpenTK.OpenGL.Enums.ExtDrawInstanced)type, (IntPtr)indices, (Int32)primcount);
            }

            public static 
            void DrawElementsInstance(OpenTK.OpenGL.Enums.BeginMode mode, Int32 count, OpenTK.OpenGL.Enums.ExtDrawInstanced type, [In, Out] object indices, Int32 primcount)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glDrawElementsInstancedEXT((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)count, (OpenTK.OpenGL.Enums.ExtDrawInstanced)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TexBuffer(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.ExtTextureBufferObject internalformat, UInt32 buffer)
            {
                Delegates.glTexBufferEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.ExtTextureBufferObject)internalformat, (UInt32)buffer);
            }

            public static 
            void TexBuffer(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.ExtTextureBufferObject internalformat, Int32 buffer)
            {
                Delegates.glTexBufferEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.ExtTextureBufferObject)internalformat, (UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void ColorMaskIndexe(UInt32 index, bool r, bool g, bool b, bool a)
            {
                Delegates.glColorMaskIndexedEXT((UInt32)index, (bool)r, (bool)g, (bool)b, (bool)a);
            }

            public static 
            void ColorMaskIndexe(Int32 index, bool r, bool g, bool b, bool a)
            {
                Delegates.glColorMaskIndexedEXT((UInt32)index, (bool)r, (bool)g, (bool)b, (bool)a);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetBooleanIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetBooleanIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (bool*)data_ptr);
                    }
                }
            }

            public static 
            void GetBooleanIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index, [Out] bool[] data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = data)
                    {
                        Delegates.glGetBooleanIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (bool*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetBooleanIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetBooleanIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetBooleanIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index, [Out] out bool data)
            {
                unsafe
                {
                    fixed (bool* data_ptr = &data)
                    {
                        Delegates.glGetBooleanIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (bool*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBooleanIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index, [Out] bool* data)
            {
                Delegates.glGetBooleanIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetBooleanIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index, [Out] bool* data)
            {
                Delegates.glGetBooleanIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (bool*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetIntegerIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (Int32*)data_ptr);
                    }
                }
            }

            public static 
            void GetIntegerIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index, [Out] Int32[] data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (Int32*)data_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetIntegerIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            public static 
            void GetIntegerIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index, [Out] out Int32 data)
            {
                unsafe
                {
                    fixed (Int32* data_ptr = &data)
                    {
                        Delegates.glGetIntegerIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (Int32*)data_ptr);
                        data = *data_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetIntegerIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index, [Out] Int32* data)
            {
                Delegates.glGetIntegerIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetIntegerIndexed(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index, [Out] Int32* data)
            {
                Delegates.glGetIntegerIndexedvEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index, (Int32*)data);
            }

            [System.CLSCompliant(false)]
            public static 
            void EnableIndexe(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index)
            {
                Delegates.glEnableIndexedEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index);
            }

            public static 
            void EnableIndexe(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index)
            {
                Delegates.glEnableIndexedEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index);
            }

            [System.CLSCompliant(false)]
            public static 
            void DisableIndexe(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index)
            {
                Delegates.glDisableIndexedEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index);
            }

            public static 
            void DisableIndexe(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index)
            {
                Delegates.glDisableIndexedEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsEnabledIndexe(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, UInt32 index)
            {
                return Delegates.glIsEnabledIndexedEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index);
            }

            public static 
            bool IsEnabledIndexe(OpenTK.OpenGL.Enums.ExtDrawBuffers2 target, Int32 index)
            {
                return Delegates.glIsEnabledIndexedEXT((OpenTK.OpenGL.Enums.ExtDrawBuffers2)target, (UInt32)index);
            }

            [System.CLSCompliant(false)]
            public static 
            void UniformBuffer(UInt32 program, Int32 location, UInt32 buffer)
            {
                Delegates.glUniformBufferEXT((UInt32)program, (Int32)location, (UInt32)buffer);
            }

            public static 
            void UniformBuffer(Int32 program, Int32 location, Int32 buffer)
            {
                Delegates.glUniformBufferEXT((UInt32)program, (Int32)location, (UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GetUniformBufferSize(UInt32 program, Int32 location)
            {
                return Delegates.glGetUniformBufferSizeEXT((UInt32)program, (Int32)location);
            }

            public static 
            Int32 GetUniformBufferSize(Int32 program, Int32 location)
            {
                return Delegates.glGetUniformBufferSizeEXT((UInt32)program, (Int32)location);
            }

            [System.CLSCompliant(false)]
            public static 
            IntPtr GetUniformOffset(UInt32 program, Int32 location)
            {
                return Delegates.glGetUniformOffsetEXT((UInt32)program, (Int32)location);
            }

            public static 
            IntPtr GetUniformOffset(Int32 program, Int32 location)
            {
                return Delegates.glGetUniformOffsetEXT((UInt32)program, (Int32)location);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexParameterIv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void TexParameterIv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TexParameterIv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, ref UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void TexParameterIv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexParameterIv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, UInt32* @params)
            {
                Delegates.glTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexParameterIv(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.TextureParameterName pname, Int32* @params)
            {
                Delegates.glTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.TextureParameterName)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetTexParameterI(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glGetTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetTexParameterI(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetTexParameterI(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] out UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glGetTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetTexParameterI(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexParameterI(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] UInt32* @params)
            {
                Delegates.glGetTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexParameterI(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.GetTextureParameter pname, [Out] Int32* @params)
            {
                Delegates.glGetTexParameterIuivEXT((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.GetTextureParameter)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ClearColorI(UInt32 red, UInt32 green, UInt32 blue, UInt32 alpha)
            {
                Delegates.glClearColorIuiEXT((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
            }

            public static 
            void ClearColorI(Int32 red, Int32 green, Int32 blue, Int32 alpha)
            {
                Delegates.glClearColorIuiEXT((UInt32)red, (UInt32)green, (UInt32)blue, (UInt32)alpha);
            }

        }

        public static partial class Sgis
        {
            public static 
            void GetTexFilterFunc(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.SgisTextureFilter4 filter, [Out] Single[] weights)
            {
                unsafe
                {
                    fixed (Single* weights_ptr = weights)
                    {
                        Delegates.glGetTexFilterFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.SgisTextureFilter4)filter, (Single*)weights_ptr);
                    }
                }
            }

            public static 
            void GetTexFilterFunc(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.SgisTextureFilter4 filter, [Out] out Single weights)
            {
                unsafe
                {
                    fixed (Single* weights_ptr = &weights)
                    {
                        Delegates.glGetTexFilterFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.SgisTextureFilter4)filter, (Single*)weights_ptr);
                        weights = *weights_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexFilterFunc(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.SgisTextureFilter4 filter, [Out] Single* weights)
            {
                Delegates.glGetTexFilterFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.SgisTextureFilter4)filter, (Single*)weights);
            }

            public static 
            void TexFilterFunc(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.SgisTextureFilter4 filter, Int32 n, Single[] weights)
            {
                unsafe
                {
                    fixed (Single* weights_ptr = weights)
                    {
                        Delegates.glTexFilterFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.SgisTextureFilter4)filter, (Int32)n, (Single*)weights_ptr);
                    }
                }
            }

            public static 
            void TexFilterFunc(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.SgisTextureFilter4 filter, Int32 n, ref Single weights)
            {
                unsafe
                {
                    fixed (Single* weights_ptr = &weights)
                    {
                        Delegates.glTexFilterFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.SgisTextureFilter4)filter, (Int32)n, (Single*)weights_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexFilterFunc(OpenTK.OpenGL.Enums.TextureTarget target, OpenTK.OpenGL.Enums.SgisTextureFilter4 filter, Int32 n, Single* weights)
            {
                Delegates.glTexFilterFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (OpenTK.OpenGL.Enums.SgisTextureFilter4)filter, (Int32)n, (Single*)weights);
            }

            public static 
            void PixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, Int32 param)
            {
                Delegates.glPixelTexGenParameteriSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Int32)param);
            }

            public static 
            void PixelTexGenParameterv(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glPixelTexGenParameterivSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void PixelTexGenParameterv(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glPixelTexGenParameterivSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTexGenParameterv(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, Int32* @params)
            {
                Delegates.glPixelTexGenParameterivSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Int32*)@params);
            }

            public static 
            void PixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, Single param)
            {
                Delegates.glPixelTexGenParameterfSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Single)param);
            }

            public static 
            void PixelTexGenParameterv(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glPixelTexGenParameterfvSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void PixelTexGenParameterv(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glPixelTexGenParameterfvSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PixelTexGenParameterv(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, Single* @params)
            {
                Delegates.glPixelTexGenParameterfvSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Single*)@params);
            }

            public static 
            void GetPixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetPixelTexGenParameterivSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetPixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetPixelTexGenParameterivSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetPixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, [Out] Int32* @params)
            {
                Delegates.glGetPixelTexGenParameterivSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Int32*)@params);
            }

            public static 
            void GetPixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetPixelTexGenParameterfvSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetPixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetPixelTexGenParameterfvSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetPixelTexGenParameter(OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis pname, [Out] Single* @params)
            {
                Delegates.glGetPixelTexGenParameterfvSGIS((OpenTK.OpenGL.Enums.PixelTexGenParameterNameSgis)pname, (Single*)@params);
            }

            public static 
            void TexImage4D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 size4d, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
            {
                Delegates.glTexImage4DSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
            }

            public static 
            void TexImage4D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height, Int32 depth, Int32 size4d, Int32 border, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexImage4DSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (Int32)border, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }

            public static 
            void TexSubImage4D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 woffset, Int32 width, Int32 height, Int32 depth, Int32 size4d, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr pixels)
            {
                Delegates.glTexSubImage4DSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)woffset, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels);
            }

            public static 
            void TexSubImage4D(OpenTK.OpenGL.Enums.TextureTarget target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 zoffset, Int32 woffset, Int32 width, Int32 height, Int32 depth, Int32 size4d, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object pixels)
            {
                System.Runtime.InteropServices.GCHandle pixels_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pixels, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexSubImage4DSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)zoffset, (Int32)woffset, (Int32)width, (Int32)height, (Int32)depth, (Int32)size4d, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pixels_ptr.Free();
                }
            }

            public static 
            void DetailTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, Int32 n, Single[] points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = points)
                    {
                        Delegates.glDetailTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
                    }
                }
            }

            public static 
            void DetailTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, Int32 n, ref Single points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = &points)
                    {
                        Delegates.glDetailTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DetailTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, Int32 n, Single* points)
            {
                Delegates.glDetailTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)n, (Single*)points);
            }

            public static 
            void GetDetailTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, [Out] Single[] points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = points)
                    {
                        Delegates.glGetDetailTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Single*)points_ptr);
                    }
                }
            }

            public static 
            void GetDetailTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, [Out] out Single points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = &points)
                    {
                        Delegates.glGetDetailTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Single*)points_ptr);
                        points = *points_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetDetailTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, [Out] Single* points)
            {
                Delegates.glGetDetailTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Single*)points);
            }

            public static 
            void SharpenTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, Int32 n, Single[] points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = points)
                    {
                        Delegates.glSharpenTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
                    }
                }
            }

            public static 
            void SharpenTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, Int32 n, ref Single points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = &points)
                    {
                        Delegates.glSharpenTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)n, (Single*)points_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SharpenTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, Int32 n, Single* points)
            {
                Delegates.glSharpenTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Int32)n, (Single*)points);
            }

            public static 
            void GetSharpenTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, [Out] Single[] points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = points)
                    {
                        Delegates.glGetSharpenTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Single*)points_ptr);
                    }
                }
            }

            public static 
            void GetSharpenTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, [Out] out Single points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = &points)
                    {
                        Delegates.glGetSharpenTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Single*)points_ptr);
                        points = *points_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetSharpenTexFunc(OpenTK.OpenGL.Enums.TextureTarget target, [Out] Single* points)
            {
                Delegates.glGetSharpenTexFuncSGIS((OpenTK.OpenGL.Enums.TextureTarget)target, (Single*)points);
            }

            public static 
            void SampleMask(Single value, bool invert)
            {
                Delegates.glSampleMaskSGIS((Single)value, (bool)invert);
            }

            public static 
            void SamplePattern(OpenTK.OpenGL.Enums.SamplePatternSgis pattern)
            {
                Delegates.glSamplePatternSGIS((OpenTK.OpenGL.Enums.SamplePatternSgis)pattern);
            }

            public static 
            void PointParameter(OpenTK.OpenGL.Enums.SgisPointParameters pname, Single param)
            {
                Delegates.glPointParameterfSGIS((OpenTK.OpenGL.Enums.SgisPointParameters)pname, (Single)param);
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.SgisPointParameters pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glPointParameterfvSGIS((OpenTK.OpenGL.Enums.SgisPointParameters)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.SgisPointParameters pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterfvSGIS((OpenTK.OpenGL.Enums.SgisPointParameters)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameterv(OpenTK.OpenGL.Enums.SgisPointParameters pname, Single* @params)
            {
                Delegates.glPointParameterfvSGIS((OpenTK.OpenGL.Enums.SgisPointParameters)pname, (Single*)@params);
            }

            public static 
            void FogFunc(Int32 n, Single[] points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = points)
                    {
                        Delegates.glFogFuncSGIS((Int32)n, (Single*)points_ptr);
                    }
                }
            }

            public static 
            void FogFunc(Int32 n, ref Single points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = &points)
                    {
                        Delegates.glFogFuncSGIS((Int32)n, (Single*)points_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FogFunc(Int32 n, Single* points)
            {
                Delegates.glFogFuncSGIS((Int32)n, (Single*)points);
            }

            public static 
            void GetFogFunc([Out] Single[] points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = points)
                    {
                        Delegates.glGetFogFuncSGIS((Single*)points_ptr);
                    }
                }
            }

            public static 
            void GetFogFunc([Out] out Single points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = &points)
                    {
                        Delegates.glGetFogFuncSGIS((Single*)points_ptr);
                        points = *points_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFogFunc([Out] Single* points)
            {
                Delegates.glGetFogFuncSGIS((Single*)points);
            }

            public static 
            void TextureColorMask(bool red, bool green, bool blue, bool alpha)
            {
                Delegates.glTextureColorMaskSGIS((bool)red, (bool)green, (bool)blue, (bool)alpha);
            }

        }

        public static partial class Sgi
        {
            public static 
            void ColorTable(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, IntPtr table)
            {
                Delegates.glColorTableSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table);
            }

            public static 
            void ColorTable(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object table)
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorTableSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }

            public static 
            void ColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glColorTableParameterfvSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glColorTableParameterfvSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi pname, Single* @params)
            {
                Delegates.glColorTableParameterfvSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi)pname, (Single*)@params);
            }

            public static 
            void ColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glColorTableParameterivSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void ColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glColorTableParameterivSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi pname, Int32* @params)
            {
                Delegates.glColorTableParameterivSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.ColorTableParameterPNameSgi)pname, (Int32*)@params);
            }

            public static 
            void CopyColorTable(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 x, Int32 y, Int32 width)
            {
                Delegates.glCopyColorTableSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)x, (Int32)y, (Int32)width);
            }

            public static 
            void GetColorTable(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [Out] IntPtr table)
            {
                Delegates.glGetColorTableSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table);
            }

            public static 
            void GetColorTable(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.PixelFormat format, OpenTK.OpenGL.Enums.PixelType type, [In, Out] object table)
            {
                System.Runtime.InteropServices.GCHandle table_ptr = System.Runtime.InteropServices.GCHandle.Alloc(table, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetColorTableSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.PixelFormat)format, (OpenTK.OpenGL.Enums.PixelType)type, (IntPtr)table_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    table_ptr.Free();
                }
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterfvSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterfvSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi pname, [Out] Single* @params)
            {
                Delegates.glGetColorTableParameterfvSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi)pname, (Single*)@params);
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetColorTableParameterivSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetColorTableParameterivSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetColorTableParameter(OpenTK.OpenGL.Enums.ColorTableTargetSgi target, OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi pname, [Out] Int32* @params)
            {
                Delegates.glGetColorTableParameterivSGI((OpenTK.OpenGL.Enums.ColorTableTargetSgi)target, (OpenTK.OpenGL.Enums.GetColorTableParameterPNameSgi)pname, (Int32*)@params);
            }

        }

        public static partial class Sgix
        {
            public static 
            void PixelTexGen(OpenTK.OpenGL.Enums.SgixPixelTexture mode)
            {
                Delegates.glPixelTexGenSGIX((OpenTK.OpenGL.Enums.SgixPixelTexture)mode);
            }

            public static 
            void SpriteParameter(OpenTK.OpenGL.Enums.SgixSprite pname, Single param)
            {
                Delegates.glSpriteParameterfSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Single)param);
            }

            public static 
            void SpriteParameterv(OpenTK.OpenGL.Enums.SgixSprite pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glSpriteParameterfvSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void SpriteParameterv(OpenTK.OpenGL.Enums.SgixSprite pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glSpriteParameterfvSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SpriteParameterv(OpenTK.OpenGL.Enums.SgixSprite pname, Single* @params)
            {
                Delegates.glSpriteParameterfvSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Single*)@params);
            }

            public static 
            void SpriteParameter(OpenTK.OpenGL.Enums.SgixSprite pname, Int32 param)
            {
                Delegates.glSpriteParameteriSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Int32)param);
            }

            public static 
            void SpriteParameterv(OpenTK.OpenGL.Enums.SgixSprite pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glSpriteParameterivSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void SpriteParameterv(OpenTK.OpenGL.Enums.SgixSprite pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glSpriteParameterivSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SpriteParameterv(OpenTK.OpenGL.Enums.SgixSprite pname, Int32* @params)
            {
                Delegates.glSpriteParameterivSGIX((OpenTK.OpenGL.Enums.SgixSprite)pname, (Int32*)@params);
            }

            public static 
            Int32 GetInstruments()
            {
                return Delegates.glGetInstrumentsSGIX();
            }

            public static 
            void InstrumentsBuffer(Int32 size, [Out] Int32[] buffer)
            {
                unsafe
                {
                    fixed (Int32* buffer_ptr = buffer)
                    {
                        Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer_ptr);
                    }
                }
            }

            public static 
            void InstrumentsBuffer(Int32 size, [Out] out Int32 buffer)
            {
                unsafe
                {
                    fixed (Int32* buffer_ptr = &buffer)
                    {
                        Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer_ptr);
                        buffer = *buffer_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void InstrumentsBuffer(Int32 size, [Out] Int32* buffer)
            {
                Delegates.glInstrumentsBufferSGIX((Int32)size, (Int32*)buffer);
            }

            public static 
            Int32 PollInstruments([Out] Int32[] marker_p)
            {
                unsafe
                {
                    fixed (Int32* marker_p_ptr = marker_p)
                    {
                        return Delegates.glPollInstrumentsSGIX((Int32*)marker_p_ptr);
                    }
                }
            }

            public static 
            Int32 PollInstruments([Out] out Int32 marker_p)
            {
                unsafe
                {
                    fixed (Int32* marker_p_ptr = &marker_p)
                    {
                        Int32 retval = Delegates.glPollInstrumentsSGIX((Int32*)marker_p_ptr);
                        marker_p = *marker_p_ptr;
                        return retval;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe Int32 PollInstruments([Out] Int32* marker_p)
            {
                return Delegates.glPollInstrumentsSGIX((Int32*)marker_p);
            }

            public static 
            void ReadInstruments(Int32 marker)
            {
                Delegates.glReadInstrumentsSGIX((Int32)marker);
            }

            public static 
            void StartInstruments()
            {
                Delegates.glStartInstrumentsSGIX();
            }

            public static 
            void StopInstruments(Int32 marker)
            {
                Delegates.glStopInstrumentsSGIX((Int32)marker);
            }

            public static 
            void FrameZoom(Int32 factor)
            {
                Delegates.glFrameZoomSGIX((Int32)factor);
            }

            public static 
            void TagSampleBuffer()
            {
                Delegates.glTagSampleBufferSGIX();
            }

            public static 
            void DeformationMap3(OpenTK.OpenGL.Enums.FfdTargetSgix target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, Double[] points)
            {
                unsafe
                {
                    fixed (Double* points_ptr = points)
                    {
                        Delegates.glDeformationMap3dSGIX((OpenTK.OpenGL.Enums.FfdTargetSgix)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points_ptr);
                    }
                }
            }

            public static 
            void DeformationMap3(OpenTK.OpenGL.Enums.FfdTargetSgix target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, ref Double points)
            {
                unsafe
                {
                    fixed (Double* points_ptr = &points)
                    {
                        Delegates.glDeformationMap3dSGIX((OpenTK.OpenGL.Enums.FfdTargetSgix)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeformationMap3(OpenTK.OpenGL.Enums.FfdTargetSgix target, Double u1, Double u2, Int32 ustride, Int32 uorder, Double v1, Double v2, Int32 vstride, Int32 vorder, Double w1, Double w2, Int32 wstride, Int32 worder, Double* points)
            {
                Delegates.glDeformationMap3dSGIX((OpenTK.OpenGL.Enums.FfdTargetSgix)target, (Double)u1, (Double)u2, (Int32)ustride, (Int32)uorder, (Double)v1, (Double)v2, (Int32)vstride, (Int32)vorder, (Double)w1, (Double)w2, (Int32)wstride, (Int32)worder, (Double*)points);
            }

            public static 
            void DeformationMap3(OpenTK.OpenGL.Enums.FfdTargetSgix target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, Single[] points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = points)
                    {
                        Delegates.glDeformationMap3fSGIX((OpenTK.OpenGL.Enums.FfdTargetSgix)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points_ptr);
                    }
                }
            }

            public static 
            void DeformationMap3(OpenTK.OpenGL.Enums.FfdTargetSgix target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, ref Single points)
            {
                unsafe
                {
                    fixed (Single* points_ptr = &points)
                    {
                        Delegates.glDeformationMap3fSGIX((OpenTK.OpenGL.Enums.FfdTargetSgix)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeformationMap3(OpenTK.OpenGL.Enums.FfdTargetSgix target, Single u1, Single u2, Int32 ustride, Int32 uorder, Single v1, Single v2, Int32 vstride, Int32 vorder, Single w1, Single w2, Int32 wstride, Int32 worder, Single* points)
            {
                Delegates.glDeformationMap3fSGIX((OpenTK.OpenGL.Enums.FfdTargetSgix)target, (Single)u1, (Single)u2, (Int32)ustride, (Int32)uorder, (Single)v1, (Single)v2, (Int32)vstride, (Int32)vorder, (Single)w1, (Single)w2, (Int32)wstride, (Int32)worder, (Single*)points);
            }

            public static 
            void Deform(OpenTK.OpenGL.Enums.FfdMaskSgix mask)
            {
                Delegates.glDeformSGIX((OpenTK.OpenGL.Enums.FfdMaskSgix)mask);
            }

            public static 
            void LoadIdentityDeformationMap(OpenTK.OpenGL.Enums.FfdMaskSgix mask)
            {
                Delegates.glLoadIdentityDeformationMapSGIX((OpenTK.OpenGL.Enums.FfdMaskSgix)mask);
            }

            public static 
            void ReferencePlane(Double[] equation)
            {
                unsafe
                {
                    fixed (Double* equation_ptr = equation)
                    {
                        Delegates.glReferencePlaneSGIX((Double*)equation_ptr);
                    }
                }
            }

            public static 
            void ReferencePlane(ref Double equation)
            {
                unsafe
                {
                    fixed (Double* equation_ptr = &equation)
                    {
                        Delegates.glReferencePlaneSGIX((Double*)equation_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReferencePlane(Double* equation)
            {
                Delegates.glReferencePlaneSGIX((Double*)equation);
            }

            public static 
            void FlushRaster()
            {
                Delegates.glFlushRasterSGIX();
            }

            [System.CLSCompliant(false)]
            public static 
            void GetListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Single* @params)
            {
                Delegates.glGetListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Single* @params)
            {
                Delegates.glGetListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Int32* @params)
            {
                Delegates.glGetListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, [Out] Int32* @params)
            {
                Delegates.glGetListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Single param)
            {
                Delegates.glListParameterfSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single)param);
            }

            public static 
            void ListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Single param)
            {
                Delegates.glListParameterfSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single)param);
            }

            [System.CLSCompliant(false)]
            public static 
            void ListParameterv(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ListParameterv(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ListParameterv(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ListParameterv(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameterv(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Single* @params)
            {
                Delegates.glListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameterv(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Single* @params)
            {
                Delegates.glListParameterfvSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ListParameter(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Int32 param)
            {
                Delegates.glListParameteriSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32)param);
            }

            public static 
            void ListParameter(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Int32 param)
            {
                Delegates.glListParameteriSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32)param);
            }

            [System.CLSCompliant(false)]
            public static 
            void ListParameterv(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void ListParameterv(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ListParameterv(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void ListParameterv(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameterv(UInt32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Int32* @params)
            {
                Delegates.glListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ListParameterv(Int32 list, OpenTK.OpenGL.Enums.ListParameterName pname, Int32* @params)
            {
                Delegates.glListParameterivSGIX((UInt32)list, (OpenTK.OpenGL.Enums.ListParameterName)pname, (Int32*)@params);
            }

            public static 
            void FragmentColorMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter mode)
            {
                Delegates.glFragmentColorMaterialSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)mode);
            }

            public static 
            void FragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, Single param)
            {
                Delegates.glFragmentLightfSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Single)param);
            }

            public static 
            void FragmentLightv(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightfvSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void FragmentLightv(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightfvSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightv(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, Single* @params)
            {
                Delegates.glFragmentLightfvSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Single*)@params);
            }

            public static 
            void FragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, Int32 param)
            {
                Delegates.glFragmentLightiSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Int32)param);
            }

            public static 
            void FragmentLightv(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightivSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void FragmentLightv(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightivSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightv(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, Int32* @params)
            {
                Delegates.glFragmentLightivSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Int32*)@params);
            }

            public static 
            void FragmentLightModel(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, Single param)
            {
                Delegates.glFragmentLightModelfSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Single)param);
            }

            public static 
            void FragmentLightModelv(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightModelfvSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void FragmentLightModelv(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightModelfvSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightModelv(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, Single* @params)
            {
                Delegates.glFragmentLightModelfvSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Single*)@params);
            }

            public static 
            void FragmentLightModel(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, Int32 param)
            {
                Delegates.glFragmentLightModeliSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Int32)param);
            }

            public static 
            void FragmentLightModelv(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glFragmentLightModelivSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void FragmentLightModelv(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glFragmentLightModelivSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentLightModelv(OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix pname, Int32* @params)
            {
                Delegates.glFragmentLightModelivSGIX((OpenTK.OpenGL.Enums.FragmentLightModelParameterSgix)pname, (Int32*)@params);
            }

            public static 
            void FragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Single param)
            {
                Delegates.glFragmentMaterialfSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single)param);
            }

            public static 
            void FragmentMaterialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glFragmentMaterialfvSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void FragmentMaterialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glFragmentMaterialfvSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentMaterialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Single* @params)
            {
                Delegates.glFragmentMaterialfvSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params);
            }

            public static 
            void FragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Int32 param)
            {
                Delegates.glFragmentMaterialiSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32)param);
            }

            public static 
            void FragmentMaterialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glFragmentMaterialivSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void FragmentMaterialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glFragmentMaterialivSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FragmentMaterialv(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, Int32* @params)
            {
                Delegates.glFragmentMaterialivSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params);
            }

            public static 
            void GetFragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentLightfvSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentLightfvSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, [Out] Single* @params)
            {
                Delegates.glGetFragmentLightfvSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Single*)@params);
            }

            public static 
            void GetFragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentLightivSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentLightivSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentLight(OpenTK.OpenGL.Enums.SgixFragmentLighting light, OpenTK.OpenGL.Enums.SgixFragmentLighting pname, [Out] Int32* @params)
            {
                Delegates.glGetFragmentLightivSGIX((OpenTK.OpenGL.Enums.SgixFragmentLighting)light, (OpenTK.OpenGL.Enums.SgixFragmentLighting)pname, (Int32*)@params);
            }

            public static 
            void GetFragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentMaterialfvSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentMaterialfvSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Single* @params)
            {
                Delegates.glGetFragmentMaterialfvSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Single*)@params);
            }

            public static 
            void GetFragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetFragmentMaterialivSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetFragmentMaterialivSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFragmentMaterial(OpenTK.OpenGL.Enums.MaterialFace face, OpenTK.OpenGL.Enums.MaterialParameter pname, [Out] Int32* @params)
            {
                Delegates.glGetFragmentMaterialivSGIX((OpenTK.OpenGL.Enums.MaterialFace)face, (OpenTK.OpenGL.Enums.MaterialParameter)pname, (Int32*)@params);
            }

            public static 
            void LightEnv(OpenTK.OpenGL.Enums.LightEnvParameterSgix pname, Int32 param)
            {
                Delegates.glLightEnviSGIX((OpenTK.OpenGL.Enums.LightEnvParameterSgix)pname, (Int32)param);
            }

            [System.CLSCompliant(false)]
            public static 
            void AsyncMarker(UInt32 marker)
            {
                Delegates.glAsyncMarkerSGIX((UInt32)marker);
            }

            public static 
            void AsyncMarker(Int32 marker)
            {
                Delegates.glAsyncMarkerSGIX((UInt32)marker);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 FinishAsync([Out] UInt32[] markerp)
            {
                unsafe
                {
                    fixed (UInt32* markerp_ptr = markerp)
                    {
                        return Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                    }
                }
            }

            public static 
            Int32 FinishAsync([Out] Int32[] markerp)
            {
                unsafe
                {
                    fixed (Int32* markerp_ptr = markerp)
                    {
                        return Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 FinishAsync([Out] out UInt32 markerp)
            {
                unsafe
                {
                    fixed (UInt32* markerp_ptr = &markerp)
                    {
                        Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }

            public static 
            Int32 FinishAsync([Out] out Int32 markerp)
            {
                unsafe
                {
                    fixed (Int32* markerp_ptr = &markerp)
                    {
                        Int32 retval = Delegates.glFinishAsyncSGIX((UInt32*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe Int32 FinishAsync([Out] UInt32* markerp)
            {
                return Delegates.glFinishAsyncSGIX((UInt32*)markerp);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe Int32 FinishAsync([Out] Int32* markerp)
            {
                return Delegates.glFinishAsyncSGIX((UInt32*)markerp);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 PollAsync([Out] UInt32[] markerp)
            {
                unsafe
                {
                    fixed (UInt32* markerp_ptr = markerp)
                    {
                        return Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                    }
                }
            }

            public static 
            Int32 PollAsync([Out] Int32[] markerp)
            {
                unsafe
                {
                    fixed (Int32* markerp_ptr = markerp)
                    {
                        return Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 PollAsync([Out] out UInt32 markerp)
            {
                unsafe
                {
                    fixed (UInt32* markerp_ptr = &markerp)
                    {
                        Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }

            public static 
            Int32 PollAsync([Out] out Int32 markerp)
            {
                unsafe
                {
                    fixed (Int32* markerp_ptr = &markerp)
                    {
                        Int32 retval = Delegates.glPollAsyncSGIX((UInt32*)markerp_ptr);
                        markerp = *markerp_ptr;
                        return retval;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe Int32 PollAsync([Out] UInt32* markerp)
            {
                return Delegates.glPollAsyncSGIX((UInt32*)markerp);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe Int32 PollAsync([Out] Int32* markerp)
            {
                return Delegates.glPollAsyncSGIX((UInt32*)markerp);
            }

            public static 
            Int32 GenAsyncMarkers(Int32 range)
            {
                return Delegates.glGenAsyncMarkersSGIX((Int32)range);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteAsyncMarkers(UInt32 marker, Int32 range)
            {
                Delegates.glDeleteAsyncMarkersSGIX((UInt32)marker, (Int32)range);
            }

            public static 
            void DeleteAsyncMarkers(Int32 marker, Int32 range)
            {
                Delegates.glDeleteAsyncMarkersSGIX((UInt32)marker, (Int32)range);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsAsyncMarker(UInt32 marker)
            {
                return Delegates.glIsAsyncMarkerSGIX((UInt32)marker);
            }

            public static 
            bool IsAsyncMarker(Int32 marker)
            {
                return Delegates.glIsAsyncMarkerSGIX((UInt32)marker);
            }

            public static 
            void IglooInterface(OpenTK.OpenGL.Enums.All pname, IntPtr @params)
            {
                Delegates.glIglooInterfaceSGIX((OpenTK.OpenGL.Enums.All)pname, (IntPtr)@params);
            }

            public static 
            void IglooInterface(OpenTK.OpenGL.Enums.All pname, [In, Out] object @params)
            {
                System.Runtime.InteropServices.GCHandle @params_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@params, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glIglooInterfaceSGIX((OpenTK.OpenGL.Enums.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
            }

        }

        public static partial class HP
        {
            public static 
            void ImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, Int32 param)
            {
                Delegates.glImageTransformParameteriHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Int32)param);
            }

            public static 
            void ImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, Single param)
            {
                Delegates.glImageTransformParameterfHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Single)param);
            }

            public static 
            void ImageTransformParameterv(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glImageTransformParameterivHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void ImageTransformParameterv(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glImageTransformParameterivHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ImageTransformParameterv(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, Int32* @params)
            {
                Delegates.glImageTransformParameterivHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Int32*)@params);
            }

            public static 
            void ImageTransformParameterv(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glImageTransformParameterfvHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ImageTransformParameterv(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glImageTransformParameterfvHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ImageTransformParameterv(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, Single* @params)
            {
                Delegates.glImageTransformParameterfvHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Single*)@params);
            }

            public static 
            void GetImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetImageTransformParameterivHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetImageTransformParameterivHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, [Out] Int32* @params)
            {
                Delegates.glGetImageTransformParameterivHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Int32*)@params);
            }

            public static 
            void GetImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetImageTransformParameterfvHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetImageTransformParameterfvHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetImageTransformParameter(OpenTK.OpenGL.Enums.HpImageTransform target, OpenTK.OpenGL.Enums.HpImageTransform pname, [Out] Single* @params)
            {
                Delegates.glGetImageTransformParameterfvHP((OpenTK.OpenGL.Enums.HpImageTransform)target, (OpenTK.OpenGL.Enums.HpImageTransform)pname, (Single*)@params);
            }

        }

        public static partial class Pgi
        {
            public static 
            void Hint(OpenTK.OpenGL.Enums.PgiMiscHints target, Int32 mode)
            {
                Delegates.glHintPGI((OpenTK.OpenGL.Enums.PgiMiscHints)target, (Int32)mode);
            }

        }

        public static partial class Intel
        {
            public static 
            void VertexPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, IntPtr pointer)
            {
                Delegates.glVertexPointervINTEL((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (IntPtr)pointer);
            }

            public static 
            void VertexPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexPointervINTEL((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void NormalPointer(OpenTK.OpenGL.Enums.NormalPointerType type, IntPtr pointer)
            {
                Delegates.glNormalPointervINTEL((OpenTK.OpenGL.Enums.NormalPointerType)type, (IntPtr)pointer);
            }

            public static 
            void NormalPointer(OpenTK.OpenGL.Enums.NormalPointerType type, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glNormalPointervINTEL((OpenTK.OpenGL.Enums.NormalPointerType)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void ColorPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, IntPtr pointer)
            {
                Delegates.glColorPointervINTEL((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (IntPtr)pointer);
            }

            public static 
            void ColorPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorPointervINTEL((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void TexCoordPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, IntPtr pointer)
            {
                Delegates.glTexCoordPointervINTEL((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (IntPtr)pointer);
            }

            public static 
            void TexCoordPointer(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexCoordPointervINTEL((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

        }

        public static partial class Sunx
        {
            public static 
            void FinishTexture()
            {
                Delegates.glFinishTextureSUNX();
            }

        }

        public static partial class Sun
        {
            [System.CLSCompliant(false)]
            public static 
            void GlobalAlphaFactor(SByte factor)
            {
                Delegates.glGlobalAlphaFactorbSUN((SByte)factor);
            }

            public static 
            void GlobalAlphaFactors(Int16 factor)
            {
                Delegates.glGlobalAlphaFactorsSUN((Int16)factor);
            }

            public static 
            void GlobalAlphaFactor(Single factor)
            {
                Delegates.glGlobalAlphaFactorfSUN((Single)factor);
            }

            public static 
            void GlobalAlphaFactor(Double factor)
            {
                Delegates.glGlobalAlphaFactordSUN((Double)factor);
            }

            public static 
            void GlobalAlphaFactor(Byte factor)
            {
                Delegates.glGlobalAlphaFactorubSUN((Byte)factor);
            }

            [System.CLSCompliant(false)]
            public static 
            void GlobalAlphaFactor(UInt16 factor)
            {
                Delegates.glGlobalAlphaFactorusSUN((UInt16)factor);
            }

            public static 
            void GlobalAlphaFactor(Int16 factor)
            {
                Delegates.glGlobalAlphaFactorusSUN((UInt16)factor);
            }

            [System.CLSCompliant(false)]
            public static 
            void GlobalAlphaFactor(UInt32 factor)
            {
                Delegates.glGlobalAlphaFactoruiSUN((UInt32)factor);
            }

            public static 
            void GlobalAlphaFactor(Int32 factor)
            {
                Delegates.glGlobalAlphaFactoruiSUN((UInt32)factor);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCode(UInt32 code)
            {
                Delegates.glReplacementCodeuiSUN((UInt32)code);
            }

            public static 
            void ReplacementCode(Int32 code)
            {
                Delegates.glReplacementCodeuiSUN((UInt32)code);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCode(UInt16 code)
            {
                Delegates.glReplacementCodeusSUN((UInt16)code);
            }

            public static 
            void ReplacementCode(Int16 code)
            {
                Delegates.glReplacementCodeusSUN((UInt16)code);
            }

            public static 
            void ReplacementCode(Byte code)
            {
                Delegates.glReplacementCodeubSUN((Byte)code);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodev(UInt32[] code)
            {
                unsafe
                {
                    fixed (UInt32* code_ptr = code)
                    {
                        Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodev(Int32[] code)
            {
                unsafe
                {
                    fixed (Int32* code_ptr = code)
                    {
                        Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodev(ref UInt32 code)
            {
                unsafe
                {
                    fixed (UInt32* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodev(ref Int32 code)
            {
                unsafe
                {
                    fixed (Int32* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeuivSUN((UInt32*)code_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodev(UInt32* code)
            {
                Delegates.glReplacementCodeuivSUN((UInt32*)code);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodev(Int32* code)
            {
                Delegates.glReplacementCodeuivSUN((UInt32*)code);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodev(UInt16[] code)
            {
                unsafe
                {
                    fixed (UInt16* code_ptr = code)
                    {
                        Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodev(Int16[] code)
            {
                unsafe
                {
                    fixed (Int16* code_ptr = code)
                    {
                        Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodev(ref UInt16 code)
            {
                unsafe
                {
                    fixed (UInt16* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodev(ref Int16 code)
            {
                unsafe
                {
                    fixed (Int16* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeusvSUN((UInt16*)code_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodev(UInt16* code)
            {
                Delegates.glReplacementCodeusvSUN((UInt16*)code);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodev(Int16* code)
            {
                Delegates.glReplacementCodeusvSUN((UInt16*)code);
            }

            public static 
            void ReplacementCodev(Byte[] code)
            {
                unsafe
                {
                    fixed (Byte* code_ptr = code)
                    {
                        Delegates.glReplacementCodeubvSUN((Byte*)code_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodev(ref Byte code)
            {
                unsafe
                {
                    fixed (Byte* code_ptr = &code)
                    {
                        Delegates.glReplacementCodeubvSUN((Byte*)code_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodev(Byte* code)
            {
                Delegates.glReplacementCodeubvSUN((Byte*)code);
            }

            public static 
            void ReplacementCodePointer(OpenTK.OpenGL.Enums.SunTriangleList type, Int32 stride, IntPtr pointer)
            {
                Delegates.glReplacementCodePointerSUN((OpenTK.OpenGL.Enums.SunTriangleList)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void ReplacementCodePointer(OpenTK.OpenGL.Enums.SunTriangleList type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glReplacementCodePointerSUN((OpenTK.OpenGL.Enums.SunTriangleList)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void Color4ubVertex2(Byte r, Byte g, Byte b, Byte a, Single x, Single y)
            {
                Delegates.glColor4ubVertex2fSUN((Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y);
            }

            public static 
            void Color4ubVertex2(Byte[] c, Single[] v)
            {
                unsafe
                {
                    fixed (Byte* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void Color4ubVertex2(ref Byte c, ref Single v)
            {
                unsafe
                {
                    fixed (Byte* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex2fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex2(Byte* c, Single* v)
            {
                Delegates.glColor4ubVertex2fvSUN((Byte*)c, (Single*)v);
            }

            public static 
            void Color4ubVertex3(Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
            {
                Delegates.glColor4ubVertex3fSUN((Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void Color4ubVertex3(Byte[] c, Single[] v)
            {
                unsafe
                {
                    fixed (Byte* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void Color4ubVertex3(ref Byte c, ref Single v)
            {
                unsafe
                {
                    fixed (Byte* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glColor4ubVertex3fvSUN((Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4ubVertex3(Byte* c, Single* v)
            {
                Delegates.glColor4ubVertex3fvSUN((Byte*)c, (Single*)v);
            }

            public static 
            void Color3fVertex3(Single r, Single g, Single b, Single x, Single y, Single z)
            {
                Delegates.glColor3fVertex3fSUN((Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void Color3fVertex3(Single[] c, Single[] v)
            {
                unsafe
                {
                    fixed (Single* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void Color3fVertex3(ref Single c, ref Single v)
            {
                unsafe
                {
                    fixed (Single* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glColor3fVertex3fvSUN((Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3fVertex3(Single* c, Single* v)
            {
                Delegates.glColor3fVertex3fvSUN((Single*)c, (Single*)v);
            }

            public static 
            void Normal3fVertex3(Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glNormal3fVertex3fSUN((Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void Normal3fVertex3(Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void Normal3fVertex3(ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glNormal3fVertex3fvSUN((Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3fVertex3(Single* n, Single* v)
            {
                Delegates.glNormal3fVertex3fvSUN((Single*)n, (Single*)v);
            }

            public static 
            void Color4fNormal3fVertex3(Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glColor4fNormal3fVertex3fSUN((Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void Color4fNormal3fVertex3(Single[] c, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Single* c_ptr = c)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void Color4fNormal3fVertex3(ref Single c, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Single* c_ptr = &c)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4fNormal3fVertex3(Single* c, Single* n, Single* v)
            {
                Delegates.glColor4fNormal3fVertex3fvSUN((Single*)c, (Single*)n, (Single*)v);
            }

            public static 
            void TexCoord2fVertex3(Single s, Single t, Single x, Single y, Single z)
            {
                Delegates.glTexCoord2fVertex3fSUN((Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void TexCoord2fVertex3(Single[] tc, Single[] v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord2fVertex3(ref Single tc, ref Single v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fVertex3fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fVertex3(Single* tc, Single* v)
            {
                Delegates.glTexCoord2fVertex3fvSUN((Single*)tc, (Single*)v);
            }

            public static 
            void TexCoord4fVertex4(Single s, Single t, Single p, Single q, Single x, Single y, Single z, Single w)
            {
                Delegates.glTexCoord4fVertex4fSUN((Single)s, (Single)t, (Single)p, (Single)q, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void TexCoord4fVertex4(Single[] tc, Single[] v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord4fVertex4(ref Single tc, ref Single v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fVertex4fvSUN((Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fVertex4(Single* tc, Single* v)
            {
                Delegates.glTexCoord4fVertex4fvSUN((Single*)tc, (Single*)v);
            }

            public static 
            void TexCoord2fColor4ubVertex3(Single s, Single t, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
            {
                Delegates.glTexCoord2fColor4ubVertex3fSUN((Single)s, (Single)t, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void TexCoord2fColor4ubVertex3(Single[] tc, Byte[] c, Single[] v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = tc)
                    fixed (Byte* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord2fColor4ubVertex3(ref Single tc, ref Byte c, ref Single v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = &tc)
                    fixed (Byte* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4ubVertex3(Single* tc, Byte* c, Single* v)
            {
                Delegates.glTexCoord2fColor4ubVertex3fvSUN((Single*)tc, (Byte*)c, (Single*)v);
            }

            public static 
            void TexCoord2fColor3fVertex3(Single s, Single t, Single r, Single g, Single b, Single x, Single y, Single z)
            {
                Delegates.glTexCoord2fColor3fVertex3fSUN((Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void TexCoord2fColor3fVertex3(Single[] tc, Single[] c, Single[] v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord2fColor3fVertex3(ref Single tc, ref Single c, ref Single v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor3fVertex3(Single* tc, Single* c, Single* v)
            {
                Delegates.glTexCoord2fColor3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)v);
            }

            public static 
            void TexCoord2fNormal3fVertex3(Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glTexCoord2fNormal3fVertex3fSUN((Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void TexCoord2fNormal3fVertex3(Single[] tc, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord2fNormal3fVertex3(ref Single tc, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fNormal3fVertex3(Single* tc, Single* n, Single* v)
            {
                Delegates.glTexCoord2fNormal3fVertex3fvSUN((Single*)tc, (Single*)n, (Single*)v);
            }

            public static 
            void TexCoord2fColor4fNormal3fVertex3(Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glTexCoord2fColor4fNormal3fVertex3fSUN((Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void TexCoord2fColor4fNormal3fVertex3(Single[] tc, Single[] c, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord2fColor4fNormal3fVertex3(ref Single tc, ref Single c, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2fColor4fNormal3fVertex3(Single* tc, Single* c, Single* n, Single* v)
            {
                Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v);
            }

            public static 
            void TexCoord4fColor4fNormal3fVertex4(Single s, Single t, Single p, Single q, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z, Single w)
            {
                Delegates.glTexCoord4fColor4fNormal3fVertex4fSUN((Single)s, (Single)t, (Single)p, (Single)q, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void TexCoord4fColor4fNormal3fVertex4(Single[] tc, Single[] c, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord4fColor4fNormal3fVertex4(ref Single tc, ref Single c, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4fColor4fNormal3fVertex4(Single* tc, Single* c, Single* n, Single* v)
            {
                Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN((Single*)tc, (Single*)c, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3(UInt32 rc, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiVertex3fSUN((UInt32)rc, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiVertex3(Int32 rc, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiVertex3fSUN((UInt32)rc, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3v(UInt32[] rc, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiVertex3v(Int32[] rc, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiVertex3v(ref UInt32 rc, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiVertex3v(ref Int32 rc, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3v(UInt32* rc, Single* v)
            {
                Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiVertex3v(Int32* rc, Single* v)
            {
                Delegates.glReplacementCodeuiVertex3fvSUN((UInt32*)rc, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3(UInt32 rc, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiColor4ubVertex3fSUN((UInt32)rc, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiColor4ubVertex3(Int32 rc, Byte r, Byte g, Byte b, Byte a, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiColor4ubVertex3fSUN((UInt32)rc, (Byte)r, (Byte)g, (Byte)b, (Byte)a, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3v(UInt32[] rc, Byte[] c, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Byte* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiColor4ubVertex3v(Int32[] rc, Byte[] c, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Byte* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4ubVertex3v(ref UInt32 rc, ref Byte c, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Byte* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiColor4ubVertex3v(ref Int32 rc, ref Byte c, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Byte* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc_ptr, (Byte*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3v(UInt32* rc, Byte* c, Single* v)
            {
                Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4ubVertex3v(Int32* rc, Byte* c, Single* v)
            {
                Delegates.glReplacementCodeuiColor4ubVertex3fvSUN((UInt32*)rc, (Byte*)c, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3(UInt32 rc, Single r, Single g, Single b, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiColor3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiColor3fVertex3(Int32 rc, Single r, Single g, Single b, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiColor3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3v(UInt32[] rc, Single[] c, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiColor3fVertex3v(Int32[] rc, Single[] c, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor3fVertex3v(ref UInt32 rc, ref Single c, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiColor3fVertex3v(ref Int32 rc, ref Single c, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3v(UInt32* rc, Single* c, Single* v)
            {
                Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor3fVertex3v(Int32* rc, Single* c, Single* v)
            {
                Delegates.glReplacementCodeuiColor3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3(UInt32 rc, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiNormal3fVertex3fSUN((UInt32)rc, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiNormal3fVertex3(Int32 rc, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiNormal3fVertex3fSUN((UInt32)rc, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3v(UInt32[] rc, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiNormal3fVertex3v(Int32[] rc, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiNormal3fVertex3v(ref UInt32 rc, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiNormal3fVertex3v(ref Int32 rc, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3v(UInt32* rc, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiNormal3fVertex3v(Int32* rc, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiNormal3fVertex3fvSUN((UInt32*)rc, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3(UInt32 rc, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3(Int32 rc, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32[] rc, Single[] c, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3v(Int32[] rc, Single[] c, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3v(ref UInt32 rc, ref Single c, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiColor4fNormal3fVertex3v(ref Int32 rc, ref Single c, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(UInt32* rc, Single* c, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiColor4fNormal3fVertex3v(Int32* rc, Single* c, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)c, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3(UInt32 rc, Single s, Single t, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiTexCoord2fVertex3(Int32 rc, Single s, Single t, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3v(UInt32[] rc, Single[] tc, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiTexCoord2fVertex3v(Int32[] rc, Single[] tc, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fVertex3v(ref UInt32 rc, ref Single tc, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiTexCoord2fVertex3v(ref Int32 rc, ref Single tc, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3v(UInt32* rc, Single* tc, Single* v)
            {
                Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fVertex3v(Int32* rc, Single* tc, Single* v)
            {
                Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3(UInt32 rc, Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3(Int32 rc, Single s, Single t, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32[] rc, Single[] tc, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32[] rc, Single[] tc, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiTexCoord2fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(UInt32* rc, Single* tc, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fNormal3fVertex3v(Int32* rc, Single* tc, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3(UInt32 rc, Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3(Int32 rc, Single s, Single t, Single r, Single g, Single b, Single a, Single nx, Single ny, Single nz, Single x, Single y, Single z)
            {
                Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN((UInt32)rc, (Single)s, (Single)t, (Single)r, (Single)g, (Single)b, (Single)a, (Single)nx, (Single)ny, (Single)nz, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32[] rc, Single[] tc, Single[] c, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = rc)
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32[] rc, Single[] tc, Single[] c, Single[] n, Single[] v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = rc)
                    fixed (Single* tc_ptr = tc)
                    fixed (Single* c_ptr = c)
                    fixed (Single* n_ptr = n)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref UInt32 rc, ref Single tc, ref Single c, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (UInt32* rc_ptr = &rc)
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(ref Int32 rc, ref Single tc, ref Single c, ref Single n, ref Single v)
            {
                unsafe
                {
                    fixed (Int32* rc_ptr = &rc)
                    fixed (Single* tc_ptr = &tc)
                    fixed (Single* c_ptr = &c)
                    fixed (Single* n_ptr = &n)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc_ptr, (Single*)tc_ptr, (Single*)c_ptr, (Single*)n_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(UInt32* rc, Single* tc, Single* c, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3v(Int32* rc, Single* tc, Single* c, Single* n, Single* v)
            {
                Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN((UInt32*)rc, (Single*)tc, (Single*)c, (Single*)n, (Single*)v);
            }

            public static 
            void DrawMeshArrays(OpenTK.OpenGL.Enums.BeginMode mode, Int32 first, Int32 count, Int32 width)
            {
                Delegates.glDrawMeshArraysSUN((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)first, (Int32)count, (Int32)width);
            }

        }

        public static partial class Ingr
        {
            public static 
            void BlendFuncSeparate(OpenTK.OpenGL.Enums.All sfactorRGB, OpenTK.OpenGL.Enums.All dfactorRGB, OpenTK.OpenGL.Enums.All sfactorAlpha, OpenTK.OpenGL.Enums.All dfactorAlpha)
            {
                Delegates.glBlendFuncSeparateINGR((OpenTK.OpenGL.Enums.All)sfactorRGB, (OpenTK.OpenGL.Enums.All)dfactorRGB, (OpenTK.OpenGL.Enums.All)sfactorAlpha, (OpenTK.OpenGL.Enums.All)dfactorAlpha);
            }

        }

        public static partial class NV
        {
            public static 
            void FlushVertexArrayRange()
            {
                Delegates.glFlushVertexArrayRangeNV();
            }

            public static 
            void VertexArrayRange(Int32 length, IntPtr pointer)
            {
                Delegates.glVertexArrayRangeNV((Int32)length, (IntPtr)pointer);
            }

            public static 
            void VertexArrayRange(Int32 length, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexArrayRangeNV((Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void CombinerParameterv(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glCombinerParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void CombinerParameterv(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glCombinerParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void CombinerParameterv(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, Single* @params)
            {
                Delegates.glCombinerParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params);
            }

            public static 
            void CombinerParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, Single param)
            {
                Delegates.glCombinerParameterfNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single)param);
            }

            public static 
            void CombinerParameterv(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glCombinerParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void CombinerParameterv(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glCombinerParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void CombinerParameterv(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, Int32* @params)
            {
                Delegates.glCombinerParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params);
            }

            public static 
            void CombinerParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners pname, Int32 param)
            {
                Delegates.glCombinerParameteriNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32)param);
            }

            public static 
            void CombinerInput(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners input, OpenTK.OpenGL.Enums.NvRegisterCombiners mapping, OpenTK.OpenGL.Enums.NvRegisterCombiners componentUsage)
            {
                Delegates.glCombinerInputNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)input, (OpenTK.OpenGL.Enums.NvRegisterCombiners)mapping, (OpenTK.OpenGL.Enums.NvRegisterCombiners)componentUsage);
            }

            public static 
            void CombinerOutput(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners abOutput, OpenTK.OpenGL.Enums.NvRegisterCombiners cdOutput, OpenTK.OpenGL.Enums.NvRegisterCombiners sumOutput, OpenTK.OpenGL.Enums.NvRegisterCombiners scale, OpenTK.OpenGL.Enums.NvRegisterCombiners bias, bool abDotProduct, bool cdDotProduct, bool muxSum)
            {
                Delegates.glCombinerOutputNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)abOutput, (OpenTK.OpenGL.Enums.NvRegisterCombiners)cdOutput, (OpenTK.OpenGL.Enums.NvRegisterCombiners)sumOutput, (OpenTK.OpenGL.Enums.NvRegisterCombiners)scale, (OpenTK.OpenGL.Enums.NvRegisterCombiners)bias, (bool)abDotProduct, (bool)cdDotProduct, (bool)muxSum);
            }

            public static 
            void FinalCombinerInput(OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners input, OpenTK.OpenGL.Enums.NvRegisterCombiners mapping, OpenTK.OpenGL.Enums.NvRegisterCombiners componentUsage)
            {
                Delegates.glFinalCombinerInputNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)input, (OpenTK.OpenGL.Enums.NvRegisterCombiners)mapping, (OpenTK.OpenGL.Enums.NvRegisterCombiners)componentUsage);
            }

            public static 
            void GetCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerInputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerInputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Single* @params)
            {
                Delegates.glGetCombinerInputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params);
            }

            public static 
            void GetCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerInputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerInputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Int32* @params)
            {
                Delegates.glGetCombinerInputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params);
            }

            public static 
            void GetCombinerOutputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerOutputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetCombinerOutputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerOutputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerOutputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Single* @params)
            {
                Delegates.glGetCombinerOutputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params);
            }

            public static 
            void GetCombinerOutputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerOutputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetCombinerOutputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerOutputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerOutputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners stage, OpenTK.OpenGL.Enums.NvRegisterCombiners portion, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Int32* @params)
            {
                Delegates.glGetCombinerOutputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners)portion, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params);
            }

            public static 
            void GetFinalCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetFinalCombinerInputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFinalCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetFinalCombinerInputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFinalCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Single* @params)
            {
                Delegates.glGetFinalCombinerInputParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Single*)@params);
            }

            public static 
            void GetFinalCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetFinalCombinerInputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFinalCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetFinalCombinerInputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFinalCombinerInputParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners variable, OpenTK.OpenGL.Enums.NvRegisterCombiners pname, [Out] Int32* @params)
            {
                Delegates.glGetFinalCombinerInputParameterivNV((OpenTK.OpenGL.Enums.NvRegisterCombiners)variable, (OpenTK.OpenGL.Enums.NvRegisterCombiners)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(Int32 n, UInt32[] fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            public static 
            void DeleteFences(Int32 n, Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(Int32 n, ref UInt32 fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            public static 
            void DeleteFences(Int32 n, ref Int32 fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(Int32 n, UInt32* fences)
            {
                Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(Int32 n, Int32* fences)
            {
                Delegates.glDeleteFencesNV((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenFences(Int32 n, [Out] UInt32[] fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = fences)
                    {
                        Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            public static 
            void GenFences(Int32 n, [Out] Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenFences(Int32 n, [Out] out UInt32 fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }

            public static 
            void GenFences(Int32 n, [Out] out Int32 fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesNV((Int32)n, (UInt32*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(Int32 n, [Out] UInt32* fences)
            {
                Delegates.glGenFencesNV((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(Int32 n, [Out] Int32* fences)
            {
                Delegates.glGenFencesNV((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsFence(UInt32 fence)
            {
                return Delegates.glIsFenceNV((UInt32)fence);
            }

            public static 
            bool IsFence(Int32 fence)
            {
                return Delegates.glIsFenceNV((UInt32)fence);
            }

            [System.CLSCompliant(false)]
            public static 
            bool TestFence(UInt32 fence)
            {
                return Delegates.glTestFenceNV((UInt32)fence);
            }

            public static 
            bool TestFence(Int32 fence)
            {
                return Delegates.glTestFenceNV((UInt32)fence);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetFence(UInt32 fence, OpenTK.OpenGL.Enums.NvFence pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetFenceivNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetFence(Int32 fence, OpenTK.OpenGL.Enums.NvFence pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetFenceivNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetFence(UInt32 fence, OpenTK.OpenGL.Enums.NvFence pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetFenceivNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetFence(Int32 fence, OpenTK.OpenGL.Enums.NvFence pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetFenceivNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFence(UInt32 fence, OpenTK.OpenGL.Enums.NvFence pname, [Out] Int32* @params)
            {
                Delegates.glGetFenceivNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetFence(Int32 fence, OpenTK.OpenGL.Enums.NvFence pname, [Out] Int32* @params)
            {
                Delegates.glGetFenceivNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void FinishFence(UInt32 fence)
            {
                Delegates.glFinishFenceNV((UInt32)fence);
            }

            public static 
            void FinishFence(Int32 fence)
            {
                Delegates.glFinishFenceNV((UInt32)fence);
            }

            [System.CLSCompliant(false)]
            public static 
            void SetFence(UInt32 fence, OpenTK.OpenGL.Enums.NvFence condition)
            {
                Delegates.glSetFenceNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)condition);
            }

            public static 
            void SetFence(Int32 fence, OpenTK.OpenGL.Enums.NvFence condition)
            {
                Delegates.glSetFenceNV((UInt32)fence, (OpenTK.OpenGL.Enums.NvFence)condition);
            }

            [System.CLSCompliant(false)]
            public static 
            void MapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, bool packed, IntPtr points)
            {
                Delegates.glMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (bool)packed, (IntPtr)points);
            }

            public static 
            void MapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, bool packed, IntPtr points)
            {
                Delegates.glMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (bool)packed, (IntPtr)points);
            }

            [System.CLSCompliant(false)]
            public static 
            void MapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, bool packed, [In, Out] object points)
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (bool)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }

            public static 
            void MapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, Int32 uorder, Int32 vorder, bool packed, [In, Out] object points)
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (Int32)uorder, (Int32)vorder, (bool)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }

            public static 
            void MapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glMapParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void MapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glMapParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, Int32* @params)
            {
                Delegates.glMapParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params);
            }

            public static 
            void MapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glMapParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void MapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glMapParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, Single* @params)
            {
                Delegates.glMapParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetMapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, bool packed, [Out] IntPtr points)
            {
                Delegates.glGetMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (bool)packed, (IntPtr)points);
            }

            public static 
            void GetMapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, bool packed, [Out] IntPtr points)
            {
                Delegates.glGetMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (bool)packed, (IntPtr)points);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetMapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, bool packed, [In, Out] object points)
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (bool)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }

            public static 
            void GetMapControlPoints(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators type, Int32 ustride, Int32 vstride, bool packed, [In, Out] object points)
            {
                System.Runtime.InteropServices.GCHandle points_ptr = System.Runtime.InteropServices.GCHandle.Alloc(points, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetMapControlPointsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)type, (Int32)ustride, (Int32)vstride, (bool)packed, (IntPtr)points_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    points_ptr.Free();
                }
            }

            public static 
            void GetMapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetMapParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetMapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetMapParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Int32* @params)
            {
                Delegates.glGetMapParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params);
            }

            public static 
            void GetMapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetMapParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetMapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetMapParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapParameter(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Single* @params)
            {
                Delegates.glGetMapParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Int32* @params)
            {
                Delegates.glGetMapAttribParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Int32* @params)
            {
                Delegates.glGetMapAttribParameterivNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetMapAttribParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, UInt32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Single* @params)
            {
                Delegates.glGetMapAttribParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetMapAttribParameter(OpenTK.OpenGL.Enums.NvEvaluators target, Int32 index, OpenTK.OpenGL.Enums.NvEvaluators pname, [Out] Single* @params)
            {
                Delegates.glGetMapAttribParameterfvNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvEvaluators)pname, (Single*)@params);
            }

            public static 
            void EvalMap(OpenTK.OpenGL.Enums.NvEvaluators target, OpenTK.OpenGL.Enums.NvEvaluators mode)
            {
                Delegates.glEvalMapsNV((OpenTK.OpenGL.Enums.NvEvaluators)target, (OpenTK.OpenGL.Enums.NvEvaluators)mode);
            }

            public static 
            void CombinerStageParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners2 stage, OpenTK.OpenGL.Enums.NvRegisterCombiners2 pname, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glCombinerStageParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners2)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners2)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void CombinerStageParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners2 stage, OpenTK.OpenGL.Enums.NvRegisterCombiners2 pname, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glCombinerStageParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners2)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners2)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void CombinerStageParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners2 stage, OpenTK.OpenGL.Enums.NvRegisterCombiners2 pname, Single* @params)
            {
                Delegates.glCombinerStageParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners2)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners2)pname, (Single*)@params);
            }

            public static 
            void GetCombinerStageParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners2 stage, OpenTK.OpenGL.Enums.NvRegisterCombiners2 pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetCombinerStageParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners2)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners2)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetCombinerStageParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners2 stage, OpenTK.OpenGL.Enums.NvRegisterCombiners2 pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetCombinerStageParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners2)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners2)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetCombinerStageParameter(OpenTK.OpenGL.Enums.NvRegisterCombiners2 stage, OpenTK.OpenGL.Enums.NvRegisterCombiners2 pname, [Out] Single* @params)
            {
                Delegates.glGetCombinerStageParameterfvNV((OpenTK.OpenGL.Enums.NvRegisterCombiners2)stage, (OpenTK.OpenGL.Enums.NvRegisterCombiners2)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            bool AreProgramsResident(Int32 n, UInt32[] programs, [Out] bool[] residences)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = programs)
                    fixed (bool* residences_ptr = residences)
                    {
                        return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (bool*)residences_ptr);
                    }
                }
            }

            public static 
            bool AreProgramsResident(Int32 n, Int32[] programs, [Out] bool[] residences)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    fixed (bool* residences_ptr = residences)
                    {
                        return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (bool*)residences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            bool AreProgramsResident(Int32 n, ref UInt32 programs, [Out] out bool residences)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = &programs)
                    fixed (bool* residences_ptr = &residences)
                    {
                        bool retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (bool*)residences_ptr);
                        residences = *residences_ptr;
                        return retval;
                    }
                }
            }

            public static 
            bool AreProgramsResident(Int32 n, ref Int32 programs, [Out] out bool residences)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    fixed (bool* residences_ptr = &residences)
                    {
                        bool retval = Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs_ptr, (bool*)residences_ptr);
                        residences = *residences_ptr;
                        return retval;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe bool AreProgramsResident(Int32 n, UInt32* programs, [Out] bool* residences)
            {
                return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs, (bool*)residences);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe bool AreProgramsResident(Int32 n, Int32* programs, [Out] bool* residences)
            {
                return Delegates.glAreProgramsResidentNV((Int32)n, (UInt32*)programs, (bool*)residences);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 id)
            {
                Delegates.glBindProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id);
            }

            public static 
            void BindProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 id)
            {
                Delegates.glBindProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteProgram(Int32 n, UInt32[] programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void DeleteProgram(Int32 n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteProgram(Int32 n, ref UInt32 programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void DeleteProgram(Int32 n, ref Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteProgram(Int32 n, UInt32* programs)
            {
                Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteProgram(Int32 n, Int32* programs)
            {
                Delegates.glDeleteProgramsNV((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            void ExecuteProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 id, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glExecuteProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ExecuteProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 id, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glExecuteProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ExecuteProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 id, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glExecuteProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ExecuteProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 id, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glExecuteProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ExecuteProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 id, Single* @params)
            {
                Delegates.glExecuteProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ExecuteProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 id, Single* @params)
            {
                Delegates.glExecuteProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenProgram(Int32 n, [Out] UInt32[] programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void GenProgram(Int32 n, [Out] Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenProgram(Int32 n, [Out] out UInt32 programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }

            public static 
            void GenProgram(Int32 n, [Out] out Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs_ptr);
                        programs = *programs_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenProgram(Int32 n, [Out] UInt32* programs)
            {
                Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenProgram(Int32 n, [Out] Int32* programs)
            {
                Delegates.glGenProgramsNV((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterdvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterdvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterdvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterdvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double* @params)
            {
                Delegates.glGetProgramParameterdvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double* @params)
            {
                Delegates.glGetProgramParameterdvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterfvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramParameterfvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterfvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramParameterfvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single* @params)
            {
                Delegates.glGetProgramParameterfvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramParameter(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single* @params)
            {
                Delegates.glGetProgramParameterfvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgram(UInt32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgram(Int32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgram(UInt32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgram(Int32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgram(UInt32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetProgramivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgram(Int32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetProgramivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramString(UInt32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Byte[] program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = program)
                    {
                        Delegates.glGetProgramStringNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Byte*)program_ptr);
                    }
                }
            }

            public static 
            void GetProgramString(Int32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Byte[] program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = program)
                    {
                        Delegates.glGetProgramStringNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Byte*)program_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramString(UInt32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Byte program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = &program)
                    {
                        Delegates.glGetProgramStringNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Byte*)program_ptr);
                        program = *program_ptr;
                    }
                }
            }

            public static 
            void GetProgramString(Int32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Byte program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = &program)
                    {
                        Delegates.glGetProgramStringNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Byte*)program_ptr);
                        program = *program_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramString(UInt32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Byte* program)
            {
                Delegates.glGetProgramStringNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Byte*)program);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramString(Int32 id, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Byte* program)
            {
                Delegates.glGetProgramStringNV((UInt32)id, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Byte*)program);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetTrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 address, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetTrackMatrixivNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetTrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 address, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetTrackMatrixivNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetTrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 address, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetTrackMatrixivNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetTrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 address, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetTrackMatrixivNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 address, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetTrackMatrixivNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 address, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetTrackMatrixivNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribdvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribdvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double* @params)
            {
                Delegates.glGetVertexAttribdvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Double* @params)
            {
                Delegates.glGetVertexAttribdvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribfvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribfvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single* @params)
            {
                Delegates.glGetVertexAttribfvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Single* @params)
            {
                Delegates.glGetVertexAttribfvNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribivNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribivNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribivNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttrib(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribivNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribPointer(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] IntPtr pointer)
            {
                Delegates.glGetVertexAttribPointervNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (IntPtr)pointer);
            }

            public static 
            void GetVertexAttribPointer(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [Out] IntPtr pointer)
            {
                Delegates.glGetVertexAttribPointervNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (IntPtr)pointer);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribPointer(UInt32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void GetVertexAttribPointer(Int32 index, OpenTK.OpenGL.Enums.NvVertexProgram pname, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glGetVertexAttribPointervNV((UInt32)index, (OpenTK.OpenGL.Enums.NvVertexProgram)pname, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsProgram(UInt32 id)
            {
                return Delegates.glIsProgramNV((UInt32)id);
            }

            public static 
            bool IsProgram(Int32 id)
            {
                return Delegates.glIsProgramNV((UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            void LoadProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 id, Int32 len, Byte[] program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = program)
                    {
                        Delegates.glLoadProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                    }
                }
            }

            public static 
            void LoadProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 id, Int32 len, Byte[] program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = program)
                    {
                        Delegates.glLoadProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void LoadProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 id, Int32 len, ref Byte program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = &program)
                    {
                        Delegates.glLoadProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                    }
                }
            }

            public static 
            void LoadProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 id, Int32 len, ref Byte program)
            {
                unsafe
                {
                    fixed (Byte* program_ptr = &program)
                    {
                        Delegates.glLoadProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Int32)len, (Byte*)program_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 id, Int32 len, Byte* program)
            {
                Delegates.glLoadProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Int32)len, (Byte*)program);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void LoadProgram(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 id, Int32 len, Byte* program)
            {
                Delegates.glLoadProgramNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)id, (Int32)len, (Byte*)program);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramParameter4dNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramParameter4dNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glProgramParameter4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glProgramParameter4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, Double* v)
            {
                Delegates.glProgramParameter4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Double* v)
            {
                Delegates.glProgramParameter4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramParameter4fNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramParameter4fNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glProgramParameter4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glProgramParameter4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glProgramParameter4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, Single* v)
            {
                Delegates.glProgramParameter4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameter4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Single* v)
            {
                Delegates.glProgramParameter4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, UInt32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glProgramParameters4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glProgramParameters4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, UInt32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, UInt32 count, Double* v)
            {
                Delegates.glProgramParameters4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Int32 count, Double* v)
            {
                Delegates.glProgramParameters4dvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, UInt32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glProgramParameters4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glProgramParameters4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, UInt32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glProgramParameters4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 index, UInt32 count, Single* v)
            {
                Delegates.glProgramParameters4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramParameters4(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 index, Int32 count, Single* v)
            {
                Delegates.glProgramParameters4fvNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)index, (UInt32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void RequestResidentProgram(Int32 n, UInt32[] programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = programs)
                    {
                        Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void RequestResidentProgram(Int32 n, Int32[] programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = programs)
                    {
                        Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void RequestResidentProgram(Int32 n, ref UInt32 programs)
            {
                unsafe
                {
                    fixed (UInt32* programs_ptr = &programs)
                    {
                        Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            public static 
            void RequestResidentProgram(Int32 n, ref Int32 programs)
            {
                unsafe
                {
                    fixed (Int32* programs_ptr = &programs)
                    {
                        Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void RequestResidentProgram(Int32 n, UInt32* programs)
            {
                Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void RequestResidentProgram(Int32 n, Int32* programs)
            {
                Delegates.glRequestResidentProgramsNV((Int32)n, (UInt32*)programs);
            }

            [System.CLSCompliant(false)]
            public static 
            void TrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, UInt32 address, OpenTK.OpenGL.Enums.NvVertexProgram matrix, OpenTK.OpenGL.Enums.NvVertexProgram transform)
            {
                Delegates.glTrackMatrixNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)matrix, (OpenTK.OpenGL.Enums.NvVertexProgram)transform);
            }

            public static 
            void TrackMatrix(OpenTK.OpenGL.Enums.NvVertexProgram target, Int32 address, OpenTK.OpenGL.Enums.NvVertexProgram matrix, OpenTK.OpenGL.Enums.NvVertexProgram transform)
            {
                Delegates.glTrackMatrixNV((OpenTK.OpenGL.Enums.NvVertexProgram)target, (UInt32)address, (OpenTK.OpenGL.Enums.NvVertexProgram)matrix, (OpenTK.OpenGL.Enums.NvVertexProgram)transform);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribPointer(UInt32 index, Int32 fsize, OpenTK.OpenGL.Enums.NvVertexProgram type, Int32 stride, IntPtr pointer)
            {
                Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (OpenTK.OpenGL.Enums.NvVertexProgram)type, (Int32)stride, (IntPtr)pointer);
            }

            public static 
            void VertexAttribPointer(Int32 index, Int32 fsize, OpenTK.OpenGL.Enums.NvVertexProgram type, Int32 stride, IntPtr pointer)
            {
                Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (OpenTK.OpenGL.Enums.NvVertexProgram)type, (Int32)stride, (IntPtr)pointer);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribPointer(UInt32 index, Int32 fsize, OpenTK.OpenGL.Enums.NvVertexProgram type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (OpenTK.OpenGL.Enums.NvVertexProgram)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void VertexAttribPointer(Int32 index, Int32 fsize, OpenTK.OpenGL.Enums.NvVertexProgram type, Int32 stride, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexAttribPointerNV((UInt32)index, (Int32)fsize, (OpenTK.OpenGL.Enums.NvVertexProgram)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1(UInt32 index, Double x)
            {
                Delegates.glVertexAttrib1dNV((UInt32)index, (Double)x);
            }

            public static 
            void VertexAttrib1(Int32 index, Double x)
            {
                Delegates.glVertexAttrib1dNV((UInt32)index, (Double)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib1dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1(UInt32 index, Single x)
            {
                Delegates.glVertexAttrib1fNV((UInt32)index, (Single)x);
            }

            public static 
            void VertexAttrib1(Int32 index, Single x)
            {
                Delegates.glVertexAttrib1fNV((UInt32)index, (Single)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib1fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1(UInt32 index, Int16 x)
            {
                Delegates.glVertexAttrib1sNV((UInt32)index, (Int16)x);
            }

            public static 
            void VertexAttrib1(Int32 index, Int16 x)
            {
                Delegates.glVertexAttrib1sNV((UInt32)index, (Int16)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1v(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1v(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1v(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib1svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Double x, Double y)
            {
                Delegates.glVertexAttrib2dNV((UInt32)index, (Double)x, (Double)y);
            }

            public static 
            void VertexAttrib2(Int32 index, Double x, Double y)
            {
                Delegates.glVertexAttrib2dNV((UInt32)index, (Double)x, (Double)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib2dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Single x, Single y)
            {
                Delegates.glVertexAttrib2fNV((UInt32)index, (Single)x, (Single)y);
            }

            public static 
            void VertexAttrib2(Int32 index, Single x, Single y)
            {
                Delegates.glVertexAttrib2fNV((UInt32)index, (Single)x, (Single)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib2fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Int16 x, Int16 y)
            {
                Delegates.glVertexAttrib2sNV((UInt32)index, (Int16)x, (Int16)y);
            }

            public static 
            void VertexAttrib2(Int32 index, Int16 x, Int16 y)
            {
                Delegates.glVertexAttrib2sNV((UInt32)index, (Int16)x, (Int16)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib2svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Double x, Double y, Double z)
            {
                Delegates.glVertexAttrib3dNV((UInt32)index, (Double)x, (Double)y, (Double)z);
            }

            public static 
            void VertexAttrib3(Int32 index, Double x, Double y, Double z)
            {
                Delegates.glVertexAttrib3dNV((UInt32)index, (Double)x, (Double)y, (Double)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib3dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Single x, Single y, Single z)
            {
                Delegates.glVertexAttrib3fNV((UInt32)index, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void VertexAttrib3(Int32 index, Single x, Single y, Single z)
            {
                Delegates.glVertexAttrib3fNV((UInt32)index, (Single)x, (Single)y, (Single)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib3fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertexAttrib3sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
            }

            public static 
            void VertexAttrib3(Int32 index, Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertexAttrib3sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib3svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glVertexAttrib4dNV((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            public static 
            void VertexAttrib4(Int32 index, Double x, Double y, Double z, Double w)
            {
                Delegates.glVertexAttrib4dNV((UInt32)index, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Double* v)
            {
                Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Double* v)
            {
                Delegates.glVertexAttrib4dvNV((UInt32)index, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glVertexAttrib4fNV((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void VertexAttrib4(Int32 index, Single x, Single y, Single z, Single w)
            {
                Delegates.glVertexAttrib4fNV((UInt32)index, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Single* v)
            {
                Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Single* v)
            {
                Delegates.glVertexAttrib4fvNV((UInt32)index, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertexAttrib4sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
            }

            public static 
            void VertexAttrib4(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertexAttrib4sNV((UInt32)index, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Int16* v)
            {
                Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib4svNV((UInt32)index, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Byte x, Byte y, Byte z, Byte w)
            {
                Delegates.glVertexAttrib4ubNV((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
            }

            public static 
            void VertexAttrib4(Int32 index, Byte x, Byte y, Byte z, Byte w)
            {
                Delegates.glVertexAttrib4ubNV((UInt32)index, (Byte)x, (Byte)y, (Byte)z, (Byte)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4(UInt32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4(Int32 index, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(UInt32 index, Byte* v)
            {
                Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4(Int32 index, Byte* v)
            {
                Delegates.glVertexAttrib4ubvNV((UInt32)index, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1(UInt32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1(Int32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1(UInt32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1(Int32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1(UInt32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1(Int32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs1dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1(UInt32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1(Int32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1(UInt32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1(Int32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1(UInt32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1(Int32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs1fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1(UInt32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1(Int32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1(UInt32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1(Int32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1(UInt32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1(Int32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs1svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2(UInt32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2(Int32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2(UInt32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2(Int32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2(UInt32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2(Int32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs2dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2(UInt32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2(Int32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2(UInt32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2(Int32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2(UInt32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2(Int32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs2fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2(UInt32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2(Int32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2(UInt32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2(Int32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2(UInt32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2(Int32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs2svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3(UInt32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3(Int32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3(UInt32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3(Int32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3(UInt32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3(Int32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs3dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3(UInt32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3(Int32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3(UInt32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3(Int32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3(UInt32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3(Int32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs3fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3(UInt32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3(Int32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3(UInt32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3(Int32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3(UInt32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3(Int32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs3svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(UInt32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(Int32 index, Int32 count, Double* v)
            {
                Delegates.glVertexAttribs4dvNV((UInt32)index, (Int32)count, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(UInt32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(Int32 index, Int32 count, Single* v)
            {
                Delegates.glVertexAttribs4fvNV((UInt32)index, (Int32)count, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(UInt32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(Int32 index, Int32 count, Int16* v)
            {
                Delegates.glVertexAttribs4svNV((UInt32)index, (Int32)count, (Int16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, Byte[] v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4(UInt32 index, Int32 count, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4(Int32 index, Int32 count, ref Byte v)
            {
                unsafe
                {
                    fixed (Byte* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(UInt32 index, Int32 count, Byte* v)
            {
                Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4(Int32 index, Int32 count, Byte* v)
            {
                Delegates.glVertexAttribs4ubvNV((UInt32)index, (Int32)count, (Byte*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenOcclusionQueries(Int32 n, [Out] UInt32[] ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            public static 
            void GenOcclusionQueries(Int32 n, [Out] Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenOcclusionQueries(Int32 n, [Out] out UInt32 ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = &ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }

            public static 
            void GenOcclusionQueries(Int32 n, [Out] out Int32 ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                        ids = *ids_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenOcclusionQueries(Int32 n, [Out] UInt32* ids)
            {
                Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenOcclusionQueries(Int32 n, [Out] Int32* ids)
            {
                Delegates.glGenOcclusionQueriesNV((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteOcclusionQueries(Int32 n, UInt32[] ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            public static 
            void DeleteOcclusionQueries(Int32 n, Int32[] ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteOcclusionQueries(Int32 n, ref UInt32 ids)
            {
                unsafe
                {
                    fixed (UInt32* ids_ptr = &ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            public static 
            void DeleteOcclusionQueries(Int32 n, ref Int32 ids)
            {
                unsafe
                {
                    fixed (Int32* ids_ptr = &ids)
                    {
                        Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteOcclusionQueries(Int32 n, UInt32* ids)
            {
                Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteOcclusionQueries(Int32 n, Int32* ids)
            {
                Delegates.glDeleteOcclusionQueriesNV((Int32)n, (UInt32*)ids);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsOcclusionQuery(UInt32 id)
            {
                return Delegates.glIsOcclusionQueryNV((UInt32)id);
            }

            public static 
            bool IsOcclusionQuery(Int32 id)
            {
                return Delegates.glIsOcclusionQueryNV((UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            void BeginOcclusionQuery(UInt32 id)
            {
                Delegates.glBeginOcclusionQueryNV((UInt32)id);
            }

            public static 
            void BeginOcclusionQuery(Int32 id)
            {
                Delegates.glBeginOcclusionQueryNV((UInt32)id);
            }

            public static 
            void EndOcclusionQuery()
            {
                Delegates.glEndOcclusionQueryNV();
            }

            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQuery(UInt32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetOcclusionQueryivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQuery(UInt32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetOcclusionQueryivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetOcclusionQuery(UInt32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] Int32* @params)
            {
                Delegates.glGetOcclusionQueryivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQuery(UInt32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetOcclusionQuery(Int32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetOcclusionQuery(UInt32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] out UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetOcclusionQuery(Int32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetOcclusionQueryuivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetOcclusionQuery(UInt32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] UInt32* @params)
            {
                Delegates.glGetOcclusionQueryuivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetOcclusionQuery(Int32 id, OpenTK.OpenGL.Enums.NvOcclusionQuery pname, [Out] Int32* @params)
            {
                Delegates.glGetOcclusionQueryuivNV((UInt32)id, (OpenTK.OpenGL.Enums.NvOcclusionQuery)pname, (UInt32*)@params);
            }

            public static 
            void PointParameter(OpenTK.OpenGL.Enums.NvPointSprite pname, Int32 param)
            {
                Delegates.glPointParameteriNV((OpenTK.OpenGL.Enums.NvPointSprite)pname, (Int32)param);
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.NvPointSprite pname, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glPointParameterivNV((OpenTK.OpenGL.Enums.NvPointSprite)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void PointParameterv(OpenTK.OpenGL.Enums.NvPointSprite pname, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glPointParameterivNV((OpenTK.OpenGL.Enums.NvPointSprite)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void PointParameterv(OpenTK.OpenGL.Enums.NvPointSprite pname, Int32* @params)
            {
                Delegates.glPointParameterivNV((OpenTK.OpenGL.Enums.NvPointSprite)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, Byte[] name, Single x, Single y, Single z, Single w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, Byte[] name, Single x, Single y, Single z, Single w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, ref Byte name, Single x, Single y, Single z, Single w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, ref Byte name, Single x, Single y, Single z, Single w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single)x, (Single)y, (Single)z, (Single)w);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(UInt32 id, Int32 len, Byte* name, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(Int32 id, Int32 len, Byte* name, Single x, Single y, Single z, Single w)
            {
                Delegates.glProgramNamedParameter4fNV((UInt32)id, (Int32)len, (Byte*)name, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, Byte[] name, Double x, Double y, Double z, Double w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, Byte[] name, Double x, Double y, Double z, Double w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    {
                        Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, ref Byte name, Double x, Double y, Double z, Double w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, ref Byte name, Double x, Double y, Double z, Double w)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    {
                        Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double)x, (Double)y, (Double)z, (Double)w);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(UInt32 id, Int32 len, Byte* name, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(Int32 id, Int32 len, Byte* name, Double x, Double y, Double z, Double w)
            {
                Delegates.glProgramNamedParameter4dNV((UInt32)id, (Int32)len, (Byte*)name, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, Byte[] name, Single[] v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, Byte[] name, Single[] v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, ref Byte name, ref Single v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, ref Byte name, ref Single v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(UInt32 id, Int32 len, Byte* name, Single* v)
            {
                Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(Int32 id, Int32 len, Byte* name, Single* v)
            {
                Delegates.glProgramNamedParameter4fvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, Byte[] name, Double[] v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, Byte[] name, Double[] v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramNamedParameter4(UInt32 id, Int32 len, ref Byte name, ref Double v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                    }
                }
            }

            public static 
            void ProgramNamedParameter4(Int32 id, Int32 len, ref Byte name, ref Double v)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(UInt32 id, Int32 len, Byte* name, Double* v)
            {
                Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramNamedParameter4(Int32 id, Int32 len, Byte* name, Double* v)
            {
                Delegates.glProgramNamedParameter4dvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameter(UInt32 id, Int32 len, Byte[] name, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramNamedParameter(Int32 id, Int32 len, Byte[] name, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameter(UInt32 id, Int32 len, ref Byte name, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramNamedParameter(Int32 id, Int32 len, ref Byte name, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameter(UInt32 id, Int32 len, Byte* name, [Out] Single* @params)
            {
                Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameter(Int32 id, Int32 len, Byte* name, [Out] Single* @params)
            {
                Delegates.glGetProgramNamedParameterfvNV((UInt32)id, (Int32)len, (Byte*)name, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameter(UInt32 id, Int32 len, Byte[] name, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramNamedParameter(Int32 id, Int32 len, Byte[] name, [Out] Double[] @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = name)
                    fixed (Double* @params_ptr = @params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramNamedParameter(UInt32 id, Int32 len, ref Byte name, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramNamedParameter(Int32 id, Int32 len, ref Byte name, [Out] out Double @params)
            {
                unsafe
                {
                    fixed (Byte* name_ptr = &name)
                    fixed (Double* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name_ptr, (Double*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameter(UInt32 id, Int32 len, Byte* name, [Out] Double* @params)
            {
                Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramNamedParameter(Int32 id, Int32 len, Byte* name, [Out] Double* @params)
            {
                Delegates.glGetProgramNamedParameterdvNV((UInt32)id, (Int32)len, (Byte*)name, (Double*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex2h(UInt16 x, UInt16 y)
            {
                Delegates.glVertex2hNV((UInt16)x, (UInt16)y);
            }

            public static 
            void Vertex2h(Int16 x, Int16 y)
            {
                Delegates.glVertex2hNV((UInt16)x, (UInt16)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex2h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertex2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Vertex2h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertex2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex2h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertex2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Vertex2h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertex2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex2h(UInt16* v)
            {
                Delegates.glVertex2hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex2h(Int16* v)
            {
                Delegates.glVertex2hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex3h(UInt16 x, UInt16 y, UInt16 z)
            {
                Delegates.glVertex3hNV((UInt16)x, (UInt16)y, (UInt16)z);
            }

            public static 
            void Vertex3h(Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertex3hNV((UInt16)x, (UInt16)y, (UInt16)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex3h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertex3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Vertex3h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertex3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex3h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertex3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Vertex3h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertex3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex3h(UInt16* v)
            {
                Delegates.glVertex3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex3h(Int16* v)
            {
                Delegates.glVertex3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex4h(UInt16 x, UInt16 y, UInt16 z, UInt16 w)
            {
                Delegates.glVertex4hNV((UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
            }

            public static 
            void Vertex4h(Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertex4hNV((UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex4h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertex4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Vertex4h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertex4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Vertex4h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertex4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Vertex4h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertex4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex4h(UInt16* v)
            {
                Delegates.glVertex4hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Vertex4h(Int16* v)
            {
                Delegates.glVertex4hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void Normal3h(UInt16 nx, UInt16 ny, UInt16 nz)
            {
                Delegates.glNormal3hNV((UInt16)nx, (UInt16)ny, (UInt16)nz);
            }

            public static 
            void Normal3h(Int16 nx, Int16 ny, Int16 nz)
            {
                Delegates.glNormal3hNV((UInt16)nx, (UInt16)ny, (UInt16)nz);
            }

            [System.CLSCompliant(false)]
            public static 
            void Normal3h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glNormal3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Normal3h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glNormal3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Normal3h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glNormal3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Normal3h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glNormal3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3h(UInt16* v)
            {
                Delegates.glNormal3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Normal3h(Int16* v)
            {
                Delegates.glNormal3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void Color3h(UInt16 red, UInt16 green, UInt16 blue)
            {
                Delegates.glColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
            }

            public static 
            void Color3h(Int16 red, Int16 green, Int16 blue)
            {
                Delegates.glColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
            }

            [System.CLSCompliant(false)]
            public static 
            void Color3h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Color3h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Color3h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Color3h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3h(UInt16* v)
            {
                Delegates.glColor3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color3h(Int16* v)
            {
                Delegates.glColor3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void Color4h(UInt16 red, UInt16 green, UInt16 blue, UInt16 alpha)
            {
                Delegates.glColor4hNV((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
            }

            public static 
            void Color4h(Int16 red, Int16 green, Int16 blue, Int16 alpha)
            {
                Delegates.glColor4hNV((UInt16)red, (UInt16)green, (UInt16)blue, (UInt16)alpha);
            }

            [System.CLSCompliant(false)]
            public static 
            void Color4h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glColor4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Color4h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glColor4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void Color4h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glColor4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void Color4h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glColor4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4h(UInt16* v)
            {
                Delegates.glColor4hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void Color4h(Int16* v)
            {
                Delegates.glColor4hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord1h(UInt16 s)
            {
                Delegates.glTexCoord1hNV((UInt16)s);
            }

            public static 
            void TexCoord1h(Int16 s)
            {
                Delegates.glTexCoord1hNV((UInt16)s);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord1hv(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord1hv(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord1hv(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord1hv(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord1hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord1hv(UInt16* v)
            {
                Delegates.glTexCoord1hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord1hv(Int16* v)
            {
                Delegates.glTexCoord1hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord2h(UInt16 s, UInt16 t)
            {
                Delegates.glTexCoord2hNV((UInt16)s, (UInt16)t);
            }

            public static 
            void TexCoord2h(Int16 s, Int16 t)
            {
                Delegates.glTexCoord2hNV((UInt16)s, (UInt16)t);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord2h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord2h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord2h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord2h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord2hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2h(UInt16* v)
            {
                Delegates.glTexCoord2hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord2h(Int16* v)
            {
                Delegates.glTexCoord2hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord3h(UInt16 s, UInt16 t, UInt16 r)
            {
                Delegates.glTexCoord3hNV((UInt16)s, (UInt16)t, (UInt16)r);
            }

            public static 
            void TexCoord3h(Int16 s, Int16 t, Int16 r)
            {
                Delegates.glTexCoord3hNV((UInt16)s, (UInt16)t, (UInt16)r);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord3h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord3h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord3h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord3h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord3h(UInt16* v)
            {
                Delegates.glTexCoord3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord3h(Int16* v)
            {
                Delegates.glTexCoord3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord4h(UInt16 s, UInt16 t, UInt16 r, UInt16 q)
            {
                Delegates.glTexCoord4hNV((UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
            }

            public static 
            void TexCoord4h(Int16 s, Int16 t, Int16 r, Int16 q)
            {
                Delegates.glTexCoord4hNV((UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord4h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord4h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TexCoord4h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void TexCoord4h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glTexCoord4hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4h(UInt16* v)
            {
                Delegates.glTexCoord4hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexCoord4h(Int16* v)
            {
                Delegates.glTexCoord4hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord1h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16 s)
            {
                Delegates.glMultiTexCoord1hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s);
            }

            public static 
            void MultiTexCoord1h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16 s)
            {
                Delegates.glMultiTexCoord1hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord1hv(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord1hv(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord1hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord1hv(OpenTK.OpenGL.Enums.NvHalfFloat target, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord1hv(OpenTK.OpenGL.Enums.NvHalfFloat target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord1hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1hv(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16* v)
            {
                Delegates.glMultiTexCoord1hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord1hv(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16* v)
            {
                Delegates.glMultiTexCoord1hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16 s, UInt16 t)
            {
                Delegates.glMultiTexCoord2hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s, (UInt16)t);
            }

            public static 
            void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16 s, Int16 t)
            {
                Delegates.glMultiTexCoord2hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s, (UInt16)t);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord2hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord2hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16* v)
            {
                Delegates.glMultiTexCoord2hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord2h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16* v)
            {
                Delegates.glMultiTexCoord2hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16 s, UInt16 t, UInt16 r)
            {
                Delegates.glMultiTexCoord3hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s, (UInt16)t, (UInt16)r);
            }

            public static 
            void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16 s, Int16 t, Int16 r)
            {
                Delegates.glMultiTexCoord3hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s, (UInt16)t, (UInt16)r);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord3hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord3hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16* v)
            {
                Delegates.glMultiTexCoord3hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord3h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16* v)
            {
                Delegates.glMultiTexCoord3hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16 s, UInt16 t, UInt16 r, UInt16 q)
            {
                Delegates.glMultiTexCoord4hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
            }

            public static 
            void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16 s, Int16 t, Int16 r, Int16 q)
            {
                Delegates.glMultiTexCoord4hNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16)s, (UInt16)t, (UInt16)r, (UInt16)q);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glMultiTexCoord4hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glMultiTexCoord4hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, UInt16* v)
            {
                Delegates.glMultiTexCoord4hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiTexCoord4h(OpenTK.OpenGL.Enums.NvHalfFloat target, Int16* v)
            {
                Delegates.glMultiTexCoord4hvNV((OpenTK.OpenGL.Enums.NvHalfFloat)target, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void FogCoordh(UInt16 fog)
            {
                Delegates.glFogCoordhNV((UInt16)fog);
            }

            public static 
            void FogCoordh(Int16 fog)
            {
                Delegates.glFogCoordhNV((UInt16)fog);
            }

            [System.CLSCompliant(false)]
            public static 
            void FogCoordhv(UInt16[] fog)
            {
                unsafe
                {
                    fixed (UInt16* fog_ptr = fog)
                    {
                        Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                    }
                }
            }

            public static 
            void FogCoordhv(Int16[] fog)
            {
                unsafe
                {
                    fixed (Int16* fog_ptr = fog)
                    {
                        Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void FogCoordhv(ref UInt16 fog)
            {
                unsafe
                {
                    fixed (UInt16* fog_ptr = &fog)
                    {
                        Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                    }
                }
            }

            public static 
            void FogCoordhv(ref Int16 fog)
            {
                unsafe
                {
                    fixed (Int16* fog_ptr = &fog)
                    {
                        Delegates.glFogCoordhvNV((UInt16*)fog_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordhv(UInt16* fog)
            {
                Delegates.glFogCoordhvNV((UInt16*)fog);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void FogCoordhv(Int16* fog)
            {
                Delegates.glFogCoordhvNV((UInt16*)fog);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3h(UInt16 red, UInt16 green, UInt16 blue)
            {
                Delegates.glSecondaryColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
            }

            public static 
            void SecondaryColor3h(Int16 red, Int16 green, Int16 blue)
            {
                Delegates.glSecondaryColor3hNV((UInt16)red, (UInt16)green, (UInt16)blue);
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3h(UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3h(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void SecondaryColor3h(ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void SecondaryColor3h(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glSecondaryColor3hvNV((UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3h(UInt16* v)
            {
                Delegates.glSecondaryColor3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SecondaryColor3h(Int16* v)
            {
                Delegates.glSecondaryColor3hvNV((UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexWeighth(UInt16 weight)
            {
                Delegates.glVertexWeighthNV((UInt16)weight);
            }

            public static 
            void VertexWeighth(Int16 weight)
            {
                Delegates.glVertexWeighthNV((UInt16)weight);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexWeighthv(UInt16[] weight)
            {
                unsafe
                {
                    fixed (UInt16* weight_ptr = weight)
                    {
                        Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                    }
                }
            }

            public static 
            void VertexWeighthv(Int16[] weight)
            {
                unsafe
                {
                    fixed (Int16* weight_ptr = weight)
                    {
                        Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexWeighthv(ref UInt16 weight)
            {
                unsafe
                {
                    fixed (UInt16* weight_ptr = &weight)
                    {
                        Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                    }
                }
            }

            public static 
            void VertexWeighthv(ref Int16 weight)
            {
                unsafe
                {
                    fixed (Int16* weight_ptr = &weight)
                    {
                        Delegates.glVertexWeighthvNV((UInt16*)weight_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexWeighthv(UInt16* weight)
            {
                Delegates.glVertexWeighthvNV((UInt16*)weight);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexWeighthv(Int16* weight)
            {
                Delegates.glVertexWeighthvNV((UInt16*)weight);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1h(UInt32 index, UInt16 x)
            {
                Delegates.glVertexAttrib1hNV((UInt32)index, (UInt16)x);
            }

            public static 
            void VertexAttrib1h(Int32 index, Int16 x)
            {
                Delegates.glVertexAttrib1hNV((UInt32)index, (UInt16)x);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1hv(UInt32 index, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1hv(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib1hv(UInt32 index, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib1hv(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1hv(UInt32 index, UInt16* v)
            {
                Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib1hv(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib1hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2h(UInt32 index, UInt16 x, UInt16 y)
            {
                Delegates.glVertexAttrib2hNV((UInt32)index, (UInt16)x, (UInt16)y);
            }

            public static 
            void VertexAttrib2h(Int32 index, Int16 x, Int16 y)
            {
                Delegates.glVertexAttrib2hNV((UInt32)index, (UInt16)x, (UInt16)y);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2h(UInt32 index, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2h(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib2h(UInt32 index, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib2h(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2h(UInt32 index, UInt16* v)
            {
                Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib2h(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib2hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3h(UInt32 index, UInt16 x, UInt16 y, UInt16 z)
            {
                Delegates.glVertexAttrib3hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z);
            }

            public static 
            void VertexAttrib3h(Int32 index, Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertexAttrib3hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3h(UInt32 index, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3h(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib3h(UInt32 index, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib3h(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3h(UInt32 index, UInt16* v)
            {
                Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib3h(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib3hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4h(UInt32 index, UInt16 x, UInt16 y, UInt16 z, UInt16 w)
            {
                Delegates.glVertexAttrib4hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
            }

            public static 
            void VertexAttrib4h(Int32 index, Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertexAttrib4hNV((UInt32)index, (UInt16)x, (UInt16)y, (UInt16)z, (UInt16)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4h(UInt32 index, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4h(Int32 index, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttrib4h(UInt32 index, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttrib4h(Int32 index, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4h(UInt32 index, UInt16* v)
            {
                Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttrib4h(Int32 index, Int16* v)
            {
                Delegates.glVertexAttrib4hvNV((UInt32)index, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1h(UInt32 index, Int32 n, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1h(Int32 index, Int32 n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs1h(UInt32 index, Int32 n, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs1h(Int32 index, Int32 n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1h(UInt32 index, Int32 n, UInt16* v)
            {
                Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs1h(Int32 index, Int32 n, Int16* v)
            {
                Delegates.glVertexAttribs1hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2h(UInt32 index, Int32 n, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2h(Int32 index, Int32 n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs2h(UInt32 index, Int32 n, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs2h(Int32 index, Int32 n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2h(UInt32 index, Int32 n, UInt16* v)
            {
                Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs2h(Int32 index, Int32 n, Int16* v)
            {
                Delegates.glVertexAttribs2hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3h(UInt32 index, Int32 n, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3h(Int32 index, Int32 n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs3h(UInt32 index, Int32 n, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs3h(Int32 index, Int32 n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3h(UInt32 index, Int32 n, UInt16* v)
            {
                Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs3h(Int32 index, Int32 n, Int16* v)
            {
                Delegates.glVertexAttribs3hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4h(UInt32 index, Int32 n, UInt16[] v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4h(Int32 index, Int32 n, Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribs4h(UInt32 index, Int32 n, ref UInt16 v)
            {
                unsafe
                {
                    fixed (UInt16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            public static 
            void VertexAttribs4h(Int32 index, Int32 n, ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4h(UInt32 index, Int32 n, UInt16* v)
            {
                Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexAttribs4h(Int32 index, Int32 n, Int16* v)
            {
                Delegates.glVertexAttribs4hvNV((UInt32)index, (Int32)n, (UInt16*)v);
            }

            public static 
            void PixelDataRange(OpenTK.OpenGL.Enums.NvPixelDataRange target, Int32 length, [Out] IntPtr pointer)
            {
                Delegates.glPixelDataRangeNV((OpenTK.OpenGL.Enums.NvPixelDataRange)target, (Int32)length, (IntPtr)pointer);
            }

            public static 
            void PixelDataRange(OpenTK.OpenGL.Enums.NvPixelDataRange target, Int32 length, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glPixelDataRangeNV((OpenTK.OpenGL.Enums.NvPixelDataRange)target, (Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void FlushPixelDataRange(OpenTK.OpenGL.Enums.NvPixelDataRange target)
            {
                Delegates.glFlushPixelDataRangeNV((OpenTK.OpenGL.Enums.NvPixelDataRange)target);
            }

            public static 
            void PrimitiveRestart()
            {
                Delegates.glPrimitiveRestartNV();
            }

            [System.CLSCompliant(false)]
            public static 
            void PrimitiveRestartIndex(UInt32 index)
            {
                Delegates.glPrimitiveRestartIndexNV((UInt32)index);
            }

            public static 
            void PrimitiveRestartIndex(Int32 index)
            {
                Delegates.glPrimitiveRestartIndexNV((UInt32)index);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glProgramLocalParameterI4iNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameterI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameterI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32* @params)
            {
                Delegates.glProgramLocalParameterI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParametersI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParametersI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, Int32* @params)
            {
                Delegates.glProgramLocalParametersI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
            {
                Delegates.glProgramLocalParameterI4uiNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
            }

            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glProgramLocalParameterI4uiNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, ref UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, UInt32* @params)
            {
                Delegates.glProgramLocalParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32* @params)
            {
                Delegates.glProgramLocalParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, ref UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramLocalParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, UInt32* @params)
            {
                Delegates.glProgramLocalParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramLocalParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 count, Int32* @params)
            {
                Delegates.glProgramLocalParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glProgramEnvParameterI4iNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameterI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameterI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32* @params)
            {
                Delegates.glProgramEnvParameterI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParametersI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParametersI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, Int32* @params)
            {
                Delegates.glProgramEnvParametersI4ivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, UInt32 x, UInt32 y, UInt32 z, UInt32 w)
            {
                Delegates.glProgramEnvParameterI4uiNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
            }

            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glProgramEnvParameterI4uiNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32)x, (UInt32)y, (UInt32)z, (UInt32)w);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, ref UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, UInt32* @params)
            {
                Delegates.glProgramEnvParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParameterI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32* @params)
            {
                Delegates.glProgramEnvParameterI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, ref UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramEnvParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, Int32 count, UInt32* @params)
            {
                Delegates.glProgramEnvParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramEnvParametersI4(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, Int32 count, Int32* @params)
            {
                Delegates.glProgramEnvParametersI4uivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32)count, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterIivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterIivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] Int32* @params)
            {
                Delegates.glGetProgramLocalParameterIivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] out UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramLocalParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] UInt32* @params)
            {
                Delegates.glGetProgramLocalParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramLocalParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, [Out] Int32* @params)
            {
                Delegates.glGetProgramLocalParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterIivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterIivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] Int32* @params)
            {
                Delegates.glGetProgramEnvParameterIivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] out UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetProgramEnvParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, UInt32 index, [Out] UInt32* @params)
            {
                Delegates.glGetProgramEnvParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetProgramEnvParameterI(OpenTK.OpenGL.Enums.NvGpuProgram4 target, Int32 index, [Out] Int32* @params)
            {
                Delegates.glGetProgramEnvParameterIuivNV((OpenTK.OpenGL.Enums.NvGpuProgram4)target, (UInt32)index, (UInt32*)@params);
            }

            public static 
            void ProgramVertexLimit(OpenTK.OpenGL.Enums.NvGeometryProgram4 target, Int32 limit)
            {
                Delegates.glProgramVertexLimitNV((OpenTK.OpenGL.Enums.NvGeometryProgram4)target, (Int32)limit);
            }

            public static 
            void DepthRange(Double zNear, Double zFar)
            {
                Delegates.glDepthRangedNV((Double)zNear, (Double)zFar);
            }

            public static 
            void ClearDepth(Double depth)
            {
                Delegates.glClearDepthdNV((Double)depth);
            }

            public static 
            void DepthBounds(Double zmin, Double zmax)
            {
                Delegates.glDepthBoundsdNV((Double)zmin, (Double)zmax);
            }

            public static 
            void RenderbufferStorageMultisampleCoverage(OpenTK.OpenGL.Enums.NvFramebufferMultisampleCoverage target, Int32 coverageSamples, Int32 colorSamples, OpenTK.OpenGL.Enums.PixelInternalFormat internalformat, Int32 width, Int32 height)
            {
                Delegates.glRenderbufferStorageMultisampleCoverageNV((OpenTK.OpenGL.Enums.NvFramebufferMultisampleCoverage)target, (Int32)coverageSamples, (Int32)colorSamples, (OpenTK.OpenGL.Enums.PixelInternalFormat)internalformat, (Int32)width, (Int32)height);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParameters(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersfvNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramBufferParameters(OpenTK.OpenGL.Enums.NvParameterBufferObject target, Int32 buffer, Int32 index, Int32 count, Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersfvNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParameters(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersfvNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramBufferParameters(OpenTK.OpenGL.Enums.NvParameterBufferObject target, Int32 buffer, Int32 index, Int32 count, ref Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersfvNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParameters(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, Single* @params)
            {
                Delegates.glProgramBufferParametersfvNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParameters(OpenTK.OpenGL.Enums.NvParameterBufferObject target, Int32 buffer, Int32 index, Int32 count, Single* @params)
            {
                Delegates.glProgramBufferParametersfvNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersIivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersIivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, Int32* @params)
            {
                Delegates.glProgramBufferParametersIivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, UInt32[] @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, Int32 buffer, Int32 index, Int32 count, Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, ref UInt32 @params)
            {
                unsafe
                {
                    fixed (UInt32* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            public static 
            void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, Int32 buffer, Int32 index, Int32 count, ref Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glProgramBufferParametersIuivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, UInt32 buffer, UInt32 index, Int32 count, UInt32* @params)
            {
                Delegates.glProgramBufferParametersIuivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void ProgramBufferParametersI(OpenTK.OpenGL.Enums.NvParameterBufferObject target, Int32 buffer, Int32 index, Int32 count, Int32* @params)
            {
                Delegates.glProgramBufferParametersIuivNV((OpenTK.OpenGL.Enums.NvParameterBufferObject)target, (UInt32)buffer, (UInt32)index, (Int32)count, (UInt32*)@params);
            }

            public static 
            void BeginTransformFeedback(OpenTK.OpenGL.Enums.NvTransformFeedback primitiveMode)
            {
                Delegates.glBeginTransformFeedbackNV((OpenTK.OpenGL.Enums.NvTransformFeedback)primitiveMode);
            }

            public static 
            void EndTransformFeedback()
            {
                Delegates.glEndTransformFeedbackNV();
            }

            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackAttrib(UInt32 count, Int32[] attribs, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* attribs_ptr = attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            public static 
            void TransformFeedbackAttrib(Int32 count, Int32[] attribs, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* attribs_ptr = attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackAttrib(UInt32 count, ref Int32 attribs, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* attribs_ptr = &attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            public static 
            void TransformFeedbackAttrib(Int32 count, ref Int32 attribs, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* attribs_ptr = &attribs)
                    {
                        Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackAttrib(UInt32 count, Int32* attribs, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackAttrib(Int32 count, Int32* attribs, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                Delegates.glTransformFeedbackAttribsNV((UInt32)count, (Int32*)attribs, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindBufferRange(OpenTK.OpenGL.Enums.NvTransformFeedback target, UInt32 index, UInt32 buffer, IntPtr offset, IntPtr size)
            {
                Delegates.glBindBufferRangeNV((OpenTK.OpenGL.Enums.NvTransformFeedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset, (IntPtr)size);
            }

            public static 
            void BindBufferRange(OpenTK.OpenGL.Enums.NvTransformFeedback target, Int32 index, Int32 buffer, IntPtr offset, IntPtr size)
            {
                Delegates.glBindBufferRangeNV((OpenTK.OpenGL.Enums.NvTransformFeedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset, (IntPtr)size);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindBufferOffset(OpenTK.OpenGL.Enums.NvTransformFeedback target, UInt32 index, UInt32 buffer, IntPtr offset)
            {
                Delegates.glBindBufferOffsetNV((OpenTK.OpenGL.Enums.NvTransformFeedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset);
            }

            public static 
            void BindBufferOffset(OpenTK.OpenGL.Enums.NvTransformFeedback target, Int32 index, Int32 buffer, IntPtr offset)
            {
                Delegates.glBindBufferOffsetNV((OpenTK.OpenGL.Enums.NvTransformFeedback)target, (UInt32)index, (UInt32)buffer, (IntPtr)offset);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindBufferBase(OpenTK.OpenGL.Enums.NvTransformFeedback target, UInt32 index, UInt32 buffer)
            {
                Delegates.glBindBufferBaseNV((OpenTK.OpenGL.Enums.NvTransformFeedback)target, (UInt32)index, (UInt32)buffer);
            }

            public static 
            void BindBufferBase(OpenTK.OpenGL.Enums.NvTransformFeedback target, Int32 index, Int32 buffer)
            {
                Delegates.glBindBufferBaseNV((OpenTK.OpenGL.Enums.NvTransformFeedback)target, (UInt32)index, (UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackVarying(UInt32 program, Int32 count, Int32[] locations, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* locations_ptr = locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            public static 
            void TransformFeedbackVarying(Int32 program, Int32 count, Int32[] locations, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* locations_ptr = locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void TransformFeedbackVarying(UInt32 program, Int32 count, ref Int32 locations, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* locations_ptr = &locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            public static 
            void TransformFeedbackVarying(Int32 program, Int32 count, ref Int32 locations, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                unsafe
                {
                    fixed (Int32* locations_ptr = &locations)
                    {
                        Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackVarying(UInt32 program, Int32 count, Int32* locations, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TransformFeedbackVarying(Int32 program, Int32 count, Int32* locations, OpenTK.OpenGL.Enums.NvTransformFeedback bufferMode)
            {
                Delegates.glTransformFeedbackVaryingsNV((UInt32)program, (Int32)count, (Int32*)locations, (OpenTK.OpenGL.Enums.NvTransformFeedback)bufferMode);
            }

            [System.CLSCompliant(false)]
            public static 
            void ActiveVarying(UInt32 program, System.String name)
            {
                Delegates.glActiveVaryingNV((UInt32)program, (System.String)name);
            }

            public static 
            void ActiveVarying(Int32 program, System.String name)
            {
                Delegates.glActiveVaryingNV((UInt32)program, (System.String)name);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GetVaryingLocation(UInt32 program, System.String name)
            {
                return Delegates.glGetVaryingLocationNV((UInt32)program, (System.String)name);
            }

            public static 
            Int32 GetVaryingLocation(Int32 program, System.String name)
            {
                return Delegates.glGetVaryingLocationNV((UInt32)program, (System.String)name);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.NvTransformFeedback[] type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    fixed (Int32* size_ptr = size)
                    fixed (OpenTK.OpenGL.Enums.NvTransformFeedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }

            public static 
            void GetActiveVarying(Int32 program, Int32 index, Int32 bufSize, [Out] Int32[] length, [Out] Int32[] size, [Out] OpenTK.OpenGL.Enums.NvTransformFeedback[] type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = length)
                    fixed (Int32* size_ptr = size)
                    fixed (OpenTK.OpenGL.Enums.NvTransformFeedback* type_ptr = type)
                    {
                        Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback*)type_ptr, (System.Text.StringBuilder)name);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetActiveVarying(UInt32 program, UInt32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.NvTransformFeedback type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    fixed (Int32* size_ptr = &size)
                    fixed (OpenTK.OpenGL.Enums.NvTransformFeedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }

            public static 
            void GetActiveVarying(Int32 program, Int32 index, Int32 bufSize, [Out] out Int32 length, [Out] out Int32 size, [Out] out OpenTK.OpenGL.Enums.NvTransformFeedback type, [Out] System.Text.StringBuilder name)
            {
                unsafe
                {
                    fixed (Int32* length_ptr = &length)
                    fixed (Int32* size_ptr = &size)
                    fixed (OpenTK.OpenGL.Enums.NvTransformFeedback* type_ptr = &type)
                    {
                        Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length_ptr, (Int32*)size_ptr, (OpenTK.OpenGL.Enums.NvTransformFeedback*)type_ptr, (System.Text.StringBuilder)name);
                        length = *length_ptr;
                        size = *size_ptr;
                        type = *type_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(UInt32 program, UInt32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.NvTransformFeedback* type, [Out] System.Text.StringBuilder name)
            {
                Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.NvTransformFeedback*)type, (System.Text.StringBuilder)name);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetActiveVarying(Int32 program, Int32 index, Int32 bufSize, [Out] Int32* length, [Out] Int32* size, [Out] OpenTK.OpenGL.Enums.NvTransformFeedback* type, [Out] System.Text.StringBuilder name)
            {
                Delegates.glGetActiveVaryingNV((UInt32)program, (UInt32)index, (Int32)bufSize, (Int32*)length, (Int32*)size, (OpenTK.OpenGL.Enums.NvTransformFeedback*)type, (System.Text.StringBuilder)name);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetTransformFeedbackVarying(UInt32 program, UInt32 index, [Out] Int32[] location)
            {
                unsafe
                {
                    fixed (Int32* location_ptr = location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                    }
                }
            }

            public static 
            void GetTransformFeedbackVarying(Int32 program, Int32 index, [Out] Int32[] location)
            {
                unsafe
                {
                    fixed (Int32* location_ptr = location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetTransformFeedbackVarying(UInt32 program, UInt32 index, [Out] out Int32 location)
            {
                unsafe
                {
                    fixed (Int32* location_ptr = &location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                        location = *location_ptr;
                    }
                }
            }

            public static 
            void GetTransformFeedbackVarying(Int32 program, Int32 index, [Out] out Int32 location)
            {
                unsafe
                {
                    fixed (Int32* location_ptr = &location)
                    {
                        Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location_ptr);
                        location = *location_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTransformFeedbackVarying(UInt32 program, UInt32 index, [Out] Int32* location)
            {
                Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTransformFeedbackVarying(Int32 program, Int32 index, [Out] Int32* location)
            {
                Delegates.glGetTransformFeedbackVaryingNV((UInt32)program, (UInt32)index, (Int32*)location);
            }

        }

        public static partial class Mesa
        {
            public static 
            void ResizeBuffers()
            {
                Delegates.glResizeBuffersMESA();
            }

            public static 
            void WindowPos2(Double x, Double y)
            {
                Delegates.glWindowPos2dMESA((Double)x, (Double)y);
            }

            public static 
            void WindowPos2(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glWindowPos2dvMESA((Double*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glWindowPos2dvMESA((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Double* v)
            {
                Delegates.glWindowPos2dvMESA((Double*)v);
            }

            public static 
            void WindowPos2(Single x, Single y)
            {
                Delegates.glWindowPos2fMESA((Single)x, (Single)y);
            }

            public static 
            void WindowPos2(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glWindowPos2fvMESA((Single*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glWindowPos2fvMESA((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Single* v)
            {
                Delegates.glWindowPos2fvMESA((Single*)v);
            }

            public static 
            void WindowPos2(Int32 x, Int32 y)
            {
                Delegates.glWindowPos2iMESA((Int32)x, (Int32)y);
            }

            public static 
            void WindowPos2(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glWindowPos2ivMESA((Int32*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glWindowPos2ivMESA((Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Int32* v)
            {
                Delegates.glWindowPos2ivMESA((Int32*)v);
            }

            public static 
            void WindowPos2(Int16 x, Int16 y)
            {
                Delegates.glWindowPos2sMESA((Int16)x, (Int16)y);
            }

            public static 
            void WindowPos2(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glWindowPos2svMESA((Int16*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos2(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glWindowPos2svMESA((Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos2(Int16* v)
            {
                Delegates.glWindowPos2svMESA((Int16*)v);
            }

            public static 
            void WindowPos3(Double x, Double y, Double z)
            {
                Delegates.glWindowPos3dMESA((Double)x, (Double)y, (Double)z);
            }

            public static 
            void WindowPos3(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glWindowPos3dvMESA((Double*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glWindowPos3dvMESA((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Double* v)
            {
                Delegates.glWindowPos3dvMESA((Double*)v);
            }

            public static 
            void WindowPos3(Single x, Single y, Single z)
            {
                Delegates.glWindowPos3fMESA((Single)x, (Single)y, (Single)z);
            }

            public static 
            void WindowPos3(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glWindowPos3fvMESA((Single*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glWindowPos3fvMESA((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Single* v)
            {
                Delegates.glWindowPos3fvMESA((Single*)v);
            }

            public static 
            void WindowPos3(Int32 x, Int32 y, Int32 z)
            {
                Delegates.glWindowPos3iMESA((Int32)x, (Int32)y, (Int32)z);
            }

            public static 
            void WindowPos3(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glWindowPos3ivMESA((Int32*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glWindowPos3ivMESA((Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Int32* v)
            {
                Delegates.glWindowPos3ivMESA((Int32*)v);
            }

            public static 
            void WindowPos3(Int16 x, Int16 y, Int16 z)
            {
                Delegates.glWindowPos3sMESA((Int16)x, (Int16)y, (Int16)z);
            }

            public static 
            void WindowPos3(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glWindowPos3svMESA((Int16*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos3(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glWindowPos3svMESA((Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos3(Int16* v)
            {
                Delegates.glWindowPos3svMESA((Int16*)v);
            }

            public static 
            void WindowPos4(Double x, Double y, Double z, Double w)
            {
                Delegates.glWindowPos4dMESA((Double)x, (Double)y, (Double)z, (Double)w);
            }

            public static 
            void WindowPos4(Double[] v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = v)
                    {
                        Delegates.glWindowPos4dvMESA((Double*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos4(ref Double v)
            {
                unsafe
                {
                    fixed (Double* v_ptr = &v)
                    {
                        Delegates.glWindowPos4dvMESA((Double*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4(Double* v)
            {
                Delegates.glWindowPos4dvMESA((Double*)v);
            }

            public static 
            void WindowPos4(Single x, Single y, Single z, Single w)
            {
                Delegates.glWindowPos4fMESA((Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void WindowPos4(Single[] v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = v)
                    {
                        Delegates.glWindowPos4fvMESA((Single*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos4(ref Single v)
            {
                unsafe
                {
                    fixed (Single* v_ptr = &v)
                    {
                        Delegates.glWindowPos4fvMESA((Single*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4(Single* v)
            {
                Delegates.glWindowPos4fvMESA((Single*)v);
            }

            public static 
            void WindowPos4(Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glWindowPos4iMESA((Int32)x, (Int32)y, (Int32)z, (Int32)w);
            }

            public static 
            void WindowPos4(Int32[] v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = v)
                    {
                        Delegates.glWindowPos4ivMESA((Int32*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos4(ref Int32 v)
            {
                unsafe
                {
                    fixed (Int32* v_ptr = &v)
                    {
                        Delegates.glWindowPos4ivMESA((Int32*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4(Int32* v)
            {
                Delegates.glWindowPos4ivMESA((Int32*)v);
            }

            public static 
            void WindowPos4(Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glWindowPos4sMESA((Int16)x, (Int16)y, (Int16)z, (Int16)w);
            }

            public static 
            void WindowPos4(Int16[] v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = v)
                    {
                        Delegates.glWindowPos4svMESA((Int16*)v_ptr);
                    }
                }
            }

            public static 
            void WindowPos4(ref Int16 v)
            {
                unsafe
                {
                    fixed (Int16* v_ptr = &v)
                    {
                        Delegates.glWindowPos4svMESA((Int16*)v_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void WindowPos4(Int16* v)
            {
                Delegates.glWindowPos4svMESA((Int16*)v);
            }

        }

        public static partial class Ibm
        {
            public static 
            void MultiModeDrawArrays(OpenTK.OpenGL.Enums.BeginMode[] mode, Int32[] first, Int32[] count, Int32 primcount, Int32 modestride)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.BeginMode* mode_ptr = mode)
                    fixed (Int32* first_ptr = first)
                    fixed (Int32* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((OpenTK.OpenGL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                    }
                }
            }

            public static 
            void MultiModeDrawArrays(ref OpenTK.OpenGL.Enums.BeginMode mode, ref Int32 first, ref Int32 count, Int32 primcount, Int32 modestride)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (Int32* first_ptr = &first)
                    fixed (Int32* count_ptr = &count)
                    {
                        Delegates.glMultiModeDrawArraysIBM((OpenTK.OpenGL.Enums.BeginMode*)mode_ptr, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount, (Int32)modestride);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawArrays(OpenTK.OpenGL.Enums.BeginMode* mode, Int32* first, Int32* count, Int32 primcount, Int32 modestride)
            {
                Delegates.glMultiModeDrawArraysIBM((OpenTK.OpenGL.Enums.BeginMode*)mode, (Int32*)first, (Int32*)count, (Int32)primcount, (Int32)modestride);
            }

            public static 
            void MultiModeDrawElements(OpenTK.OpenGL.Enums.BeginMode[] mode, Int32[] count, OpenTK.OpenGL.Enums.IbmMultimodeDrawArrays type, IntPtr indices, Int32 primcount, Int32 modestride)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.BeginMode* mode_ptr = mode)
                    fixed (Int32* count_ptr = count)
                    {
                        Delegates.glMultiModeDrawElementsIBM((OpenTK.OpenGL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (OpenTK.OpenGL.Enums.IbmMultimodeDrawArrays)type, (IntPtr)indices, (Int32)primcount, (Int32)modestride);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiModeDrawElements(OpenTK.OpenGL.Enums.BeginMode* mode, Int32* count, OpenTK.OpenGL.Enums.IbmMultimodeDrawArrays type, [In, Out] object indices, Int32 primcount, Int32 modestride)
            {
                System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glMultiModeDrawElementsIBM((OpenTK.OpenGL.Enums.BeginMode*)mode, (Int32*)count, (OpenTK.OpenGL.Enums.IbmMultimodeDrawArrays)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                }
                finally
                {
                    indices_ptr.Free();
                }
            }

            public static 
            void MultiModeDrawElements(ref OpenTK.OpenGL.Enums.BeginMode mode, ref Int32 count, OpenTK.OpenGL.Enums.IbmMultimodeDrawArrays type, [In, Out] object indices, Int32 primcount, Int32 modestride)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.BeginMode* mode_ptr = &mode)
                    fixed (Int32* count_ptr = &count)
                    {
                        System.Runtime.InteropServices.GCHandle indices_ptr = System.Runtime.InteropServices.GCHandle.Alloc(indices, System.Runtime.InteropServices.GCHandleType.Pinned);
                        try
                        {
                            Delegates.glMultiModeDrawElementsIBM((OpenTK.OpenGL.Enums.BeginMode*)mode_ptr, (Int32*)count_ptr, (OpenTK.OpenGL.Enums.IbmMultimodeDrawArrays)type, (IntPtr)indices_ptr.AddrOfPinnedObject(), (Int32)primcount, (Int32)modestride);
                        }
                        finally
                        {
                            indices_ptr.Free();
                        }
                    }
                }
            }

            public static 
            void ColorPointerList(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, IntPtr pointer, Int32 ptrstride)
            {
                Delegates.glColorPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }

            public static 
            void ColorPointerList(Int32 size, OpenTK.OpenGL.Enums.ColorPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glColorPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.ColorPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void SecondaryColorPointerList(Int32 size, OpenTK.OpenGL.Enums.IbmVertexArrayLists type, Int32 stride, IntPtr pointer, Int32 ptrstride)
            {
                Delegates.glSecondaryColorPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.IbmVertexArrayLists)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }

            public static 
            void SecondaryColorPointerList(Int32 size, OpenTK.OpenGL.Enums.IbmVertexArrayLists type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glSecondaryColorPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.IbmVertexArrayLists)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void EdgeFlagPointerList(Int32 stride, bool[] pointer, Int32 ptrstride)
            {
                unsafe
                {
                    fixed (bool* pointer_ptr = pointer)
                    {
                        Delegates.glEdgeFlagPointerListIBM((Int32)stride, (bool*)pointer_ptr, (Int32)ptrstride);
                    }
                }
            }

            public static 
            void EdgeFlagPointerList(Int32 stride, ref bool pointer, Int32 ptrstride)
            {
                unsafe
                {
                    fixed (bool* pointer_ptr = &pointer)
                    {
                        Delegates.glEdgeFlagPointerListIBM((Int32)stride, (bool*)pointer_ptr, (Int32)ptrstride);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void EdgeFlagPointerList(Int32 stride, bool* pointer, Int32 ptrstride)
            {
                Delegates.glEdgeFlagPointerListIBM((Int32)stride, (bool*)pointer, (Int32)ptrstride);
            }

            public static 
            void FogCoordPointerList(OpenTK.OpenGL.Enums.IbmVertexArrayLists type, Int32 stride, IntPtr pointer, Int32 ptrstride)
            {
                Delegates.glFogCoordPointerListIBM((OpenTK.OpenGL.Enums.IbmVertexArrayLists)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }

            public static 
            void FogCoordPointerList(OpenTK.OpenGL.Enums.IbmVertexArrayLists type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glFogCoordPointerListIBM((OpenTK.OpenGL.Enums.IbmVertexArrayLists)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void IndexPointerList(OpenTK.OpenGL.Enums.IndexPointerType type, Int32 stride, IntPtr pointer, Int32 ptrstride)
            {
                Delegates.glIndexPointerListIBM((OpenTK.OpenGL.Enums.IndexPointerType)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }

            public static 
            void IndexPointerList(OpenTK.OpenGL.Enums.IndexPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glIndexPointerListIBM((OpenTK.OpenGL.Enums.IndexPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void NormalPointerList(OpenTK.OpenGL.Enums.NormalPointerType type, Int32 stride, IntPtr pointer, Int32 ptrstride)
            {
                Delegates.glNormalPointerListIBM((OpenTK.OpenGL.Enums.NormalPointerType)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }

            public static 
            void NormalPointerList(OpenTK.OpenGL.Enums.NormalPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glNormalPointerListIBM((OpenTK.OpenGL.Enums.NormalPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void TexCoordPointerList(Int32 size, OpenTK.OpenGL.Enums.TexCoordPointerType type, Int32 stride, IntPtr pointer, Int32 ptrstride)
            {
                Delegates.glTexCoordPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.TexCoordPointerType)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }

            public static 
            void TexCoordPointerList(Int32 size, OpenTK.OpenGL.Enums.TexCoordPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glTexCoordPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.TexCoordPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void VertexPointerList(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, Int32 stride, IntPtr pointer, Int32 ptrstride)
            {
                Delegates.glVertexPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (Int32)stride, (IntPtr)pointer, (Int32)ptrstride);
            }

            public static 
            void VertexPointerList(Int32 size, OpenTK.OpenGL.Enums.VertexPointerType type, Int32 stride, [In, Out] object pointer, Int32 ptrstride)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexPointerListIBM((Int32)size, (OpenTK.OpenGL.Enums.VertexPointerType)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (Int32)ptrstride);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

        }

        public static partial class GL_3dfx
        {
            [System.CLSCompliant(false)]
            public static 
            void TbufferMask(UInt32 mask)
            {
                Delegates.glTbufferMask3DFX((UInt32)mask);
            }

            public static 
            void TbufferMask(Int32 mask)
            {
                Delegates.glTbufferMask3DFX((UInt32)mask);
            }

        }

        public static partial class Ata
        {
            public static 
            void TexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, Int32[] param)
            {
                unsafe
                {
                    fixed (Int32* param_ptr = param)
                    {
                        Delegates.glTexBumpParameterivATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Int32*)param_ptr);
                    }
                }
            }

            public static 
            void TexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, ref Int32 param)
            {
                unsafe
                {
                    fixed (Int32* param_ptr = &param)
                    {
                        Delegates.glTexBumpParameterivATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Int32*)param_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, Int32* param)
            {
                Delegates.glTexBumpParameterivATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Int32*)param);
            }

            public static 
            void TexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, Single[] param)
            {
                unsafe
                {
                    fixed (Single* param_ptr = param)
                    {
                        Delegates.glTexBumpParameterfvATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Single*)param_ptr);
                    }
                }
            }

            public static 
            void TexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, ref Single param)
            {
                unsafe
                {
                    fixed (Single* param_ptr = &param)
                    {
                        Delegates.glTexBumpParameterfvATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Single*)param_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void TexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, Single* param)
            {
                Delegates.glTexBumpParameterfvATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Single*)param);
            }

            public static 
            void GetTexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, [Out] Int32[] param)
            {
                unsafe
                {
                    fixed (Int32* param_ptr = param)
                    {
                        Delegates.glGetTexBumpParameterivATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Int32*)param_ptr);
                    }
                }
            }

            public static 
            void GetTexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, [Out] out Int32 param)
            {
                unsafe
                {
                    fixed (Int32* param_ptr = &param)
                    {
                        Delegates.glGetTexBumpParameterivATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Int32*)param_ptr);
                        param = *param_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, [Out] Int32* param)
            {
                Delegates.glGetTexBumpParameterivATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Int32*)param);
            }

            public static 
            void GetTexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, [Out] Single[] param)
            {
                unsafe
                {
                    fixed (Single* param_ptr = param)
                    {
                        Delegates.glGetTexBumpParameterfvATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Single*)param_ptr);
                    }
                }
            }

            public static 
            void GetTexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, [Out] out Single param)
            {
                unsafe
                {
                    fixed (Single* param_ptr = &param)
                    {
                        Delegates.glGetTexBumpParameterfvATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Single*)param_ptr);
                        param = *param_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetTexBumpParameter(OpenTK.OpenGL.Enums.AtiEnvmapBumpmap pname, [Out] Single* param)
            {
                Delegates.glGetTexBumpParameterfvATI((OpenTK.OpenGL.Enums.AtiEnvmapBumpmap)pname, (Single*)param);
            }

            [System.CLSCompliant(false)]
            public static 
            Int32 GenFragmentShaders(UInt32 range)
            {
                return Delegates.glGenFragmentShadersATI((UInt32)range);
            }

            public static 
            Int32 GenFragmentShaders(Int32 range)
            {
                return Delegates.glGenFragmentShadersATI((UInt32)range);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindFragmentShader(UInt32 id)
            {
                Delegates.glBindFragmentShaderATI((UInt32)id);
            }

            public static 
            void BindFragmentShader(Int32 id)
            {
                Delegates.glBindFragmentShaderATI((UInt32)id);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteFragmentShader(UInt32 id)
            {
                Delegates.glDeleteFragmentShaderATI((UInt32)id);
            }

            public static 
            void DeleteFragmentShader(Int32 id)
            {
                Delegates.glDeleteFragmentShaderATI((UInt32)id);
            }

            public static 
            void BeginFragmentShader()
            {
                Delegates.glBeginFragmentShaderATI();
            }

            public static 
            void EndFragmentShader()
            {
                Delegates.glEndFragmentShaderATI();
            }

            [System.CLSCompliant(false)]
            public static 
            void PassTexCoor(UInt32 dst, UInt32 coord, OpenTK.OpenGL.Enums.AtiFragmentShader swizzle)
            {
                Delegates.glPassTexCoordATI((UInt32)dst, (UInt32)coord, (OpenTK.OpenGL.Enums.AtiFragmentShader)swizzle);
            }

            public static 
            void PassTexCoor(Int32 dst, Int32 coord, OpenTK.OpenGL.Enums.AtiFragmentShader swizzle)
            {
                Delegates.glPassTexCoordATI((UInt32)dst, (UInt32)coord, (OpenTK.OpenGL.Enums.AtiFragmentShader)swizzle);
            }

            [System.CLSCompliant(false)]
            public static 
            void SampleMap(UInt32 dst, UInt32 interp, OpenTK.OpenGL.Enums.AtiFragmentShader swizzle)
            {
                Delegates.glSampleMapATI((UInt32)dst, (UInt32)interp, (OpenTK.OpenGL.Enums.AtiFragmentShader)swizzle);
            }

            public static 
            void SampleMap(Int32 dst, Int32 interp, OpenTK.OpenGL.Enums.AtiFragmentShader swizzle)
            {
                Delegates.glSampleMapATI((UInt32)dst, (UInt32)interp, (OpenTK.OpenGL.Enums.AtiFragmentShader)swizzle);
            }

            [System.CLSCompliant(false)]
            public static 
            void ColorFragmentOp1(OpenTK.OpenGL.Enums.AtiFragmentShader op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
            {
                Delegates.glColorFragmentOp1ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
            }

            public static 
            void ColorFragmentOp1(OpenTK.OpenGL.Enums.AtiFragmentShader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
            {
                Delegates.glColorFragmentOp1ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
            }

            [System.CLSCompliant(false)]
            public static 
            void ColorFragmentOp2(OpenTK.OpenGL.Enums.AtiFragmentShader op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
            {
                Delegates.glColorFragmentOp2ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
            }

            public static 
            void ColorFragmentOp2(OpenTK.OpenGL.Enums.AtiFragmentShader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
            {
                Delegates.glColorFragmentOp2ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
            }

            [System.CLSCompliant(false)]
            public static 
            void ColorFragmentOp3(OpenTK.OpenGL.Enums.AtiFragmentShader op, UInt32 dst, UInt32 dstMask, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
            {
                Delegates.glColorFragmentOp3ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
            }

            public static 
            void ColorFragmentOp3(OpenTK.OpenGL.Enums.AtiFragmentShader op, Int32 dst, Int32 dstMask, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod, Int32 arg3, Int32 arg3Rep, Int32 arg3Mod)
            {
                Delegates.glColorFragmentOp3ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMask, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
            }

            [System.CLSCompliant(false)]
            public static 
            void AlphaFragmentOp1(OpenTK.OpenGL.Enums.AtiFragmentShader op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod)
            {
                Delegates.glAlphaFragmentOp1ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
            }

            public static 
            void AlphaFragmentOp1(OpenTK.OpenGL.Enums.AtiFragmentShader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod)
            {
                Delegates.glAlphaFragmentOp1ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod);
            }

            [System.CLSCompliant(false)]
            public static 
            void AlphaFragmentOp2(OpenTK.OpenGL.Enums.AtiFragmentShader op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod)
            {
                Delegates.glAlphaFragmentOp2ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
            }

            public static 
            void AlphaFragmentOp2(OpenTK.OpenGL.Enums.AtiFragmentShader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod)
            {
                Delegates.glAlphaFragmentOp2ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod);
            }

            [System.CLSCompliant(false)]
            public static 
            void AlphaFragmentOp3(OpenTK.OpenGL.Enums.AtiFragmentShader op, UInt32 dst, UInt32 dstMod, UInt32 arg1, UInt32 arg1Rep, UInt32 arg1Mod, UInt32 arg2, UInt32 arg2Rep, UInt32 arg2Mod, UInt32 arg3, UInt32 arg3Rep, UInt32 arg3Mod)
            {
                Delegates.glAlphaFragmentOp3ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
            }

            public static 
            void AlphaFragmentOp3(OpenTK.OpenGL.Enums.AtiFragmentShader op, Int32 dst, Int32 dstMod, Int32 arg1, Int32 arg1Rep, Int32 arg1Mod, Int32 arg2, Int32 arg2Rep, Int32 arg2Mod, Int32 arg3, Int32 arg3Rep, Int32 arg3Mod)
            {
                Delegates.glAlphaFragmentOp3ATI((OpenTK.OpenGL.Enums.AtiFragmentShader)op, (UInt32)dst, (UInt32)dstMod, (UInt32)arg1, (UInt32)arg1Rep, (UInt32)arg1Mod, (UInt32)arg2, (UInt32)arg2Rep, (UInt32)arg2Mod, (UInt32)arg3, (UInt32)arg3Rep, (UInt32)arg3Mod);
            }

            [System.CLSCompliant(false)]
            public static 
            void SetFragmentShaderConstant(UInt32 dst, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void SetFragmentShaderConstant(Int32 dst, Single[] value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void SetFragmentShaderConstant(UInt32 dst, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                    }
                }
            }

            public static 
            void SetFragmentShaderConstant(Int32 dst, ref Single value)
            {
                unsafe
                {
                    fixed (Single* value_ptr = &value)
                    {
                        Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SetFragmentShaderConstant(UInt32 dst, Single* value)
            {
                Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void SetFragmentShaderConstant(Int32 dst, Single* value)
            {
                Delegates.glSetFragmentShaderConstantATI((UInt32)dst, (Single*)value);
            }

            public static 
            void PNTriangles(OpenTK.OpenGL.Enums.AtiPnTriangles pname, Int32 param)
            {
                Delegates.glPNTrianglesiATI((OpenTK.OpenGL.Enums.AtiPnTriangles)pname, (Int32)param);
            }

            public static 
            void PNTriangles(OpenTK.OpenGL.Enums.AtiPnTriangles pname, Single param)
            {
                Delegates.glPNTrianglesfATI((OpenTK.OpenGL.Enums.AtiPnTriangles)pname, (Single)param);
            }

            public static 
            Int32 NewObjectBuffer(Int32 size, IntPtr pointer, OpenTK.OpenGL.Enums.AtiVertexArrayObject usage)
            {
                return Delegates.glNewObjectBufferATI((Int32)size, (IntPtr)pointer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)usage);
            }

            public static 
            Int32 NewObjectBuffer(Int32 size, [In, Out] object pointer, OpenTK.OpenGL.Enums.AtiVertexArrayObject usage)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    return Delegates.glNewObjectBufferATI((Int32)size, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (OpenTK.OpenGL.Enums.AtiVertexArrayObject)usage);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsObjectBuffer(UInt32 buffer)
            {
                return Delegates.glIsObjectBufferATI((UInt32)buffer);
            }

            public static 
            bool IsObjectBuffer(Int32 buffer)
            {
                return Delegates.glIsObjectBufferATI((UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void UpdateObjectBuffer(UInt32 buffer, UInt32 offset, Int32 size, IntPtr pointer, OpenTK.OpenGL.Enums.AtiVertexArrayObject preserve)
            {
                Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)preserve);
            }

            public static 
            void UpdateObjectBuffer(Int32 buffer, Int32 offset, Int32 size, IntPtr pointer, OpenTK.OpenGL.Enums.AtiVertexArrayObject preserve)
            {
                Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)preserve);
            }

            [System.CLSCompliant(false)]
            public static 
            void UpdateObjectBuffer(UInt32 buffer, UInt32 offset, Int32 size, [In, Out] object pointer, OpenTK.OpenGL.Enums.AtiVertexArrayObject preserve)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (OpenTK.OpenGL.Enums.AtiVertexArrayObject)preserve);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void UpdateObjectBuffer(Int32 buffer, Int32 offset, Int32 size, [In, Out] object pointer, OpenTK.OpenGL.Enums.AtiVertexArrayObject preserve)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glUpdateObjectBufferATI((UInt32)buffer, (UInt32)offset, (Int32)size, (IntPtr)pointer_ptr.AddrOfPinnedObject(), (OpenTK.OpenGL.Enums.AtiVertexArrayObject)preserve);
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectBuffer(UInt32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferfvATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetObjectBuffer(Int32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferfvATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectBuffer(UInt32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferfvATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetObjectBuffer(Int32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferfvATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBuffer(UInt32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single* @params)
            {
                Delegates.glGetObjectBufferfvATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBuffer(Int32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single* @params)
            {
                Delegates.glGetObjectBufferfvATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectBuffer(UInt32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferivATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetObjectBuffer(Int32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetObjectBufferivATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetObjectBuffer(UInt32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferivATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetObjectBuffer(Int32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetObjectBufferivATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBuffer(UInt32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32* @params)
            {
                Delegates.glGetObjectBufferivATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetObjectBuffer(Int32 buffer, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32* @params)
            {
                Delegates.glGetObjectBufferivATI((UInt32)buffer, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void FreeObjectBuffer(UInt32 buffer)
            {
                Delegates.glFreeObjectBufferATI((UInt32)buffer);
            }

            public static 
            void FreeObjectBuffer(Int32 buffer)
            {
                Delegates.glFreeObjectBufferATI((UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void ArrayObject(OpenTK.OpenGL.Enums.EnableCap array, Int32 size, OpenTK.OpenGL.Enums.AtiVertexArrayObject type, Int32 stride, UInt32 buffer, UInt32 offset)
            {
                Delegates.glArrayObjectATI((OpenTK.OpenGL.Enums.EnableCap)array, (Int32)size, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
            }

            public static 
            void ArrayObject(OpenTK.OpenGL.Enums.EnableCap array, Int32 size, OpenTK.OpenGL.Enums.AtiVertexArrayObject type, Int32 stride, Int32 buffer, Int32 offset)
            {
                Delegates.glArrayObjectATI((OpenTK.OpenGL.Enums.EnableCap)array, (Int32)size, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
            }

            public static 
            void GetArrayObject(OpenTK.OpenGL.Enums.EnableCap array, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetArrayObjectfvATI((OpenTK.OpenGL.Enums.EnableCap)array, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetArrayObject(OpenTK.OpenGL.Enums.EnableCap array, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetArrayObjectfvATI((OpenTK.OpenGL.Enums.EnableCap)array, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetArrayObject(OpenTK.OpenGL.Enums.EnableCap array, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single* @params)
            {
                Delegates.glGetArrayObjectfvATI((OpenTK.OpenGL.Enums.EnableCap)array, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params);
            }

            public static 
            void GetArrayObject(OpenTK.OpenGL.Enums.EnableCap array, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetArrayObjectivATI((OpenTK.OpenGL.Enums.EnableCap)array, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetArrayObject(OpenTK.OpenGL.Enums.EnableCap array, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetArrayObjectivATI((OpenTK.OpenGL.Enums.EnableCap)array, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetArrayObject(OpenTK.OpenGL.Enums.EnableCap array, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32* @params)
            {
                Delegates.glGetArrayObjectivATI((OpenTK.OpenGL.Enums.EnableCap)array, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void VariantArrayObject(UInt32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject type, Int32 stride, UInt32 buffer, UInt32 offset)
            {
                Delegates.glVariantArrayObjectATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
            }

            public static 
            void VariantArrayObject(Int32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject type, Int32 stride, Int32 buffer, Int32 offset)
            {
                Delegates.glVariantArrayObjectATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)type, (Int32)stride, (UInt32)buffer, (UInt32)offset);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObject(UInt32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVariantArrayObject(Int32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObject(UInt32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVariantArrayObject(Int32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObject(UInt32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single* @params)
            {
                Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObject(Int32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Single* @params)
            {
                Delegates.glGetVariantArrayObjectfvATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObject(UInt32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVariantArrayObject(Int32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVariantArrayObject(UInt32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVariantArrayObject(Int32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVariantArrayObjectivATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObject(UInt32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32* @params)
            {
                Delegates.glGetVariantArrayObjectivATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVariantArrayObject(Int32 id, OpenTK.OpenGL.Enums.AtiVertexArrayObject pname, [Out] Int32* @params)
            {
                Delegates.glGetVariantArrayObjectivATI((UInt32)id, (OpenTK.OpenGL.Enums.AtiVertexArrayObject)pname, (Int32*)@params);
            }

            public static 
            void VertexStream1(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16 x)
            {
                Delegates.glVertexStream1sATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16)x);
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16[] coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int16 coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16* coords)
            {
                Delegates.glVertexStream1svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords);
            }

            public static 
            void VertexStream1(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32 x)
            {
                Delegates.glVertexStream1iATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32)x);
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32[] coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int32 coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32* coords)
            {
                Delegates.glVertexStream1ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords);
            }

            public static 
            void VertexStream1(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single x)
            {
                Delegates.glVertexStream1fATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single)x);
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single[] coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Single coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single* coords)
            {
                Delegates.glVertexStream1fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords);
            }

            public static 
            void VertexStream1(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double x)
            {
                Delegates.glVertexStream1dATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double)x);
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double[] coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = coords)
                    {
                        Delegates.glVertexStream1dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Double coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream1dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream1v(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double* coords)
            {
                Delegates.glVertexStream1dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16 x, Int16 y)
            {
                Delegates.glVertexStream2sATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16)x, (Int16)y);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16[] coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int16 coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16* coords)
            {
                Delegates.glVertexStream2svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32 x, Int32 y)
            {
                Delegates.glVertexStream2iATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32)x, (Int32)y);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32[] coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int32 coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32* coords)
            {
                Delegates.glVertexStream2ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single x, Single y)
            {
                Delegates.glVertexStream2fATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single)x, (Single)y);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single[] coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Single coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single* coords)
            {
                Delegates.glVertexStream2fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double x, Double y)
            {
                Delegates.glVertexStream2dATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double)x, (Double)y);
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double[] coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = coords)
                    {
                        Delegates.glVertexStream2dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Double coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream2dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream2(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double* coords)
            {
                Delegates.glVertexStream2dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16 x, Int16 y, Int16 z)
            {
                Delegates.glVertexStream3sATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16)x, (Int16)y, (Int16)z);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16[] coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int16 coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16* coords)
            {
                Delegates.glVertexStream3svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32 x, Int32 y, Int32 z)
            {
                Delegates.glVertexStream3iATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32)x, (Int32)y, (Int32)z);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32[] coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int32 coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32* coords)
            {
                Delegates.glVertexStream3ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single x, Single y, Single z)
            {
                Delegates.glVertexStream3fATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single)x, (Single)y, (Single)z);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single[] coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Single coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single* coords)
            {
                Delegates.glVertexStream3fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double x, Double y, Double z)
            {
                Delegates.glVertexStream3dATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double)x, (Double)y, (Double)z);
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double[] coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = coords)
                    {
                        Delegates.glVertexStream3dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Double coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream3dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double* coords)
            {
                Delegates.glVertexStream3dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16 x, Int16 y, Int16 z, Int16 w)
            {
                Delegates.glVertexStream4sATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16)x, (Int16)y, (Int16)z, (Int16)w);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16[] coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int16 coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16* coords)
            {
                Delegates.glVertexStream4svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32 x, Int32 y, Int32 z, Int32 w)
            {
                Delegates.glVertexStream4iATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32)x, (Int32)y, (Int32)z, (Int32)w);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32[] coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int32 coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32* coords)
            {
                Delegates.glVertexStream4ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single x, Single y, Single z, Single w)
            {
                Delegates.glVertexStream4fATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single)x, (Single)y, (Single)z, (Single)w);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single[] coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Single coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single* coords)
            {
                Delegates.glVertexStream4fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double x, Double y, Double z, Double w)
            {
                Delegates.glVertexStream4dATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double)x, (Double)y, (Double)z, (Double)w);
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double[] coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = coords)
                    {
                        Delegates.glVertexStream4dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            public static 
            void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Double coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = &coords)
                    {
                        Delegates.glVertexStream4dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void VertexStream4(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double* coords)
            {
                Delegates.glVertexStream4dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords);
            }

            [System.CLSCompliant(false)]
            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, SByte nx, SByte ny, SByte nz)
            {
                Delegates.glNormalStream3bATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte)nx, (SByte)ny, (SByte)nz);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Byte nx, Byte ny, Byte nz)
            {
                Delegates.glNormalStream3bATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte)nx, (SByte)ny, (SByte)nz);
            }

            [System.CLSCompliant(false)]
            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, SByte[] coords)
            {
                unsafe
                {
                    fixed (SByte* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3bvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte*)coords_ptr);
                    }
                }
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Byte[] coords)
            {
                unsafe
                {
                    fixed (Byte* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3bvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref SByte coords)
            {
                unsafe
                {
                    fixed (SByte* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3bvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte*)coords_ptr);
                    }
                }
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Byte coords)
            {
                unsafe
                {
                    fixed (Byte* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3bvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, SByte* coords)
            {
                Delegates.glNormalStream3bvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte*)coords);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Byte* coords)
            {
                Delegates.glNormalStream3bvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (SByte*)coords);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16 nx, Int16 ny, Int16 nz)
            {
                Delegates.glNormalStream3sATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16)nx, (Int16)ny, (Int16)nz);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16[] coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int16 coords)
            {
                unsafe
                {
                    fixed (Int16* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int16* coords)
            {
                Delegates.glNormalStream3svATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int16*)coords);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32 nx, Int32 ny, Int32 nz)
            {
                Delegates.glNormalStream3iATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32)nx, (Int32)ny, (Int32)nz);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32[] coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Int32 coords)
            {
                unsafe
                {
                    fixed (Int32* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Int32* coords)
            {
                Delegates.glNormalStream3ivATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Int32*)coords);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single nx, Single ny, Single nz)
            {
                Delegates.glNormalStream3fATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single)nx, (Single)ny, (Single)nz);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single[] coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Single coords)
            {
                unsafe
                {
                    fixed (Single* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Single* coords)
            {
                Delegates.glNormalStream3fvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Single*)coords);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double nx, Double ny, Double nz)
            {
                Delegates.glNormalStream3dATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double)nx, (Double)ny, (Double)nz);
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double[] coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = coords)
                    {
                        Delegates.glNormalStream3dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            public static 
            void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, ref Double coords)
            {
                unsafe
                {
                    fixed (Double* coords_ptr = &coords)
                    {
                        Delegates.glNormalStream3dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void NormalStream3(OpenTK.OpenGL.Enums.AtiVertexStreams stream, Double* coords)
            {
                Delegates.glNormalStream3dvATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream, (Double*)coords);
            }

            public static 
            void ClientActiveVertexStream(OpenTK.OpenGL.Enums.AtiVertexStreams stream)
            {
                Delegates.glClientActiveVertexStreamATI((OpenTK.OpenGL.Enums.AtiVertexStreams)stream);
            }

            public static 
            void VertexBlendEnv(OpenTK.OpenGL.Enums.AtiVertexStreams pname, Int32 param)
            {
                Delegates.glVertexBlendEnviATI((OpenTK.OpenGL.Enums.AtiVertexStreams)pname, (Int32)param);
            }

            public static 
            void VertexBlendEnv(OpenTK.OpenGL.Enums.AtiVertexStreams pname, Single param)
            {
                Delegates.glVertexBlendEnvfATI((OpenTK.OpenGL.Enums.AtiVertexStreams)pname, (Single)param);
            }

            public static 
            void ElementPointer(OpenTK.OpenGL.Enums.AtiElementArray type, IntPtr pointer)
            {
                Delegates.glElementPointerATI((OpenTK.OpenGL.Enums.AtiElementArray)type, (IntPtr)pointer);
            }

            public static 
            void ElementPointer(OpenTK.OpenGL.Enums.AtiElementArray type, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glElementPointerATI((OpenTK.OpenGL.Enums.AtiElementArray)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void DrawElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32 count)
            {
                Delegates.glDrawElementArrayATI((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)count);
            }

            [System.CLSCompliant(false)]
            public static 
            void DrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 count)
            {
                Delegates.glDrawRangeElementArrayATI((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count);
            }

            public static 
            void DrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 count)
            {
                Delegates.glDrawRangeElementArrayATI((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)count);
            }

            public static 
            void DrawBuffers(Int32 n, OpenTK.OpenGL.Enums.AtiDrawBuffers[] bufs)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.AtiDrawBuffers* bufs_ptr = bufs)
                    {
                        Delegates.glDrawBuffersATI((Int32)n, (OpenTK.OpenGL.Enums.AtiDrawBuffers*)bufs_ptr);
                    }
                }
            }

            public static 
            void DrawBuffers(Int32 n, ref OpenTK.OpenGL.Enums.AtiDrawBuffers bufs)
            {
                unsafe
                {
                    fixed (OpenTK.OpenGL.Enums.AtiDrawBuffers* bufs_ptr = &bufs)
                    {
                        Delegates.glDrawBuffersATI((Int32)n, (OpenTK.OpenGL.Enums.AtiDrawBuffers*)bufs_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DrawBuffers(Int32 n, OpenTK.OpenGL.Enums.AtiDrawBuffers* bufs)
            {
                Delegates.glDrawBuffersATI((Int32)n, (OpenTK.OpenGL.Enums.AtiDrawBuffers*)bufs);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe IntPtr MapObjectBuffer(UInt32 buffer)
            {
                return Delegates.glMapObjectBufferATI((UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe IntPtr MapObjectBuffer(Int32 buffer)
            {
                return Delegates.glMapObjectBufferATI((UInt32)buffer);
            }

            [System.CLSCompliant(false)]
            public static 
            void UnmapObjectBuffer(UInt32 buffer)
            {
                Delegates.glUnmapObjectBufferATI((UInt32)buffer);
            }

            public static 
            void UnmapObjectBuffer(Int32 buffer)
            {
                Delegates.glUnmapObjectBufferATI((UInt32)buffer);
            }

            public static 
            void StencilOpSeparate(OpenTK.OpenGL.Enums.AtiSeparateStencil face, OpenTK.OpenGL.Enums.StencilOp sfail, OpenTK.OpenGL.Enums.StencilOp dpfail, OpenTK.OpenGL.Enums.StencilOp dppass)
            {
                Delegates.glStencilOpSeparateATI((OpenTK.OpenGL.Enums.AtiSeparateStencil)face, (OpenTK.OpenGL.Enums.StencilOp)sfail, (OpenTK.OpenGL.Enums.StencilOp)dpfail, (OpenTK.OpenGL.Enums.StencilOp)dppass);
            }

            [System.CLSCompliant(false)]
            public static 
            void StencilFuncSeparate(OpenTK.OpenGL.Enums.StencilFunction frontfunc, OpenTK.OpenGL.Enums.StencilFunction backfunc, Int32 @ref, UInt32 mask)
            {
                Delegates.glStencilFuncSeparateATI((OpenTK.OpenGL.Enums.StencilFunction)frontfunc, (OpenTK.OpenGL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
            }

            public static 
            void StencilFuncSeparate(OpenTK.OpenGL.Enums.StencilFunction frontfunc, OpenTK.OpenGL.Enums.StencilFunction backfunc, Int32 @ref, Int32 mask)
            {
                Delegates.glStencilFuncSeparateATI((OpenTK.OpenGL.Enums.StencilFunction)frontfunc, (OpenTK.OpenGL.Enums.StencilFunction)backfunc, (Int32)@ref, (UInt32)mask);
            }

            [System.CLSCompliant(false)]
            public static 
            void VertexAttribArrayObject(UInt32 index, Int32 size, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject type, bool normalized, Int32 stride, UInt32 buffer, UInt32 offset)
            {
                Delegates.glVertexAttribArrayObjectATI((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)type, (bool)normalized, (Int32)stride, (UInt32)buffer, (UInt32)offset);
            }

            public static 
            void VertexAttribArrayObject(Int32 index, Int32 size, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject type, bool normalized, Int32 stride, Int32 buffer, Int32 offset)
            {
                Delegates.glVertexAttribArrayObjectATI((UInt32)index, (Int32)size, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)type, (bool)normalized, (Int32)stride, (UInt32)buffer, (UInt32)offset);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObject(UInt32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Single*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttribArrayObject(Int32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Single[] @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Single*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObject(UInt32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttribArrayObject(Int32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] out Single @params)
            {
                unsafe
                {
                    fixed (Single* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Single*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObject(UInt32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Single* @params)
            {
                Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObject(Int32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Single* @params)
            {
                Delegates.glGetVertexAttribArrayObjectfvATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Single*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObject(UInt32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            public static 
            void GetVertexAttribArrayObject(Int32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Int32[] @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Int32*)@params_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GetVertexAttribArrayObject(UInt32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            public static 
            void GetVertexAttribArrayObject(Int32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] out Int32 @params)
            {
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Int32*)@params_ptr);
                        @params = *@params_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObject(UInt32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Int32*)@params);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GetVertexAttribArrayObject(Int32 index, OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject pname, [Out] Int32* @params)
            {
                Delegates.glGetVertexAttribArrayObjectivATI((UInt32)index, (OpenTK.OpenGL.Enums.AtiVertexAttribArrayObject)pname, (Int32*)@params);
            }

        }

        public static partial class Apple
        {
            public static 
            void ElementPointer(OpenTK.OpenGL.Enums.AppleElementArray type, IntPtr pointer)
            {
                Delegates.glElementPointerAPPLE((OpenTK.OpenGL.Enums.AppleElementArray)type, (IntPtr)pointer);
            }

            public static 
            void ElementPointer(OpenTK.OpenGL.Enums.AppleElementArray type, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glElementPointerAPPLE((OpenTK.OpenGL.Enums.AppleElementArray)type, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void DrawElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32 first, Int32 count)
            {
                Delegates.glDrawElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32)first, (Int32)count);
            }

            [System.CLSCompliant(false)]
            public static 
            void DrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32 first, Int32 count)
            {
                Delegates.glDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)first, (Int32)count);
            }

            public static 
            void DrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32 first, Int32 count)
            {
                Delegates.glDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32)first, (Int32)count);
            }

            public static 
            void MultiDrawElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32[] first, Int32[] count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = first)
                    fixed (Int32* count_ptr = count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    }
                }
            }

            public static 
            void MultiDrawElementArray(OpenTK.OpenGL.Enums.BeginMode mode, ref Int32 first, ref Int32 count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = &first)
                    fixed (Int32* count_ptr = &count)
                    {
                        Delegates.glMultiDrawElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32* first, Int32* count, Int32 primcount)
            {
                Delegates.glMultiDrawElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (Int32*)first, (Int32*)count, (Int32)primcount);
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiDrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32[] first, Int32[] count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = first)
                    fixed (Int32* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    }
                }
            }

            public static 
            void MultiDrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32[] first, Int32[] count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = first)
                    fixed (Int32* count_ptr = count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void MultiDrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, ref Int32 first, ref Int32 count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = &first)
                    fixed (Int32* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    }
                }
            }

            public static 
            void MultiDrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, ref Int32 first, ref Int32 count, Int32 primcount)
            {
                unsafe
                {
                    fixed (Int32* first_ptr = &first)
                    fixed (Int32* count_ptr = &count)
                    {
                        Delegates.glMultiDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first_ptr, (Int32*)count_ptr, (Int32)primcount);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, UInt32 start, UInt32 end, Int32* first, Int32* count, Int32 primcount)
            {
                Delegates.glMultiDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count, (Int32)primcount);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void MultiDrawRangeElementArray(OpenTK.OpenGL.Enums.BeginMode mode, Int32 start, Int32 end, Int32* first, Int32* count, Int32 primcount)
            {
                Delegates.glMultiDrawRangeElementArrayAPPLE((OpenTK.OpenGL.Enums.BeginMode)mode, (UInt32)start, (UInt32)end, (Int32*)first, (Int32*)count, (Int32)primcount);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenFences(Int32 n, [Out] UInt32[] fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = fences)
                    {
                        Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            public static 
            void GenFences(Int32 n, [Out] Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenFences(Int32 n, [Out] out UInt32 fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }

            public static 
            void GenFences(Int32 n, [Out] out Int32 fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                        fences = *fences_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(Int32 n, [Out] UInt32* fences)
            {
                Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenFences(Int32 n, [Out] Int32* fences)
            {
                Delegates.glGenFencesAPPLE((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(Int32 n, UInt32[] fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            public static 
            void DeleteFences(Int32 n, Int32[] fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = fences)
                    {
                        Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteFences(Int32 n, ref UInt32 fences)
            {
                unsafe
                {
                    fixed (UInt32* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            public static 
            void DeleteFences(Int32 n, ref Int32 fences)
            {
                unsafe
                {
                    fixed (Int32* fences_ptr = &fences)
                    {
                        Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(Int32 n, UInt32* fences)
            {
                Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteFences(Int32 n, Int32* fences)
            {
                Delegates.glDeleteFencesAPPLE((Int32)n, (UInt32*)fences);
            }

            [System.CLSCompliant(false)]
            public static 
            void SetFence(UInt32 fence)
            {
                Delegates.glSetFenceAPPLE((UInt32)fence);
            }

            public static 
            void SetFence(Int32 fence)
            {
                Delegates.glSetFenceAPPLE((UInt32)fence);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsFence(UInt32 fence)
            {
                return Delegates.glIsFenceAPPLE((UInt32)fence);
            }

            public static 
            bool IsFence(Int32 fence)
            {
                return Delegates.glIsFenceAPPLE((UInt32)fence);
            }

            [System.CLSCompliant(false)]
            public static 
            bool TestFence(UInt32 fence)
            {
                return Delegates.glTestFenceAPPLE((UInt32)fence);
            }

            public static 
            bool TestFence(Int32 fence)
            {
                return Delegates.glTestFenceAPPLE((UInt32)fence);
            }

            [System.CLSCompliant(false)]
            public static 
            void FinishFence(UInt32 fence)
            {
                Delegates.glFinishFenceAPPLE((UInt32)fence);
            }

            public static 
            void FinishFence(Int32 fence)
            {
                Delegates.glFinishFenceAPPLE((UInt32)fence);
            }

            [System.CLSCompliant(false)]
            public static 
            bool TestObject(OpenTK.OpenGL.Enums.AppleFence @object, UInt32 name)
            {
                return Delegates.glTestObjectAPPLE((OpenTK.OpenGL.Enums.AppleFence)@object, (UInt32)name);
            }

            public static 
            bool TestObject(OpenTK.OpenGL.Enums.AppleFence @object, Int32 name)
            {
                return Delegates.glTestObjectAPPLE((OpenTK.OpenGL.Enums.AppleFence)@object, (UInt32)name);
            }

            public static 
            void FinishObject(OpenTK.OpenGL.Enums.AppleFence @object, Int32 name)
            {
                Delegates.glFinishObjectAPPLE((OpenTK.OpenGL.Enums.AppleFence)@object, (Int32)name);
            }

            [System.CLSCompliant(false)]
            public static 
            void BindVertexArray(UInt32 array)
            {
                Delegates.glBindVertexArrayAPPLE((UInt32)array);
            }

            public static 
            void BindVertexArray(Int32 array)
            {
                Delegates.glBindVertexArrayAPPLE((UInt32)array);
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteVertexArrays(Int32 n, UInt32[] arrays)
            {
                unsafe
                {
                    fixed (UInt32* arrays_ptr = arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    }
                }
            }

            public static 
            void DeleteVertexArrays(Int32 n, Int32[] arrays)
            {
                unsafe
                {
                    fixed (Int32* arrays_ptr = arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void DeleteVertexArrays(Int32 n, ref UInt32 arrays)
            {
                unsafe
                {
                    fixed (UInt32* arrays_ptr = &arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    }
                }
            }

            public static 
            void DeleteVertexArrays(Int32 n, ref Int32 arrays)
            {
                unsafe
                {
                    fixed (Int32* arrays_ptr = &arrays)
                    {
                        Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteVertexArrays(Int32 n, UInt32* arrays)
            {
                Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void DeleteVertexArrays(Int32 n, Int32* arrays)
            {
                Delegates.glDeleteVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
            }

            [System.CLSCompliant(false)]
            public static 
            void GenVertexArrays(Int32 n, [Out] UInt32[] arrays)
            {
                unsafe
                {
                    fixed (UInt32* arrays_ptr = arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    }
                }
            }

            public static 
            void GenVertexArrays(Int32 n, [Out] Int32[] arrays)
            {
                unsafe
                {
                    fixed (Int32* arrays_ptr = arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            void GenVertexArrays(Int32 n, [Out] out UInt32 arrays)
            {
                unsafe
                {
                    fixed (UInt32* arrays_ptr = &arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                        arrays = *arrays_ptr;
                    }
                }
            }

            public static 
            void GenVertexArrays(Int32 n, [Out] out Int32 arrays)
            {
                unsafe
                {
                    fixed (Int32* arrays_ptr = &arrays)
                    {
                        Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays_ptr);
                        arrays = *arrays_ptr;
                    }
                }
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenVertexArrays(Int32 n, [Out] UInt32* arrays)
            {
                Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
            }

            [System.CLSCompliant(false)]
            public static 
            unsafe void GenVertexArrays(Int32 n, [Out] Int32* arrays)
            {
                Delegates.glGenVertexArraysAPPLE((Int32)n, (UInt32*)arrays);
            }

            [System.CLSCompliant(false)]
            public static 
            bool IsVertexArray(UInt32 array)
            {
                return Delegates.glIsVertexArrayAPPLE((UInt32)array);
            }

            public static 
            bool IsVertexArray(Int32 array)
            {
                return Delegates.glIsVertexArrayAPPLE((UInt32)array);
            }

            public static 
            void VertexArrayRange(Int32 length, [Out] IntPtr pointer)
            {
                Delegates.glVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer);
            }

            public static 
            void VertexArrayRange(Int32 length, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void FlushVertexArrayRange(Int32 length, [Out] IntPtr pointer)
            {
                Delegates.glFlushVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer);
            }

            public static 
            void FlushVertexArrayRange(Int32 length, [In, Out] object pointer)
            {
                System.Runtime.InteropServices.GCHandle pointer_ptr = System.Runtime.InteropServices.GCHandle.Alloc(pointer, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glFlushVertexArrayRangeAPPLE((Int32)length, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
            }

            public static 
            void VertexArrayParameter(OpenTK.OpenGL.Enums.AppleVertexArrayRange pname, Int32 param)
            {
                Delegates.glVertexArrayParameteriAPPLE((OpenTK.OpenGL.Enums.AppleVertexArrayRange)pname, (Int32)param);
            }

            public static 
            void BufferParameter(OpenTK.OpenGL.Enums.AppleFlushBufferRange target, OpenTK.OpenGL.Enums.AppleFlushBufferRange pname, Int32 param)
            {
                Delegates.glBufferParameteriAPPLE((OpenTK.OpenGL.Enums.AppleFlushBufferRange)target, (OpenTK.OpenGL.Enums.AppleFlushBufferRange)pname, (Int32)param);
            }

            public static 
            void FlushMappedBufferRange(OpenTK.OpenGL.Enums.AppleFlushBufferRange target, IntPtr offset, IntPtr size)
            {
                Delegates.glFlushMappedBufferRangeAPPLE((OpenTK.OpenGL.Enums.AppleFlushBufferRange)target, (IntPtr)offset, (IntPtr)size);
            }

        }

        public static partial class Gremedy
        {
            public static 
            void StringMarker(Int32 len, IntPtr @string)
            {
                Delegates.glStringMarkerGREMEDY((Int32)len, (IntPtr)@string);
            }

            public static 
            void StringMarker(Int32 len, [In, Out] object @string)
            {
                System.Runtime.InteropServices.GCHandle @string_ptr = System.Runtime.InteropServices.GCHandle.Alloc(@string, System.Runtime.InteropServices.GCHandleType.Pinned);
                try
                {
                    Delegates.glStringMarkerGREMEDY((Int32)len, (IntPtr)@string_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @string_ptr.Free();
                }
            }

        }

    }
}