diff --git a/OpenTK.sln b/OpenTK.sln index f6df0f98..4c1c6482 100644 --- a/OpenTK.sln +++ b/OpenTK.sln @@ -3,15 +3,18 @@ Microsoft Visual Studio Solution File, Format Version 9.00 # Visual Studio 2005 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Documentation", "Documentation", "{80BD2C66-A90B-42E7-BED8-CBF7BB8C2E3F}" ProjectSection(SolutionItems) = preProject + changelog.txt = changelog.txt license.txt = license.txt + Todo.txt = Todo.txt EndProjectSection EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Specifications", "Specifications", "{B23A6DCD-9FE9-4523-95FB-01C8D4631555}" ProjectSection(SolutionItems) = preProject + Specifications\cs_types.txt = Specifications\cs_types.txt Specifications\enum.spec = Specifications\enum.spec Specifications\enumext.spec = Specifications\enumext.spec Specifications\gl.spec = Specifications\gl.spec - Specifications\TypeMap.txt = Specifications\TypeMap.txt + Specifications\gl_types.txt = Specifications\gl_types.txt EndProjectSection EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Projects", "Projects", "{E9FF51BB-295E-4891-AA30-D1374F26DCE0}" diff --git a/OpenTK.suo b/OpenTK.suo deleted file mode 100644 index 6049c24c..00000000 Binary files a/OpenTK.suo and /dev/null differ diff --git a/Source/Examples/OpenGL/DisplayLists/DisplayLists.cs b/Source/Examples/OpenGL/DisplayLists/DisplayLists.cs index 08211840..f639fe1e 100644 --- a/Source/Examples/OpenGL/DisplayLists/DisplayLists.cs +++ b/Source/Examples/OpenGL/DisplayLists/DisplayLists.cs @@ -15,7 +15,7 @@ namespace OpenTK.OpenGL.Test public partial class DisplayLists : Form { Context context; - uint[] lists = new uint[2]; + int[] lists = new int[2]; public DisplayLists() { diff --git a/Source/Examples/OpenGL/DisplayLists/Properties/AssemblyInfo.cs b/Source/Examples/OpenGL/DisplayLists/Properties/AssemblyInfo.cs index 77efdada..9a7553e4 100644 --- a/Source/Examples/OpenGL/DisplayLists/Properties/AssemblyInfo.cs +++ b/Source/Examples/OpenGL/DisplayLists/Properties/AssemblyInfo.cs @@ -29,5 +29,5 @@ using System.Runtime.InteropServices; // Build Number // Revision // -[assembly: AssemblyVersion("1.0.0.0")] -[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: AssemblyVersion("1.0.0.1")] +[assembly: AssemblyFileVersion("1.0.0.1")] diff --git a/Source/OpenGL/Bind/Main.cs b/Source/OpenGL/Bind/Main.cs index df0ae41b..8d52fe86 100644 --- a/Source/OpenGL/Bind/Main.cs +++ b/Source/OpenGL/Bind/Main.cs @@ -7,8 +7,10 @@ using System.Text; using System.IO; using System.Security; using System.Security.Permissions; -using Settings = OpenTK.OpenGL.Bind.Properties.Bind; +//using Settings = Tao.OpenGl.Bind.Properties.Bind; using System.Threading; +using System.Collections.Generic; +using System.Collections; [assembly:CLSCompliant(true), FileIOPermission(SecurityAction.RequestMinimum, Unrestricted = true)] namespace OpenTK.OpenGL.Bind @@ -21,13 +23,15 @@ namespace OpenTK.OpenGL.Bind System.Reflection.Assembly.GetExecutingAssembly().GetName().Name, System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString()); + #region Handle Arguments + try { foreach (string a in arguments) { if (a.StartsWith("--") || a.StartsWith("-") || a.StartsWith("/")) { - string[] b = a.Split(new char[] { '-', '/', '=' }, StringSplitOptions.RemoveEmptyEntries); + string[] b = a.Split(new char[] { '-', '/', ':', '=' }, StringSplitOptions.RemoveEmptyEntries); switch (b[0]) { case "?": @@ -36,14 +40,14 @@ namespace OpenTK.OpenGL.Bind return; case "in": case "input": - Properties.Bind.Default.InputPath = b[1]; + Settings.InputPath = b[1]; break; case "out": case "Properties.Bind.Default.OutputPath": - Properties.Bind.Default.OutputPath = b[1]; + Settings.OutputPath = b[1]; break; case "class": - Properties.Bind.Default.OutputGLClass = b[1]; + Settings.OutputClass = b[1]; break; default: throw new ArgumentException("Argument " + a + " not recognized. Use the '/?' switch for help."); @@ -62,21 +66,54 @@ namespace OpenTK.OpenGL.Bind return; } + #endregion + try { - new Process(); + long ticks = System.DateTime.Now.Ticks; + + List wrappers; + List functions = SpecReader.ReadFunctionSpecs("gl.spec"); + Hashtable enums = SpecReader.ReadEnumSpecs("enum.spec"); + Hashtable enums2= SpecReader.ReadEnumSpecs("enumext.spec"); + foreach (Enum e in enums2.Values) + if (!enums.ContainsKey(e.Name)) + enums.Add(e.Name, e); + else + { + foreach (Constant c in e.ConstantCollection.Values) + if (!((Enum)enums[e.Name]).ConstantCollection.ContainsKey(c.Name)) + ((Enum)enums[e.Name]).ConstantCollection.Add(c.Name, c); + } + + Translation.GLtypes = SpecReader.ReadTypeMap("gl_types.txt"); + Translation.CStypes = SpecReader.ReadTypeMap("cs_types.txt"); + + Translation.TranslateFunctions(functions, enums, out wrappers); + Translation.TranslateEnums(enums); + + SpecWriter.WriteSpecs(Settings.OutputPath, functions, wrappers, enums); + //SpecWriter.WriteWrappers(Properties.Bind.Default.OutputPath, wrappers); + + ContextWriter.WriteMainContext(Settings.OutputPath, functions); + ContextWriter.WriteDerivedContext(Settings.OutputPath, "WindowsContext", functions, "1.0", "1.1"); + ContextWriter.WriteDerivedContext(Settings.OutputPath, "WindowsVistaContext", functions, "1.0", "1.1", "1.2", "1.3", "1.4"); + ContextWriter.WriteDerivedContext(Settings.OutputPath, "X11Context", functions, "1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "2.0"); + + ticks = System.DateTime.Now.Ticks - ticks; + + Console.WriteLine("Bindings generated in {0} seconds.", ticks / (double)10000000.0); } catch (SecurityException e) { Console.WriteLine("Security violation \"{0}\" in method \"{1}\".", e.Message, e.Method); Console.WriteLine("This application does not have permission to take the requested actions."); } - /*finally - { - Console.WriteLine("Press any key to continue..."); - while (!Console.KeyAvailable) - Thread.Sleep(100); - }*/ + //finally + //{ + // Console.WriteLine("Press any key to continue..."); + // Console.ReadKey(false); + //} } } } diff --git a/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj b/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj index 682678d1..7514466d 100644 --- a/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj +++ b/Source/OpenGL/Bind/OpenTK.OpenGL.Bind.csproj @@ -42,28 +42,18 @@ --> - - - - - - - - - True - True - Bind.settings - True - - - - - - - - + + + + + + + + + + $(TargetName) @@ -83,11 +73,4 @@ H:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\System.XML.dll - - - - SettingsSingleFileGenerator - Bind.Designer.cs - - \ No newline at end of file diff --git a/Source/OpenGL/Bind/Properties/AssemblyInfo.cs b/Source/OpenGL/Bind/Properties/AssemblyInfo.cs index 6c872722..b70f6790 100644 --- a/Source/OpenGL/Bind/Properties/AssemblyInfo.cs +++ b/Source/OpenGL/Bind/Properties/AssemblyInfo.cs @@ -10,7 +10,7 @@ using System.Runtime.InteropServices; [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("")] -[assembly: AssemblyCopyright("Copyright © 2006")] +[assembly: AssemblyCopyright("Copyright © 2006 Stefanos Apostolopoulos")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] @@ -29,5 +29,5 @@ using System.Runtime.InteropServices; // Build Number // Revision // -[assembly: AssemblyVersion("0.7.2.2")] -[assembly: AssemblyFileVersion("0.7.2.2")] +[assembly: AssemblyVersion("0.7.4.0")] +[assembly: AssemblyFileVersion("0.7.4.0")] diff --git a/Source/OpenGL/Bind/ReadSpecs.cs b/Source/OpenGL/Bind/ReadSpecs.cs new file mode 100644 index 00000000..bb8f50a5 --- /dev/null +++ b/Source/OpenGL/Bind/ReadSpecs.cs @@ -0,0 +1,363 @@ +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System; +using System.Collections.Generic; +using System.Text; +using System.IO; +using System.Collections; + +namespace OpenTK.OpenGL.Bind +{ + static class SpecReader + { + #region Read function specs + + public static List ReadFunctionSpecs(string file) + { + List functions = new List(); + + string path = Path.Combine(Settings.InputPath, file); + StreamReader sr; + + try + { + sr = new StreamReader(path); + } + catch (Exception e) + { + Console.WriteLine("Error opening spec file: {0}", path); + Console.WriteLine("Error: {0}", e.Message); + throw e; + } + Console.WriteLine("Reading function specs from file: {0}", file); + + do + { + string line = sr.ReadLine().Trim(); + + if (String.IsNullOrEmpty(line) || + line.StartsWith("#") || // Disregard comments. + line.StartsWith("passthru") || // Disregard passthru statements. + line.StartsWith("required-props:") || + line.StartsWith("param:") || + line.StartsWith("dlflags:") || + line.StartsWith("glxflags:") || + line.StartsWith("vectorequiv:") || + line.StartsWith("category:") || + line.StartsWith("version:") || + line.StartsWith("glxsingle:") || + line.StartsWith("glxropcode:") || + line.StartsWith("glxvendorpriv:") || + line.StartsWith("glsflags:") || + line.StartsWith("glsopcode:") || + line.StartsWith("glsalias:") || + line.StartsWith("wglflags:") || + line.StartsWith("extension:") || + line.StartsWith("alias:") || + line.StartsWith("offset:")) + continue; + + while (line.Contains("(") && !sr.EndOfStream) + { + Function f = new Function(); + + f.Name = line.Split(Translation.Separators, StringSplitOptions.RemoveEmptyEntries)[0]; + if (f.Name.EndsWith("ARB") || + f.Name.EndsWith("EXT") || + f.Name.EndsWith("ATI") || + f.Name.EndsWith("NV") || + f.Name.EndsWith("SUN") || + f.Name.EndsWith("SUNX") || + f.Name.EndsWith("SGI") || + f.Name.EndsWith("SGIS") || + f.Name.EndsWith("SGIX") || + f.Name.EndsWith("MESA") || + f.Name.EndsWith("3DFX") || + f.Name.EndsWith("IBM") || + f.Name.EndsWith("GREMEDY") || + f.Name.EndsWith("HP") || + f.Name.EndsWith("INTEL") || + f.Name.EndsWith("PGI") || + f.Name.EndsWith("INGR") || + f.Name.EndsWith("APPLE")) + f.Extension = true; + + do + { + line = sr.ReadLine(); + line = line.Replace('\t', ' '); + + string[] words = line.Split(Translation.Separators, StringSplitOptions.RemoveEmptyEntries); + + if (String.IsNullOrEmpty(line) || words.Length == 0) + break; + + switch (words[0]) + { + case "return": + f.ReturnValue = words[1]; + break; + case "param": + Parameter p = new Parameter(); + p.Name = words[1]; + p.Flow = words[3] == "in" ? Parameter.FlowDirection.In : Parameter.FlowDirection.Out; + p.Type = words[2]; + if (words[4] == "array") + p.Array = true; + f.Parameters.Add(p); + break; + case "version": + f.Version = words[1]; + break; + } + } + while (!sr.EndOfStream); + + functions.Add(f); + } + } + while (!sr.EndOfStream); + + return functions; + } + + #endregion + + #region Read constant specs + [Obsolete] + public static List ReadConstantSpecs(string file) + { + List constants = new List(); + + string path = Path.Combine(Settings.InputPath, file); + StreamReader sr; + + try + { + sr = new StreamReader(path); + } + catch (Exception) + { + Console.WriteLine("Error opening spec file: {0}", path); + return null; + } + Console.WriteLine("Reading constant specs from file: {0}", file); + + do + { + string line = sr.ReadLine().Trim(); + + if (String.IsNullOrEmpty(line) || + line.StartsWith("#") || // Disregard comments. + line.StartsWith("passthru") || // Disregard passthru statements. + line.StartsWith("required-props:") || + line.StartsWith("param:") || + line.StartsWith("dlflags:") || + line.StartsWith("glxflags:") || + line.StartsWith("vectorequiv:") || + line.StartsWith("category:") || + line.StartsWith("version:") || + line.StartsWith("glxsingle:") || + line.StartsWith("glxropcode:") || + line.StartsWith("glxvendorpriv:") || + line.StartsWith("glsflags:") || + line.StartsWith("glsopcode:") || + line.StartsWith("glsalias:") || + line.StartsWith("wglflags:") || + line.StartsWith("extension:") || + line.StartsWith("alias:") || + line.StartsWith("offset:") || + line.Contains("enum:")) + continue; + + line = line.Replace('\t', ' '); + + string[] words = line.Split(Translation.Separators, StringSplitOptions.RemoveEmptyEntries); + if (words.Length == 0) + continue; + + Constant c = new Constant(); + if (line.Contains("=")) + { + c.Name = words[0]; + c.Value = words[2]; + } + + if (!String.IsNullOrEmpty(c.Name) && !ListContainsConstant(constants, c)) + constants.Add(c); + } + while (!sr.EndOfStream); + + return constants; + } + + public static bool ListContainsConstant(List constants, Constant c) + { + foreach (Constant d in constants) + if (d.Name == c.Name) + return true; + return false; + } + + #endregion + + #region Read enum specs + + public static Hashtable ReadEnumSpecs(string file) + { + Hashtable enums = new Hashtable(); + + string path = Path.Combine(Settings.InputPath, file); + StreamReader sr; + + try + { + sr = new StreamReader(path); + } + catch (Exception) + { + Console.WriteLine("Error opening spec file: {0}", path); + return null; + } + Console.WriteLine("Reading enum specs from file: {0}", file); + + do + { + string line = sr.ReadLine().Trim(); + + if (String.IsNullOrEmpty(line) || + line.StartsWith("#") || // Disregard comments. + line.StartsWith("passthru") || // Disregard passthru statements. + line.StartsWith("required-props:") || + line.StartsWith("param:") || + line.StartsWith("dlflags:") || + line.StartsWith("glxflags:") || + line.StartsWith("vectorequiv:") || + line.StartsWith("category:") || + line.StartsWith("version:") || + line.StartsWith("glxsingle:") || + line.StartsWith("glxropcode:") || + line.StartsWith("glxvendorpriv:") || + line.StartsWith("glsflags:") || + line.StartsWith("glsopcode:") || + line.StartsWith("glsalias:") || + line.StartsWith("wglflags:") || + line.StartsWith("extension:") || + line.StartsWith("alias:") || + line.StartsWith("offset:")) + continue; + + line = line.Replace('\t', ' '); + + while (line.Contains("enum") && !sr.EndOfStream) + { + string[] words = line.Split(Translation.Separators, StringSplitOptions.RemoveEmptyEntries); + if (words.Length == 0) + continue; + + Enum e = new Enum(); + e.Name = words[0]; + + do + { + line = sr.ReadLine(); + + if (String.IsNullOrEmpty(line) || line.StartsWith("#")) + continue; + + if (line.Contains("enum:") || sr.EndOfStream) + break; + + line = line.Replace('\t', ' '); + + words = line.Split(Translation.Separators, StringSplitOptions.RemoveEmptyEntries); + + if (words.Length == 0) + continue; + + Constant c = new Constant(); + if (words[0] == "use") + { + c.Name = words[2]; + c.Value = words[1] + "." + words[2]; + } + + if (line.Contains("=")) + { + c.Name = words[0]; + c.Value = words[2]; + } + + if (!String.IsNullOrEmpty(c.Name) && !e.ConstantCollection.ContainsKey(c.Name)) + e.ConstantCollection.Add(c.Name, c); + } + while (!sr.EndOfStream); + + if (enums.ContainsKey(e.Name)) + { + //Merge keys: + foreach (Constant c in e.ConstantCollection.Values) + { + if (!((Enum)enums[e.Name]).ConstantCollection.ContainsKey(c.Name)) + ((Enum)enums[e.Name]).ConstantCollection.Add(c.Name, c); + } + } + else + enums.Add(e.Name, e); + } + } + while (!sr.EndOfStream); + + return enums; + } + + #endregion + + #region Read type map + + public static Dictionary ReadTypeMap(string file) + { + Dictionary map = new Dictionary(); + + string path = Path.Combine(Settings.InputPath, file); + StreamReader sr; + + try + { + sr = new StreamReader(path); + } + catch (Exception) + { + Console.WriteLine("Error opening typemap file: {0}", path); + return null; + } + Console.WriteLine("Reading typemaps from file: {0}", file); + + do + { + string line = sr.ReadLine(); + + if (String.IsNullOrEmpty(line) || line.StartsWith("#")) + continue; + + string[] words = line.Split(new char[] { ' ', ',', '*', '\t' }, StringSplitOptions.RemoveEmptyEntries); + + if (words[0] == "void") // Special case for "void" -> "" + map.Add("void", String.Empty); + else if (words[0] == "VoidPointer") // Special case for "VoidPointer" -> "GLvoid*" + map.Add("VoidPointer", "IntPtr"); + else if (words[0] == "CharPointer") + map.Add("CharPointer", "string"); + else + map.Add(words[0], words[1]); + } + while (!sr.EndOfStream); + + return map; + } + + #endregion + } +} diff --git a/Source/OpenGL/Bind/Settings.cs b/Source/OpenGL/Bind/Settings.cs new file mode 100644 index 00000000..4c0bf685 --- /dev/null +++ b/Source/OpenGL/Bind/Settings.cs @@ -0,0 +1,18 @@ +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.OpenGL.Bind +{ + static class Settings + { + public static string InputPath = "..\\..\\Specifications"; + public static string OutputPath = "..\\..\\Source\\OpenGL\\OpenGL\\Bindings"; + public static string OutputClass = "GL"; + public static string OutputNamespace = "OpenTK.OpenGL"; + } +} diff --git a/Source/OpenGL/Bind/Structures/Constant.cs b/Source/OpenGL/Bind/Structures/Constant.cs new file mode 100644 index 00000000..75f5183a --- /dev/null +++ b/Source/OpenGL/Bind/Structures/Constant.cs @@ -0,0 +1,91 @@ +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.OpenGL.Bind +{ + /// + /// Represents an opengl constant in C# format. Both the constant name and value + /// can be retrieved or set. All opengl constants are translated to 'const uint'. + /// + public class Constant + { + #region Name + + string _name; + + /// + /// Gets or sets the name of the opengl constant (eg. GL_LINES). + /// + public string Name + { + get { return _name; } + set + { + if (!String.IsNullOrEmpty(value)) + _name = value.Trim(); + } + } + + #endregion + + #region Value + + string _value; + + /// + /// Gets or sets the value of the opengl constant (eg. 0x00000001). + /// + public string Value + { + get { return _value; } + set + { + if (!String.IsNullOrEmpty(value)) + _value = value.Trim(); + } + } + + #endregion + + #region Constructors + + /// + /// Creates an empty Constant. + /// + public Constant() + { + } + + /// + /// Creates a Constant with the given name and value. + /// + /// The Name of the Constant. + /// The Type of the Constant. + public Constant(string name, string value) + { + Name = name; + Value = value; + } + + #endregion + + #region Helper functions + + /// + /// Returns a string that represents the full constant declaration without decorations + /// (eg const uint GL_XXX_YYY = 0xDEADBEEF). + /// + /// + new public string ToString() + { + return Name + " = " + Value; + } + + #endregion + } +} diff --git a/Source/OpenGL/Bind/Structures/Enum.cs b/Source/OpenGL/Bind/Structures/Enum.cs new file mode 100644 index 00000000..f9f1df63 --- /dev/null +++ b/Source/OpenGL/Bind/Structures/Enum.cs @@ -0,0 +1,44 @@ +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.OpenGL.Bind +{ + public class Enum + { + string _name; + + public string Name + { + get { return _name; } + set { _name = value; } + } + + System.Collections.Hashtable _constant_collection = new System.Collections.Hashtable(); + + public System.Collections.Hashtable ConstantCollection + { + get { return _constant_collection; } + set { _constant_collection = value; } + } + + public override string ToString() + { + StringBuilder sb = new StringBuilder(); + + sb.AppendLine(" public enum " + Name + " : uint"); + sb.AppendLine(" {"); + foreach (Constant c in ConstantCollection.Values) + { + sb.AppendLine(" " + c.Name + " = " + c.Value + ","); + } + sb.AppendLine(" }"); + + return sb.ToString(); + } + } +} diff --git a/Source/OpenGL/Bind/Structures/Function.cs b/Source/OpenGL/Bind/Structures/Function.cs new file mode 100644 index 00000000..6e69646d --- /dev/null +++ b/Source/OpenGL/Bind/Structures/Function.cs @@ -0,0 +1,130 @@ +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.OpenGL.Bind +{ + /// + /// Represents an opengl function. + /// The return value, function name, function parameters and opengl version can be retrieved or set. + /// + public class Function + { + #region Needs wrapper property + + bool _needs_wrapper; + + /// + /// Indicates whether this function needs to be wrapped with a Marshaling function. + /// This flag is set if a function contains an Array parameter, or returns + /// an Array or string. + /// + public bool NeedsWrapper + { + get { return _needs_wrapper; } + set { _needs_wrapper = value; } + } + + #endregion + + #region Return value property + + string _return_value; + /// + /// Gets or sets the return value of the opengl function. + /// + public string ReturnValue + { + get { return _return_value; } + set { _return_value = value; } + } + + #endregion + + #region Name property + + string _name; + /// + /// Gets or sets the name of the opengl function. + /// + public string Name + { + get { return _name; } + set + { + if (!String.IsNullOrEmpty(value)) + _name = value.Trim(); + else + _name = value; + } + } + + #endregion + + #region Parameter collection property + + ParameterCollection _parameters = new ParameterCollection(); + + public ParameterCollection Parameters + { + get { return _parameters; } + set { _parameters = value; } + } + + #endregion + + #region Version property + + string _version; + + /// + /// Defines the opengl version that introduced this function. + /// + public string Version + { + get { return _version; } + set { _version = value; } + } + + #endregion + + #region Extension property + + bool _extension = false; + + public bool Extension + { + get { return _extension; } + set { _extension = value; } + } + + #endregion + + #region Constructor + + public Function() + { + } + + #endregion + + #region ToString function + + /// + /// Gets the string representing the full function declaration without decorations + /// (ie "void glClearColor(float red, float green, float blue, float alpha)" + /// + override public string ToString() + { + StringBuilder sb = new StringBuilder(); + sb.Append(ReturnValue + " " + Name + Parameters.ToString()); + return sb.ToString(); + } + + #endregion + } +} diff --git a/Source/OpenGL/Bind/Structures/Parameter.cs b/Source/OpenGL/Bind/Structures/Parameter.cs new file mode 100644 index 00000000..fd4754b1 --- /dev/null +++ b/Source/OpenGL/Bind/Structures/Parameter.cs @@ -0,0 +1,127 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OpenTK.OpenGL.Bind +{ + /// + /// Represents a single parameter of an opengl function. + /// + public class Parameter + { + #region Name property + + string _name; + /// + /// Gets or sets the name of the parameter. + /// + public string Name + { + get { return _name; } + set { _name = value; } + } + + #endregion + + #region _unmanaged_type property + + UnmanagedType _unmanaged_type; + /// + /// Gets or sets the name of the parameter. + /// + public UnmanagedType UnmanagedType + { + get { return _unmanaged_type; } + set { _unmanaged_type = value; } + } + + #endregion + + #region Type property + + string _type; + /// + /// Gets the type of the parameter. + /// + public string Type + { + get { return _type; } + set { _type = value; } + } + + #endregion + + #region Flow property + + /// + /// Enumarates the possible flows of a parameter (ie. is this parameter + /// used as input or as output?) + /// + public enum FlowDirection + { + Undefined = 0, + In, + Out + } + + FlowDirection _flow; + + /// + /// Gets or sets the flow of the parameter. + /// + public FlowDirection Flow + { + get { return _flow; } + set { _flow = value; } + } + + #endregion + + #region Array property + + bool _array = false; + + public bool Array + { + get { return _array; } + set { _array = value; } + } + + #endregion + + #region Constructors + + /// + /// Creates a new Parameter without type and name. + /// + public Parameter() { } + + #endregion + + #region ToString function + override public string ToString() + { + StringBuilder sb = new StringBuilder(); + + if (UnmanagedType == UnmanagedType.AsAny && Flow == FlowDirection.In) + sb.Append("[MarshalAs(UnmanagedType.AsAny)] "); + + if (UnmanagedType == UnmanagedType.LPArray) + sb.Append("[MarshalAs(UnmanagedType.LPArray)] "); + + if (Flow == FlowDirection.Out && !Array) + sb.Append("out "); + + sb.Append(Type); + if (Array) + sb.Append("[]"); + + sb.Append(" "); + sb.Append(Name); + + return sb.ToString(); + } + #endregion + } +} diff --git a/Source/OpenGL/Bind/Structures/ParameterCollection.cs b/Source/OpenGL/Bind/Structures/ParameterCollection.cs new file mode 100644 index 00000000..3eb35cb9 --- /dev/null +++ b/Source/OpenGL/Bind/Structures/ParameterCollection.cs @@ -0,0 +1,48 @@ +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System; +using System.Collections.Generic; +using System.Text; + +namespace OpenTK.OpenGL.Bind +{ + public class ParameterCollection : List + { + #region Constructors + + public ParameterCollection() + { + } + + #endregion + + override public string ToString() + { + StringBuilder sb = new StringBuilder(); + sb.Append("("); + if (this.Count > 0) + { + foreach (Parameter p in this) + { + sb.Append(p.ToString()); + sb.Append(", "); + } + sb.Replace(", ", ")", sb.Length - 2, 2); + } + else + sb.Append(")"); + + return sb.ToString(); + } + + public bool ContainsType(string type) + { + foreach (Parameter p in this) + if (p.Type == type) + return true; + return false; + } + } +} diff --git a/Source/OpenGL/Bind/TranslateSpecs.cs b/Source/OpenGL/Bind/TranslateSpecs.cs new file mode 100644 index 00000000..45c09392 --- /dev/null +++ b/Source/OpenGL/Bind/TranslateSpecs.cs @@ -0,0 +1,306 @@ +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; + +namespace OpenTK.OpenGL.Bind +{ + static class Translation + { + public static char[] Separators = { ' ', '\n', ',', '(', ')', ';', '#' }; + + #region Dictionaries + + static Dictionary parameter_names = new Dictionary(); + //static Dictionary parameter_types = new Dictionary(); + + private static Dictionary _gl_types; + public static Dictionary GLtypes + { + get { return Translation._gl_types; } + set { Translation._gl_types = value; } + } + + private static Dictionary _cs_types; + + public static Dictionary CStypes + { + get { return Translation._cs_types; } + set { Translation._cs_types = value; } + } + + #endregion + + #region Constructor + + static Translation() + { + // Names + parameter_names.Add("base", "@base"); + parameter_names.Add("object", "@object"); + parameter_names.Add("string", "@string"); + parameter_names.Add("ref", "reference"); + parameter_names.Add("params", "parameters"); + parameter_names.Add("in", "@in"); + + #region Commented out + + //// Types + //parameter_types.Add("Boolean", "bool"); + //parameter_types.Add("BooleanPointer", "bool[]"); + //parameter_types.Add("Char", "char"); + //parameter_types.Add("CharPointer", "string"); + + //parameter_types.Add("CheckedFloat32", "float"); + //parameter_types.Add("CheckedInt32", "int"); + + //parameter_types.Add("ClampedColorF", "float"); + //parameter_types.Add("ClampedFloat32", "float"); + //parameter_types.Add("ClampedFloat64", "double"); + //parameter_types.Add("ClampedStencilValue", "int"); + + //parameter_types.Add("ColorB", "byte"); + //parameter_types.Add("ColorS", "short"); + //parameter_types.Add("ColorI", "int"); + //parameter_types.Add("ColorUB", "byte"); + //parameter_types.Add("ColorUS", "ushort"); + //parameter_types.Add("ColorUI", "uint"); + //parameter_types.Add("ColorF", "float"); + //parameter_types.Add("ColorD", "double"); + + //parameter_types.Add("ColorIndexValueD", "double"); + //parameter_types.Add("ColorIndexValueF", "float"); + //parameter_types.Add("ColorIndexValueI", "int"); + //parameter_types.Add("ColorIndexValueS", "short"); + //parameter_types.Add("ColorIndexValueUB", "byte"); + + //parameter_types.Add("CompressedTextureARB", "void"); + //parameter_types.Add("ControlPointNV", "void"); + + //parameter_types.Add("CoordF", "float"); + //parameter_types.Add("CoordD", "double"); + //parameter_types.Add("CoordI", "int"); + //parameter_types.Add("CoordS", "short"); + + //parameter_types.Add("FeedbackElement", "float"); + //parameter_types.Add("FenceNV", "uint"); + + /////////////////////////////////////// + //parameter_types.Add("Int8", "byte"); + //parameter_types.Add("Int16", "short"); + //parameter_types.Add("Int32", "int"); + //parameter_types.Add("UInt8", "byte"); + //parameter_types.Add("UInt16", "ushort"); + //parameter_types.Add("UInt32", "uint"); + //parameter_types.Add("Float32", "float"); + //parameter_types.Add("Float64", "double"); + + //parameter_types.Add("ConstFloat32", "float"); + //parameter_types.Add("ConstInt32", "double"); + //parameter_types.Add("ConstUInt32", "uint"); + //parameter_types.Add("ConstVoid", "void"); + //parameter_types.Add("ConstVoidPointer", "void[]"); + + //parameter_types.Add("String", "string"); + //parameter_types.Add("Void", "void"); + //parameter_types.Add("VoidPointer", "void[]"); + //parameter_types.Add("void", "void"); + + //parameter_types.Add("Float32Pointer", "float"); + //parameter_types.Add("Float32Double", "double"); + ///////////////////////////////////////// + + //parameter_types.Add("List", "uint"); + //parameter_types.Add("SizeI", "int"); + //parameter_types.Add("LineStipple", "ushort"); + //parameter_types.Add("WinCoord", "int"); + + //parameter_types.Add("Texture", "uint"); + //parameter_types.Add("TextureComponentCount", "int"); + + //parameter_types.Add("SelectName", "uint"); + + //parameter_types.Add("MaskedColorIndexValueF", "float"); + //parameter_types.Add("MaskedColorIndexValueI", "uint"); + //parameter_types.Add("MaskedStencilValue", "uint"); + //parameter_types.Add("StencilValue", "int"); + + //parameter_types.Add("handleARB", "uint"); + //parameter_types.Add("charARB", "char"); // Maybe this should be byte? + //parameter_types.Add("charPointerARB", "string"); + + //parameter_types.Add("GLenum", "uint"); + + //parameter_types.Add("VertexBufferSize", "IntPtr"); + //parameter_types.Add("VertexBufferOffset", "IntPtr"); + //parameter_types.Add("VertexBufferSizeARB", "IntPtr"); + //parameter_types.Add("VertexBufferOffsetARB", "IntPtr"); + + //parameter_types.Add("IglooParameterSGIX", "IntPtr"); + + //parameter_types.Add("Half16NV", "ushort"); + //parameter_types.Add("PixelDataRangeTargetNV", "uint"); + + #endregion + } + + #endregion + + #region Translate constants + public static List TranslateConstants(List constants) + { + uint value; + + foreach (Constant c in constants) + { + c.Name = "GL_" + c.Name; + if (!Char.IsDigit(c.Value[0]) && !c.Value.StartsWith("GL_")) + c.Value = "GL_" + c.Value; + //if (String.CompareOrdinal(c.Value, "0x7FFFFFFF") > 0) + if (UInt32.TryParse(c.Value.Replace("0x", String.Empty), System.Globalization.NumberStyles.AllowHexSpecifier, null, out value)) + if (value > 0x7FFFFFFF) + c.Value = "unchecked((int)" + c.Value + ")"; + } + return constants; + } + #endregion + + #region Translate functions + public static void TranslateFunctions(List functions, Hashtable enums, out List wrappers) + { + wrappers = new List(); + + foreach (Function f in functions) + { + TranslateReturnValue(f, enums); + TranslateParameters(f, enums); + Function wrapper = GenerateWrapper(f); + if (wrapper != null) + wrappers.Add(wrapper); + + if (f.NeedsWrapper) + f.Name = f.Name + "_"; + } + } + #endregion + + #region TranslateReturnValue + private static void TranslateReturnValue(Function f, Hashtable enums) + { + string s; + + if (f.ReturnValue == "void") + return; + + if (GLtypes.TryGetValue(f.ReturnValue, out s)) + f.ReturnValue = s; + //if (CStypes.TryGetValue(f.ReturnValue, out s)) + // f.ReturnValue = s; + + if (f.ReturnValue == "void[]") + { + f.ReturnValue = "IntPtr"; + } + + if (f.ReturnValue == "string") + { + f.ReturnValue = "IntPtr"; + } + + if (f.ReturnValue == "IntPtr") + { + f.NeedsWrapper = true; + } + } + #endregion + + #region TranslateParameters + private static void TranslateParameters(Function f, Hashtable enums) + { + string s; + + // Map parameters. + foreach (Parameter p in f.Parameters) + { + if (parameter_names.TryGetValue(p.Name, out s)) + p.Name = s; + + if (enums.ContainsKey(p.Type)) + { + p.Type = "Enums." + p.Type; + continue; + } + else if (GLtypes.TryGetValue(p.Type, out s)) + p.Type = s; + //if (CStypes.TryGetValue(p.Type, out s)) + // p.Type = s; + + if (p.Array && !p.Type.Contains("void")) + { + p.UnmanagedType = System.Runtime.InteropServices.UnmanagedType.LPArray; + } + else if (p.Array && p.Type.Contains("void")) + { + p.Array = false; + p.Type = "IntPtr"; + f.NeedsWrapper = true; + } + + //if (p.Flow == Parameter.FlowDirection.Out && p.Type.Contains("string")) + // p.Type.Replace("string", "StringBuilder"); + + //if (p.Type.Contains("[][]")) + //{ + // p.Type = "ref " + p.Type.Replace("[][]", "[]"); + //} + } + } + #endregion + + #region GenerateWrapper + private static Function GenerateWrapper(Function f) + { + if (!f.NeedsWrapper) + return null; + + // These do not need wrapping! + if (f.Name.Contains("TexImage") || f.Name.Contains("TexSubImage")) + { + f.NeedsWrapper = false; + return null; + } + + return f; + } + #endregion + + #region Translate enums + + public static void TranslateEnums(System.Collections.Hashtable enums) + { + foreach (Enum e in enums.Values) + { + if (Char.IsDigit(e.Name[0])) + e.Name = e.Name.Insert(0, "_"); + + if (e.Name == "Boolean") + continue; + + foreach (Constant c in e.ConstantCollection.Values) + { + if (Char.IsDigit(c.Name[0])) + c.Name = c.Name.Insert(0, "_"); + + if (c.Value.Contains(".") && Char.IsDigit(c.Value[c.Value.IndexOf('.') + 1])) + c.Value = c.Value.Insert(c.Value.IndexOf('.') + 1, "_"); + } + } + } + + #endregion + } +} diff --git a/Source/OpenGL/Bind/WriteContexts.cs b/Source/OpenGL/Bind/WriteContexts.cs new file mode 100644 index 00000000..b1014a14 --- /dev/null +++ b/Source/OpenGL/Bind/WriteContexts.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.IO; + +namespace OpenTK.OpenGL.Bind +{ + static class ContextWriter + { + public static void WriteMainContext(string output_path, List functions) + { + string filename = Path.Combine(output_path, "ContextLoad.cs"); + + if (!Directory.Exists(Settings.OutputPath)) + Directory.CreateDirectory(Settings.OutputPath); + + StreamWriter sw = new StreamWriter(filename, false); + + Console.WriteLine("Writing Context.Load() function to {1}", Settings.OutputClass, filename); + + SpecWriter.WriteLicense(sw); + + sw.WriteLine("using System;"); + sw.WriteLine("using System.Runtime.InteropServices;"); + sw.WriteLine(); + sw.WriteLine("namespace {0}", Settings.OutputNamespace); + sw.WriteLine("{"); + sw.WriteLine(" public abstract partial class Context"); + sw.WriteLine(" {"); + + sw.WriteLine(" #region OpenGL function loading"); + sw.WriteLine(); + sw.WriteLine(" public virtual void Load()"); + sw.WriteLine(" {"); + + foreach (Function f in functions) + { + sw.WriteLine(" {2}.{0} = ({2}.Delegates.{0})GetAddress(\"gl{1}\", typeof({2}.Delegates.{0}));", f.Name, f.Name.TrimEnd('_'), Settings.OutputClass); + } + + sw.WriteLine(" }"); + sw.WriteLine(" #endregion"); + sw.WriteLine(" }"); + sw.WriteLine("}"); + sw.WriteLine(); + + sw.Flush(); + sw.Close(); + } + + public static void WriteDerivedContext(string output_path, string class_name, List functions, params string[] import_list) + { + string filename = Path.Combine(output_path, class_name + "Load.cs"); + + if (!Directory.Exists(Settings.OutputPath)) + Directory.CreateDirectory(Settings.OutputPath); + + StreamWriter sw = new StreamWriter(filename, false); + + Console.WriteLine("Writing {0}.Load() function to {1}", class_name, filename); + + SpecWriter.WriteLicense(sw); + + sw.WriteLine("using System;"); + sw.WriteLine("using System.Runtime.InteropServices;"); + sw.WriteLine(); + sw.WriteLine("namespace {0}.Platform", Settings.OutputNamespace); + sw.WriteLine("{"); + sw.WriteLine(" public partial class {0}", class_name); + sw.WriteLine(" {"); + + sw.WriteLine(" #region OpenGL core and extension function loading"); + sw.WriteLine(); + sw.WriteLine(" public override void Load()"); + sw.WriteLine(" {"); + sw.WriteLine(" base.Load();"); + + foreach (Function f in functions) + { + if (IsImportFunction(f, import_list)) + sw.WriteLine(" {0}.{1} = new {0}.Delegates.{1}({0}.Imports.{1});", Settings.OutputClass, f.Name); + } + + sw.WriteLine(" }"); + sw.WriteLine(" #endregion"); + sw.WriteLine(" }"); + sw.WriteLine("}"); + sw.WriteLine(); + + sw.Flush(); + sw.Close(); + } + + #region IsImport + private static bool IsImportFunction(Function f, string[] import_list) + { + if (f.Extension) + return false; + + foreach (string version in import_list) + if (f.Version == version) + return true; + + return false; + } + #endregion + } +} diff --git a/Source/OpenGL/Bind/WriteSpecs.cs b/Source/OpenGL/Bind/WriteSpecs.cs new file mode 100644 index 00000000..c23138b4 --- /dev/null +++ b/Source/OpenGL/Bind/WriteSpecs.cs @@ -0,0 +1,322 @@ +using System; +using System.Collections.Generic; +using System.Text; +/* Copyright (c) 2006 Stephen Apostolopoulos + * See license.txt for license info + */ + +using System.IO; +using System.Runtime.InteropServices; +using System.Collections; + +namespace OpenTK.OpenGL.Bind +{ + static partial class SpecWriter + { + #region WriteSpecs + public static void WriteSpecs(string output_path, List functions, List wrappers, Hashtable enums) + { + string filename = Path.Combine(output_path, Settings.OutputClass + ".cs"); + + if (!Directory.Exists(Settings.OutputPath)) + Directory.CreateDirectory(Settings.OutputPath); + + StreamWriter sw = new StreamWriter(filename, false); + + Console.WriteLine("Writing {0} class to {1}", Settings.OutputClass, filename); + + WriteLicense(sw); + + sw.WriteLine("using System;"); + sw.WriteLine("using System.Runtime.InteropServices;"); + sw.WriteLine(); + sw.WriteLine("namespace {0}", Settings.OutputNamespace); + sw.WriteLine("{"); + + WriteTypes(sw); + WriteEnums(sw, enums); + + sw.WriteLine(" public static partial class {0}", Settings.OutputClass); + sw.WriteLine(" {"); + + WriteFunctionSignatures(sw, functions); + WriteDllImports(sw, functions); + WriteFunctions(sw, functions); + WriteWrappers(sw, wrappers); + //WriteConstructor(sw, functions); + + sw.WriteLine(" }"); + sw.WriteLine("}"); + sw.WriteLine(); + + sw.Flush(); + sw.Close(); + } + + #endregion + + public static void WriteLicense(StreamWriter sw) + { + } + + #region WriteTypes + private static void WriteTypes(StreamWriter sw) + { + sw.WriteLine(" #region Types"); + //foreach ( c in constants) + foreach (string key in Translation.CStypes.Keys) + { + sw.WriteLine(" using {0} = System.{1};", key, Translation.CStypes[key]); + //sw.WriteLine(" public const {0};", c.ToString()); + } + sw.WriteLine(" #endregion"); + sw.WriteLine(); + } + #endregion + + #region Write enums + private static void WriteEnums(StreamWriter sw, Hashtable enums) + { + sw.WriteLine(" #region Enums"); + sw.WriteLine(" public struct Enums"); + sw.WriteLine(" {"); + + #region Missing constants + + sw.WriteLine(" #region Missing Constants"); + sw.WriteLine(); + + // Version 1.4 enum + sw.WriteLine(" const uint GL_FOG_COORDINATE_SOURCE = 0x8450;"); + sw.WriteLine(" const uint GL_FOG_COORDINATE = 0x8451;"); + sw.WriteLine(" const uint GL_CURRENT_FOG_COORDINATE = 0x8453;"); + sw.WriteLine(" const uint GL_FOG_COORDINATE_ARRAY_TYPE = 0x8454;"); + sw.WriteLine(" const uint GL_FOG_COORDINATE_ARRAY_STRIDE = 0x8455;"); + sw.WriteLine(" const uint GL_FOG_COORDINATE_ARRAY_POINTER = 0x8456;"); + sw.WriteLine(" const uint GL_FOG_COORDINATE_ARRAY = 0x8457;"); + + // Version 1.5 enum + sw.WriteLine(" const uint GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D;"); + + // Version 1.3 enum + sw.WriteLine(" const uint GL_SOURCE0_RGB = 0x8580;"); + sw.WriteLine(" const uint GL_SOURCE1_RGB = 0x8581;"); + sw.WriteLine(" const uint GL_SOURCE2_RGB = 0x8582;"); + sw.WriteLine(" const uint GL_SOURCE0_ALPHA = 0x8588;"); + sw.WriteLine(" const uint GL_SOURCE1_ALPHA = 0x8589;"); + sw.WriteLine(" const uint GL_SOURCE2_ALPHA = 0x858A;"); + + // Version 2.0 enum + sw.WriteLine(" const uint GL_BLEND_EQUATION = 0x8009;"); + + sw.WriteLine(" const uint GL_MODELVIEW_MATRIX = 0x0BA6;"); + sw.WriteLine(" const uint GL_MODELVIEW = 0x1700;"); + sw.WriteLine(" const uint GL_MODELVIEW_STACK_DEPTH = 0x0BA3;"); + + // NV_texture_shader enum + sw.WriteLine(" const uint GL_OFFSET_TEXTURE_MATRIX_NV = 0x86E1;"); + sw.WriteLine(" const uint GL_OFFSET_TEXTURE_SCALE_NV = 0x86E2;"); + sw.WriteLine(" const uint GL_OFFSET_TEXTURE_BIAS_NV = 0x86E3;"); + + sw.WriteLine(); + sw.WriteLine(" #endregion"); + sw.WriteLine(); + + #endregion + + foreach (Enum e in enums.Values) + { + sw.WriteLine(e.ToString()); + } + + sw.WriteLine(" }"); + sw.WriteLine(" #endregion"); + sw.WriteLine(); + } + #endregion + + #region Write function signatures + private static void WriteFunctionSignatures(StreamWriter sw, List functions) + { + sw.WriteLine(" #region Function signatures"); + sw.WriteLine(); + sw.WriteLine(" public static class Delegates"); + sw.WriteLine(" {"); + + foreach (Function f in functions) + { + sw.WriteLine(" public delegate {0};", f.ToString()); + } + + sw.WriteLine(" }"); + sw.WriteLine(" #endregion"); + sw.WriteLine(); + } + #endregion + + #region Write dll imports + private static void WriteDllImports(StreamWriter sw, List functions) + { + sw.WriteLine(" #region Imports"); + sw.WriteLine(); + sw.WriteLine(" internal class Imports"); + sw.WriteLine(" {"); + + foreach (Function f in functions) + { + if (!f.Extension) + { + sw.WriteLine(" [DllImport(\"opengl32\", EntryPoint = \"gl{0}\")]", f.Name.TrimEnd('_')); + sw.WriteLine(" public static extern {0};", f.ToString()); + } + } + + sw.WriteLine(" }"); + sw.WriteLine(" #endregion"); + sw.WriteLine(); + } + #endregion + + #region Write functions + private static void WriteFunctions(StreamWriter sw, List functions) + { + sw.WriteLine(" #region Function initialisation"); + sw.WriteLine(); + + foreach (Function f in functions) + { + sw.WriteLine(" public static Delegates.{0} {0};", f.Name); + } + + sw.WriteLine(" #endregion"); + sw.WriteLine(); + } + #endregion + + #region Write wrappers + + public static void WriteWrappers(StreamWriter sw, List wrappers) + { + sw.WriteLine(" #region Wrappers"); + sw.WriteLine(); + + foreach (Function f in wrappers) + { + // Hack! Should implement these in the future. + if (f.Extension) + continue; + + if (f.Parameters.ToString().Contains("out IntPtr")) + continue; + + if (f.Parameters.ToString().Contains("IntPtr[]")) + continue; + + sw.WriteLine(" #region {0}", f.Name.TrimEnd('_')); + + if (f.Name == "glGetString") + { + sw.WriteLine(" public static {0} {1}{2}", "string", f.Name.TrimEnd('_'), f.Parameters.ToString()); + sw.WriteLine(" {"); + sw.WriteLine(" return Marshal.PtrToStringAnsi(glGetString_({0}));", f.Parameters[0].Name); + sw.WriteLine(" }"); + + } + else if (f.Parameters.ToString().Contains("IntPtr")) + { + sw.WriteLine(" public static {0} {1}{2}", f.ReturnValue, f.Name.TrimEnd('_'), f.Parameters.ToString().Replace("IntPtr", "object")); + sw.WriteLine(" {"); + int i = 0; + StringBuilder sb = new StringBuilder(); + sb.Append("("); + foreach (Parameter p in f.Parameters) + { + if (p.Type == "IntPtr") + { + sw.WriteLine(" GCHandle h{0} = GCHandle.Alloc({1}, GCHandleType.Pinned);", i, p.Name); + sb.Append("h" + i + ".AddrOfPinnedObject()" + ", "); + i++; + } + else + { + sb.Append(p.Name + ", "); + } + } + sb.Replace(", ", ")", sb.Length - 2, 2); + + sw.WriteLine(" try"); + sw.WriteLine(" {"); + if (f.ReturnValue == "void") + sw.WriteLine(" {0}{1};", f.Name, sb.ToString()); + else + sw.WriteLine(" return {0}{1};", f.Name, sb.ToString()); + sw.WriteLine(" }"); + sw.WriteLine(" finally"); + sw.WriteLine(" {"); + while (i > 0) + { + sw.WriteLine(" h{0}.Free();", --i); + } + sw.WriteLine(" }"); + sw.WriteLine(" }"); + } + + sw.WriteLine(" #endregion"); + sw.WriteLine(); + } + sw.WriteLine(" #endregion"); + sw.WriteLine(); + + // if (fw.Parameters.ContainsType("object")) + // { + // Function f = WeakNameLookup(fw.Name, FunctionCollection); + + // sw.WriteLine(" public {0} {1}{2}", fw.ReturnValue, fw.Name, fw.Parameters.ToString()); + // sw.WriteLine(" {"); + + // int i = 0; + // StringBuilder sb = new StringBuilder(); + // sb.Append("("); + // foreach (Parameter p in fw.Parameters) + // { + // if (p.Type == "object") + // { + // sw.WriteLine(" GCHandle h{0} = GCHandle.Alloc({1}, GCHandleType.Pinned);", i, p.Name); + // sb.Append("h" + i + ".AddrOfPinnedObject()" + ", "); + // i++; + // } + // else + // { + // sb.Append(p.Name + ", "); + // } + // } + // sb.Replace(", ", ")", sb.Length - 2, 2); + + // sw.WriteLine(" try"); + // sw.WriteLine(" {"); + // if (fw.ReturnValue == "void") + // sw.WriteLine(" {0}{1};", f.Name, sb.ToString()); + // else + // sw.WriteLine(" return {0}{1};", f.Name, sb.ToString()); + // sw.WriteLine(" }"); + // sw.WriteLine(" finally"); + // sw.WriteLine(" {"); + // while (i > 0) + // { + // sw.WriteLine(" h{0}.Free();", --i); + // } + // sw.WriteLine(" }"); + // sw.WriteLine(" }"); + // sw.WriteLine(); + // } + + //sw.WriteLine(" #endregion"); + //sw.WriteLine(" }"); + //sw.WriteLine("}"); + + //sw.Flush(); + //sw.Close(); + } + #endregion + } +} \ No newline at end of file diff --git a/Source/OpenGL/OpenGL/Bindings/ContextLoad.cs b/Source/OpenGL/OpenGL/Bindings/ContextLoad.cs new file mode 100644 index 00000000..9cb6ae5b --- /dev/null +++ b/Source/OpenGL/OpenGL/Bindings/ContextLoad.cs @@ -0,0 +1,1438 @@ +using System; +using System.Runtime.InteropServices; + +namespace OpenTK.OpenGL +{ + public abstract partial class Context + { + #region OpenGL function loading + + public virtual void Load() + { + GL.NewList = (GL.Delegates.NewList)GetAddress("glNewList", typeof(GL.Delegates.NewList)); + GL.EndList = (GL.Delegates.EndList)GetAddress("glEndList", typeof(GL.Delegates.EndList)); + GL.CallList = (GL.Delegates.CallList)GetAddress("glCallList", typeof(GL.Delegates.CallList)); + GL.CallLists_ = (GL.Delegates.CallLists_)GetAddress("glCallLists", typeof(GL.Delegates.CallLists_)); + GL.DeleteLists = (GL.Delegates.DeleteLists)GetAddress("glDeleteLists", typeof(GL.Delegates.DeleteLists)); + GL.GenLists = (GL.Delegates.GenLists)GetAddress("glGenLists", typeof(GL.Delegates.GenLists)); + GL.ListBase = (GL.Delegates.ListBase)GetAddress("glListBase", typeof(GL.Delegates.ListBase)); + GL.Begin = (GL.Delegates.Begin)GetAddress("glBegin", typeof(GL.Delegates.Begin)); + GL.Bitmap = (GL.Delegates.Bitmap)GetAddress("glBitmap", typeof(GL.Delegates.Bitmap)); + GL.Color3b = (GL.Delegates.Color3b)GetAddress("glColor3b", typeof(GL.Delegates.Color3b)); + GL.Color3bv = (GL.Delegates.Color3bv)GetAddress("glColor3bv", typeof(GL.Delegates.Color3bv)); + GL.Color3d = (GL.Delegates.Color3d)GetAddress("glColor3d", typeof(GL.Delegates.Color3d)); + GL.Color3dv = (GL.Delegates.Color3dv)GetAddress("glColor3dv", typeof(GL.Delegates.Color3dv)); + GL.Color3f = (GL.Delegates.Color3f)GetAddress("glColor3f", typeof(GL.Delegates.Color3f)); + GL.Color3fv = (GL.Delegates.Color3fv)GetAddress("glColor3fv", typeof(GL.Delegates.Color3fv)); + GL.Color3i = (GL.Delegates.Color3i)GetAddress("glColor3i", typeof(GL.Delegates.Color3i)); + GL.Color3iv = (GL.Delegates.Color3iv)GetAddress("glColor3iv", typeof(GL.Delegates.Color3iv)); + GL.Color3s = (GL.Delegates.Color3s)GetAddress("glColor3s", typeof(GL.Delegates.Color3s)); + GL.Color3sv = (GL.Delegates.Color3sv)GetAddress("glColor3sv", typeof(GL.Delegates.Color3sv)); + GL.Color3ub = (GL.Delegates.Color3ub)GetAddress("glColor3ub", typeof(GL.Delegates.Color3ub)); + GL.Color3ubv = (GL.Delegates.Color3ubv)GetAddress("glColor3ubv", typeof(GL.Delegates.Color3ubv)); + GL.Color3ui = (GL.Delegates.Color3ui)GetAddress("glColor3ui", typeof(GL.Delegates.Color3ui)); + GL.Color3uiv = (GL.Delegates.Color3uiv)GetAddress("glColor3uiv", typeof(GL.Delegates.Color3uiv)); + GL.Color3us = (GL.Delegates.Color3us)GetAddress("glColor3us", typeof(GL.Delegates.Color3us)); + GL.Color3usv = (GL.Delegates.Color3usv)GetAddress("glColor3usv", typeof(GL.Delegates.Color3usv)); + GL.Color4b = (GL.Delegates.Color4b)GetAddress("glColor4b", typeof(GL.Delegates.Color4b)); + GL.Color4bv = (GL.Delegates.Color4bv)GetAddress("glColor4bv", typeof(GL.Delegates.Color4bv)); + GL.Color4d = (GL.Delegates.Color4d)GetAddress("glColor4d", typeof(GL.Delegates.Color4d)); + GL.Color4dv = (GL.Delegates.Color4dv)GetAddress("glColor4dv", typeof(GL.Delegates.Color4dv)); + GL.Color4f = (GL.Delegates.Color4f)GetAddress("glColor4f", typeof(GL.Delegates.Color4f)); + GL.Color4fv = (GL.Delegates.Color4fv)GetAddress("glColor4fv", typeof(GL.Delegates.Color4fv)); + GL.Color4i = (GL.Delegates.Color4i)GetAddress("glColor4i", typeof(GL.Delegates.Color4i)); + GL.Color4iv = (GL.Delegates.Color4iv)GetAddress("glColor4iv", typeof(GL.Delegates.Color4iv)); + GL.Color4s = (GL.Delegates.Color4s)GetAddress("glColor4s", typeof(GL.Delegates.Color4s)); + GL.Color4sv = (GL.Delegates.Color4sv)GetAddress("glColor4sv", typeof(GL.Delegates.Color4sv)); + GL.Color4ub = (GL.Delegates.Color4ub)GetAddress("glColor4ub", typeof(GL.Delegates.Color4ub)); + GL.Color4ubv = (GL.Delegates.Color4ubv)GetAddress("glColor4ubv", typeof(GL.Delegates.Color4ubv)); + GL.Color4ui = (GL.Delegates.Color4ui)GetAddress("glColor4ui", typeof(GL.Delegates.Color4ui)); + GL.Color4uiv = (GL.Delegates.Color4uiv)GetAddress("glColor4uiv", typeof(GL.Delegates.Color4uiv)); + GL.Color4us = (GL.Delegates.Color4us)GetAddress("glColor4us", typeof(GL.Delegates.Color4us)); + GL.Color4usv = (GL.Delegates.Color4usv)GetAddress("glColor4usv", typeof(GL.Delegates.Color4usv)); + GL.EdgeFlag = (GL.Delegates.EdgeFlag)GetAddress("glEdgeFlag", typeof(GL.Delegates.EdgeFlag)); + GL.EdgeFlagv = (GL.Delegates.EdgeFlagv)GetAddress("glEdgeFlagv", typeof(GL.Delegates.EdgeFlagv)); + GL.End = (GL.Delegates.End)GetAddress("glEnd", typeof(GL.Delegates.End)); + GL.Indexd = (GL.Delegates.Indexd)GetAddress("glIndexd", typeof(GL.Delegates.Indexd)); + GL.Indexdv = (GL.Delegates.Indexdv)GetAddress("glIndexdv", typeof(GL.Delegates.Indexdv)); + GL.Indexf = (GL.Delegates.Indexf)GetAddress("glIndexf", typeof(GL.Delegates.Indexf)); + GL.Indexfv = (GL.Delegates.Indexfv)GetAddress("glIndexfv", typeof(GL.Delegates.Indexfv)); + GL.Indexi = (GL.Delegates.Indexi)GetAddress("glIndexi", typeof(GL.Delegates.Indexi)); + GL.Indexiv = (GL.Delegates.Indexiv)GetAddress("glIndexiv", typeof(GL.Delegates.Indexiv)); + GL.Indexs = (GL.Delegates.Indexs)GetAddress("glIndexs", typeof(GL.Delegates.Indexs)); + GL.Indexsv = (GL.Delegates.Indexsv)GetAddress("glIndexsv", typeof(GL.Delegates.Indexsv)); + GL.Normal3b = (GL.Delegates.Normal3b)GetAddress("glNormal3b", typeof(GL.Delegates.Normal3b)); + GL.Normal3bv = (GL.Delegates.Normal3bv)GetAddress("glNormal3bv", typeof(GL.Delegates.Normal3bv)); + GL.Normal3d = (GL.Delegates.Normal3d)GetAddress("glNormal3d", typeof(GL.Delegates.Normal3d)); + GL.Normal3dv = (GL.Delegates.Normal3dv)GetAddress("glNormal3dv", typeof(GL.Delegates.Normal3dv)); + GL.Normal3f = (GL.Delegates.Normal3f)GetAddress("glNormal3f", typeof(GL.Delegates.Normal3f)); + GL.Normal3fv = (GL.Delegates.Normal3fv)GetAddress("glNormal3fv", typeof(GL.Delegates.Normal3fv)); + GL.Normal3i = (GL.Delegates.Normal3i)GetAddress("glNormal3i", typeof(GL.Delegates.Normal3i)); + GL.Normal3iv = (GL.Delegates.Normal3iv)GetAddress("glNormal3iv", typeof(GL.Delegates.Normal3iv)); + GL.Normal3s = (GL.Delegates.Normal3s)GetAddress("glNormal3s", typeof(GL.Delegates.Normal3s)); + GL.Normal3sv = (GL.Delegates.Normal3sv)GetAddress("glNormal3sv", typeof(GL.Delegates.Normal3sv)); + GL.RasterPos2d = (GL.Delegates.RasterPos2d)GetAddress("glRasterPos2d", typeof(GL.Delegates.RasterPos2d)); + GL.RasterPos2dv = (GL.Delegates.RasterPos2dv)GetAddress("glRasterPos2dv", typeof(GL.Delegates.RasterPos2dv)); + GL.RasterPos2f = (GL.Delegates.RasterPos2f)GetAddress("glRasterPos2f", typeof(GL.Delegates.RasterPos2f)); + GL.RasterPos2fv = (GL.Delegates.RasterPos2fv)GetAddress("glRasterPos2fv", typeof(GL.Delegates.RasterPos2fv)); + GL.RasterPos2i = (GL.Delegates.RasterPos2i)GetAddress("glRasterPos2i", typeof(GL.Delegates.RasterPos2i)); + GL.RasterPos2iv = (GL.Delegates.RasterPos2iv)GetAddress("glRasterPos2iv", typeof(GL.Delegates.RasterPos2iv)); + GL.RasterPos2s = (GL.Delegates.RasterPos2s)GetAddress("glRasterPos2s", typeof(GL.Delegates.RasterPos2s)); + GL.RasterPos2sv = (GL.Delegates.RasterPos2sv)GetAddress("glRasterPos2sv", typeof(GL.Delegates.RasterPos2sv)); + GL.RasterPos3d = (GL.Delegates.RasterPos3d)GetAddress("glRasterPos3d", typeof(GL.Delegates.RasterPos3d)); + GL.RasterPos3dv = (GL.Delegates.RasterPos3dv)GetAddress("glRasterPos3dv", typeof(GL.Delegates.RasterPos3dv)); + GL.RasterPos3f = (GL.Delegates.RasterPos3f)GetAddress("glRasterPos3f", typeof(GL.Delegates.RasterPos3f)); + GL.RasterPos3fv = (GL.Delegates.RasterPos3fv)GetAddress("glRasterPos3fv", typeof(GL.Delegates.RasterPos3fv)); + GL.RasterPos3i = (GL.Delegates.RasterPos3i)GetAddress("glRasterPos3i", typeof(GL.Delegates.RasterPos3i)); + GL.RasterPos3iv = (GL.Delegates.RasterPos3iv)GetAddress("glRasterPos3iv", typeof(GL.Delegates.RasterPos3iv)); + GL.RasterPos3s = (GL.Delegates.RasterPos3s)GetAddress("glRasterPos3s", typeof(GL.Delegates.RasterPos3s)); + GL.RasterPos3sv = (GL.Delegates.RasterPos3sv)GetAddress("glRasterPos3sv", typeof(GL.Delegates.RasterPos3sv)); + GL.RasterPos4d = (GL.Delegates.RasterPos4d)GetAddress("glRasterPos4d", typeof(GL.Delegates.RasterPos4d)); + GL.RasterPos4dv = (GL.Delegates.RasterPos4dv)GetAddress("glRasterPos4dv", typeof(GL.Delegates.RasterPos4dv)); + GL.RasterPos4f = (GL.Delegates.RasterPos4f)GetAddress("glRasterPos4f", typeof(GL.Delegates.RasterPos4f)); + GL.RasterPos4fv = (GL.Delegates.RasterPos4fv)GetAddress("glRasterPos4fv", typeof(GL.Delegates.RasterPos4fv)); + GL.RasterPos4i = (GL.Delegates.RasterPos4i)GetAddress("glRasterPos4i", typeof(GL.Delegates.RasterPos4i)); + GL.RasterPos4iv = (GL.Delegates.RasterPos4iv)GetAddress("glRasterPos4iv", typeof(GL.Delegates.RasterPos4iv)); + GL.RasterPos4s = (GL.Delegates.RasterPos4s)GetAddress("glRasterPos4s", typeof(GL.Delegates.RasterPos4s)); + GL.RasterPos4sv = (GL.Delegates.RasterPos4sv)GetAddress("glRasterPos4sv", typeof(GL.Delegates.RasterPos4sv)); + GL.Rectd = (GL.Delegates.Rectd)GetAddress("glRectd", typeof(GL.Delegates.Rectd)); + GL.Rectdv = (GL.Delegates.Rectdv)GetAddress("glRectdv", typeof(GL.Delegates.Rectdv)); + GL.Rectf = (GL.Delegates.Rectf)GetAddress("glRectf", typeof(GL.Delegates.Rectf)); + GL.Rectfv = (GL.Delegates.Rectfv)GetAddress("glRectfv", typeof(GL.Delegates.Rectfv)); + GL.Recti = (GL.Delegates.Recti)GetAddress("glRecti", typeof(GL.Delegates.Recti)); + GL.Rectiv = (GL.Delegates.Rectiv)GetAddress("glRectiv", typeof(GL.Delegates.Rectiv)); + GL.Rects = (GL.Delegates.Rects)GetAddress("glRects", typeof(GL.Delegates.Rects)); + GL.Rectsv = (GL.Delegates.Rectsv)GetAddress("glRectsv", typeof(GL.Delegates.Rectsv)); + GL.TexCoord1d = (GL.Delegates.TexCoord1d)GetAddress("glTexCoord1d", typeof(GL.Delegates.TexCoord1d)); + GL.TexCoord1dv = (GL.Delegates.TexCoord1dv)GetAddress("glTexCoord1dv", typeof(GL.Delegates.TexCoord1dv)); + GL.TexCoord1f = (GL.Delegates.TexCoord1f)GetAddress("glTexCoord1f", typeof(GL.Delegates.TexCoord1f)); + GL.TexCoord1fv = (GL.Delegates.TexCoord1fv)GetAddress("glTexCoord1fv", typeof(GL.Delegates.TexCoord1fv)); + GL.TexCoord1i = (GL.Delegates.TexCoord1i)GetAddress("glTexCoord1i", typeof(GL.Delegates.TexCoord1i)); + GL.TexCoord1iv = (GL.Delegates.TexCoord1iv)GetAddress("glTexCoord1iv", typeof(GL.Delegates.TexCoord1iv)); + GL.TexCoord1s = (GL.Delegates.TexCoord1s)GetAddress("glTexCoord1s", typeof(GL.Delegates.TexCoord1s)); + GL.TexCoord1sv = (GL.Delegates.TexCoord1sv)GetAddress("glTexCoord1sv", typeof(GL.Delegates.TexCoord1sv)); + GL.TexCoord2d = (GL.Delegates.TexCoord2d)GetAddress("glTexCoord2d", typeof(GL.Delegates.TexCoord2d)); + GL.TexCoord2dv = (GL.Delegates.TexCoord2dv)GetAddress("glTexCoord2dv", typeof(GL.Delegates.TexCoord2dv)); + GL.TexCoord2f = (GL.Delegates.TexCoord2f)GetAddress("glTexCoord2f", typeof(GL.Delegates.TexCoord2f)); + GL.TexCoord2fv = (GL.Delegates.TexCoord2fv)GetAddress("glTexCoord2fv", typeof(GL.Delegates.TexCoord2fv)); + GL.TexCoord2i = (GL.Delegates.TexCoord2i)GetAddress("glTexCoord2i", typeof(GL.Delegates.TexCoord2i)); + GL.TexCoord2iv = (GL.Delegates.TexCoord2iv)GetAddress("glTexCoord2iv", typeof(GL.Delegates.TexCoord2iv)); + GL.TexCoord2s = (GL.Delegates.TexCoord2s)GetAddress("glTexCoord2s", typeof(GL.Delegates.TexCoord2s)); + GL.TexCoord2sv = (GL.Delegates.TexCoord2sv)GetAddress("glTexCoord2sv", typeof(GL.Delegates.TexCoord2sv)); + GL.TexCoord3d = (GL.Delegates.TexCoord3d)GetAddress("glTexCoord3d", typeof(GL.Delegates.TexCoord3d)); + GL.TexCoord3dv = (GL.Delegates.TexCoord3dv)GetAddress("glTexCoord3dv", typeof(GL.Delegates.TexCoord3dv)); + GL.TexCoord3f = (GL.Delegates.TexCoord3f)GetAddress("glTexCoord3f", typeof(GL.Delegates.TexCoord3f)); + GL.TexCoord3fv = (GL.Delegates.TexCoord3fv)GetAddress("glTexCoord3fv", typeof(GL.Delegates.TexCoord3fv)); + GL.TexCoord3i = (GL.Delegates.TexCoord3i)GetAddress("glTexCoord3i", typeof(GL.Delegates.TexCoord3i)); + GL.TexCoord3iv = (GL.Delegates.TexCoord3iv)GetAddress("glTexCoord3iv", typeof(GL.Delegates.TexCoord3iv)); + GL.TexCoord3s = (GL.Delegates.TexCoord3s)GetAddress("glTexCoord3s", typeof(GL.Delegates.TexCoord3s)); + GL.TexCoord3sv = (GL.Delegates.TexCoord3sv)GetAddress("glTexCoord3sv", typeof(GL.Delegates.TexCoord3sv)); + GL.TexCoord4d = (GL.Delegates.TexCoord4d)GetAddress("glTexCoord4d", typeof(GL.Delegates.TexCoord4d)); + GL.TexCoord4dv = (GL.Delegates.TexCoord4dv)GetAddress("glTexCoord4dv", typeof(GL.Delegates.TexCoord4dv)); + GL.TexCoord4f = (GL.Delegates.TexCoord4f)GetAddress("glTexCoord4f", typeof(GL.Delegates.TexCoord4f)); + GL.TexCoord4fv = (GL.Delegates.TexCoord4fv)GetAddress("glTexCoord4fv", typeof(GL.Delegates.TexCoord4fv)); + GL.TexCoord4i = (GL.Delegates.TexCoord4i)GetAddress("glTexCoord4i", typeof(GL.Delegates.TexCoord4i)); + GL.TexCoord4iv = (GL.Delegates.TexCoord4iv)GetAddress("glTexCoord4iv", typeof(GL.Delegates.TexCoord4iv)); + GL.TexCoord4s = (GL.Delegates.TexCoord4s)GetAddress("glTexCoord4s", typeof(GL.Delegates.TexCoord4s)); + GL.TexCoord4sv = (GL.Delegates.TexCoord4sv)GetAddress("glTexCoord4sv", typeof(GL.Delegates.TexCoord4sv)); + GL.Vertex2d = (GL.Delegates.Vertex2d)GetAddress("glVertex2d", typeof(GL.Delegates.Vertex2d)); + GL.Vertex2dv = (GL.Delegates.Vertex2dv)GetAddress("glVertex2dv", typeof(GL.Delegates.Vertex2dv)); + GL.Vertex2f = (GL.Delegates.Vertex2f)GetAddress("glVertex2f", typeof(GL.Delegates.Vertex2f)); + GL.Vertex2fv = (GL.Delegates.Vertex2fv)GetAddress("glVertex2fv", typeof(GL.Delegates.Vertex2fv)); + GL.Vertex2i = (GL.Delegates.Vertex2i)GetAddress("glVertex2i", typeof(GL.Delegates.Vertex2i)); + GL.Vertex2iv = (GL.Delegates.Vertex2iv)GetAddress("glVertex2iv", typeof(GL.Delegates.Vertex2iv)); + GL.Vertex2s = (GL.Delegates.Vertex2s)GetAddress("glVertex2s", typeof(GL.Delegates.Vertex2s)); + GL.Vertex2sv = (GL.Delegates.Vertex2sv)GetAddress("glVertex2sv", typeof(GL.Delegates.Vertex2sv)); + GL.Vertex3d = (GL.Delegates.Vertex3d)GetAddress("glVertex3d", typeof(GL.Delegates.Vertex3d)); + GL.Vertex3dv = (GL.Delegates.Vertex3dv)GetAddress("glVertex3dv", typeof(GL.Delegates.Vertex3dv)); + GL.Vertex3f = (GL.Delegates.Vertex3f)GetAddress("glVertex3f", typeof(GL.Delegates.Vertex3f)); + GL.Vertex3fv = (GL.Delegates.Vertex3fv)GetAddress("glVertex3fv", typeof(GL.Delegates.Vertex3fv)); + GL.Vertex3i = (GL.Delegates.Vertex3i)GetAddress("glVertex3i", typeof(GL.Delegates.Vertex3i)); + GL.Vertex3iv = (GL.Delegates.Vertex3iv)GetAddress("glVertex3iv", typeof(GL.Delegates.Vertex3iv)); + GL.Vertex3s = (GL.Delegates.Vertex3s)GetAddress("glVertex3s", typeof(GL.Delegates.Vertex3s)); + GL.Vertex3sv = (GL.Delegates.Vertex3sv)GetAddress("glVertex3sv", typeof(GL.Delegates.Vertex3sv)); + GL.Vertex4d = (GL.Delegates.Vertex4d)GetAddress("glVertex4d", typeof(GL.Delegates.Vertex4d)); + GL.Vertex4dv = (GL.Delegates.Vertex4dv)GetAddress("glVertex4dv", typeof(GL.Delegates.Vertex4dv)); + GL.Vertex4f = (GL.Delegates.Vertex4f)GetAddress("glVertex4f", typeof(GL.Delegates.Vertex4f)); + GL.Vertex4fv = (GL.Delegates.Vertex4fv)GetAddress("glVertex4fv", typeof(GL.Delegates.Vertex4fv)); + GL.Vertex4i = (GL.Delegates.Vertex4i)GetAddress("glVertex4i", typeof(GL.Delegates.Vertex4i)); + GL.Vertex4iv = (GL.Delegates.Vertex4iv)GetAddress("glVertex4iv", typeof(GL.Delegates.Vertex4iv)); + GL.Vertex4s = (GL.Delegates.Vertex4s)GetAddress("glVertex4s", typeof(GL.Delegates.Vertex4s)); + GL.Vertex4sv = (GL.Delegates.Vertex4sv)GetAddress("glVertex4sv", typeof(GL.Delegates.Vertex4sv)); + GL.ClipPlane = (GL.Delegates.ClipPlane)GetAddress("glClipPlane", typeof(GL.Delegates.ClipPlane)); + GL.ColorMaterial = (GL.Delegates.ColorMaterial)GetAddress("glColorMaterial", typeof(GL.Delegates.ColorMaterial)); + GL.CullFace = (GL.Delegates.CullFace)GetAddress("glCullFace", typeof(GL.Delegates.CullFace)); + GL.Fogf = (GL.Delegates.Fogf)GetAddress("glFogf", typeof(GL.Delegates.Fogf)); + GL.Fogfv = (GL.Delegates.Fogfv)GetAddress("glFogfv", typeof(GL.Delegates.Fogfv)); + GL.Fogi = (GL.Delegates.Fogi)GetAddress("glFogi", typeof(GL.Delegates.Fogi)); + GL.Fogiv = (GL.Delegates.Fogiv)GetAddress("glFogiv", typeof(GL.Delegates.Fogiv)); + GL.FrontFace = (GL.Delegates.FrontFace)GetAddress("glFrontFace", typeof(GL.Delegates.FrontFace)); + GL.Hint = (GL.Delegates.Hint)GetAddress("glHint", typeof(GL.Delegates.Hint)); + GL.Lightf = (GL.Delegates.Lightf)GetAddress("glLightf", typeof(GL.Delegates.Lightf)); + GL.Lightfv = (GL.Delegates.Lightfv)GetAddress("glLightfv", typeof(GL.Delegates.Lightfv)); + GL.Lighti = (GL.Delegates.Lighti)GetAddress("glLighti", typeof(GL.Delegates.Lighti)); + GL.Lightiv = (GL.Delegates.Lightiv)GetAddress("glLightiv", typeof(GL.Delegates.Lightiv)); + GL.LightModelf = (GL.Delegates.LightModelf)GetAddress("glLightModelf", typeof(GL.Delegates.LightModelf)); + GL.LightModelfv = (GL.Delegates.LightModelfv)GetAddress("glLightModelfv", typeof(GL.Delegates.LightModelfv)); + GL.LightModeli = (GL.Delegates.LightModeli)GetAddress("glLightModeli", typeof(GL.Delegates.LightModeli)); + GL.LightModeliv = (GL.Delegates.LightModeliv)GetAddress("glLightModeliv", typeof(GL.Delegates.LightModeliv)); + GL.LineStipple = (GL.Delegates.LineStipple)GetAddress("glLineStipple", typeof(GL.Delegates.LineStipple)); + GL.LineWidth = (GL.Delegates.LineWidth)GetAddress("glLineWidth", typeof(GL.Delegates.LineWidth)); + GL.Materialf = (GL.Delegates.Materialf)GetAddress("glMaterialf", typeof(GL.Delegates.Materialf)); + GL.Materialfv = (GL.Delegates.Materialfv)GetAddress("glMaterialfv", typeof(GL.Delegates.Materialfv)); + GL.Materiali = (GL.Delegates.Materiali)GetAddress("glMateriali", typeof(GL.Delegates.Materiali)); + GL.Materialiv = (GL.Delegates.Materialiv)GetAddress("glMaterialiv", typeof(GL.Delegates.Materialiv)); + GL.PointSize = (GL.Delegates.PointSize)GetAddress("glPointSize", typeof(GL.Delegates.PointSize)); + GL.PolygonMode = (GL.Delegates.PolygonMode)GetAddress("glPolygonMode", typeof(GL.Delegates.PolygonMode)); + GL.PolygonStipple = (GL.Delegates.PolygonStipple)GetAddress("glPolygonStipple", typeof(GL.Delegates.PolygonStipple)); + GL.Scissor = (GL.Delegates.Scissor)GetAddress("glScissor", typeof(GL.Delegates.Scissor)); + GL.ShadeModel = (GL.Delegates.ShadeModel)GetAddress("glShadeModel", typeof(GL.Delegates.ShadeModel)); + GL.TexParameterf = (GL.Delegates.TexParameterf)GetAddress("glTexParameterf", typeof(GL.Delegates.TexParameterf)); + GL.TexParameterfv = (GL.Delegates.TexParameterfv)GetAddress("glTexParameterfv", typeof(GL.Delegates.TexParameterfv)); + GL.TexParameteri = (GL.Delegates.TexParameteri)GetAddress("glTexParameteri", typeof(GL.Delegates.TexParameteri)); + GL.TexParameteriv = (GL.Delegates.TexParameteriv)GetAddress("glTexParameteriv", typeof(GL.Delegates.TexParameteriv)); + GL.TexImage1D = (GL.Delegates.TexImage1D)GetAddress("glTexImage1D", typeof(GL.Delegates.TexImage1D)); + GL.TexImage2D = (GL.Delegates.TexImage2D)GetAddress("glTexImage2D", typeof(GL.Delegates.TexImage2D)); + GL.TexEnvf = (GL.Delegates.TexEnvf)GetAddress("glTexEnvf", typeof(GL.Delegates.TexEnvf)); + GL.TexEnvfv = (GL.Delegates.TexEnvfv)GetAddress("glTexEnvfv", typeof(GL.Delegates.TexEnvfv)); + GL.TexEnvi = (GL.Delegates.TexEnvi)GetAddress("glTexEnvi", typeof(GL.Delegates.TexEnvi)); + GL.TexEnviv = (GL.Delegates.TexEnviv)GetAddress("glTexEnviv", typeof(GL.Delegates.TexEnviv)); + GL.TexGend = (GL.Delegates.TexGend)GetAddress("glTexGend", typeof(GL.Delegates.TexGend)); + GL.TexGendv = (GL.Delegates.TexGendv)GetAddress("glTexGendv", typeof(GL.Delegates.TexGendv)); + GL.TexGenf = (GL.Delegates.TexGenf)GetAddress("glTexGenf", typeof(GL.Delegates.TexGenf)); + GL.TexGenfv = (GL.Delegates.TexGenfv)GetAddress("glTexGenfv", typeof(GL.Delegates.TexGenfv)); + GL.TexGeni = (GL.Delegates.TexGeni)GetAddress("glTexGeni", typeof(GL.Delegates.TexGeni)); + GL.TexGeniv = (GL.Delegates.TexGeniv)GetAddress("glTexGeniv", typeof(GL.Delegates.TexGeniv)); + GL.FeedbackBuffer = (GL.Delegates.FeedbackBuffer)GetAddress("glFeedbackBuffer", typeof(GL.Delegates.FeedbackBuffer)); + GL.SelectBuffer = (GL.Delegates.SelectBuffer)GetAddress("glSelectBuffer", typeof(GL.Delegates.SelectBuffer)); + GL.RenderMode = (GL.Delegates.RenderMode)GetAddress("glRenderMode", typeof(GL.Delegates.RenderMode)); + GL.InitNames = (GL.Delegates.InitNames)GetAddress("glInitNames", typeof(GL.Delegates.InitNames)); + GL.LoadName = (GL.Delegates.LoadName)GetAddress("glLoadName", typeof(GL.Delegates.LoadName)); + GL.PassThrough = (GL.Delegates.PassThrough)GetAddress("glPassThrough", typeof(GL.Delegates.PassThrough)); + GL.PopName = (GL.Delegates.PopName)GetAddress("glPopName", typeof(GL.Delegates.PopName)); + GL.PushName = (GL.Delegates.PushName)GetAddress("glPushName", typeof(GL.Delegates.PushName)); + GL.DrawBuffer = (GL.Delegates.DrawBuffer)GetAddress("glDrawBuffer", typeof(GL.Delegates.DrawBuffer)); + GL.Clear = (GL.Delegates.Clear)GetAddress("glClear", typeof(GL.Delegates.Clear)); + GL.ClearAccum = (GL.Delegates.ClearAccum)GetAddress("glClearAccum", typeof(GL.Delegates.ClearAccum)); + GL.ClearIndex = (GL.Delegates.ClearIndex)GetAddress("glClearIndex", typeof(GL.Delegates.ClearIndex)); + GL.ClearColor = (GL.Delegates.ClearColor)GetAddress("glClearColor", typeof(GL.Delegates.ClearColor)); + GL.ClearStencil = (GL.Delegates.ClearStencil)GetAddress("glClearStencil", typeof(GL.Delegates.ClearStencil)); + GL.ClearDepth = (GL.Delegates.ClearDepth)GetAddress("glClearDepth", typeof(GL.Delegates.ClearDepth)); + GL.StencilMask = (GL.Delegates.StencilMask)GetAddress("glStencilMask", typeof(GL.Delegates.StencilMask)); + GL.ColorMask = (GL.Delegates.ColorMask)GetAddress("glColorMask", typeof(GL.Delegates.ColorMask)); + GL.DepthMask = (GL.Delegates.DepthMask)GetAddress("glDepthMask", typeof(GL.Delegates.DepthMask)); + GL.IndexMask = (GL.Delegates.IndexMask)GetAddress("glIndexMask", typeof(GL.Delegates.IndexMask)); + GL.Accum = (GL.Delegates.Accum)GetAddress("glAccum", typeof(GL.Delegates.Accum)); + GL.Disable = (GL.Delegates.Disable)GetAddress("glDisable", typeof(GL.Delegates.Disable)); + GL.Enable = (GL.Delegates.Enable)GetAddress("glEnable", typeof(GL.Delegates.Enable)); + GL.Finish = (GL.Delegates.Finish)GetAddress("glFinish", typeof(GL.Delegates.Finish)); + GL.Flush = (GL.Delegates.Flush)GetAddress("glFlush", typeof(GL.Delegates.Flush)); + GL.PopAttrib = (GL.Delegates.PopAttrib)GetAddress("glPopAttrib", typeof(GL.Delegates.PopAttrib)); + GL.PushAttrib = (GL.Delegates.PushAttrib)GetAddress("glPushAttrib", typeof(GL.Delegates.PushAttrib)); + GL.Map1d = (GL.Delegates.Map1d)GetAddress("glMap1d", typeof(GL.Delegates.Map1d)); + GL.Map1f = (GL.Delegates.Map1f)GetAddress("glMap1f", typeof(GL.Delegates.Map1f)); + GL.Map2d = (GL.Delegates.Map2d)GetAddress("glMap2d", typeof(GL.Delegates.Map2d)); + GL.Map2f = (GL.Delegates.Map2f)GetAddress("glMap2f", typeof(GL.Delegates.Map2f)); + GL.MapGrid1d = (GL.Delegates.MapGrid1d)GetAddress("glMapGrid1d", typeof(GL.Delegates.MapGrid1d)); + GL.MapGrid1f = (GL.Delegates.MapGrid1f)GetAddress("glMapGrid1f", typeof(GL.Delegates.MapGrid1f)); + GL.MapGrid2d = (GL.Delegates.MapGrid2d)GetAddress("glMapGrid2d", typeof(GL.Delegates.MapGrid2d)); + GL.MapGrid2f = (GL.Delegates.MapGrid2f)GetAddress("glMapGrid2f", typeof(GL.Delegates.MapGrid2f)); + GL.EvalCoord1d = (GL.Delegates.EvalCoord1d)GetAddress("glEvalCoord1d", typeof(GL.Delegates.EvalCoord1d)); + GL.EvalCoord1dv = (GL.Delegates.EvalCoord1dv)GetAddress("glEvalCoord1dv", typeof(GL.Delegates.EvalCoord1dv)); + GL.EvalCoord1f = (GL.Delegates.EvalCoord1f)GetAddress("glEvalCoord1f", typeof(GL.Delegates.EvalCoord1f)); + GL.EvalCoord1fv = (GL.Delegates.EvalCoord1fv)GetAddress("glEvalCoord1fv", typeof(GL.Delegates.EvalCoord1fv)); + GL.EvalCoord2d = (GL.Delegates.EvalCoord2d)GetAddress("glEvalCoord2d", typeof(GL.Delegates.EvalCoord2d)); + GL.EvalCoord2dv = (GL.Delegates.EvalCoord2dv)GetAddress("glEvalCoord2dv", typeof(GL.Delegates.EvalCoord2dv)); + GL.EvalCoord2f = (GL.Delegates.EvalCoord2f)GetAddress("glEvalCoord2f", typeof(GL.Delegates.EvalCoord2f)); + GL.EvalCoord2fv = (GL.Delegates.EvalCoord2fv)GetAddress("glEvalCoord2fv", typeof(GL.Delegates.EvalCoord2fv)); + GL.EvalMesh1 = (GL.Delegates.EvalMesh1)GetAddress("glEvalMesh1", typeof(GL.Delegates.EvalMesh1)); + GL.EvalPoint1 = (GL.Delegates.EvalPoint1)GetAddress("glEvalPoint1", typeof(GL.Delegates.EvalPoint1)); + GL.EvalMesh2 = (GL.Delegates.EvalMesh2)GetAddress("glEvalMesh2", typeof(GL.Delegates.EvalMesh2)); + GL.EvalPoint2 = (GL.Delegates.EvalPoint2)GetAddress("glEvalPoint2", typeof(GL.Delegates.EvalPoint2)); + GL.AlphaFunc = (GL.Delegates.AlphaFunc)GetAddress("glAlphaFunc", typeof(GL.Delegates.AlphaFunc)); + GL.BlendFunc = (GL.Delegates.BlendFunc)GetAddress("glBlendFunc", typeof(GL.Delegates.BlendFunc)); + GL.LogicOp = (GL.Delegates.LogicOp)GetAddress("glLogicOp", typeof(GL.Delegates.LogicOp)); + GL.StencilFunc = (GL.Delegates.StencilFunc)GetAddress("glStencilFunc", typeof(GL.Delegates.StencilFunc)); + GL.StencilOp = (GL.Delegates.StencilOp)GetAddress("glStencilOp", typeof(GL.Delegates.StencilOp)); + GL.DepthFunc = (GL.Delegates.DepthFunc)GetAddress("glDepthFunc", typeof(GL.Delegates.DepthFunc)); + GL.PixelZoom = (GL.Delegates.PixelZoom)GetAddress("glPixelZoom", typeof(GL.Delegates.PixelZoom)); + GL.PixelTransferf = (GL.Delegates.PixelTransferf)GetAddress("glPixelTransferf", typeof(GL.Delegates.PixelTransferf)); + GL.PixelTransferi = (GL.Delegates.PixelTransferi)GetAddress("glPixelTransferi", typeof(GL.Delegates.PixelTransferi)); + GL.PixelStoref = (GL.Delegates.PixelStoref)GetAddress("glPixelStoref", typeof(GL.Delegates.PixelStoref)); + GL.PixelStorei = (GL.Delegates.PixelStorei)GetAddress("glPixelStorei", typeof(GL.Delegates.PixelStorei)); + GL.PixelMapfv = (GL.Delegates.PixelMapfv)GetAddress("glPixelMapfv", typeof(GL.Delegates.PixelMapfv)); + GL.PixelMapuiv = (GL.Delegates.PixelMapuiv)GetAddress("glPixelMapuiv", typeof(GL.Delegates.PixelMapuiv)); + GL.PixelMapusv = (GL.Delegates.PixelMapusv)GetAddress("glPixelMapusv", typeof(GL.Delegates.PixelMapusv)); + GL.ReadBuffer = (GL.Delegates.ReadBuffer)GetAddress("glReadBuffer", typeof(GL.Delegates.ReadBuffer)); + GL.CopyPixels = (GL.Delegates.CopyPixels)GetAddress("glCopyPixels", typeof(GL.Delegates.CopyPixels)); + GL.ReadPixels_ = (GL.Delegates.ReadPixels_)GetAddress("glReadPixels", typeof(GL.Delegates.ReadPixels_)); + GL.DrawPixels_ = (GL.Delegates.DrawPixels_)GetAddress("glDrawPixels", typeof(GL.Delegates.DrawPixels_)); + GL.GetBooleanv = (GL.Delegates.GetBooleanv)GetAddress("glGetBooleanv", typeof(GL.Delegates.GetBooleanv)); + GL.GetClipPlane = (GL.Delegates.GetClipPlane)GetAddress("glGetClipPlane", typeof(GL.Delegates.GetClipPlane)); + GL.GetDoublev = (GL.Delegates.GetDoublev)GetAddress("glGetDoublev", typeof(GL.Delegates.GetDoublev)); + GL.GetError = (GL.Delegates.GetError)GetAddress("glGetError", typeof(GL.Delegates.GetError)); + GL.GetFloatv = (GL.Delegates.GetFloatv)GetAddress("glGetFloatv", typeof(GL.Delegates.GetFloatv)); + GL.GetIntegerv = (GL.Delegates.GetIntegerv)GetAddress("glGetIntegerv", typeof(GL.Delegates.GetIntegerv)); + GL.GetLightfv = (GL.Delegates.GetLightfv)GetAddress("glGetLightfv", typeof(GL.Delegates.GetLightfv)); + GL.GetLightiv = (GL.Delegates.GetLightiv)GetAddress("glGetLightiv", typeof(GL.Delegates.GetLightiv)); + GL.GetMapdv = (GL.Delegates.GetMapdv)GetAddress("glGetMapdv", typeof(GL.Delegates.GetMapdv)); + GL.GetMapfv = (GL.Delegates.GetMapfv)GetAddress("glGetMapfv", typeof(GL.Delegates.GetMapfv)); + GL.GetMapiv = (GL.Delegates.GetMapiv)GetAddress("glGetMapiv", typeof(GL.Delegates.GetMapiv)); + GL.GetMaterialfv = (GL.Delegates.GetMaterialfv)GetAddress("glGetMaterialfv", typeof(GL.Delegates.GetMaterialfv)); + GL.GetMaterialiv = (GL.Delegates.GetMaterialiv)GetAddress("glGetMaterialiv", typeof(GL.Delegates.GetMaterialiv)); + GL.GetPixelMapfv = (GL.Delegates.GetPixelMapfv)GetAddress("glGetPixelMapfv", typeof(GL.Delegates.GetPixelMapfv)); + GL.GetPixelMapuiv = (GL.Delegates.GetPixelMapuiv)GetAddress("glGetPixelMapuiv", typeof(GL.Delegates.GetPixelMapuiv)); + GL.GetPixelMapusv = (GL.Delegates.GetPixelMapusv)GetAddress("glGetPixelMapusv", typeof(GL.Delegates.GetPixelMapusv)); + GL.GetPolygonStipple = (GL.Delegates.GetPolygonStipple)GetAddress("glGetPolygonStipple", typeof(GL.Delegates.GetPolygonStipple)); + GL.GetString = (GL.Delegates.GetString)GetAddress("glGetString", typeof(GL.Delegates.GetString)); + GL.GetTexEnvfv = (GL.Delegates.GetTexEnvfv)GetAddress("glGetTexEnvfv", typeof(GL.Delegates.GetTexEnvfv)); + GL.GetTexEnviv = (GL.Delegates.GetTexEnviv)GetAddress("glGetTexEnviv", typeof(GL.Delegates.GetTexEnviv)); + GL.GetTexGendv = (GL.Delegates.GetTexGendv)GetAddress("glGetTexGendv", typeof(GL.Delegates.GetTexGendv)); + GL.GetTexGenfv = (GL.Delegates.GetTexGenfv)GetAddress("glGetTexGenfv", typeof(GL.Delegates.GetTexGenfv)); + GL.GetTexGeniv = (GL.Delegates.GetTexGeniv)GetAddress("glGetTexGeniv", typeof(GL.Delegates.GetTexGeniv)); + GL.GetTexImage = (GL.Delegates.GetTexImage)GetAddress("glGetTexImage", typeof(GL.Delegates.GetTexImage)); + GL.GetTexParameterfv = (GL.Delegates.GetTexParameterfv)GetAddress("glGetTexParameterfv", typeof(GL.Delegates.GetTexParameterfv)); + GL.GetTexParameteriv = (GL.Delegates.GetTexParameteriv)GetAddress("glGetTexParameteriv", typeof(GL.Delegates.GetTexParameteriv)); + GL.GetTexLevelParameterfv = (GL.Delegates.GetTexLevelParameterfv)GetAddress("glGetTexLevelParameterfv", typeof(GL.Delegates.GetTexLevelParameterfv)); + GL.GetTexLevelParameteriv = (GL.Delegates.GetTexLevelParameteriv)GetAddress("glGetTexLevelParameteriv", typeof(GL.Delegates.GetTexLevelParameteriv)); + GL.IsEnabled = (GL.Delegates.IsEnabled)GetAddress("glIsEnabled", typeof(GL.Delegates.IsEnabled)); + GL.IsList = (GL.Delegates.IsList)GetAddress("glIsList", typeof(GL.Delegates.IsList)); + GL.DepthRange = (GL.Delegates.DepthRange)GetAddress("glDepthRange", typeof(GL.Delegates.DepthRange)); + GL.Frustum = (GL.Delegates.Frustum)GetAddress("glFrustum", typeof(GL.Delegates.Frustum)); + GL.LoadIdentity = (GL.Delegates.LoadIdentity)GetAddress("glLoadIdentity", typeof(GL.Delegates.LoadIdentity)); + GL.LoadMatrixf = (GL.Delegates.LoadMatrixf)GetAddress("glLoadMatrixf", typeof(GL.Delegates.LoadMatrixf)); + GL.LoadMatrixd = (GL.Delegates.LoadMatrixd)GetAddress("glLoadMatrixd", typeof(GL.Delegates.LoadMatrixd)); + GL.MatrixMode = (GL.Delegates.MatrixMode)GetAddress("glMatrixMode", typeof(GL.Delegates.MatrixMode)); + GL.MultMatrixf = (GL.Delegates.MultMatrixf)GetAddress("glMultMatrixf", typeof(GL.Delegates.MultMatrixf)); + GL.MultMatrixd = (GL.Delegates.MultMatrixd)GetAddress("glMultMatrixd", typeof(GL.Delegates.MultMatrixd)); + GL.Ortho = (GL.Delegates.Ortho)GetAddress("glOrtho", typeof(GL.Delegates.Ortho)); + GL.PopMatrix = (GL.Delegates.PopMatrix)GetAddress("glPopMatrix", typeof(GL.Delegates.PopMatrix)); + GL.PushMatrix = (GL.Delegates.PushMatrix)GetAddress("glPushMatrix", typeof(GL.Delegates.PushMatrix)); + GL.Rotated = (GL.Delegates.Rotated)GetAddress("glRotated", typeof(GL.Delegates.Rotated)); + GL.Rotatef = (GL.Delegates.Rotatef)GetAddress("glRotatef", typeof(GL.Delegates.Rotatef)); + GL.Scaled = (GL.Delegates.Scaled)GetAddress("glScaled", typeof(GL.Delegates.Scaled)); + GL.Scalef = (GL.Delegates.Scalef)GetAddress("glScalef", typeof(GL.Delegates.Scalef)); + GL.Translated = (GL.Delegates.Translated)GetAddress("glTranslated", typeof(GL.Delegates.Translated)); + GL.Translatef = (GL.Delegates.Translatef)GetAddress("glTranslatef", typeof(GL.Delegates.Translatef)); + GL.Viewport = (GL.Delegates.Viewport)GetAddress("glViewport", typeof(GL.Delegates.Viewport)); + GL.ArrayElement = (GL.Delegates.ArrayElement)GetAddress("glArrayElement", typeof(GL.Delegates.ArrayElement)); + GL.ColorPointer_ = (GL.Delegates.ColorPointer_)GetAddress("glColorPointer", typeof(GL.Delegates.ColorPointer_)); + GL.DisableClientState = (GL.Delegates.DisableClientState)GetAddress("glDisableClientState", typeof(GL.Delegates.DisableClientState)); + GL.DrawArrays = (GL.Delegates.DrawArrays)GetAddress("glDrawArrays", typeof(GL.Delegates.DrawArrays)); + GL.DrawElements_ = (GL.Delegates.DrawElements_)GetAddress("glDrawElements", typeof(GL.Delegates.DrawElements_)); + GL.EdgeFlagPointer_ = (GL.Delegates.EdgeFlagPointer_)GetAddress("glEdgeFlagPointer", typeof(GL.Delegates.EdgeFlagPointer_)); + GL.EnableClientState = (GL.Delegates.EnableClientState)GetAddress("glEnableClientState", typeof(GL.Delegates.EnableClientState)); + GL.GetPointerv = (GL.Delegates.GetPointerv)GetAddress("glGetPointerv", typeof(GL.Delegates.GetPointerv)); + GL.IndexPointer_ = (GL.Delegates.IndexPointer_)GetAddress("glIndexPointer", typeof(GL.Delegates.IndexPointer_)); + GL.InterleavedArrays_ = (GL.Delegates.InterleavedArrays_)GetAddress("glInterleavedArrays", typeof(GL.Delegates.InterleavedArrays_)); + GL.NormalPointer_ = (GL.Delegates.NormalPointer_)GetAddress("glNormalPointer", typeof(GL.Delegates.NormalPointer_)); + GL.TexCoordPointer_ = (GL.Delegates.TexCoordPointer_)GetAddress("glTexCoordPointer", typeof(GL.Delegates.TexCoordPointer_)); + GL.VertexPointer_ = (GL.Delegates.VertexPointer_)GetAddress("glVertexPointer", typeof(GL.Delegates.VertexPointer_)); + GL.PolygonOffset = (GL.Delegates.PolygonOffset)GetAddress("glPolygonOffset", typeof(GL.Delegates.PolygonOffset)); + GL.CopyTexImage1D = (GL.Delegates.CopyTexImage1D)GetAddress("glCopyTexImage1D", typeof(GL.Delegates.CopyTexImage1D)); + GL.CopyTexImage2D = (GL.Delegates.CopyTexImage2D)GetAddress("glCopyTexImage2D", typeof(GL.Delegates.CopyTexImage2D)); + GL.CopyTexSubImage1D = (GL.Delegates.CopyTexSubImage1D)GetAddress("glCopyTexSubImage1D", typeof(GL.Delegates.CopyTexSubImage1D)); + GL.CopyTexSubImage2D = (GL.Delegates.CopyTexSubImage2D)GetAddress("glCopyTexSubImage2D", typeof(GL.Delegates.CopyTexSubImage2D)); + GL.TexSubImage1D = (GL.Delegates.TexSubImage1D)GetAddress("glTexSubImage1D", typeof(GL.Delegates.TexSubImage1D)); + GL.TexSubImage2D = (GL.Delegates.TexSubImage2D)GetAddress("glTexSubImage2D", typeof(GL.Delegates.TexSubImage2D)); + GL.AreTexturesResident = (GL.Delegates.AreTexturesResident)GetAddress("glAreTexturesResident", typeof(GL.Delegates.AreTexturesResident)); + GL.BindTexture = (GL.Delegates.BindTexture)GetAddress("glBindTexture", typeof(GL.Delegates.BindTexture)); + GL.DeleteTextures = (GL.Delegates.DeleteTextures)GetAddress("glDeleteTextures", typeof(GL.Delegates.DeleteTextures)); + GL.GenTextures = (GL.Delegates.GenTextures)GetAddress("glGenTextures", typeof(GL.Delegates.GenTextures)); + GL.IsTexture = (GL.Delegates.IsTexture)GetAddress("glIsTexture", typeof(GL.Delegates.IsTexture)); + GL.PrioritizeTextures = (GL.Delegates.PrioritizeTextures)GetAddress("glPrioritizeTextures", typeof(GL.Delegates.PrioritizeTextures)); + GL.Indexub = (GL.Delegates.Indexub)GetAddress("glIndexub", typeof(GL.Delegates.Indexub)); + GL.Indexubv = (GL.Delegates.Indexubv)GetAddress("glIndexubv", typeof(GL.Delegates.Indexubv)); + GL.PopClientAttrib = (GL.Delegates.PopClientAttrib)GetAddress("glPopClientAttrib", typeof(GL.Delegates.PopClientAttrib)); + GL.PushClientAttrib = (GL.Delegates.PushClientAttrib)GetAddress("glPushClientAttrib", typeof(GL.Delegates.PushClientAttrib)); + GL.BlendColor = (GL.Delegates.BlendColor)GetAddress("glBlendColor", typeof(GL.Delegates.BlendColor)); + GL.BlendEquation = (GL.Delegates.BlendEquation)GetAddress("glBlendEquation", typeof(GL.Delegates.BlendEquation)); + GL.DrawRangeElements_ = (GL.Delegates.DrawRangeElements_)GetAddress("glDrawRangeElements", typeof(GL.Delegates.DrawRangeElements_)); + GL.ColorTable_ = (GL.Delegates.ColorTable_)GetAddress("glColorTable", typeof(GL.Delegates.ColorTable_)); + GL.ColorTableParameterfv = (GL.Delegates.ColorTableParameterfv)GetAddress("glColorTableParameterfv", typeof(GL.Delegates.ColorTableParameterfv)); + GL.ColorTableParameteriv = (GL.Delegates.ColorTableParameteriv)GetAddress("glColorTableParameteriv", typeof(GL.Delegates.ColorTableParameteriv)); + GL.CopyColorTable = (GL.Delegates.CopyColorTable)GetAddress("glCopyColorTable", typeof(GL.Delegates.CopyColorTable)); + GL.GetColorTable_ = (GL.Delegates.GetColorTable_)GetAddress("glGetColorTable", typeof(GL.Delegates.GetColorTable_)); + GL.GetColorTableParameterfv = (GL.Delegates.GetColorTableParameterfv)GetAddress("glGetColorTableParameterfv", typeof(GL.Delegates.GetColorTableParameterfv)); + GL.GetColorTableParameteriv = (GL.Delegates.GetColorTableParameteriv)GetAddress("glGetColorTableParameteriv", typeof(GL.Delegates.GetColorTableParameteriv)); + GL.ColorSubTable_ = (GL.Delegates.ColorSubTable_)GetAddress("glColorSubTable", typeof(GL.Delegates.ColorSubTable_)); + GL.CopyColorSubTable = (GL.Delegates.CopyColorSubTable)GetAddress("glCopyColorSubTable", typeof(GL.Delegates.CopyColorSubTable)); + GL.ConvolutionFilter1D_ = (GL.Delegates.ConvolutionFilter1D_)GetAddress("glConvolutionFilter1D", typeof(GL.Delegates.ConvolutionFilter1D_)); + GL.ConvolutionFilter2D_ = (GL.Delegates.ConvolutionFilter2D_)GetAddress("glConvolutionFilter2D", typeof(GL.Delegates.ConvolutionFilter2D_)); + GL.ConvolutionParameterf = (GL.Delegates.ConvolutionParameterf)GetAddress("glConvolutionParameterf", typeof(GL.Delegates.ConvolutionParameterf)); + GL.ConvolutionParameterfv = (GL.Delegates.ConvolutionParameterfv)GetAddress("glConvolutionParameterfv", typeof(GL.Delegates.ConvolutionParameterfv)); + GL.ConvolutionParameteri = (GL.Delegates.ConvolutionParameteri)GetAddress("glConvolutionParameteri", typeof(GL.Delegates.ConvolutionParameteri)); + GL.ConvolutionParameteriv = (GL.Delegates.ConvolutionParameteriv)GetAddress("glConvolutionParameteriv", typeof(GL.Delegates.ConvolutionParameteriv)); + GL.CopyConvolutionFilter1D = (GL.Delegates.CopyConvolutionFilter1D)GetAddress("glCopyConvolutionFilter1D", typeof(GL.Delegates.CopyConvolutionFilter1D)); + GL.CopyConvolutionFilter2D = (GL.Delegates.CopyConvolutionFilter2D)GetAddress("glCopyConvolutionFilter2D", typeof(GL.Delegates.CopyConvolutionFilter2D)); + GL.GetConvolutionFilter_ = (GL.Delegates.GetConvolutionFilter_)GetAddress("glGetConvolutionFilter", typeof(GL.Delegates.GetConvolutionFilter_)); + GL.GetConvolutionParameterfv = (GL.Delegates.GetConvolutionParameterfv)GetAddress("glGetConvolutionParameterfv", typeof(GL.Delegates.GetConvolutionParameterfv)); + GL.GetConvolutionParameteriv = (GL.Delegates.GetConvolutionParameteriv)GetAddress("glGetConvolutionParameteriv", typeof(GL.Delegates.GetConvolutionParameteriv)); + GL.GetSeparableFilter_ = (GL.Delegates.GetSeparableFilter_)GetAddress("glGetSeparableFilter", typeof(GL.Delegates.GetSeparableFilter_)); + GL.SeparableFilter2D_ = (GL.Delegates.SeparableFilter2D_)GetAddress("glSeparableFilter2D", typeof(GL.Delegates.SeparableFilter2D_)); + GL.GetHistogram_ = (GL.Delegates.GetHistogram_)GetAddress("glGetHistogram", typeof(GL.Delegates.GetHistogram_)); + GL.GetHistogramParameterfv = (GL.Delegates.GetHistogramParameterfv)GetAddress("glGetHistogramParameterfv", typeof(GL.Delegates.GetHistogramParameterfv)); + GL.GetHistogramParameteriv = (GL.Delegates.GetHistogramParameteriv)GetAddress("glGetHistogramParameteriv", typeof(GL.Delegates.GetHistogramParameteriv)); + GL.GetMinmax_ = (GL.Delegates.GetMinmax_)GetAddress("glGetMinmax", typeof(GL.Delegates.GetMinmax_)); + GL.GetMinmaxParameterfv = (GL.Delegates.GetMinmaxParameterfv)GetAddress("glGetMinmaxParameterfv", typeof(GL.Delegates.GetMinmaxParameterfv)); + GL.GetMinmaxParameteriv = (GL.Delegates.GetMinmaxParameteriv)GetAddress("glGetMinmaxParameteriv", typeof(GL.Delegates.GetMinmaxParameteriv)); + GL.Histogram = (GL.Delegates.Histogram)GetAddress("glHistogram", typeof(GL.Delegates.Histogram)); + GL.Minmax = (GL.Delegates.Minmax)GetAddress("glMinmax", typeof(GL.Delegates.Minmax)); + GL.ResetHistogram = (GL.Delegates.ResetHistogram)GetAddress("glResetHistogram", typeof(GL.Delegates.ResetHistogram)); + GL.ResetMinmax = (GL.Delegates.ResetMinmax)GetAddress("glResetMinmax", typeof(GL.Delegates.ResetMinmax)); + GL.TexImage3D = (GL.Delegates.TexImage3D)GetAddress("glTexImage3D", typeof(GL.Delegates.TexImage3D)); + GL.TexSubImage3D = (GL.Delegates.TexSubImage3D)GetAddress("glTexSubImage3D", typeof(GL.Delegates.TexSubImage3D)); + GL.CopyTexSubImage3D = (GL.Delegates.CopyTexSubImage3D)GetAddress("glCopyTexSubImage3D", typeof(GL.Delegates.CopyTexSubImage3D)); + GL.ActiveTexture = (GL.Delegates.ActiveTexture)GetAddress("glActiveTexture", typeof(GL.Delegates.ActiveTexture)); + GL.ClientActiveTexture = (GL.Delegates.ClientActiveTexture)GetAddress("glClientActiveTexture", typeof(GL.Delegates.ClientActiveTexture)); + GL.MultiTexCoord1d = (GL.Delegates.MultiTexCoord1d)GetAddress("glMultiTexCoord1d", typeof(GL.Delegates.MultiTexCoord1d)); + GL.MultiTexCoord1dv = (GL.Delegates.MultiTexCoord1dv)GetAddress("glMultiTexCoord1dv", typeof(GL.Delegates.MultiTexCoord1dv)); + GL.MultiTexCoord1f = (GL.Delegates.MultiTexCoord1f)GetAddress("glMultiTexCoord1f", typeof(GL.Delegates.MultiTexCoord1f)); + GL.MultiTexCoord1fv = (GL.Delegates.MultiTexCoord1fv)GetAddress("glMultiTexCoord1fv", typeof(GL.Delegates.MultiTexCoord1fv)); + GL.MultiTexCoord1i = (GL.Delegates.MultiTexCoord1i)GetAddress("glMultiTexCoord1i", typeof(GL.Delegates.MultiTexCoord1i)); + GL.MultiTexCoord1iv = (GL.Delegates.MultiTexCoord1iv)GetAddress("glMultiTexCoord1iv", typeof(GL.Delegates.MultiTexCoord1iv)); + GL.MultiTexCoord1s = (GL.Delegates.MultiTexCoord1s)GetAddress("glMultiTexCoord1s", typeof(GL.Delegates.MultiTexCoord1s)); + GL.MultiTexCoord1sv = (GL.Delegates.MultiTexCoord1sv)GetAddress("glMultiTexCoord1sv", typeof(GL.Delegates.MultiTexCoord1sv)); + GL.MultiTexCoord2d = (GL.Delegates.MultiTexCoord2d)GetAddress("glMultiTexCoord2d", typeof(GL.Delegates.MultiTexCoord2d)); + GL.MultiTexCoord2dv = (GL.Delegates.MultiTexCoord2dv)GetAddress("glMultiTexCoord2dv", typeof(GL.Delegates.MultiTexCoord2dv)); + GL.MultiTexCoord2f = (GL.Delegates.MultiTexCoord2f)GetAddress("glMultiTexCoord2f", typeof(GL.Delegates.MultiTexCoord2f)); + GL.MultiTexCoord2fv = (GL.Delegates.MultiTexCoord2fv)GetAddress("glMultiTexCoord2fv", typeof(GL.Delegates.MultiTexCoord2fv)); + GL.MultiTexCoord2i = (GL.Delegates.MultiTexCoord2i)GetAddress("glMultiTexCoord2i", typeof(GL.Delegates.MultiTexCoord2i)); + GL.MultiTexCoord2iv = (GL.Delegates.MultiTexCoord2iv)GetAddress("glMultiTexCoord2iv", typeof(GL.Delegates.MultiTexCoord2iv)); + GL.MultiTexCoord2s = (GL.Delegates.MultiTexCoord2s)GetAddress("glMultiTexCoord2s", typeof(GL.Delegates.MultiTexCoord2s)); + GL.MultiTexCoord2sv = (GL.Delegates.MultiTexCoord2sv)GetAddress("glMultiTexCoord2sv", typeof(GL.Delegates.MultiTexCoord2sv)); + GL.MultiTexCoord3d = (GL.Delegates.MultiTexCoord3d)GetAddress("glMultiTexCoord3d", typeof(GL.Delegates.MultiTexCoord3d)); + GL.MultiTexCoord3dv = (GL.Delegates.MultiTexCoord3dv)GetAddress("glMultiTexCoord3dv", typeof(GL.Delegates.MultiTexCoord3dv)); + GL.MultiTexCoord3f = (GL.Delegates.MultiTexCoord3f)GetAddress("glMultiTexCoord3f", typeof(GL.Delegates.MultiTexCoord3f)); + GL.MultiTexCoord3fv = (GL.Delegates.MultiTexCoord3fv)GetAddress("glMultiTexCoord3fv", typeof(GL.Delegates.MultiTexCoord3fv)); + GL.MultiTexCoord3i = (GL.Delegates.MultiTexCoord3i)GetAddress("glMultiTexCoord3i", typeof(GL.Delegates.MultiTexCoord3i)); + GL.MultiTexCoord3iv = (GL.Delegates.MultiTexCoord3iv)GetAddress("glMultiTexCoord3iv", typeof(GL.Delegates.MultiTexCoord3iv)); + GL.MultiTexCoord3s = (GL.Delegates.MultiTexCoord3s)GetAddress("glMultiTexCoord3s", typeof(GL.Delegates.MultiTexCoord3s)); + GL.MultiTexCoord3sv = (GL.Delegates.MultiTexCoord3sv)GetAddress("glMultiTexCoord3sv", typeof(GL.Delegates.MultiTexCoord3sv)); + GL.MultiTexCoord4d = (GL.Delegates.MultiTexCoord4d)GetAddress("glMultiTexCoord4d", typeof(GL.Delegates.MultiTexCoord4d)); + GL.MultiTexCoord4dv = (GL.Delegates.MultiTexCoord4dv)GetAddress("glMultiTexCoord4dv", typeof(GL.Delegates.MultiTexCoord4dv)); + GL.MultiTexCoord4f = (GL.Delegates.MultiTexCoord4f)GetAddress("glMultiTexCoord4f", typeof(GL.Delegates.MultiTexCoord4f)); + GL.MultiTexCoord4fv = (GL.Delegates.MultiTexCoord4fv)GetAddress("glMultiTexCoord4fv", typeof(GL.Delegates.MultiTexCoord4fv)); + GL.MultiTexCoord4i = (GL.Delegates.MultiTexCoord4i)GetAddress("glMultiTexCoord4i", typeof(GL.Delegates.MultiTexCoord4i)); + GL.MultiTexCoord4iv = (GL.Delegates.MultiTexCoord4iv)GetAddress("glMultiTexCoord4iv", typeof(GL.Delegates.MultiTexCoord4iv)); + GL.MultiTexCoord4s = (GL.Delegates.MultiTexCoord4s)GetAddress("glMultiTexCoord4s", typeof(GL.Delegates.MultiTexCoord4s)); + GL.MultiTexCoord4sv = (GL.Delegates.MultiTexCoord4sv)GetAddress("glMultiTexCoord4sv", typeof(GL.Delegates.MultiTexCoord4sv)); + GL.LoadTransposeMatrixf = (GL.Delegates.LoadTransposeMatrixf)GetAddress("glLoadTransposeMatrixf", typeof(GL.Delegates.LoadTransposeMatrixf)); + GL.LoadTransposeMatrixd = (GL.Delegates.LoadTransposeMatrixd)GetAddress("glLoadTransposeMatrixd", typeof(GL.Delegates.LoadTransposeMatrixd)); + GL.MultTransposeMatrixf = (GL.Delegates.MultTransposeMatrixf)GetAddress("glMultTransposeMatrixf", typeof(GL.Delegates.MultTransposeMatrixf)); + GL.MultTransposeMatrixd = (GL.Delegates.MultTransposeMatrixd)GetAddress("glMultTransposeMatrixd", typeof(GL.Delegates.MultTransposeMatrixd)); + GL.SampleCoverage = (GL.Delegates.SampleCoverage)GetAddress("glSampleCoverage", typeof(GL.Delegates.SampleCoverage)); + GL.CompressedTexImage3D = (GL.Delegates.CompressedTexImage3D)GetAddress("glCompressedTexImage3D", typeof(GL.Delegates.CompressedTexImage3D)); + GL.CompressedTexImage2D = (GL.Delegates.CompressedTexImage2D)GetAddress("glCompressedTexImage2D", typeof(GL.Delegates.CompressedTexImage2D)); + GL.CompressedTexImage1D = (GL.Delegates.CompressedTexImage1D)GetAddress("glCompressedTexImage1D", typeof(GL.Delegates.CompressedTexImage1D)); + GL.CompressedTexSubImage3D = (GL.Delegates.CompressedTexSubImage3D)GetAddress("glCompressedTexSubImage3D", typeof(GL.Delegates.CompressedTexSubImage3D)); + GL.CompressedTexSubImage2D = (GL.Delegates.CompressedTexSubImage2D)GetAddress("glCompressedTexSubImage2D", typeof(GL.Delegates.CompressedTexSubImage2D)); + GL.CompressedTexSubImage1D = (GL.Delegates.CompressedTexSubImage1D)GetAddress("glCompressedTexSubImage1D", typeof(GL.Delegates.CompressedTexSubImage1D)); + GL.GetCompressedTexImage = (GL.Delegates.GetCompressedTexImage)GetAddress("glGetCompressedTexImage", typeof(GL.Delegates.GetCompressedTexImage)); + GL.BlendFuncSeparate = (GL.Delegates.BlendFuncSeparate)GetAddress("glBlendFuncSeparate", typeof(GL.Delegates.BlendFuncSeparate)); + GL.FogCoordf = (GL.Delegates.FogCoordf)GetAddress("glFogCoordf", typeof(GL.Delegates.FogCoordf)); + GL.FogCoordfv = (GL.Delegates.FogCoordfv)GetAddress("glFogCoordfv", typeof(GL.Delegates.FogCoordfv)); + GL.FogCoordd = (GL.Delegates.FogCoordd)GetAddress("glFogCoordd", typeof(GL.Delegates.FogCoordd)); + GL.FogCoorddv = (GL.Delegates.FogCoorddv)GetAddress("glFogCoorddv", typeof(GL.Delegates.FogCoorddv)); + GL.FogCoordPointer_ = (GL.Delegates.FogCoordPointer_)GetAddress("glFogCoordPointer", typeof(GL.Delegates.FogCoordPointer_)); + GL.MultiDrawArrays = (GL.Delegates.MultiDrawArrays)GetAddress("glMultiDrawArrays", typeof(GL.Delegates.MultiDrawArrays)); + GL.MultiDrawElements = (GL.Delegates.MultiDrawElements)GetAddress("glMultiDrawElements", typeof(GL.Delegates.MultiDrawElements)); + GL.PointParameterf = (GL.Delegates.PointParameterf)GetAddress("glPointParameterf", typeof(GL.Delegates.PointParameterf)); + GL.PointParameterfv = (GL.Delegates.PointParameterfv)GetAddress("glPointParameterfv", typeof(GL.Delegates.PointParameterfv)); + GL.PointParameteri = (GL.Delegates.PointParameteri)GetAddress("glPointParameteri", typeof(GL.Delegates.PointParameteri)); + GL.PointParameteriv = (GL.Delegates.PointParameteriv)GetAddress("glPointParameteriv", typeof(GL.Delegates.PointParameteriv)); + GL.SecondaryColor3b = (GL.Delegates.SecondaryColor3b)GetAddress("glSecondaryColor3b", typeof(GL.Delegates.SecondaryColor3b)); + GL.SecondaryColor3bv = (GL.Delegates.SecondaryColor3bv)GetAddress("glSecondaryColor3bv", typeof(GL.Delegates.SecondaryColor3bv)); + GL.SecondaryColor3d = (GL.Delegates.SecondaryColor3d)GetAddress("glSecondaryColor3d", typeof(GL.Delegates.SecondaryColor3d)); + GL.SecondaryColor3dv = (GL.Delegates.SecondaryColor3dv)GetAddress("glSecondaryColor3dv", typeof(GL.Delegates.SecondaryColor3dv)); + GL.SecondaryColor3f = (GL.Delegates.SecondaryColor3f)GetAddress("glSecondaryColor3f", typeof(GL.Delegates.SecondaryColor3f)); + GL.SecondaryColor3fv = (GL.Delegates.SecondaryColor3fv)GetAddress("glSecondaryColor3fv", typeof(GL.Delegates.SecondaryColor3fv)); + GL.SecondaryColor3i = (GL.Delegates.SecondaryColor3i)GetAddress("glSecondaryColor3i", typeof(GL.Delegates.SecondaryColor3i)); + GL.SecondaryColor3iv = (GL.Delegates.SecondaryColor3iv)GetAddress("glSecondaryColor3iv", typeof(GL.Delegates.SecondaryColor3iv)); + GL.SecondaryColor3s = (GL.Delegates.SecondaryColor3s)GetAddress("glSecondaryColor3s", typeof(GL.Delegates.SecondaryColor3s)); + GL.SecondaryColor3sv = (GL.Delegates.SecondaryColor3sv)GetAddress("glSecondaryColor3sv", typeof(GL.Delegates.SecondaryColor3sv)); + GL.SecondaryColor3ub = (GL.Delegates.SecondaryColor3ub)GetAddress("glSecondaryColor3ub", typeof(GL.Delegates.SecondaryColor3ub)); + GL.SecondaryColor3ubv = (GL.Delegates.SecondaryColor3ubv)GetAddress("glSecondaryColor3ubv", typeof(GL.Delegates.SecondaryColor3ubv)); + GL.SecondaryColor3ui = (GL.Delegates.SecondaryColor3ui)GetAddress("glSecondaryColor3ui", typeof(GL.Delegates.SecondaryColor3ui)); + GL.SecondaryColor3uiv = (GL.Delegates.SecondaryColor3uiv)GetAddress("glSecondaryColor3uiv", typeof(GL.Delegates.SecondaryColor3uiv)); + GL.SecondaryColor3us = (GL.Delegates.SecondaryColor3us)GetAddress("glSecondaryColor3us", typeof(GL.Delegates.SecondaryColor3us)); + GL.SecondaryColor3usv = (GL.Delegates.SecondaryColor3usv)GetAddress("glSecondaryColor3usv", typeof(GL.Delegates.SecondaryColor3usv)); + GL.SecondaryColorPointer_ = (GL.Delegates.SecondaryColorPointer_)GetAddress("glSecondaryColorPointer", typeof(GL.Delegates.SecondaryColorPointer_)); + GL.WindowPos2d = (GL.Delegates.WindowPos2d)GetAddress("glWindowPos2d", typeof(GL.Delegates.WindowPos2d)); + GL.WindowPos2dv = (GL.Delegates.WindowPos2dv)GetAddress("glWindowPos2dv", typeof(GL.Delegates.WindowPos2dv)); + GL.WindowPos2f = (GL.Delegates.WindowPos2f)GetAddress("glWindowPos2f", typeof(GL.Delegates.WindowPos2f)); + GL.WindowPos2fv = (GL.Delegates.WindowPos2fv)GetAddress("glWindowPos2fv", typeof(GL.Delegates.WindowPos2fv)); + GL.WindowPos2i = (GL.Delegates.WindowPos2i)GetAddress("glWindowPos2i", typeof(GL.Delegates.WindowPos2i)); + GL.WindowPos2iv = (GL.Delegates.WindowPos2iv)GetAddress("glWindowPos2iv", typeof(GL.Delegates.WindowPos2iv)); + GL.WindowPos2s = (GL.Delegates.WindowPos2s)GetAddress("glWindowPos2s", typeof(GL.Delegates.WindowPos2s)); + GL.WindowPos2sv = (GL.Delegates.WindowPos2sv)GetAddress("glWindowPos2sv", typeof(GL.Delegates.WindowPos2sv)); + GL.WindowPos3d = (GL.Delegates.WindowPos3d)GetAddress("glWindowPos3d", typeof(GL.Delegates.WindowPos3d)); + GL.WindowPos3dv = (GL.Delegates.WindowPos3dv)GetAddress("glWindowPos3dv", typeof(GL.Delegates.WindowPos3dv)); + GL.WindowPos3f = (GL.Delegates.WindowPos3f)GetAddress("glWindowPos3f", typeof(GL.Delegates.WindowPos3f)); + GL.WindowPos3fv = (GL.Delegates.WindowPos3fv)GetAddress("glWindowPos3fv", typeof(GL.Delegates.WindowPos3fv)); + GL.WindowPos3i = (GL.Delegates.WindowPos3i)GetAddress("glWindowPos3i", typeof(GL.Delegates.WindowPos3i)); + GL.WindowPos3iv = (GL.Delegates.WindowPos3iv)GetAddress("glWindowPos3iv", typeof(GL.Delegates.WindowPos3iv)); + GL.WindowPos3s = (GL.Delegates.WindowPos3s)GetAddress("glWindowPos3s", typeof(GL.Delegates.WindowPos3s)); + GL.WindowPos3sv = (GL.Delegates.WindowPos3sv)GetAddress("glWindowPos3sv", typeof(GL.Delegates.WindowPos3sv)); + GL.GenQueries = (GL.Delegates.GenQueries)GetAddress("glGenQueries", typeof(GL.Delegates.GenQueries)); + GL.DeleteQueries = (GL.Delegates.DeleteQueries)GetAddress("glDeleteQueries", typeof(GL.Delegates.DeleteQueries)); + GL.IsQuery = (GL.Delegates.IsQuery)GetAddress("glIsQuery", typeof(GL.Delegates.IsQuery)); + GL.BeginQuery = (GL.Delegates.BeginQuery)GetAddress("glBeginQuery", typeof(GL.Delegates.BeginQuery)); + GL.EndQuery = (GL.Delegates.EndQuery)GetAddress("glEndQuery", typeof(GL.Delegates.EndQuery)); + GL.GetQueryiv = (GL.Delegates.GetQueryiv)GetAddress("glGetQueryiv", typeof(GL.Delegates.GetQueryiv)); + GL.GetQueryObjectiv = (GL.Delegates.GetQueryObjectiv)GetAddress("glGetQueryObjectiv", typeof(GL.Delegates.GetQueryObjectiv)); + GL.GetQueryObjectuiv = (GL.Delegates.GetQueryObjectuiv)GetAddress("glGetQueryObjectuiv", typeof(GL.Delegates.GetQueryObjectuiv)); + GL.BindBuffer = (GL.Delegates.BindBuffer)GetAddress("glBindBuffer", typeof(GL.Delegates.BindBuffer)); + GL.DeleteBuffers = (GL.Delegates.DeleteBuffers)GetAddress("glDeleteBuffers", typeof(GL.Delegates.DeleteBuffers)); + GL.GenBuffers = (GL.Delegates.GenBuffers)GetAddress("glGenBuffers", typeof(GL.Delegates.GenBuffers)); + GL.IsBuffer = (GL.Delegates.IsBuffer)GetAddress("glIsBuffer", typeof(GL.Delegates.IsBuffer)); + GL.BufferData_ = (GL.Delegates.BufferData_)GetAddress("glBufferData", typeof(GL.Delegates.BufferData_)); + GL.BufferSubData_ = (GL.Delegates.BufferSubData_)GetAddress("glBufferSubData", typeof(GL.Delegates.BufferSubData_)); + GL.GetBufferSubData_ = (GL.Delegates.GetBufferSubData_)GetAddress("glGetBufferSubData", typeof(GL.Delegates.GetBufferSubData_)); + GL.MapBuffer_ = (GL.Delegates.MapBuffer_)GetAddress("glMapBuffer", typeof(GL.Delegates.MapBuffer_)); + GL.UnmapBuffer = (GL.Delegates.UnmapBuffer)GetAddress("glUnmapBuffer", typeof(GL.Delegates.UnmapBuffer)); + GL.GetBufferParameteriv = (GL.Delegates.GetBufferParameteriv)GetAddress("glGetBufferParameteriv", typeof(GL.Delegates.GetBufferParameteriv)); + GL.GetBufferPointerv = (GL.Delegates.GetBufferPointerv)GetAddress("glGetBufferPointerv", typeof(GL.Delegates.GetBufferPointerv)); + GL.BlendEquationSeparate = (GL.Delegates.BlendEquationSeparate)GetAddress("glBlendEquationSeparate", typeof(GL.Delegates.BlendEquationSeparate)); + GL.DrawBuffers = (GL.Delegates.DrawBuffers)GetAddress("glDrawBuffers", typeof(GL.Delegates.DrawBuffers)); + GL.StencilOpSeparate = (GL.Delegates.StencilOpSeparate)GetAddress("glStencilOpSeparate", typeof(GL.Delegates.StencilOpSeparate)); + GL.StencilFuncSeparate = (GL.Delegates.StencilFuncSeparate)GetAddress("glStencilFuncSeparate", typeof(GL.Delegates.StencilFuncSeparate)); + GL.StencilMaskSeparate = (GL.Delegates.StencilMaskSeparate)GetAddress("glStencilMaskSeparate", typeof(GL.Delegates.StencilMaskSeparate)); + GL.AttachShader = (GL.Delegates.AttachShader)GetAddress("glAttachShader", typeof(GL.Delegates.AttachShader)); + GL.BindAttribLocation = (GL.Delegates.BindAttribLocation)GetAddress("glBindAttribLocation", typeof(GL.Delegates.BindAttribLocation)); + GL.CompileShader = (GL.Delegates.CompileShader)GetAddress("glCompileShader", typeof(GL.Delegates.CompileShader)); + GL.CreateProgram = (GL.Delegates.CreateProgram)GetAddress("glCreateProgram", typeof(GL.Delegates.CreateProgram)); + GL.CreateShader = (GL.Delegates.CreateShader)GetAddress("glCreateShader", typeof(GL.Delegates.CreateShader)); + GL.DeleteProgram = (GL.Delegates.DeleteProgram)GetAddress("glDeleteProgram", typeof(GL.Delegates.DeleteProgram)); + GL.DeleteShader = (GL.Delegates.DeleteShader)GetAddress("glDeleteShader", typeof(GL.Delegates.DeleteShader)); + GL.DetachShader = (GL.Delegates.DetachShader)GetAddress("glDetachShader", typeof(GL.Delegates.DetachShader)); + GL.DisableVertexAttribArray = (GL.Delegates.DisableVertexAttribArray)GetAddress("glDisableVertexAttribArray", typeof(GL.Delegates.DisableVertexAttribArray)); + GL.EnableVertexAttribArray = (GL.Delegates.EnableVertexAttribArray)GetAddress("glEnableVertexAttribArray", typeof(GL.Delegates.EnableVertexAttribArray)); + GL.GetActiveAttrib = (GL.Delegates.GetActiveAttrib)GetAddress("glGetActiveAttrib", typeof(GL.Delegates.GetActiveAttrib)); + GL.GetActiveUniform = (GL.Delegates.GetActiveUniform)GetAddress("glGetActiveUniform", typeof(GL.Delegates.GetActiveUniform)); + GL.GetAttachedShaders = (GL.Delegates.GetAttachedShaders)GetAddress("glGetAttachedShaders", typeof(GL.Delegates.GetAttachedShaders)); + GL.GetAttribLocation = (GL.Delegates.GetAttribLocation)GetAddress("glGetAttribLocation", typeof(GL.Delegates.GetAttribLocation)); + GL.GetProgramiv = (GL.Delegates.GetProgramiv)GetAddress("glGetProgramiv", typeof(GL.Delegates.GetProgramiv)); + GL.GetProgramInfoLog = (GL.Delegates.GetProgramInfoLog)GetAddress("glGetProgramInfoLog", typeof(GL.Delegates.GetProgramInfoLog)); + GL.GetShaderiv = (GL.Delegates.GetShaderiv)GetAddress("glGetShaderiv", typeof(GL.Delegates.GetShaderiv)); + GL.GetShaderInfoLog = (GL.Delegates.GetShaderInfoLog)GetAddress("glGetShaderInfoLog", typeof(GL.Delegates.GetShaderInfoLog)); + GL.GetShaderSource = (GL.Delegates.GetShaderSource)GetAddress("glGetShaderSource", typeof(GL.Delegates.GetShaderSource)); + GL.GetUniformLocation = (GL.Delegates.GetUniformLocation)GetAddress("glGetUniformLocation", typeof(GL.Delegates.GetUniformLocation)); + GL.GetUniformfv = (GL.Delegates.GetUniformfv)GetAddress("glGetUniformfv", typeof(GL.Delegates.GetUniformfv)); + GL.GetUniformiv = (GL.Delegates.GetUniformiv)GetAddress("glGetUniformiv", typeof(GL.Delegates.GetUniformiv)); + GL.GetVertexAttribdv = (GL.Delegates.GetVertexAttribdv)GetAddress("glGetVertexAttribdv", typeof(GL.Delegates.GetVertexAttribdv)); + GL.GetVertexAttribfv = (GL.Delegates.GetVertexAttribfv)GetAddress("glGetVertexAttribfv", typeof(GL.Delegates.GetVertexAttribfv)); + GL.GetVertexAttribiv = (GL.Delegates.GetVertexAttribiv)GetAddress("glGetVertexAttribiv", typeof(GL.Delegates.GetVertexAttribiv)); + GL.GetVertexAttribPointerv = (GL.Delegates.GetVertexAttribPointerv)GetAddress("glGetVertexAttribPointerv", typeof(GL.Delegates.GetVertexAttribPointerv)); + GL.IsProgram = (GL.Delegates.IsProgram)GetAddress("glIsProgram", typeof(GL.Delegates.IsProgram)); + GL.IsShader = (GL.Delegates.IsShader)GetAddress("glIsShader", typeof(GL.Delegates.IsShader)); + GL.LinkProgram = (GL.Delegates.LinkProgram)GetAddress("glLinkProgram", typeof(GL.Delegates.LinkProgram)); + GL.ShaderSource = (GL.Delegates.ShaderSource)GetAddress("glShaderSource", typeof(GL.Delegates.ShaderSource)); + GL.UseProgram = (GL.Delegates.UseProgram)GetAddress("glUseProgram", typeof(GL.Delegates.UseProgram)); + GL.Uniform1f = (GL.Delegates.Uniform1f)GetAddress("glUniform1f", typeof(GL.Delegates.Uniform1f)); + GL.Uniform2f = (GL.Delegates.Uniform2f)GetAddress("glUniform2f", typeof(GL.Delegates.Uniform2f)); + GL.Uniform3f = (GL.Delegates.Uniform3f)GetAddress("glUniform3f", typeof(GL.Delegates.Uniform3f)); + GL.Uniform4f = (GL.Delegates.Uniform4f)GetAddress("glUniform4f", typeof(GL.Delegates.Uniform4f)); + GL.Uniform1i = (GL.Delegates.Uniform1i)GetAddress("glUniform1i", typeof(GL.Delegates.Uniform1i)); + GL.Uniform2i = (GL.Delegates.Uniform2i)GetAddress("glUniform2i", typeof(GL.Delegates.Uniform2i)); + GL.Uniform3i = (GL.Delegates.Uniform3i)GetAddress("glUniform3i", typeof(GL.Delegates.Uniform3i)); + GL.Uniform4i = (GL.Delegates.Uniform4i)GetAddress("glUniform4i", typeof(GL.Delegates.Uniform4i)); + GL.Uniform1fv = (GL.Delegates.Uniform1fv)GetAddress("glUniform1fv", typeof(GL.Delegates.Uniform1fv)); + GL.Uniform2fv = (GL.Delegates.Uniform2fv)GetAddress("glUniform2fv", typeof(GL.Delegates.Uniform2fv)); + GL.Uniform3fv = (GL.Delegates.Uniform3fv)GetAddress("glUniform3fv", typeof(GL.Delegates.Uniform3fv)); + GL.Uniform4fv = (GL.Delegates.Uniform4fv)GetAddress("glUniform4fv", typeof(GL.Delegates.Uniform4fv)); + GL.Uniform1iv = (GL.Delegates.Uniform1iv)GetAddress("glUniform1iv", typeof(GL.Delegates.Uniform1iv)); + GL.Uniform2iv = (GL.Delegates.Uniform2iv)GetAddress("glUniform2iv", typeof(GL.Delegates.Uniform2iv)); + GL.Uniform3iv = (GL.Delegates.Uniform3iv)GetAddress("glUniform3iv", typeof(GL.Delegates.Uniform3iv)); + GL.Uniform4iv = (GL.Delegates.Uniform4iv)GetAddress("glUniform4iv", typeof(GL.Delegates.Uniform4iv)); + GL.UniformMatrix2fv = (GL.Delegates.UniformMatrix2fv)GetAddress("glUniformMatrix2fv", typeof(GL.Delegates.UniformMatrix2fv)); + GL.UniformMatrix3fv = (GL.Delegates.UniformMatrix3fv)GetAddress("glUniformMatrix3fv", typeof(GL.Delegates.UniformMatrix3fv)); + GL.UniformMatrix4fv = (GL.Delegates.UniformMatrix4fv)GetAddress("glUniformMatrix4fv", typeof(GL.Delegates.UniformMatrix4fv)); + GL.ValidateProgram = (GL.Delegates.ValidateProgram)GetAddress("glValidateProgram", typeof(GL.Delegates.ValidateProgram)); + GL.VertexAttrib1d = (GL.Delegates.VertexAttrib1d)GetAddress("glVertexAttrib1d", typeof(GL.Delegates.VertexAttrib1d)); + GL.VertexAttrib1dv = (GL.Delegates.VertexAttrib1dv)GetAddress("glVertexAttrib1dv", typeof(GL.Delegates.VertexAttrib1dv)); + GL.VertexAttrib1f = (GL.Delegates.VertexAttrib1f)GetAddress("glVertexAttrib1f", typeof(GL.Delegates.VertexAttrib1f)); + GL.VertexAttrib1fv = (GL.Delegates.VertexAttrib1fv)GetAddress("glVertexAttrib1fv", typeof(GL.Delegates.VertexAttrib1fv)); + GL.VertexAttrib1s = (GL.Delegates.VertexAttrib1s)GetAddress("glVertexAttrib1s", typeof(GL.Delegates.VertexAttrib1s)); + GL.VertexAttrib1sv = (GL.Delegates.VertexAttrib1sv)GetAddress("glVertexAttrib1sv", typeof(GL.Delegates.VertexAttrib1sv)); + GL.VertexAttrib2d = (GL.Delegates.VertexAttrib2d)GetAddress("glVertexAttrib2d", typeof(GL.Delegates.VertexAttrib2d)); + GL.VertexAttrib2dv = (GL.Delegates.VertexAttrib2dv)GetAddress("glVertexAttrib2dv", typeof(GL.Delegates.VertexAttrib2dv)); + GL.VertexAttrib2f = (GL.Delegates.VertexAttrib2f)GetAddress("glVertexAttrib2f", typeof(GL.Delegates.VertexAttrib2f)); + GL.VertexAttrib2fv = (GL.Delegates.VertexAttrib2fv)GetAddress("glVertexAttrib2fv", typeof(GL.Delegates.VertexAttrib2fv)); + GL.VertexAttrib2s = (GL.Delegates.VertexAttrib2s)GetAddress("glVertexAttrib2s", typeof(GL.Delegates.VertexAttrib2s)); + GL.VertexAttrib2sv = (GL.Delegates.VertexAttrib2sv)GetAddress("glVertexAttrib2sv", typeof(GL.Delegates.VertexAttrib2sv)); + GL.VertexAttrib3d = (GL.Delegates.VertexAttrib3d)GetAddress("glVertexAttrib3d", typeof(GL.Delegates.VertexAttrib3d)); + GL.VertexAttrib3dv = (GL.Delegates.VertexAttrib3dv)GetAddress("glVertexAttrib3dv", typeof(GL.Delegates.VertexAttrib3dv)); + GL.VertexAttrib3f = (GL.Delegates.VertexAttrib3f)GetAddress("glVertexAttrib3f", typeof(GL.Delegates.VertexAttrib3f)); + GL.VertexAttrib3fv = (GL.Delegates.VertexAttrib3fv)GetAddress("glVertexAttrib3fv", typeof(GL.Delegates.VertexAttrib3fv)); + GL.VertexAttrib3s = (GL.Delegates.VertexAttrib3s)GetAddress("glVertexAttrib3s", typeof(GL.Delegates.VertexAttrib3s)); + GL.VertexAttrib3sv = (GL.Delegates.VertexAttrib3sv)GetAddress("glVertexAttrib3sv", typeof(GL.Delegates.VertexAttrib3sv)); + GL.VertexAttrib4Nbv = (GL.Delegates.VertexAttrib4Nbv)GetAddress("glVertexAttrib4Nbv", typeof(GL.Delegates.VertexAttrib4Nbv)); + GL.VertexAttrib4Niv = (GL.Delegates.VertexAttrib4Niv)GetAddress("glVertexAttrib4Niv", typeof(GL.Delegates.VertexAttrib4Niv)); + GL.VertexAttrib4Nsv = (GL.Delegates.VertexAttrib4Nsv)GetAddress("glVertexAttrib4Nsv", typeof(GL.Delegates.VertexAttrib4Nsv)); + GL.VertexAttrib4Nub = (GL.Delegates.VertexAttrib4Nub)GetAddress("glVertexAttrib4Nub", typeof(GL.Delegates.VertexAttrib4Nub)); + GL.VertexAttrib4Nubv = (GL.Delegates.VertexAttrib4Nubv)GetAddress("glVertexAttrib4Nubv", typeof(GL.Delegates.VertexAttrib4Nubv)); + GL.VertexAttrib4Nuiv = (GL.Delegates.VertexAttrib4Nuiv)GetAddress("glVertexAttrib4Nuiv", typeof(GL.Delegates.VertexAttrib4Nuiv)); + GL.VertexAttrib4Nusv = (GL.Delegates.VertexAttrib4Nusv)GetAddress("glVertexAttrib4Nusv", typeof(GL.Delegates.VertexAttrib4Nusv)); + GL.VertexAttrib4bv = (GL.Delegates.VertexAttrib4bv)GetAddress("glVertexAttrib4bv", typeof(GL.Delegates.VertexAttrib4bv)); + GL.VertexAttrib4d = (GL.Delegates.VertexAttrib4d)GetAddress("glVertexAttrib4d", typeof(GL.Delegates.VertexAttrib4d)); + GL.VertexAttrib4dv = (GL.Delegates.VertexAttrib4dv)GetAddress("glVertexAttrib4dv", typeof(GL.Delegates.VertexAttrib4dv)); + GL.VertexAttrib4f = (GL.Delegates.VertexAttrib4f)GetAddress("glVertexAttrib4f", typeof(GL.Delegates.VertexAttrib4f)); + GL.VertexAttrib4fv = (GL.Delegates.VertexAttrib4fv)GetAddress("glVertexAttrib4fv", typeof(GL.Delegates.VertexAttrib4fv)); + GL.VertexAttrib4iv = (GL.Delegates.VertexAttrib4iv)GetAddress("glVertexAttrib4iv", typeof(GL.Delegates.VertexAttrib4iv)); + GL.VertexAttrib4s = (GL.Delegates.VertexAttrib4s)GetAddress("glVertexAttrib4s", typeof(GL.Delegates.VertexAttrib4s)); + GL.VertexAttrib4sv = (GL.Delegates.VertexAttrib4sv)GetAddress("glVertexAttrib4sv", typeof(GL.Delegates.VertexAttrib4sv)); + GL.VertexAttrib4ubv = (GL.Delegates.VertexAttrib4ubv)GetAddress("glVertexAttrib4ubv", typeof(GL.Delegates.VertexAttrib4ubv)); + GL.VertexAttrib4uiv = (GL.Delegates.VertexAttrib4uiv)GetAddress("glVertexAttrib4uiv", typeof(GL.Delegates.VertexAttrib4uiv)); + GL.VertexAttrib4usv = (GL.Delegates.VertexAttrib4usv)GetAddress("glVertexAttrib4usv", typeof(GL.Delegates.VertexAttrib4usv)); + GL.VertexAttribPointer_ = (GL.Delegates.VertexAttribPointer_)GetAddress("glVertexAttribPointer", typeof(GL.Delegates.VertexAttribPointer_)); + GL.ActiveTextureARB = (GL.Delegates.ActiveTextureARB)GetAddress("glActiveTextureARB", typeof(GL.Delegates.ActiveTextureARB)); + GL.ClientActiveTextureARB = (GL.Delegates.ClientActiveTextureARB)GetAddress("glClientActiveTextureARB", typeof(GL.Delegates.ClientActiveTextureARB)); + GL.MultiTexCoord1dARB = (GL.Delegates.MultiTexCoord1dARB)GetAddress("glMultiTexCoord1dARB", typeof(GL.Delegates.MultiTexCoord1dARB)); + GL.MultiTexCoord1dvARB = (GL.Delegates.MultiTexCoord1dvARB)GetAddress("glMultiTexCoord1dvARB", typeof(GL.Delegates.MultiTexCoord1dvARB)); + GL.MultiTexCoord1fARB = (GL.Delegates.MultiTexCoord1fARB)GetAddress("glMultiTexCoord1fARB", typeof(GL.Delegates.MultiTexCoord1fARB)); + GL.MultiTexCoord1fvARB = (GL.Delegates.MultiTexCoord1fvARB)GetAddress("glMultiTexCoord1fvARB", typeof(GL.Delegates.MultiTexCoord1fvARB)); + GL.MultiTexCoord1iARB = (GL.Delegates.MultiTexCoord1iARB)GetAddress("glMultiTexCoord1iARB", typeof(GL.Delegates.MultiTexCoord1iARB)); + GL.MultiTexCoord1ivARB = (GL.Delegates.MultiTexCoord1ivARB)GetAddress("glMultiTexCoord1ivARB", typeof(GL.Delegates.MultiTexCoord1ivARB)); + GL.MultiTexCoord1sARB = (GL.Delegates.MultiTexCoord1sARB)GetAddress("glMultiTexCoord1sARB", typeof(GL.Delegates.MultiTexCoord1sARB)); + GL.MultiTexCoord1svARB = (GL.Delegates.MultiTexCoord1svARB)GetAddress("glMultiTexCoord1svARB", typeof(GL.Delegates.MultiTexCoord1svARB)); + GL.MultiTexCoord2dARB = (GL.Delegates.MultiTexCoord2dARB)GetAddress("glMultiTexCoord2dARB", typeof(GL.Delegates.MultiTexCoord2dARB)); + GL.MultiTexCoord2dvARB = (GL.Delegates.MultiTexCoord2dvARB)GetAddress("glMultiTexCoord2dvARB", typeof(GL.Delegates.MultiTexCoord2dvARB)); + GL.MultiTexCoord2fARB = (GL.Delegates.MultiTexCoord2fARB)GetAddress("glMultiTexCoord2fARB", typeof(GL.Delegates.MultiTexCoord2fARB)); + GL.MultiTexCoord2fvARB = (GL.Delegates.MultiTexCoord2fvARB)GetAddress("glMultiTexCoord2fvARB", typeof(GL.Delegates.MultiTexCoord2fvARB)); + GL.MultiTexCoord2iARB = (GL.Delegates.MultiTexCoord2iARB)GetAddress("glMultiTexCoord2iARB", typeof(GL.Delegates.MultiTexCoord2iARB)); + GL.MultiTexCoord2ivARB = (GL.Delegates.MultiTexCoord2ivARB)GetAddress("glMultiTexCoord2ivARB", typeof(GL.Delegates.MultiTexCoord2ivARB)); + GL.MultiTexCoord2sARB = (GL.Delegates.MultiTexCoord2sARB)GetAddress("glMultiTexCoord2sARB", typeof(GL.Delegates.MultiTexCoord2sARB)); + GL.MultiTexCoord2svARB = (GL.Delegates.MultiTexCoord2svARB)GetAddress("glMultiTexCoord2svARB", typeof(GL.Delegates.MultiTexCoord2svARB)); + GL.MultiTexCoord3dARB = (GL.Delegates.MultiTexCoord3dARB)GetAddress("glMultiTexCoord3dARB", typeof(GL.Delegates.MultiTexCoord3dARB)); + GL.MultiTexCoord3dvARB = (GL.Delegates.MultiTexCoord3dvARB)GetAddress("glMultiTexCoord3dvARB", typeof(GL.Delegates.MultiTexCoord3dvARB)); + GL.MultiTexCoord3fARB = (GL.Delegates.MultiTexCoord3fARB)GetAddress("glMultiTexCoord3fARB", typeof(GL.Delegates.MultiTexCoord3fARB)); + GL.MultiTexCoord3fvARB = (GL.Delegates.MultiTexCoord3fvARB)GetAddress("glMultiTexCoord3fvARB", typeof(GL.Delegates.MultiTexCoord3fvARB)); + GL.MultiTexCoord3iARB = (GL.Delegates.MultiTexCoord3iARB)GetAddress("glMultiTexCoord3iARB", typeof(GL.Delegates.MultiTexCoord3iARB)); + GL.MultiTexCoord3ivARB = (GL.Delegates.MultiTexCoord3ivARB)GetAddress("glMultiTexCoord3ivARB", typeof(GL.Delegates.MultiTexCoord3ivARB)); + GL.MultiTexCoord3sARB = (GL.Delegates.MultiTexCoord3sARB)GetAddress("glMultiTexCoord3sARB", typeof(GL.Delegates.MultiTexCoord3sARB)); + GL.MultiTexCoord3svARB = (GL.Delegates.MultiTexCoord3svARB)GetAddress("glMultiTexCoord3svARB", typeof(GL.Delegates.MultiTexCoord3svARB)); + GL.MultiTexCoord4dARB = (GL.Delegates.MultiTexCoord4dARB)GetAddress("glMultiTexCoord4dARB", typeof(GL.Delegates.MultiTexCoord4dARB)); + GL.MultiTexCoord4dvARB = (GL.Delegates.MultiTexCoord4dvARB)GetAddress("glMultiTexCoord4dvARB", typeof(GL.Delegates.MultiTexCoord4dvARB)); + GL.MultiTexCoord4fARB = (GL.Delegates.MultiTexCoord4fARB)GetAddress("glMultiTexCoord4fARB", typeof(GL.Delegates.MultiTexCoord4fARB)); + GL.MultiTexCoord4fvARB = (GL.Delegates.MultiTexCoord4fvARB)GetAddress("glMultiTexCoord4fvARB", typeof(GL.Delegates.MultiTexCoord4fvARB)); + GL.MultiTexCoord4iARB = (GL.Delegates.MultiTexCoord4iARB)GetAddress("glMultiTexCoord4iARB", typeof(GL.Delegates.MultiTexCoord4iARB)); + GL.MultiTexCoord4ivARB = (GL.Delegates.MultiTexCoord4ivARB)GetAddress("glMultiTexCoord4ivARB", typeof(GL.Delegates.MultiTexCoord4ivARB)); + GL.MultiTexCoord4sARB = (GL.Delegates.MultiTexCoord4sARB)GetAddress("glMultiTexCoord4sARB", typeof(GL.Delegates.MultiTexCoord4sARB)); + GL.MultiTexCoord4svARB = (GL.Delegates.MultiTexCoord4svARB)GetAddress("glMultiTexCoord4svARB", typeof(GL.Delegates.MultiTexCoord4svARB)); + GL.LoadTransposeMatrixfARB = (GL.Delegates.LoadTransposeMatrixfARB)GetAddress("glLoadTransposeMatrixfARB", typeof(GL.Delegates.LoadTransposeMatrixfARB)); + GL.LoadTransposeMatrixdARB = (GL.Delegates.LoadTransposeMatrixdARB)GetAddress("glLoadTransposeMatrixdARB", typeof(GL.Delegates.LoadTransposeMatrixdARB)); + GL.MultTransposeMatrixfARB = (GL.Delegates.MultTransposeMatrixfARB)GetAddress("glMultTransposeMatrixfARB", typeof(GL.Delegates.MultTransposeMatrixfARB)); + GL.MultTransposeMatrixdARB = (GL.Delegates.MultTransposeMatrixdARB)GetAddress("glMultTransposeMatrixdARB", typeof(GL.Delegates.MultTransposeMatrixdARB)); + GL.SampleCoverageARB = (GL.Delegates.SampleCoverageARB)GetAddress("glSampleCoverageARB", typeof(GL.Delegates.SampleCoverageARB)); + GL.CompressedTexImage3DARB = (GL.Delegates.CompressedTexImage3DARB)GetAddress("glCompressedTexImage3DARB", typeof(GL.Delegates.CompressedTexImage3DARB)); + GL.CompressedTexImage2DARB = (GL.Delegates.CompressedTexImage2DARB)GetAddress("glCompressedTexImage2DARB", typeof(GL.Delegates.CompressedTexImage2DARB)); + GL.CompressedTexImage1DARB = (GL.Delegates.CompressedTexImage1DARB)GetAddress("glCompressedTexImage1DARB", typeof(GL.Delegates.CompressedTexImage1DARB)); + GL.CompressedTexSubImage3DARB = (GL.Delegates.CompressedTexSubImage3DARB)GetAddress("glCompressedTexSubImage3DARB", typeof(GL.Delegates.CompressedTexSubImage3DARB)); + GL.CompressedTexSubImage2DARB = (GL.Delegates.CompressedTexSubImage2DARB)GetAddress("glCompressedTexSubImage2DARB", typeof(GL.Delegates.CompressedTexSubImage2DARB)); + GL.CompressedTexSubImage1DARB = (GL.Delegates.CompressedTexSubImage1DARB)GetAddress("glCompressedTexSubImage1DARB", typeof(GL.Delegates.CompressedTexSubImage1DARB)); + GL.GetCompressedTexImageARB = (GL.Delegates.GetCompressedTexImageARB)GetAddress("glGetCompressedTexImageARB", typeof(GL.Delegates.GetCompressedTexImageARB)); + GL.PointParameterfARB = (GL.Delegates.PointParameterfARB)GetAddress("glPointParameterfARB", typeof(GL.Delegates.PointParameterfARB)); + GL.PointParameterfvARB = (GL.Delegates.PointParameterfvARB)GetAddress("glPointParameterfvARB", typeof(GL.Delegates.PointParameterfvARB)); + GL.WeightbvARB = (GL.Delegates.WeightbvARB)GetAddress("glWeightbvARB", typeof(GL.Delegates.WeightbvARB)); + GL.WeightsvARB = (GL.Delegates.WeightsvARB)GetAddress("glWeightsvARB", typeof(GL.Delegates.WeightsvARB)); + GL.WeightivARB = (GL.Delegates.WeightivARB)GetAddress("glWeightivARB", typeof(GL.Delegates.WeightivARB)); + GL.WeightfvARB = (GL.Delegates.WeightfvARB)GetAddress("glWeightfvARB", typeof(GL.Delegates.WeightfvARB)); + GL.WeightdvARB = (GL.Delegates.WeightdvARB)GetAddress("glWeightdvARB", typeof(GL.Delegates.WeightdvARB)); + GL.WeightubvARB = (GL.Delegates.WeightubvARB)GetAddress("glWeightubvARB", typeof(GL.Delegates.WeightubvARB)); + GL.WeightusvARB = (GL.Delegates.WeightusvARB)GetAddress("glWeightusvARB", typeof(GL.Delegates.WeightusvARB)); + GL.WeightuivARB = (GL.Delegates.WeightuivARB)GetAddress("glWeightuivARB", typeof(GL.Delegates.WeightuivARB)); + GL.WeightPointerARB_ = (GL.Delegates.WeightPointerARB_)GetAddress("glWeightPointerARB", typeof(GL.Delegates.WeightPointerARB_)); + GL.VertexBlendARB = (GL.Delegates.VertexBlendARB)GetAddress("glVertexBlendARB", typeof(GL.Delegates.VertexBlendARB)); + GL.CurrentPaletteMatrixARB = (GL.Delegates.CurrentPaletteMatrixARB)GetAddress("glCurrentPaletteMatrixARB", typeof(GL.Delegates.CurrentPaletteMatrixARB)); + GL.MatrixIndexubvARB = (GL.Delegates.MatrixIndexubvARB)GetAddress("glMatrixIndexubvARB", typeof(GL.Delegates.MatrixIndexubvARB)); + GL.MatrixIndexusvARB = (GL.Delegates.MatrixIndexusvARB)GetAddress("glMatrixIndexusvARB", typeof(GL.Delegates.MatrixIndexusvARB)); + GL.MatrixIndexuivARB = (GL.Delegates.MatrixIndexuivARB)GetAddress("glMatrixIndexuivARB", typeof(GL.Delegates.MatrixIndexuivARB)); + GL.MatrixIndexPointerARB_ = (GL.Delegates.MatrixIndexPointerARB_)GetAddress("glMatrixIndexPointerARB", typeof(GL.Delegates.MatrixIndexPointerARB_)); + GL.WindowPos2dARB = (GL.Delegates.WindowPos2dARB)GetAddress("glWindowPos2dARB", typeof(GL.Delegates.WindowPos2dARB)); + GL.WindowPos2dvARB = (GL.Delegates.WindowPos2dvARB)GetAddress("glWindowPos2dvARB", typeof(GL.Delegates.WindowPos2dvARB)); + GL.WindowPos2fARB = (GL.Delegates.WindowPos2fARB)GetAddress("glWindowPos2fARB", typeof(GL.Delegates.WindowPos2fARB)); + GL.WindowPos2fvARB = (GL.Delegates.WindowPos2fvARB)GetAddress("glWindowPos2fvARB", typeof(GL.Delegates.WindowPos2fvARB)); + GL.WindowPos2iARB = (GL.Delegates.WindowPos2iARB)GetAddress("glWindowPos2iARB", typeof(GL.Delegates.WindowPos2iARB)); + GL.WindowPos2ivARB = (GL.Delegates.WindowPos2ivARB)GetAddress("glWindowPos2ivARB", typeof(GL.Delegates.WindowPos2ivARB)); + GL.WindowPos2sARB = (GL.Delegates.WindowPos2sARB)GetAddress("glWindowPos2sARB", typeof(GL.Delegates.WindowPos2sARB)); + GL.WindowPos2svARB = (GL.Delegates.WindowPos2svARB)GetAddress("glWindowPos2svARB", typeof(GL.Delegates.WindowPos2svARB)); + GL.WindowPos3dARB = (GL.Delegates.WindowPos3dARB)GetAddress("glWindowPos3dARB", typeof(GL.Delegates.WindowPos3dARB)); + GL.WindowPos3dvARB = (GL.Delegates.WindowPos3dvARB)GetAddress("glWindowPos3dvARB", typeof(GL.Delegates.WindowPos3dvARB)); + GL.WindowPos3fARB = (GL.Delegates.WindowPos3fARB)GetAddress("glWindowPos3fARB", typeof(GL.Delegates.WindowPos3fARB)); + GL.WindowPos3fvARB = (GL.Delegates.WindowPos3fvARB)GetAddress("glWindowPos3fvARB", typeof(GL.Delegates.WindowPos3fvARB)); + GL.WindowPos3iARB = (GL.Delegates.WindowPos3iARB)GetAddress("glWindowPos3iARB", typeof(GL.Delegates.WindowPos3iARB)); + GL.WindowPos3ivARB = (GL.Delegates.WindowPos3ivARB)GetAddress("glWindowPos3ivARB", typeof(GL.Delegates.WindowPos3ivARB)); + GL.WindowPos3sARB = (GL.Delegates.WindowPos3sARB)GetAddress("glWindowPos3sARB", typeof(GL.Delegates.WindowPos3sARB)); + GL.WindowPos3svARB = (GL.Delegates.WindowPos3svARB)GetAddress("glWindowPos3svARB", typeof(GL.Delegates.WindowPos3svARB)); + GL.VertexAttrib1dARB = (GL.Delegates.VertexAttrib1dARB)GetAddress("glVertexAttrib1dARB", typeof(GL.Delegates.VertexAttrib1dARB)); + GL.VertexAttrib1dvARB = (GL.Delegates.VertexAttrib1dvARB)GetAddress("glVertexAttrib1dvARB", typeof(GL.Delegates.VertexAttrib1dvARB)); + GL.VertexAttrib1fARB = (GL.Delegates.VertexAttrib1fARB)GetAddress("glVertexAttrib1fARB", typeof(GL.Delegates.VertexAttrib1fARB)); + GL.VertexAttrib1fvARB = (GL.Delegates.VertexAttrib1fvARB)GetAddress("glVertexAttrib1fvARB", typeof(GL.Delegates.VertexAttrib1fvARB)); + GL.VertexAttrib1sARB = (GL.Delegates.VertexAttrib1sARB)GetAddress("glVertexAttrib1sARB", typeof(GL.Delegates.VertexAttrib1sARB)); + GL.VertexAttrib1svARB = (GL.Delegates.VertexAttrib1svARB)GetAddress("glVertexAttrib1svARB", typeof(GL.Delegates.VertexAttrib1svARB)); + GL.VertexAttrib2dARB = (GL.Delegates.VertexAttrib2dARB)GetAddress("glVertexAttrib2dARB", typeof(GL.Delegates.VertexAttrib2dARB)); + GL.VertexAttrib2dvARB = (GL.Delegates.VertexAttrib2dvARB)GetAddress("glVertexAttrib2dvARB", typeof(GL.Delegates.VertexAttrib2dvARB)); + GL.VertexAttrib2fARB = (GL.Delegates.VertexAttrib2fARB)GetAddress("glVertexAttrib2fARB", typeof(GL.Delegates.VertexAttrib2fARB)); + GL.VertexAttrib2fvARB = (GL.Delegates.VertexAttrib2fvARB)GetAddress("glVertexAttrib2fvARB", typeof(GL.Delegates.VertexAttrib2fvARB)); + GL.VertexAttrib2sARB = (GL.Delegates.VertexAttrib2sARB)GetAddress("glVertexAttrib2sARB", typeof(GL.Delegates.VertexAttrib2sARB)); + GL.VertexAttrib2svARB = (GL.Delegates.VertexAttrib2svARB)GetAddress("glVertexAttrib2svARB", typeof(GL.Delegates.VertexAttrib2svARB)); + GL.VertexAttrib3dARB = (GL.Delegates.VertexAttrib3dARB)GetAddress("glVertexAttrib3dARB", typeof(GL.Delegates.VertexAttrib3dARB)); + GL.VertexAttrib3dvARB = (GL.Delegates.VertexAttrib3dvARB)GetAddress("glVertexAttrib3dvARB", typeof(GL.Delegates.VertexAttrib3dvARB)); + GL.VertexAttrib3fARB = (GL.Delegates.VertexAttrib3fARB)GetAddress("glVertexAttrib3fARB", typeof(GL.Delegates.VertexAttrib3fARB)); + GL.VertexAttrib3fvARB = (GL.Delegates.VertexAttrib3fvARB)GetAddress("glVertexAttrib3fvARB", typeof(GL.Delegates.VertexAttrib3fvARB)); + GL.VertexAttrib3sARB = (GL.Delegates.VertexAttrib3sARB)GetAddress("glVertexAttrib3sARB", typeof(GL.Delegates.VertexAttrib3sARB)); + GL.VertexAttrib3svARB = (GL.Delegates.VertexAttrib3svARB)GetAddress("glVertexAttrib3svARB", typeof(GL.Delegates.VertexAttrib3svARB)); + GL.VertexAttrib4NbvARB = (GL.Delegates.VertexAttrib4NbvARB)GetAddress("glVertexAttrib4NbvARB", typeof(GL.Delegates.VertexAttrib4NbvARB)); + GL.VertexAttrib4NivARB = (GL.Delegates.VertexAttrib4NivARB)GetAddress("glVertexAttrib4NivARB", typeof(GL.Delegates.VertexAttrib4NivARB)); + GL.VertexAttrib4NsvARB = (GL.Delegates.VertexAttrib4NsvARB)GetAddress("glVertexAttrib4NsvARB", typeof(GL.Delegates.VertexAttrib4NsvARB)); + GL.VertexAttrib4NubARB = (GL.Delegates.VertexAttrib4NubARB)GetAddress("glVertexAttrib4NubARB", typeof(GL.Delegates.VertexAttrib4NubARB)); + GL.VertexAttrib4NubvARB = (GL.Delegates.VertexAttrib4NubvARB)GetAddress("glVertexAttrib4NubvARB", typeof(GL.Delegates.VertexAttrib4NubvARB)); + GL.VertexAttrib4NuivARB = (GL.Delegates.VertexAttrib4NuivARB)GetAddress("glVertexAttrib4NuivARB", typeof(GL.Delegates.VertexAttrib4NuivARB)); + GL.VertexAttrib4NusvARB = (GL.Delegates.VertexAttrib4NusvARB)GetAddress("glVertexAttrib4NusvARB", typeof(GL.Delegates.VertexAttrib4NusvARB)); + GL.VertexAttrib4bvARB = (GL.Delegates.VertexAttrib4bvARB)GetAddress("glVertexAttrib4bvARB", typeof(GL.Delegates.VertexAttrib4bvARB)); + GL.VertexAttrib4dARB = (GL.Delegates.VertexAttrib4dARB)GetAddress("glVertexAttrib4dARB", typeof(GL.Delegates.VertexAttrib4dARB)); + GL.VertexAttrib4dvARB = (GL.Delegates.VertexAttrib4dvARB)GetAddress("glVertexAttrib4dvARB", typeof(GL.Delegates.VertexAttrib4dvARB)); + GL.VertexAttrib4fARB = (GL.Delegates.VertexAttrib4fARB)GetAddress("glVertexAttrib4fARB", typeof(GL.Delegates.VertexAttrib4fARB)); + GL.VertexAttrib4fvARB = (GL.Delegates.VertexAttrib4fvARB)GetAddress("glVertexAttrib4fvARB", typeof(GL.Delegates.VertexAttrib4fvARB)); + GL.VertexAttrib4ivARB = (GL.Delegates.VertexAttrib4ivARB)GetAddress("glVertexAttrib4ivARB", typeof(GL.Delegates.VertexAttrib4ivARB)); + GL.VertexAttrib4sARB = (GL.Delegates.VertexAttrib4sARB)GetAddress("glVertexAttrib4sARB", typeof(GL.Delegates.VertexAttrib4sARB)); + GL.VertexAttrib4svARB = (GL.Delegates.VertexAttrib4svARB)GetAddress("glVertexAttrib4svARB", typeof(GL.Delegates.VertexAttrib4svARB)); + GL.VertexAttrib4ubvARB = (GL.Delegates.VertexAttrib4ubvARB)GetAddress("glVertexAttrib4ubvARB", typeof(GL.Delegates.VertexAttrib4ubvARB)); + GL.VertexAttrib4uivARB = (GL.Delegates.VertexAttrib4uivARB)GetAddress("glVertexAttrib4uivARB", typeof(GL.Delegates.VertexAttrib4uivARB)); + GL.VertexAttrib4usvARB = (GL.Delegates.VertexAttrib4usvARB)GetAddress("glVertexAttrib4usvARB", typeof(GL.Delegates.VertexAttrib4usvARB)); + GL.VertexAttribPointerARB_ = (GL.Delegates.VertexAttribPointerARB_)GetAddress("glVertexAttribPointerARB", typeof(GL.Delegates.VertexAttribPointerARB_)); + GL.EnableVertexAttribArrayARB = (GL.Delegates.EnableVertexAttribArrayARB)GetAddress("glEnableVertexAttribArrayARB", typeof(GL.Delegates.EnableVertexAttribArrayARB)); + GL.DisableVertexAttribArrayARB = (GL.Delegates.DisableVertexAttribArrayARB)GetAddress("glDisableVertexAttribArrayARB", typeof(GL.Delegates.DisableVertexAttribArrayARB)); + GL.ProgramStringARB_ = (GL.Delegates.ProgramStringARB_)GetAddress("glProgramStringARB", typeof(GL.Delegates.ProgramStringARB_)); + GL.BindProgramARB = (GL.Delegates.BindProgramARB)GetAddress("glBindProgramARB", typeof(GL.Delegates.BindProgramARB)); + GL.DeleteProgramsARB = (GL.Delegates.DeleteProgramsARB)GetAddress("glDeleteProgramsARB", typeof(GL.Delegates.DeleteProgramsARB)); + GL.GenProgramsARB = (GL.Delegates.GenProgramsARB)GetAddress("glGenProgramsARB", typeof(GL.Delegates.GenProgramsARB)); + GL.ProgramEnvParameter4dARB = (GL.Delegates.ProgramEnvParameter4dARB)GetAddress("glProgramEnvParameter4dARB", typeof(GL.Delegates.ProgramEnvParameter4dARB)); + GL.ProgramEnvParameter4dvARB = (GL.Delegates.ProgramEnvParameter4dvARB)GetAddress("glProgramEnvParameter4dvARB", typeof(GL.Delegates.ProgramEnvParameter4dvARB)); + GL.ProgramEnvParameter4fARB = (GL.Delegates.ProgramEnvParameter4fARB)GetAddress("glProgramEnvParameter4fARB", typeof(GL.Delegates.ProgramEnvParameter4fARB)); + GL.ProgramEnvParameter4fvARB = (GL.Delegates.ProgramEnvParameter4fvARB)GetAddress("glProgramEnvParameter4fvARB", typeof(GL.Delegates.ProgramEnvParameter4fvARB)); + GL.ProgramLocalParameter4dARB = (GL.Delegates.ProgramLocalParameter4dARB)GetAddress("glProgramLocalParameter4dARB", typeof(GL.Delegates.ProgramLocalParameter4dARB)); + GL.ProgramLocalParameter4dvARB = (GL.Delegates.ProgramLocalParameter4dvARB)GetAddress("glProgramLocalParameter4dvARB", typeof(GL.Delegates.ProgramLocalParameter4dvARB)); + GL.ProgramLocalParameter4fARB = (GL.Delegates.ProgramLocalParameter4fARB)GetAddress("glProgramLocalParameter4fARB", typeof(GL.Delegates.ProgramLocalParameter4fARB)); + GL.ProgramLocalParameter4fvARB = (GL.Delegates.ProgramLocalParameter4fvARB)GetAddress("glProgramLocalParameter4fvARB", typeof(GL.Delegates.ProgramLocalParameter4fvARB)); + GL.GetProgramEnvParameterdvARB = (GL.Delegates.GetProgramEnvParameterdvARB)GetAddress("glGetProgramEnvParameterdvARB", typeof(GL.Delegates.GetProgramEnvParameterdvARB)); + GL.GetProgramEnvParameterfvARB = (GL.Delegates.GetProgramEnvParameterfvARB)GetAddress("glGetProgramEnvParameterfvARB", typeof(GL.Delegates.GetProgramEnvParameterfvARB)); + GL.GetProgramLocalParameterdvARB = (GL.Delegates.GetProgramLocalParameterdvARB)GetAddress("glGetProgramLocalParameterdvARB", typeof(GL.Delegates.GetProgramLocalParameterdvARB)); + GL.GetProgramLocalParameterfvARB = (GL.Delegates.GetProgramLocalParameterfvARB)GetAddress("glGetProgramLocalParameterfvARB", typeof(GL.Delegates.GetProgramLocalParameterfvARB)); + GL.GetProgramivARB = (GL.Delegates.GetProgramivARB)GetAddress("glGetProgramivARB", typeof(GL.Delegates.GetProgramivARB)); + GL.GetProgramStringARB_ = (GL.Delegates.GetProgramStringARB_)GetAddress("glGetProgramStringARB", typeof(GL.Delegates.GetProgramStringARB_)); + GL.GetVertexAttribdvARB = (GL.Delegates.GetVertexAttribdvARB)GetAddress("glGetVertexAttribdvARB", typeof(GL.Delegates.GetVertexAttribdvARB)); + GL.GetVertexAttribfvARB = (GL.Delegates.GetVertexAttribfvARB)GetAddress("glGetVertexAttribfvARB", typeof(GL.Delegates.GetVertexAttribfvARB)); + GL.GetVertexAttribivARB = (GL.Delegates.GetVertexAttribivARB)GetAddress("glGetVertexAttribivARB", typeof(GL.Delegates.GetVertexAttribivARB)); + GL.GetVertexAttribPointervARB = (GL.Delegates.GetVertexAttribPointervARB)GetAddress("glGetVertexAttribPointervARB", typeof(GL.Delegates.GetVertexAttribPointervARB)); + GL.IsProgramARB = (GL.Delegates.IsProgramARB)GetAddress("glIsProgramARB", typeof(GL.Delegates.IsProgramARB)); + GL.BindBufferARB = (GL.Delegates.BindBufferARB)GetAddress("glBindBufferARB", typeof(GL.Delegates.BindBufferARB)); + GL.DeleteBuffersARB = (GL.Delegates.DeleteBuffersARB)GetAddress("glDeleteBuffersARB", typeof(GL.Delegates.DeleteBuffersARB)); + GL.GenBuffersARB = (GL.Delegates.GenBuffersARB)GetAddress("glGenBuffersARB", typeof(GL.Delegates.GenBuffersARB)); + GL.IsBufferARB = (GL.Delegates.IsBufferARB)GetAddress("glIsBufferARB", typeof(GL.Delegates.IsBufferARB)); + GL.BufferDataARB_ = (GL.Delegates.BufferDataARB_)GetAddress("glBufferDataARB", typeof(GL.Delegates.BufferDataARB_)); + GL.BufferSubDataARB_ = (GL.Delegates.BufferSubDataARB_)GetAddress("glBufferSubDataARB", typeof(GL.Delegates.BufferSubDataARB_)); + GL.GetBufferSubDataARB_ = (GL.Delegates.GetBufferSubDataARB_)GetAddress("glGetBufferSubDataARB", typeof(GL.Delegates.GetBufferSubDataARB_)); + GL.MapBufferARB_ = (GL.Delegates.MapBufferARB_)GetAddress("glMapBufferARB", typeof(GL.Delegates.MapBufferARB_)); + GL.UnmapBufferARB = (GL.Delegates.UnmapBufferARB)GetAddress("glUnmapBufferARB", typeof(GL.Delegates.UnmapBufferARB)); + GL.GetBufferParameterivARB = (GL.Delegates.GetBufferParameterivARB)GetAddress("glGetBufferParameterivARB", typeof(GL.Delegates.GetBufferParameterivARB)); + GL.GetBufferPointervARB = (GL.Delegates.GetBufferPointervARB)GetAddress("glGetBufferPointervARB", typeof(GL.Delegates.GetBufferPointervARB)); + GL.GenQueriesARB = (GL.Delegates.GenQueriesARB)GetAddress("glGenQueriesARB", typeof(GL.Delegates.GenQueriesARB)); + GL.DeleteQueriesARB = (GL.Delegates.DeleteQueriesARB)GetAddress("glDeleteQueriesARB", typeof(GL.Delegates.DeleteQueriesARB)); + GL.IsQueryARB = (GL.Delegates.IsQueryARB)GetAddress("glIsQueryARB", typeof(GL.Delegates.IsQueryARB)); + GL.BeginQueryARB = (GL.Delegates.BeginQueryARB)GetAddress("glBeginQueryARB", typeof(GL.Delegates.BeginQueryARB)); + GL.EndQueryARB = (GL.Delegates.EndQueryARB)GetAddress("glEndQueryARB", typeof(GL.Delegates.EndQueryARB)); + GL.GetQueryivARB = (GL.Delegates.GetQueryivARB)GetAddress("glGetQueryivARB", typeof(GL.Delegates.GetQueryivARB)); + GL.GetQueryObjectivARB = (GL.Delegates.GetQueryObjectivARB)GetAddress("glGetQueryObjectivARB", typeof(GL.Delegates.GetQueryObjectivARB)); + GL.GetQueryObjectuivARB = (GL.Delegates.GetQueryObjectuivARB)GetAddress("glGetQueryObjectuivARB", typeof(GL.Delegates.GetQueryObjectuivARB)); + GL.DeleteObjectARB = (GL.Delegates.DeleteObjectARB)GetAddress("glDeleteObjectARB", typeof(GL.Delegates.DeleteObjectARB)); + GL.GetHandleARB = (GL.Delegates.GetHandleARB)GetAddress("glGetHandleARB", typeof(GL.Delegates.GetHandleARB)); + GL.DetachObjectARB = (GL.Delegates.DetachObjectARB)GetAddress("glDetachObjectARB", typeof(GL.Delegates.DetachObjectARB)); + GL.CreateShaderObjectARB = (GL.Delegates.CreateShaderObjectARB)GetAddress("glCreateShaderObjectARB", typeof(GL.Delegates.CreateShaderObjectARB)); + GL.ShaderSourceARB = (GL.Delegates.ShaderSourceARB)GetAddress("glShaderSourceARB", typeof(GL.Delegates.ShaderSourceARB)); + GL.CompileShaderARB = (GL.Delegates.CompileShaderARB)GetAddress("glCompileShaderARB", typeof(GL.Delegates.CompileShaderARB)); + GL.CreateProgramObjectARB = (GL.Delegates.CreateProgramObjectARB)GetAddress("glCreateProgramObjectARB", typeof(GL.Delegates.CreateProgramObjectARB)); + GL.AttachObjectARB = (GL.Delegates.AttachObjectARB)GetAddress("glAttachObjectARB", typeof(GL.Delegates.AttachObjectARB)); + GL.LinkProgramARB = (GL.Delegates.LinkProgramARB)GetAddress("glLinkProgramARB", typeof(GL.Delegates.LinkProgramARB)); + GL.UseProgramObjectARB = (GL.Delegates.UseProgramObjectARB)GetAddress("glUseProgramObjectARB", typeof(GL.Delegates.UseProgramObjectARB)); + GL.ValidateProgramARB = (GL.Delegates.ValidateProgramARB)GetAddress("glValidateProgramARB", typeof(GL.Delegates.ValidateProgramARB)); + GL.Uniform1fARB = (GL.Delegates.Uniform1fARB)GetAddress("glUniform1fARB", typeof(GL.Delegates.Uniform1fARB)); + GL.Uniform2fARB = (GL.Delegates.Uniform2fARB)GetAddress("glUniform2fARB", typeof(GL.Delegates.Uniform2fARB)); + GL.Uniform3fARB = (GL.Delegates.Uniform3fARB)GetAddress("glUniform3fARB", typeof(GL.Delegates.Uniform3fARB)); + GL.Uniform4fARB = (GL.Delegates.Uniform4fARB)GetAddress("glUniform4fARB", typeof(GL.Delegates.Uniform4fARB)); + GL.Uniform1iARB = (GL.Delegates.Uniform1iARB)GetAddress("glUniform1iARB", typeof(GL.Delegates.Uniform1iARB)); + GL.Uniform2iARB = (GL.Delegates.Uniform2iARB)GetAddress("glUniform2iARB", typeof(GL.Delegates.Uniform2iARB)); + GL.Uniform3iARB = (GL.Delegates.Uniform3iARB)GetAddress("glUniform3iARB", typeof(GL.Delegates.Uniform3iARB)); + GL.Uniform4iARB = (GL.Delegates.Uniform4iARB)GetAddress("glUniform4iARB", typeof(GL.Delegates.Uniform4iARB)); + GL.Uniform1fvARB = (GL.Delegates.Uniform1fvARB)GetAddress("glUniform1fvARB", typeof(GL.Delegates.Uniform1fvARB)); + GL.Uniform2fvARB = (GL.Delegates.Uniform2fvARB)GetAddress("glUniform2fvARB", typeof(GL.Delegates.Uniform2fvARB)); + GL.Uniform3fvARB = (GL.Delegates.Uniform3fvARB)GetAddress("glUniform3fvARB", typeof(GL.Delegates.Uniform3fvARB)); + GL.Uniform4fvARB = (GL.Delegates.Uniform4fvARB)GetAddress("glUniform4fvARB", typeof(GL.Delegates.Uniform4fvARB)); + GL.Uniform1ivARB = (GL.Delegates.Uniform1ivARB)GetAddress("glUniform1ivARB", typeof(GL.Delegates.Uniform1ivARB)); + GL.Uniform2ivARB = (GL.Delegates.Uniform2ivARB)GetAddress("glUniform2ivARB", typeof(GL.Delegates.Uniform2ivARB)); + GL.Uniform3ivARB = (GL.Delegates.Uniform3ivARB)GetAddress("glUniform3ivARB", typeof(GL.Delegates.Uniform3ivARB)); + GL.Uniform4ivARB = (GL.Delegates.Uniform4ivARB)GetAddress("glUniform4ivARB", typeof(GL.Delegates.Uniform4ivARB)); + GL.UniformMatrix2fvARB = (GL.Delegates.UniformMatrix2fvARB)GetAddress("glUniformMatrix2fvARB", typeof(GL.Delegates.UniformMatrix2fvARB)); + GL.UniformMatrix3fvARB = (GL.Delegates.UniformMatrix3fvARB)GetAddress("glUniformMatrix3fvARB", typeof(GL.Delegates.UniformMatrix3fvARB)); + GL.UniformMatrix4fvARB = (GL.Delegates.UniformMatrix4fvARB)GetAddress("glUniformMatrix4fvARB", typeof(GL.Delegates.UniformMatrix4fvARB)); + GL.GetObjectParameterfvARB = (GL.Delegates.GetObjectParameterfvARB)GetAddress("glGetObjectParameterfvARB", typeof(GL.Delegates.GetObjectParameterfvARB)); + GL.GetObjectParameterivARB = (GL.Delegates.GetObjectParameterivARB)GetAddress("glGetObjectParameterivARB", typeof(GL.Delegates.GetObjectParameterivARB)); + GL.GetInfoLogARB = (GL.Delegates.GetInfoLogARB)GetAddress("glGetInfoLogARB", typeof(GL.Delegates.GetInfoLogARB)); + GL.GetAttachedObjectsARB = (GL.Delegates.GetAttachedObjectsARB)GetAddress("glGetAttachedObjectsARB", typeof(GL.Delegates.GetAttachedObjectsARB)); + GL.GetUniformLocationARB = (GL.Delegates.GetUniformLocationARB)GetAddress("glGetUniformLocationARB", typeof(GL.Delegates.GetUniformLocationARB)); + GL.GetActiveUniformARB = (GL.Delegates.GetActiveUniformARB)GetAddress("glGetActiveUniformARB", typeof(GL.Delegates.GetActiveUniformARB)); + GL.GetUniformfvARB = (GL.Delegates.GetUniformfvARB)GetAddress("glGetUniformfvARB", typeof(GL.Delegates.GetUniformfvARB)); + GL.GetUniformivARB = (GL.Delegates.GetUniformivARB)GetAddress("glGetUniformivARB", typeof(GL.Delegates.GetUniformivARB)); + GL.GetShaderSourceARB = (GL.Delegates.GetShaderSourceARB)GetAddress("glGetShaderSourceARB", typeof(GL.Delegates.GetShaderSourceARB)); + GL.BindAttribLocationARB = (GL.Delegates.BindAttribLocationARB)GetAddress("glBindAttribLocationARB", typeof(GL.Delegates.BindAttribLocationARB)); + GL.GetActiveAttribARB = (GL.Delegates.GetActiveAttribARB)GetAddress("glGetActiveAttribARB", typeof(GL.Delegates.GetActiveAttribARB)); + GL.GetAttribLocationARB = (GL.Delegates.GetAttribLocationARB)GetAddress("glGetAttribLocationARB", typeof(GL.Delegates.GetAttribLocationARB)); + GL.DrawBuffersARB = (GL.Delegates.DrawBuffersARB)GetAddress("glDrawBuffersARB", typeof(GL.Delegates.DrawBuffersARB)); + GL.ClampColorARB = (GL.Delegates.ClampColorARB)GetAddress("glClampColorARB", typeof(GL.Delegates.ClampColorARB)); + GL.BlendColorEXT = (GL.Delegates.BlendColorEXT)GetAddress("glBlendColorEXT", typeof(GL.Delegates.BlendColorEXT)); + GL.PolygonOffsetEXT = (GL.Delegates.PolygonOffsetEXT)GetAddress("glPolygonOffsetEXT", typeof(GL.Delegates.PolygonOffsetEXT)); + GL.TexImage3DEXT = (GL.Delegates.TexImage3DEXT)GetAddress("glTexImage3DEXT", typeof(GL.Delegates.TexImage3DEXT)); + GL.TexSubImage3DEXT = (GL.Delegates.TexSubImage3DEXT)GetAddress("glTexSubImage3DEXT", typeof(GL.Delegates.TexSubImage3DEXT)); + GL.GetTexFilterFuncSGIS = (GL.Delegates.GetTexFilterFuncSGIS)GetAddress("glGetTexFilterFuncSGIS", typeof(GL.Delegates.GetTexFilterFuncSGIS)); + GL.TexFilterFuncSGIS = (GL.Delegates.TexFilterFuncSGIS)GetAddress("glTexFilterFuncSGIS", typeof(GL.Delegates.TexFilterFuncSGIS)); + GL.TexSubImage1DEXT = (GL.Delegates.TexSubImage1DEXT)GetAddress("glTexSubImage1DEXT", typeof(GL.Delegates.TexSubImage1DEXT)); + GL.TexSubImage2DEXT = (GL.Delegates.TexSubImage2DEXT)GetAddress("glTexSubImage2DEXT", typeof(GL.Delegates.TexSubImage2DEXT)); + GL.CopyTexImage1DEXT = (GL.Delegates.CopyTexImage1DEXT)GetAddress("glCopyTexImage1DEXT", typeof(GL.Delegates.CopyTexImage1DEXT)); + GL.CopyTexImage2DEXT = (GL.Delegates.CopyTexImage2DEXT)GetAddress("glCopyTexImage2DEXT", typeof(GL.Delegates.CopyTexImage2DEXT)); + GL.CopyTexSubImage1DEXT = (GL.Delegates.CopyTexSubImage1DEXT)GetAddress("glCopyTexSubImage1DEXT", typeof(GL.Delegates.CopyTexSubImage1DEXT)); + GL.CopyTexSubImage2DEXT = (GL.Delegates.CopyTexSubImage2DEXT)GetAddress("glCopyTexSubImage2DEXT", typeof(GL.Delegates.CopyTexSubImage2DEXT)); + GL.CopyTexSubImage3DEXT = (GL.Delegates.CopyTexSubImage3DEXT)GetAddress("glCopyTexSubImage3DEXT", typeof(GL.Delegates.CopyTexSubImage3DEXT)); + GL.GetHistogramEXT_ = (GL.Delegates.GetHistogramEXT_)GetAddress("glGetHistogramEXT", typeof(GL.Delegates.GetHistogramEXT_)); + GL.GetHistogramParameterfvEXT = (GL.Delegates.GetHistogramParameterfvEXT)GetAddress("glGetHistogramParameterfvEXT", typeof(GL.Delegates.GetHistogramParameterfvEXT)); + GL.GetHistogramParameterivEXT = (GL.Delegates.GetHistogramParameterivEXT)GetAddress("glGetHistogramParameterivEXT", typeof(GL.Delegates.GetHistogramParameterivEXT)); + GL.GetMinmaxEXT_ = (GL.Delegates.GetMinmaxEXT_)GetAddress("glGetMinmaxEXT", typeof(GL.Delegates.GetMinmaxEXT_)); + GL.GetMinmaxParameterfvEXT = (GL.Delegates.GetMinmaxParameterfvEXT)GetAddress("glGetMinmaxParameterfvEXT", typeof(GL.Delegates.GetMinmaxParameterfvEXT)); + GL.GetMinmaxParameterivEXT = (GL.Delegates.GetMinmaxParameterivEXT)GetAddress("glGetMinmaxParameterivEXT", typeof(GL.Delegates.GetMinmaxParameterivEXT)); + GL.HistogramEXT = (GL.Delegates.HistogramEXT)GetAddress("glHistogramEXT", typeof(GL.Delegates.HistogramEXT)); + GL.MinmaxEXT = (GL.Delegates.MinmaxEXT)GetAddress("glMinmaxEXT", typeof(GL.Delegates.MinmaxEXT)); + GL.ResetHistogramEXT = (GL.Delegates.ResetHistogramEXT)GetAddress("glResetHistogramEXT", typeof(GL.Delegates.ResetHistogramEXT)); + GL.ResetMinmaxEXT = (GL.Delegates.ResetMinmaxEXT)GetAddress("glResetMinmaxEXT", typeof(GL.Delegates.ResetMinmaxEXT)); + GL.ConvolutionFilter1DEXT_ = (GL.Delegates.ConvolutionFilter1DEXT_)GetAddress("glConvolutionFilter1DEXT", typeof(GL.Delegates.ConvolutionFilter1DEXT_)); + GL.ConvolutionFilter2DEXT_ = (GL.Delegates.ConvolutionFilter2DEXT_)GetAddress("glConvolutionFilter2DEXT", typeof(GL.Delegates.ConvolutionFilter2DEXT_)); + GL.ConvolutionParameterfEXT = (GL.Delegates.ConvolutionParameterfEXT)GetAddress("glConvolutionParameterfEXT", typeof(GL.Delegates.ConvolutionParameterfEXT)); + GL.ConvolutionParameterfvEXT = (GL.Delegates.ConvolutionParameterfvEXT)GetAddress("glConvolutionParameterfvEXT", typeof(GL.Delegates.ConvolutionParameterfvEXT)); + GL.ConvolutionParameteriEXT = (GL.Delegates.ConvolutionParameteriEXT)GetAddress("glConvolutionParameteriEXT", typeof(GL.Delegates.ConvolutionParameteriEXT)); + GL.ConvolutionParameterivEXT = (GL.Delegates.ConvolutionParameterivEXT)GetAddress("glConvolutionParameterivEXT", typeof(GL.Delegates.ConvolutionParameterivEXT)); + GL.CopyConvolutionFilter1DEXT = (GL.Delegates.CopyConvolutionFilter1DEXT)GetAddress("glCopyConvolutionFilter1DEXT", typeof(GL.Delegates.CopyConvolutionFilter1DEXT)); + GL.CopyConvolutionFilter2DEXT = (GL.Delegates.CopyConvolutionFilter2DEXT)GetAddress("glCopyConvolutionFilter2DEXT", typeof(GL.Delegates.CopyConvolutionFilter2DEXT)); + GL.GetConvolutionFilterEXT_ = (GL.Delegates.GetConvolutionFilterEXT_)GetAddress("glGetConvolutionFilterEXT", typeof(GL.Delegates.GetConvolutionFilterEXT_)); + GL.GetConvolutionParameterfvEXT = (GL.Delegates.GetConvolutionParameterfvEXT)GetAddress("glGetConvolutionParameterfvEXT", typeof(GL.Delegates.GetConvolutionParameterfvEXT)); + GL.GetConvolutionParameterivEXT = (GL.Delegates.GetConvolutionParameterivEXT)GetAddress("glGetConvolutionParameterivEXT", typeof(GL.Delegates.GetConvolutionParameterivEXT)); + GL.GetSeparableFilterEXT_ = (GL.Delegates.GetSeparableFilterEXT_)GetAddress("glGetSeparableFilterEXT", typeof(GL.Delegates.GetSeparableFilterEXT_)); + GL.SeparableFilter2DEXT_ = (GL.Delegates.SeparableFilter2DEXT_)GetAddress("glSeparableFilter2DEXT", typeof(GL.Delegates.SeparableFilter2DEXT_)); + GL.ColorTableSGI_ = (GL.Delegates.ColorTableSGI_)GetAddress("glColorTableSGI", typeof(GL.Delegates.ColorTableSGI_)); + GL.ColorTableParameterfvSGI = (GL.Delegates.ColorTableParameterfvSGI)GetAddress("glColorTableParameterfvSGI", typeof(GL.Delegates.ColorTableParameterfvSGI)); + GL.ColorTableParameterivSGI = (GL.Delegates.ColorTableParameterivSGI)GetAddress("glColorTableParameterivSGI", typeof(GL.Delegates.ColorTableParameterivSGI)); + GL.CopyColorTableSGI = (GL.Delegates.CopyColorTableSGI)GetAddress("glCopyColorTableSGI", typeof(GL.Delegates.CopyColorTableSGI)); + GL.GetColorTableSGI_ = (GL.Delegates.GetColorTableSGI_)GetAddress("glGetColorTableSGI", typeof(GL.Delegates.GetColorTableSGI_)); + GL.GetColorTableParameterfvSGI = (GL.Delegates.GetColorTableParameterfvSGI)GetAddress("glGetColorTableParameterfvSGI", typeof(GL.Delegates.GetColorTableParameterfvSGI)); + GL.GetColorTableParameterivSGI = (GL.Delegates.GetColorTableParameterivSGI)GetAddress("glGetColorTableParameterivSGI", typeof(GL.Delegates.GetColorTableParameterivSGI)); + GL.PixelTexGenSGIX = (GL.Delegates.PixelTexGenSGIX)GetAddress("glPixelTexGenSGIX", typeof(GL.Delegates.PixelTexGenSGIX)); + GL.PixelTexGenParameteriSGIS = (GL.Delegates.PixelTexGenParameteriSGIS)GetAddress("glPixelTexGenParameteriSGIS", typeof(GL.Delegates.PixelTexGenParameteriSGIS)); + GL.PixelTexGenParameterivSGIS = (GL.Delegates.PixelTexGenParameterivSGIS)GetAddress("glPixelTexGenParameterivSGIS", typeof(GL.Delegates.PixelTexGenParameterivSGIS)); + GL.PixelTexGenParameterfSGIS = (GL.Delegates.PixelTexGenParameterfSGIS)GetAddress("glPixelTexGenParameterfSGIS", typeof(GL.Delegates.PixelTexGenParameterfSGIS)); + GL.PixelTexGenParameterfvSGIS = (GL.Delegates.PixelTexGenParameterfvSGIS)GetAddress("glPixelTexGenParameterfvSGIS", typeof(GL.Delegates.PixelTexGenParameterfvSGIS)); + GL.GetPixelTexGenParameterivSGIS = (GL.Delegates.GetPixelTexGenParameterivSGIS)GetAddress("glGetPixelTexGenParameterivSGIS", typeof(GL.Delegates.GetPixelTexGenParameterivSGIS)); + GL.GetPixelTexGenParameterfvSGIS = (GL.Delegates.GetPixelTexGenParameterfvSGIS)GetAddress("glGetPixelTexGenParameterfvSGIS", typeof(GL.Delegates.GetPixelTexGenParameterfvSGIS)); + GL.TexImage4DSGIS = (GL.Delegates.TexImage4DSGIS)GetAddress("glTexImage4DSGIS", typeof(GL.Delegates.TexImage4DSGIS)); + GL.TexSubImage4DSGIS = (GL.Delegates.TexSubImage4DSGIS)GetAddress("glTexSubImage4DSGIS", typeof(GL.Delegates.TexSubImage4DSGIS)); + GL.AreTexturesResidentEXT = (GL.Delegates.AreTexturesResidentEXT)GetAddress("glAreTexturesResidentEXT", typeof(GL.Delegates.AreTexturesResidentEXT)); + GL.BindTextureEXT = (GL.Delegates.BindTextureEXT)GetAddress("glBindTextureEXT", typeof(GL.Delegates.BindTextureEXT)); + GL.DeleteTexturesEXT = (GL.Delegates.DeleteTexturesEXT)GetAddress("glDeleteTexturesEXT", typeof(GL.Delegates.DeleteTexturesEXT)); + GL.GenTexturesEXT = (GL.Delegates.GenTexturesEXT)GetAddress("glGenTexturesEXT", typeof(GL.Delegates.GenTexturesEXT)); + GL.IsTextureEXT = (GL.Delegates.IsTextureEXT)GetAddress("glIsTextureEXT", typeof(GL.Delegates.IsTextureEXT)); + GL.PrioritizeTexturesEXT = (GL.Delegates.PrioritizeTexturesEXT)GetAddress("glPrioritizeTexturesEXT", typeof(GL.Delegates.PrioritizeTexturesEXT)); + GL.DetailTexFuncSGIS = (GL.Delegates.DetailTexFuncSGIS)GetAddress("glDetailTexFuncSGIS", typeof(GL.Delegates.DetailTexFuncSGIS)); + GL.GetDetailTexFuncSGIS = (GL.Delegates.GetDetailTexFuncSGIS)GetAddress("glGetDetailTexFuncSGIS", typeof(GL.Delegates.GetDetailTexFuncSGIS)); + GL.SharpenTexFuncSGIS = (GL.Delegates.SharpenTexFuncSGIS)GetAddress("glSharpenTexFuncSGIS", typeof(GL.Delegates.SharpenTexFuncSGIS)); + GL.GetSharpenTexFuncSGIS = (GL.Delegates.GetSharpenTexFuncSGIS)GetAddress("glGetSharpenTexFuncSGIS", typeof(GL.Delegates.GetSharpenTexFuncSGIS)); + GL.SampleMaskSGIS = (GL.Delegates.SampleMaskSGIS)GetAddress("glSampleMaskSGIS", typeof(GL.Delegates.SampleMaskSGIS)); + GL.SamplePatternSGIS = (GL.Delegates.SamplePatternSGIS)GetAddress("glSamplePatternSGIS", typeof(GL.Delegates.SamplePatternSGIS)); + GL.ArrayElementEXT = (GL.Delegates.ArrayElementEXT)GetAddress("glArrayElementEXT", typeof(GL.Delegates.ArrayElementEXT)); + GL.ColorPointerEXT_ = (GL.Delegates.ColorPointerEXT_)GetAddress("glColorPointerEXT", typeof(GL.Delegates.ColorPointerEXT_)); + GL.DrawArraysEXT = (GL.Delegates.DrawArraysEXT)GetAddress("glDrawArraysEXT", typeof(GL.Delegates.DrawArraysEXT)); + GL.EdgeFlagPointerEXT = (GL.Delegates.EdgeFlagPointerEXT)GetAddress("glEdgeFlagPointerEXT", typeof(GL.Delegates.EdgeFlagPointerEXT)); + GL.GetPointervEXT = (GL.Delegates.GetPointervEXT)GetAddress("glGetPointervEXT", typeof(GL.Delegates.GetPointervEXT)); + GL.IndexPointerEXT_ = (GL.Delegates.IndexPointerEXT_)GetAddress("glIndexPointerEXT", typeof(GL.Delegates.IndexPointerEXT_)); + GL.NormalPointerEXT_ = (GL.Delegates.NormalPointerEXT_)GetAddress("glNormalPointerEXT", typeof(GL.Delegates.NormalPointerEXT_)); + GL.TexCoordPointerEXT_ = (GL.Delegates.TexCoordPointerEXT_)GetAddress("glTexCoordPointerEXT", typeof(GL.Delegates.TexCoordPointerEXT_)); + GL.VertexPointerEXT_ = (GL.Delegates.VertexPointerEXT_)GetAddress("glVertexPointerEXT", typeof(GL.Delegates.VertexPointerEXT_)); + GL.BlendEquationEXT = (GL.Delegates.BlendEquationEXT)GetAddress("glBlendEquationEXT", typeof(GL.Delegates.BlendEquationEXT)); + GL.SpriteParameterfSGIX = (GL.Delegates.SpriteParameterfSGIX)GetAddress("glSpriteParameterfSGIX", typeof(GL.Delegates.SpriteParameterfSGIX)); + GL.SpriteParameterfvSGIX = (GL.Delegates.SpriteParameterfvSGIX)GetAddress("glSpriteParameterfvSGIX", typeof(GL.Delegates.SpriteParameterfvSGIX)); + GL.SpriteParameteriSGIX = (GL.Delegates.SpriteParameteriSGIX)GetAddress("glSpriteParameteriSGIX", typeof(GL.Delegates.SpriteParameteriSGIX)); + GL.SpriteParameterivSGIX = (GL.Delegates.SpriteParameterivSGIX)GetAddress("glSpriteParameterivSGIX", typeof(GL.Delegates.SpriteParameterivSGIX)); + GL.PointParameterfEXT = (GL.Delegates.PointParameterfEXT)GetAddress("glPointParameterfEXT", typeof(GL.Delegates.PointParameterfEXT)); + GL.PointParameterfvEXT = (GL.Delegates.PointParameterfvEXT)GetAddress("glPointParameterfvEXT", typeof(GL.Delegates.PointParameterfvEXT)); + GL.PointParameterfSGIS = (GL.Delegates.PointParameterfSGIS)GetAddress("glPointParameterfSGIS", typeof(GL.Delegates.PointParameterfSGIS)); + GL.PointParameterfvSGIS = (GL.Delegates.PointParameterfvSGIS)GetAddress("glPointParameterfvSGIS", typeof(GL.Delegates.PointParameterfvSGIS)); + GL.GetInstrumentsSGIX = (GL.Delegates.GetInstrumentsSGIX)GetAddress("glGetInstrumentsSGIX", typeof(GL.Delegates.GetInstrumentsSGIX)); + GL.InstrumentsBufferSGIX = (GL.Delegates.InstrumentsBufferSGIX)GetAddress("glInstrumentsBufferSGIX", typeof(GL.Delegates.InstrumentsBufferSGIX)); + GL.PollInstrumentsSGIX = (GL.Delegates.PollInstrumentsSGIX)GetAddress("glPollInstrumentsSGIX", typeof(GL.Delegates.PollInstrumentsSGIX)); + GL.ReadInstrumentsSGIX = (GL.Delegates.ReadInstrumentsSGIX)GetAddress("glReadInstrumentsSGIX", typeof(GL.Delegates.ReadInstrumentsSGIX)); + GL.StartInstrumentsSGIX = (GL.Delegates.StartInstrumentsSGIX)GetAddress("glStartInstrumentsSGIX", typeof(GL.Delegates.StartInstrumentsSGIX)); + GL.StopInstrumentsSGIX = (GL.Delegates.StopInstrumentsSGIX)GetAddress("glStopInstrumentsSGIX", typeof(GL.Delegates.StopInstrumentsSGIX)); + GL.FrameZoomSGIX = (GL.Delegates.FrameZoomSGIX)GetAddress("glFrameZoomSGIX", typeof(GL.Delegates.FrameZoomSGIX)); + GL.TagSampleBufferSGIX = (GL.Delegates.TagSampleBufferSGIX)GetAddress("glTagSampleBufferSGIX", typeof(GL.Delegates.TagSampleBufferSGIX)); + GL.DeformationMap3dSGIX = (GL.Delegates.DeformationMap3dSGIX)GetAddress("glDeformationMap3dSGIX", typeof(GL.Delegates.DeformationMap3dSGIX)); + GL.DeformationMap3fSGIX = (GL.Delegates.DeformationMap3fSGIX)GetAddress("glDeformationMap3fSGIX", typeof(GL.Delegates.DeformationMap3fSGIX)); + GL.DeformSGIX = (GL.Delegates.DeformSGIX)GetAddress("glDeformSGIX", typeof(GL.Delegates.DeformSGIX)); + GL.LoadIdentityDeformationMapSGIX = (GL.Delegates.LoadIdentityDeformationMapSGIX)GetAddress("glLoadIdentityDeformationMapSGIX", typeof(GL.Delegates.LoadIdentityDeformationMapSGIX)); + GL.ReferencePlaneSGIX = (GL.Delegates.ReferencePlaneSGIX)GetAddress("glReferencePlaneSGIX", typeof(GL.Delegates.ReferencePlaneSGIX)); + GL.FlushRasterSGIX = (GL.Delegates.FlushRasterSGIX)GetAddress("glFlushRasterSGIX", typeof(GL.Delegates.FlushRasterSGIX)); + GL.FogFuncSGIS = (GL.Delegates.FogFuncSGIS)GetAddress("glFogFuncSGIS", typeof(GL.Delegates.FogFuncSGIS)); + GL.GetFogFuncSGIS = (GL.Delegates.GetFogFuncSGIS)GetAddress("glGetFogFuncSGIS", typeof(GL.Delegates.GetFogFuncSGIS)); + GL.ImageTransformParameteriHP = (GL.Delegates.ImageTransformParameteriHP)GetAddress("glImageTransformParameteriHP", typeof(GL.Delegates.ImageTransformParameteriHP)); + GL.ImageTransformParameterfHP = (GL.Delegates.ImageTransformParameterfHP)GetAddress("glImageTransformParameterfHP", typeof(GL.Delegates.ImageTransformParameterfHP)); + GL.ImageTransformParameterivHP = (GL.Delegates.ImageTransformParameterivHP)GetAddress("glImageTransformParameterivHP", typeof(GL.Delegates.ImageTransformParameterivHP)); + GL.ImageTransformParameterfvHP = (GL.Delegates.ImageTransformParameterfvHP)GetAddress("glImageTransformParameterfvHP", typeof(GL.Delegates.ImageTransformParameterfvHP)); + GL.GetImageTransformParameterivHP = (GL.Delegates.GetImageTransformParameterivHP)GetAddress("glGetImageTransformParameterivHP", typeof(GL.Delegates.GetImageTransformParameterivHP)); + GL.GetImageTransformParameterfvHP = (GL.Delegates.GetImageTransformParameterfvHP)GetAddress("glGetImageTransformParameterfvHP", typeof(GL.Delegates.GetImageTransformParameterfvHP)); + GL.ColorSubTableEXT_ = (GL.Delegates.ColorSubTableEXT_)GetAddress("glColorSubTableEXT", typeof(GL.Delegates.ColorSubTableEXT_)); + GL.CopyColorSubTableEXT = (GL.Delegates.CopyColorSubTableEXT)GetAddress("glCopyColorSubTableEXT", typeof(GL.Delegates.CopyColorSubTableEXT)); + GL.HintPGI = (GL.Delegates.HintPGI)GetAddress("glHintPGI", typeof(GL.Delegates.HintPGI)); + GL.ColorTableEXT_ = (GL.Delegates.ColorTableEXT_)GetAddress("glColorTableEXT", typeof(GL.Delegates.ColorTableEXT_)); + GL.GetColorTableEXT_ = (GL.Delegates.GetColorTableEXT_)GetAddress("glGetColorTableEXT", typeof(GL.Delegates.GetColorTableEXT_)); + GL.GetColorTableParameterivEXT = (GL.Delegates.GetColorTableParameterivEXT)GetAddress("glGetColorTableParameterivEXT", typeof(GL.Delegates.GetColorTableParameterivEXT)); + GL.GetColorTableParameterfvEXT = (GL.Delegates.GetColorTableParameterfvEXT)GetAddress("glGetColorTableParameterfvEXT", typeof(GL.Delegates.GetColorTableParameterfvEXT)); + GL.GetListParameterfvSGIX = (GL.Delegates.GetListParameterfvSGIX)GetAddress("glGetListParameterfvSGIX", typeof(GL.Delegates.GetListParameterfvSGIX)); + GL.GetListParameterivSGIX = (GL.Delegates.GetListParameterivSGIX)GetAddress("glGetListParameterivSGIX", typeof(GL.Delegates.GetListParameterivSGIX)); + GL.ListParameterfSGIX = (GL.Delegates.ListParameterfSGIX)GetAddress("glListParameterfSGIX", typeof(GL.Delegates.ListParameterfSGIX)); + GL.ListParameterfvSGIX = (GL.Delegates.ListParameterfvSGIX)GetAddress("glListParameterfvSGIX", typeof(GL.Delegates.ListParameterfvSGIX)); + GL.ListParameteriSGIX = (GL.Delegates.ListParameteriSGIX)GetAddress("glListParameteriSGIX", typeof(GL.Delegates.ListParameteriSGIX)); + GL.ListParameterivSGIX = (GL.Delegates.ListParameterivSGIX)GetAddress("glListParameterivSGIX", typeof(GL.Delegates.ListParameterivSGIX)); + GL.IndexMaterialEXT = (GL.Delegates.IndexMaterialEXT)GetAddress("glIndexMaterialEXT", typeof(GL.Delegates.IndexMaterialEXT)); + GL.IndexFuncEXT = (GL.Delegates.IndexFuncEXT)GetAddress("glIndexFuncEXT", typeof(GL.Delegates.IndexFuncEXT)); + GL.LockArraysEXT = (GL.Delegates.LockArraysEXT)GetAddress("glLockArraysEXT", typeof(GL.Delegates.LockArraysEXT)); + GL.UnlockArraysEXT = (GL.Delegates.UnlockArraysEXT)GetAddress("glUnlockArraysEXT", typeof(GL.Delegates.UnlockArraysEXT)); + GL.CullParameterdvEXT = (GL.Delegates.CullParameterdvEXT)GetAddress("glCullParameterdvEXT", typeof(GL.Delegates.CullParameterdvEXT)); + GL.CullParameterfvEXT = (GL.Delegates.CullParameterfvEXT)GetAddress("glCullParameterfvEXT", typeof(GL.Delegates.CullParameterfvEXT)); + GL.FragmentColorMaterialSGIX = (GL.Delegates.FragmentColorMaterialSGIX)GetAddress("glFragmentColorMaterialSGIX", typeof(GL.Delegates.FragmentColorMaterialSGIX)); + GL.FragmentLightfSGIX = (GL.Delegates.FragmentLightfSGIX)GetAddress("glFragmentLightfSGIX", typeof(GL.Delegates.FragmentLightfSGIX)); + GL.FragmentLightfvSGIX = (GL.Delegates.FragmentLightfvSGIX)GetAddress("glFragmentLightfvSGIX", typeof(GL.Delegates.FragmentLightfvSGIX)); + GL.FragmentLightiSGIX = (GL.Delegates.FragmentLightiSGIX)GetAddress("glFragmentLightiSGIX", typeof(GL.Delegates.FragmentLightiSGIX)); + GL.FragmentLightivSGIX = (GL.Delegates.FragmentLightivSGIX)GetAddress("glFragmentLightivSGIX", typeof(GL.Delegates.FragmentLightivSGIX)); + GL.FragmentLightModelfSGIX = (GL.Delegates.FragmentLightModelfSGIX)GetAddress("glFragmentLightModelfSGIX", typeof(GL.Delegates.FragmentLightModelfSGIX)); + GL.FragmentLightModelfvSGIX = (GL.Delegates.FragmentLightModelfvSGIX)GetAddress("glFragmentLightModelfvSGIX", typeof(GL.Delegates.FragmentLightModelfvSGIX)); + GL.FragmentLightModeliSGIX = (GL.Delegates.FragmentLightModeliSGIX)GetAddress("glFragmentLightModeliSGIX", typeof(GL.Delegates.FragmentLightModeliSGIX)); + GL.FragmentLightModelivSGIX = (GL.Delegates.FragmentLightModelivSGIX)GetAddress("glFragmentLightModelivSGIX", typeof(GL.Delegates.FragmentLightModelivSGIX)); + GL.FragmentMaterialfSGIX = (GL.Delegates.FragmentMaterialfSGIX)GetAddress("glFragmentMaterialfSGIX", typeof(GL.Delegates.FragmentMaterialfSGIX)); + GL.FragmentMaterialfvSGIX = (GL.Delegates.FragmentMaterialfvSGIX)GetAddress("glFragmentMaterialfvSGIX", typeof(GL.Delegates.FragmentMaterialfvSGIX)); + GL.FragmentMaterialiSGIX = (GL.Delegates.FragmentMaterialiSGIX)GetAddress("glFragmentMaterialiSGIX", typeof(GL.Delegates.FragmentMaterialiSGIX)); + GL.FragmentMaterialivSGIX = (GL.Delegates.FragmentMaterialivSGIX)GetAddress("glFragmentMaterialivSGIX", typeof(GL.Delegates.FragmentMaterialivSGIX)); + GL.GetFragmentLightfvSGIX = (GL.Delegates.GetFragmentLightfvSGIX)GetAddress("glGetFragmentLightfvSGIX", typeof(GL.Delegates.GetFragmentLightfvSGIX)); + GL.GetFragmentLightivSGIX = (GL.Delegates.GetFragmentLightivSGIX)GetAddress("glGetFragmentLightivSGIX", typeof(GL.Delegates.GetFragmentLightivSGIX)); + GL.GetFragmentMaterialfvSGIX = (GL.Delegates.GetFragmentMaterialfvSGIX)GetAddress("glGetFragmentMaterialfvSGIX", typeof(GL.Delegates.GetFragmentMaterialfvSGIX)); + GL.GetFragmentMaterialivSGIX = (GL.Delegates.GetFragmentMaterialivSGIX)GetAddress("glGetFragmentMaterialivSGIX", typeof(GL.Delegates.GetFragmentMaterialivSGIX)); + GL.LightEnviSGIX = (GL.Delegates.LightEnviSGIX)GetAddress("glLightEnviSGIX", typeof(GL.Delegates.LightEnviSGIX)); + GL.DrawRangeElementsEXT_ = (GL.Delegates.DrawRangeElementsEXT_)GetAddress("glDrawRangeElementsEXT", typeof(GL.Delegates.DrawRangeElementsEXT_)); + GL.ApplyTextureEXT = (GL.Delegates.ApplyTextureEXT)GetAddress("glApplyTextureEXT", typeof(GL.Delegates.ApplyTextureEXT)); + GL.TextureLightEXT = (GL.Delegates.TextureLightEXT)GetAddress("glTextureLightEXT", typeof(GL.Delegates.TextureLightEXT)); + GL.TextureMaterialEXT = (GL.Delegates.TextureMaterialEXT)GetAddress("glTextureMaterialEXT", typeof(GL.Delegates.TextureMaterialEXT)); + GL.AsyncMarkerSGIX = (GL.Delegates.AsyncMarkerSGIX)GetAddress("glAsyncMarkerSGIX", typeof(GL.Delegates.AsyncMarkerSGIX)); + GL.FinishAsyncSGIX = (GL.Delegates.FinishAsyncSGIX)GetAddress("glFinishAsyncSGIX", typeof(GL.Delegates.FinishAsyncSGIX)); + GL.PollAsyncSGIX = (GL.Delegates.PollAsyncSGIX)GetAddress("glPollAsyncSGIX", typeof(GL.Delegates.PollAsyncSGIX)); + GL.GenAsyncMarkersSGIX = (GL.Delegates.GenAsyncMarkersSGIX)GetAddress("glGenAsyncMarkersSGIX", typeof(GL.Delegates.GenAsyncMarkersSGIX)); + GL.DeleteAsyncMarkersSGIX = (GL.Delegates.DeleteAsyncMarkersSGIX)GetAddress("glDeleteAsyncMarkersSGIX", typeof(GL.Delegates.DeleteAsyncMarkersSGIX)); + GL.IsAsyncMarkerSGIX = (GL.Delegates.IsAsyncMarkerSGIX)GetAddress("glIsAsyncMarkerSGIX", typeof(GL.Delegates.IsAsyncMarkerSGIX)); + GL.VertexPointervINTEL = (GL.Delegates.VertexPointervINTEL)GetAddress("glVertexPointervINTEL", typeof(GL.Delegates.VertexPointervINTEL)); + GL.NormalPointervINTEL = (GL.Delegates.NormalPointervINTEL)GetAddress("glNormalPointervINTEL", typeof(GL.Delegates.NormalPointervINTEL)); + GL.ColorPointervINTEL = (GL.Delegates.ColorPointervINTEL)GetAddress("glColorPointervINTEL", typeof(GL.Delegates.ColorPointervINTEL)); + GL.TexCoordPointervINTEL = (GL.Delegates.TexCoordPointervINTEL)GetAddress("glTexCoordPointervINTEL", typeof(GL.Delegates.TexCoordPointervINTEL)); + GL.PixelTransformParameteriEXT = (GL.Delegates.PixelTransformParameteriEXT)GetAddress("glPixelTransformParameteriEXT", typeof(GL.Delegates.PixelTransformParameteriEXT)); + GL.PixelTransformParameterfEXT = (GL.Delegates.PixelTransformParameterfEXT)GetAddress("glPixelTransformParameterfEXT", typeof(GL.Delegates.PixelTransformParameterfEXT)); + GL.PixelTransformParameterivEXT = (GL.Delegates.PixelTransformParameterivEXT)GetAddress("glPixelTransformParameterivEXT", typeof(GL.Delegates.PixelTransformParameterivEXT)); + GL.PixelTransformParameterfvEXT = (GL.Delegates.PixelTransformParameterfvEXT)GetAddress("glPixelTransformParameterfvEXT", typeof(GL.Delegates.PixelTransformParameterfvEXT)); + GL.SecondaryColor3bEXT = (GL.Delegates.SecondaryColor3bEXT)GetAddress("glSecondaryColor3bEXT", typeof(GL.Delegates.SecondaryColor3bEXT)); + GL.SecondaryColor3bvEXT = (GL.Delegates.SecondaryColor3bvEXT)GetAddress("glSecondaryColor3bvEXT", typeof(GL.Delegates.SecondaryColor3bvEXT)); + GL.SecondaryColor3dEXT = (GL.Delegates.SecondaryColor3dEXT)GetAddress("glSecondaryColor3dEXT", typeof(GL.Delegates.SecondaryColor3dEXT)); + GL.SecondaryColor3dvEXT = (GL.Delegates.SecondaryColor3dvEXT)GetAddress("glSecondaryColor3dvEXT", typeof(GL.Delegates.SecondaryColor3dvEXT)); + GL.SecondaryColor3fEXT = (GL.Delegates.SecondaryColor3fEXT)GetAddress("glSecondaryColor3fEXT", typeof(GL.Delegates.SecondaryColor3fEXT)); + GL.SecondaryColor3fvEXT = (GL.Delegates.SecondaryColor3fvEXT)GetAddress("glSecondaryColor3fvEXT", typeof(GL.Delegates.SecondaryColor3fvEXT)); + GL.SecondaryColor3iEXT = (GL.Delegates.SecondaryColor3iEXT)GetAddress("glSecondaryColor3iEXT", typeof(GL.Delegates.SecondaryColor3iEXT)); + GL.SecondaryColor3ivEXT = (GL.Delegates.SecondaryColor3ivEXT)GetAddress("glSecondaryColor3ivEXT", typeof(GL.Delegates.SecondaryColor3ivEXT)); + GL.SecondaryColor3sEXT = (GL.Delegates.SecondaryColor3sEXT)GetAddress("glSecondaryColor3sEXT", typeof(GL.Delegates.SecondaryColor3sEXT)); + GL.SecondaryColor3svEXT = (GL.Delegates.SecondaryColor3svEXT)GetAddress("glSecondaryColor3svEXT", typeof(GL.Delegates.SecondaryColor3svEXT)); + GL.SecondaryColor3ubEXT = (GL.Delegates.SecondaryColor3ubEXT)GetAddress("glSecondaryColor3ubEXT", typeof(GL.Delegates.SecondaryColor3ubEXT)); + GL.SecondaryColor3ubvEXT = (GL.Delegates.SecondaryColor3ubvEXT)GetAddress("glSecondaryColor3ubvEXT", typeof(GL.Delegates.SecondaryColor3ubvEXT)); + GL.SecondaryColor3uiEXT = (GL.Delegates.SecondaryColor3uiEXT)GetAddress("glSecondaryColor3uiEXT", typeof(GL.Delegates.SecondaryColor3uiEXT)); + GL.SecondaryColor3uivEXT = (GL.Delegates.SecondaryColor3uivEXT)GetAddress("glSecondaryColor3uivEXT", typeof(GL.Delegates.SecondaryColor3uivEXT)); + GL.SecondaryColor3usEXT = (GL.Delegates.SecondaryColor3usEXT)GetAddress("glSecondaryColor3usEXT", typeof(GL.Delegates.SecondaryColor3usEXT)); + GL.SecondaryColor3usvEXT = (GL.Delegates.SecondaryColor3usvEXT)GetAddress("glSecondaryColor3usvEXT", typeof(GL.Delegates.SecondaryColor3usvEXT)); + GL.SecondaryColorPointerEXT_ = (GL.Delegates.SecondaryColorPointerEXT_)GetAddress("glSecondaryColorPointerEXT", typeof(GL.Delegates.SecondaryColorPointerEXT_)); + GL.TextureNormalEXT = (GL.Delegates.TextureNormalEXT)GetAddress("glTextureNormalEXT", typeof(GL.Delegates.TextureNormalEXT)); + GL.MultiDrawArraysEXT = (GL.Delegates.MultiDrawArraysEXT)GetAddress("glMultiDrawArraysEXT", typeof(GL.Delegates.MultiDrawArraysEXT)); + GL.MultiDrawElementsEXT = (GL.Delegates.MultiDrawElementsEXT)GetAddress("glMultiDrawElementsEXT", typeof(GL.Delegates.MultiDrawElementsEXT)); + GL.FogCoordfEXT = (GL.Delegates.FogCoordfEXT)GetAddress("glFogCoordfEXT", typeof(GL.Delegates.FogCoordfEXT)); + GL.FogCoordfvEXT = (GL.Delegates.FogCoordfvEXT)GetAddress("glFogCoordfvEXT", typeof(GL.Delegates.FogCoordfvEXT)); + GL.FogCoorddEXT = (GL.Delegates.FogCoorddEXT)GetAddress("glFogCoorddEXT", typeof(GL.Delegates.FogCoorddEXT)); + GL.FogCoorddvEXT = (GL.Delegates.FogCoorddvEXT)GetAddress("glFogCoorddvEXT", typeof(GL.Delegates.FogCoorddvEXT)); + GL.FogCoordPointerEXT_ = (GL.Delegates.FogCoordPointerEXT_)GetAddress("glFogCoordPointerEXT", typeof(GL.Delegates.FogCoordPointerEXT_)); + GL.Tangent3bEXT = (GL.Delegates.Tangent3bEXT)GetAddress("glTangent3bEXT", typeof(GL.Delegates.Tangent3bEXT)); + GL.Tangent3bvEXT = (GL.Delegates.Tangent3bvEXT)GetAddress("glTangent3bvEXT", typeof(GL.Delegates.Tangent3bvEXT)); + GL.Tangent3dEXT = (GL.Delegates.Tangent3dEXT)GetAddress("glTangent3dEXT", typeof(GL.Delegates.Tangent3dEXT)); + GL.Tangent3dvEXT = (GL.Delegates.Tangent3dvEXT)GetAddress("glTangent3dvEXT", typeof(GL.Delegates.Tangent3dvEXT)); + GL.Tangent3fEXT = (GL.Delegates.Tangent3fEXT)GetAddress("glTangent3fEXT", typeof(GL.Delegates.Tangent3fEXT)); + GL.Tangent3fvEXT = (GL.Delegates.Tangent3fvEXT)GetAddress("glTangent3fvEXT", typeof(GL.Delegates.Tangent3fvEXT)); + GL.Tangent3iEXT = (GL.Delegates.Tangent3iEXT)GetAddress("glTangent3iEXT", typeof(GL.Delegates.Tangent3iEXT)); + GL.Tangent3ivEXT = (GL.Delegates.Tangent3ivEXT)GetAddress("glTangent3ivEXT", typeof(GL.Delegates.Tangent3ivEXT)); + GL.Tangent3sEXT = (GL.Delegates.Tangent3sEXT)GetAddress("glTangent3sEXT", typeof(GL.Delegates.Tangent3sEXT)); + GL.Tangent3svEXT = (GL.Delegates.Tangent3svEXT)GetAddress("glTangent3svEXT", typeof(GL.Delegates.Tangent3svEXT)); + GL.Binormal3bEXT = (GL.Delegates.Binormal3bEXT)GetAddress("glBinormal3bEXT", typeof(GL.Delegates.Binormal3bEXT)); + GL.Binormal3bvEXT = (GL.Delegates.Binormal3bvEXT)GetAddress("glBinormal3bvEXT", typeof(GL.Delegates.Binormal3bvEXT)); + GL.Binormal3dEXT = (GL.Delegates.Binormal3dEXT)GetAddress("glBinormal3dEXT", typeof(GL.Delegates.Binormal3dEXT)); + GL.Binormal3dvEXT = (GL.Delegates.Binormal3dvEXT)GetAddress("glBinormal3dvEXT", typeof(GL.Delegates.Binormal3dvEXT)); + GL.Binormal3fEXT = (GL.Delegates.Binormal3fEXT)GetAddress("glBinormal3fEXT", typeof(GL.Delegates.Binormal3fEXT)); + GL.Binormal3fvEXT = (GL.Delegates.Binormal3fvEXT)GetAddress("glBinormal3fvEXT", typeof(GL.Delegates.Binormal3fvEXT)); + GL.Binormal3iEXT = (GL.Delegates.Binormal3iEXT)GetAddress("glBinormal3iEXT", typeof(GL.Delegates.Binormal3iEXT)); + GL.Binormal3ivEXT = (GL.Delegates.Binormal3ivEXT)GetAddress("glBinormal3ivEXT", typeof(GL.Delegates.Binormal3ivEXT)); + GL.Binormal3sEXT = (GL.Delegates.Binormal3sEXT)GetAddress("glBinormal3sEXT", typeof(GL.Delegates.Binormal3sEXT)); + GL.Binormal3svEXT = (GL.Delegates.Binormal3svEXT)GetAddress("glBinormal3svEXT", typeof(GL.Delegates.Binormal3svEXT)); + GL.TangentPointerEXT_ = (GL.Delegates.TangentPointerEXT_)GetAddress("glTangentPointerEXT", typeof(GL.Delegates.TangentPointerEXT_)); + GL.BinormalPointerEXT_ = (GL.Delegates.BinormalPointerEXT_)GetAddress("glBinormalPointerEXT", typeof(GL.Delegates.BinormalPointerEXT_)); + GL.FinishTextureSUNX = (GL.Delegates.FinishTextureSUNX)GetAddress("glFinishTextureSUNX", typeof(GL.Delegates.FinishTextureSUNX)); + GL.GlobalAlphaFactorbSUN = (GL.Delegates.GlobalAlphaFactorbSUN)GetAddress("glGlobalAlphaFactorbSUN", typeof(GL.Delegates.GlobalAlphaFactorbSUN)); + GL.GlobalAlphaFactorsSUN = (GL.Delegates.GlobalAlphaFactorsSUN)GetAddress("glGlobalAlphaFactorsSUN", typeof(GL.Delegates.GlobalAlphaFactorsSUN)); + GL.GlobalAlphaFactoriSUN = (GL.Delegates.GlobalAlphaFactoriSUN)GetAddress("glGlobalAlphaFactoriSUN", typeof(GL.Delegates.GlobalAlphaFactoriSUN)); + GL.GlobalAlphaFactorfSUN = (GL.Delegates.GlobalAlphaFactorfSUN)GetAddress("glGlobalAlphaFactorfSUN", typeof(GL.Delegates.GlobalAlphaFactorfSUN)); + GL.GlobalAlphaFactordSUN = (GL.Delegates.GlobalAlphaFactordSUN)GetAddress("glGlobalAlphaFactordSUN", typeof(GL.Delegates.GlobalAlphaFactordSUN)); + GL.GlobalAlphaFactorubSUN = (GL.Delegates.GlobalAlphaFactorubSUN)GetAddress("glGlobalAlphaFactorubSUN", typeof(GL.Delegates.GlobalAlphaFactorubSUN)); + GL.GlobalAlphaFactorusSUN = (GL.Delegates.GlobalAlphaFactorusSUN)GetAddress("glGlobalAlphaFactorusSUN", typeof(GL.Delegates.GlobalAlphaFactorusSUN)); + GL.GlobalAlphaFactoruiSUN = (GL.Delegates.GlobalAlphaFactoruiSUN)GetAddress("glGlobalAlphaFactoruiSUN", typeof(GL.Delegates.GlobalAlphaFactoruiSUN)); + GL.ReplacementCodeuiSUN = (GL.Delegates.ReplacementCodeuiSUN)GetAddress("glReplacementCodeuiSUN", typeof(GL.Delegates.ReplacementCodeuiSUN)); + GL.ReplacementCodeusSUN = (GL.Delegates.ReplacementCodeusSUN)GetAddress("glReplacementCodeusSUN", typeof(GL.Delegates.ReplacementCodeusSUN)); + GL.ReplacementCodeubSUN = (GL.Delegates.ReplacementCodeubSUN)GetAddress("glReplacementCodeubSUN", typeof(GL.Delegates.ReplacementCodeubSUN)); + GL.ReplacementCodeuivSUN = (GL.Delegates.ReplacementCodeuivSUN)GetAddress("glReplacementCodeuivSUN", typeof(GL.Delegates.ReplacementCodeuivSUN)); + GL.ReplacementCodeusvSUN = (GL.Delegates.ReplacementCodeusvSUN)GetAddress("glReplacementCodeusvSUN", typeof(GL.Delegates.ReplacementCodeusvSUN)); + GL.ReplacementCodeubvSUN = (GL.Delegates.ReplacementCodeubvSUN)GetAddress("glReplacementCodeubvSUN", typeof(GL.Delegates.ReplacementCodeubvSUN)); + GL.ReplacementCodePointerSUN = (GL.Delegates.ReplacementCodePointerSUN)GetAddress("glReplacementCodePointerSUN", typeof(GL.Delegates.ReplacementCodePointerSUN)); + GL.Color4ubVertex2fSUN = (GL.Delegates.Color4ubVertex2fSUN)GetAddress("glColor4ubVertex2fSUN", typeof(GL.Delegates.Color4ubVertex2fSUN)); + GL.Color4ubVertex2fvSUN = (GL.Delegates.Color4ubVertex2fvSUN)GetAddress("glColor4ubVertex2fvSUN", typeof(GL.Delegates.Color4ubVertex2fvSUN)); + GL.Color4ubVertex3fSUN = (GL.Delegates.Color4ubVertex3fSUN)GetAddress("glColor4ubVertex3fSUN", typeof(GL.Delegates.Color4ubVertex3fSUN)); + GL.Color4ubVertex3fvSUN = (GL.Delegates.Color4ubVertex3fvSUN)GetAddress("glColor4ubVertex3fvSUN", typeof(GL.Delegates.Color4ubVertex3fvSUN)); + GL.Color3fVertex3fSUN = (GL.Delegates.Color3fVertex3fSUN)GetAddress("glColor3fVertex3fSUN", typeof(GL.Delegates.Color3fVertex3fSUN)); + GL.Color3fVertex3fvSUN = (GL.Delegates.Color3fVertex3fvSUN)GetAddress("glColor3fVertex3fvSUN", typeof(GL.Delegates.Color3fVertex3fvSUN)); + GL.Normal3fVertex3fSUN = (GL.Delegates.Normal3fVertex3fSUN)GetAddress("glNormal3fVertex3fSUN", typeof(GL.Delegates.Normal3fVertex3fSUN)); + GL.Normal3fVertex3fvSUN = (GL.Delegates.Normal3fVertex3fvSUN)GetAddress("glNormal3fVertex3fvSUN", typeof(GL.Delegates.Normal3fVertex3fvSUN)); + GL.Color4fNormal3fVertex3fSUN = (GL.Delegates.Color4fNormal3fVertex3fSUN)GetAddress("glColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fSUN)); + GL.Color4fNormal3fVertex3fvSUN = (GL.Delegates.Color4fNormal3fVertex3fvSUN)GetAddress("glColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fvSUN)); + GL.TexCoord2fVertex3fSUN = (GL.Delegates.TexCoord2fVertex3fSUN)GetAddress("glTexCoord2fVertex3fSUN", typeof(GL.Delegates.TexCoord2fVertex3fSUN)); + GL.TexCoord2fVertex3fvSUN = (GL.Delegates.TexCoord2fVertex3fvSUN)GetAddress("glTexCoord2fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fVertex3fvSUN)); + GL.TexCoord4fVertex4fSUN = (GL.Delegates.TexCoord4fVertex4fSUN)GetAddress("glTexCoord4fVertex4fSUN", typeof(GL.Delegates.TexCoord4fVertex4fSUN)); + GL.TexCoord4fVertex4fvSUN = (GL.Delegates.TexCoord4fVertex4fvSUN)GetAddress("glTexCoord4fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fVertex4fvSUN)); + GL.TexCoord2fColor4ubVertex3fSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fSUN)GetAddress("glTexCoord2fColor4ubVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fSUN)); + GL.TexCoord2fColor4ubVertex3fvSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fvSUN)GetAddress("glTexCoord2fColor4ubVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fvSUN)); + GL.TexCoord2fColor3fVertex3fSUN = (GL.Delegates.TexCoord2fColor3fVertex3fSUN)GetAddress("glTexCoord2fColor3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fSUN)); + GL.TexCoord2fColor3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor3fVertex3fvSUN)GetAddress("glTexCoord2fColor3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fvSUN)); + GL.TexCoord2fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fSUN)GetAddress("glTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fSUN)); + GL.TexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fvSUN)GetAddress("glTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fvSUN)); + GL.TexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN)GetAddress("glTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN)); + GL.TexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN)GetAddress("glTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN)); + GL.TexCoord4fColor4fNormal3fVertex4fSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN)GetAddress("glTexCoord4fColor4fNormal3fVertex4fSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN)); + GL.TexCoord4fColor4fNormal3fVertex4fvSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN)GetAddress("glTexCoord4fColor4fNormal3fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN)); + GL.ReplacementCodeuiVertex3fSUN = (GL.Delegates.ReplacementCodeuiVertex3fSUN)GetAddress("glReplacementCodeuiVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fSUN)); + GL.ReplacementCodeuiVertex3fvSUN = (GL.Delegates.ReplacementCodeuiVertex3fvSUN)GetAddress("glReplacementCodeuiVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fvSUN)); + GL.ReplacementCodeuiColor4ubVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN)GetAddress("glReplacementCodeuiColor4ubVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN)); + GL.ReplacementCodeuiColor4ubVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN)GetAddress("glReplacementCodeuiColor4ubVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN)); + GL.ReplacementCodeuiColor3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN)GetAddress("glReplacementCodeuiColor3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN)); + GL.ReplacementCodeuiColor3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN)GetAddress("glReplacementCodeuiColor3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN)); + GL.ReplacementCodeuiNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN)GetAddress("glReplacementCodeuiNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN)); + GL.ReplacementCodeuiNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN)GetAddress("glReplacementCodeuiNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN)); + GL.ReplacementCodeuiColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN)GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN)); + GL.ReplacementCodeuiColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN)GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN)); + GL.ReplacementCodeuiTexCoord2fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN)GetAddress("glReplacementCodeuiTexCoord2fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN)); + GL.ReplacementCodeuiTexCoord2fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN)GetAddress("glReplacementCodeuiTexCoord2fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN)); + GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)); + GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)); + GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)); + GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)); + GL.BlendFuncSeparateEXT = (GL.Delegates.BlendFuncSeparateEXT)GetAddress("glBlendFuncSeparateEXT", typeof(GL.Delegates.BlendFuncSeparateEXT)); + GL.BlendFuncSeparateINGR = (GL.Delegates.BlendFuncSeparateINGR)GetAddress("glBlendFuncSeparateINGR", typeof(GL.Delegates.BlendFuncSeparateINGR)); + GL.VertexWeightfEXT = (GL.Delegates.VertexWeightfEXT)GetAddress("glVertexWeightfEXT", typeof(GL.Delegates.VertexWeightfEXT)); + GL.VertexWeightfvEXT = (GL.Delegates.VertexWeightfvEXT)GetAddress("glVertexWeightfvEXT", typeof(GL.Delegates.VertexWeightfvEXT)); + GL.VertexWeightPointerEXT_ = (GL.Delegates.VertexWeightPointerEXT_)GetAddress("glVertexWeightPointerEXT", typeof(GL.Delegates.VertexWeightPointerEXT_)); + GL.FlushVertexArrayRangeNV = (GL.Delegates.FlushVertexArrayRangeNV)GetAddress("glFlushVertexArrayRangeNV", typeof(GL.Delegates.FlushVertexArrayRangeNV)); + GL.VertexArrayRangeNV_ = (GL.Delegates.VertexArrayRangeNV_)GetAddress("glVertexArrayRangeNV", typeof(GL.Delegates.VertexArrayRangeNV_)); + GL.CombinerParameterfvNV = (GL.Delegates.CombinerParameterfvNV)GetAddress("glCombinerParameterfvNV", typeof(GL.Delegates.CombinerParameterfvNV)); + GL.CombinerParameterfNV = (GL.Delegates.CombinerParameterfNV)GetAddress("glCombinerParameterfNV", typeof(GL.Delegates.CombinerParameterfNV)); + GL.CombinerParameterivNV = (GL.Delegates.CombinerParameterivNV)GetAddress("glCombinerParameterivNV", typeof(GL.Delegates.CombinerParameterivNV)); + GL.CombinerParameteriNV = (GL.Delegates.CombinerParameteriNV)GetAddress("glCombinerParameteriNV", typeof(GL.Delegates.CombinerParameteriNV)); + GL.CombinerInputNV = (GL.Delegates.CombinerInputNV)GetAddress("glCombinerInputNV", typeof(GL.Delegates.CombinerInputNV)); + GL.CombinerOutputNV = (GL.Delegates.CombinerOutputNV)GetAddress("glCombinerOutputNV", typeof(GL.Delegates.CombinerOutputNV)); + GL.FinalCombinerInputNV = (GL.Delegates.FinalCombinerInputNV)GetAddress("glFinalCombinerInputNV", typeof(GL.Delegates.FinalCombinerInputNV)); + GL.GetCombinerInputParameterfvNV = (GL.Delegates.GetCombinerInputParameterfvNV)GetAddress("glGetCombinerInputParameterfvNV", typeof(GL.Delegates.GetCombinerInputParameterfvNV)); + GL.GetCombinerInputParameterivNV = (GL.Delegates.GetCombinerInputParameterivNV)GetAddress("glGetCombinerInputParameterivNV", typeof(GL.Delegates.GetCombinerInputParameterivNV)); + GL.GetCombinerOutputParameterfvNV = (GL.Delegates.GetCombinerOutputParameterfvNV)GetAddress("glGetCombinerOutputParameterfvNV", typeof(GL.Delegates.GetCombinerOutputParameterfvNV)); + GL.GetCombinerOutputParameterivNV = (GL.Delegates.GetCombinerOutputParameterivNV)GetAddress("glGetCombinerOutputParameterivNV", typeof(GL.Delegates.GetCombinerOutputParameterivNV)); + GL.GetFinalCombinerInputParameterfvNV = (GL.Delegates.GetFinalCombinerInputParameterfvNV)GetAddress("glGetFinalCombinerInputParameterfvNV", typeof(GL.Delegates.GetFinalCombinerInputParameterfvNV)); + GL.GetFinalCombinerInputParameterivNV = (GL.Delegates.GetFinalCombinerInputParameterivNV)GetAddress("glGetFinalCombinerInputParameterivNV", typeof(GL.Delegates.GetFinalCombinerInputParameterivNV)); + GL.ResizeBuffersMESA = (GL.Delegates.ResizeBuffersMESA)GetAddress("glResizeBuffersMESA", typeof(GL.Delegates.ResizeBuffersMESA)); + GL.WindowPos2dMESA = (GL.Delegates.WindowPos2dMESA)GetAddress("glWindowPos2dMESA", typeof(GL.Delegates.WindowPos2dMESA)); + GL.WindowPos2dvMESA = (GL.Delegates.WindowPos2dvMESA)GetAddress("glWindowPos2dvMESA", typeof(GL.Delegates.WindowPos2dvMESA)); + GL.WindowPos2fMESA = (GL.Delegates.WindowPos2fMESA)GetAddress("glWindowPos2fMESA", typeof(GL.Delegates.WindowPos2fMESA)); + GL.WindowPos2fvMESA = (GL.Delegates.WindowPos2fvMESA)GetAddress("glWindowPos2fvMESA", typeof(GL.Delegates.WindowPos2fvMESA)); + GL.WindowPos2iMESA = (GL.Delegates.WindowPos2iMESA)GetAddress("glWindowPos2iMESA", typeof(GL.Delegates.WindowPos2iMESA)); + GL.WindowPos2ivMESA = (GL.Delegates.WindowPos2ivMESA)GetAddress("glWindowPos2ivMESA", typeof(GL.Delegates.WindowPos2ivMESA)); + GL.WindowPos2sMESA = (GL.Delegates.WindowPos2sMESA)GetAddress("glWindowPos2sMESA", typeof(GL.Delegates.WindowPos2sMESA)); + GL.WindowPos2svMESA = (GL.Delegates.WindowPos2svMESA)GetAddress("glWindowPos2svMESA", typeof(GL.Delegates.WindowPos2svMESA)); + GL.WindowPos3dMESA = (GL.Delegates.WindowPos3dMESA)GetAddress("glWindowPos3dMESA", typeof(GL.Delegates.WindowPos3dMESA)); + GL.WindowPos3dvMESA = (GL.Delegates.WindowPos3dvMESA)GetAddress("glWindowPos3dvMESA", typeof(GL.Delegates.WindowPos3dvMESA)); + GL.WindowPos3fMESA = (GL.Delegates.WindowPos3fMESA)GetAddress("glWindowPos3fMESA", typeof(GL.Delegates.WindowPos3fMESA)); + GL.WindowPos3fvMESA = (GL.Delegates.WindowPos3fvMESA)GetAddress("glWindowPos3fvMESA", typeof(GL.Delegates.WindowPos3fvMESA)); + GL.WindowPos3iMESA = (GL.Delegates.WindowPos3iMESA)GetAddress("glWindowPos3iMESA", typeof(GL.Delegates.WindowPos3iMESA)); + GL.WindowPos3ivMESA = (GL.Delegates.WindowPos3ivMESA)GetAddress("glWindowPos3ivMESA", typeof(GL.Delegates.WindowPos3ivMESA)); + GL.WindowPos3sMESA = (GL.Delegates.WindowPos3sMESA)GetAddress("glWindowPos3sMESA", typeof(GL.Delegates.WindowPos3sMESA)); + GL.WindowPos3svMESA = (GL.Delegates.WindowPos3svMESA)GetAddress("glWindowPos3svMESA", typeof(GL.Delegates.WindowPos3svMESA)); + GL.WindowPos4dMESA = (GL.Delegates.WindowPos4dMESA)GetAddress("glWindowPos4dMESA", typeof(GL.Delegates.WindowPos4dMESA)); + GL.WindowPos4dvMESA = (GL.Delegates.WindowPos4dvMESA)GetAddress("glWindowPos4dvMESA", typeof(GL.Delegates.WindowPos4dvMESA)); + GL.WindowPos4fMESA = (GL.Delegates.WindowPos4fMESA)GetAddress("glWindowPos4fMESA", typeof(GL.Delegates.WindowPos4fMESA)); + GL.WindowPos4fvMESA = (GL.Delegates.WindowPos4fvMESA)GetAddress("glWindowPos4fvMESA", typeof(GL.Delegates.WindowPos4fvMESA)); + GL.WindowPos4iMESA = (GL.Delegates.WindowPos4iMESA)GetAddress("glWindowPos4iMESA", typeof(GL.Delegates.WindowPos4iMESA)); + GL.WindowPos4ivMESA = (GL.Delegates.WindowPos4ivMESA)GetAddress("glWindowPos4ivMESA", typeof(GL.Delegates.WindowPos4ivMESA)); + GL.WindowPos4sMESA = (GL.Delegates.WindowPos4sMESA)GetAddress("glWindowPos4sMESA", typeof(GL.Delegates.WindowPos4sMESA)); + GL.WindowPos4svMESA = (GL.Delegates.WindowPos4svMESA)GetAddress("glWindowPos4svMESA", typeof(GL.Delegates.WindowPos4svMESA)); + GL.MultiModeDrawArraysIBM = (GL.Delegates.MultiModeDrawArraysIBM)GetAddress("glMultiModeDrawArraysIBM", typeof(GL.Delegates.MultiModeDrawArraysIBM)); + GL.MultiModeDrawElementsIBM_ = (GL.Delegates.MultiModeDrawElementsIBM_)GetAddress("glMultiModeDrawElementsIBM", typeof(GL.Delegates.MultiModeDrawElementsIBM_)); + GL.ColorPointerListIBM = (GL.Delegates.ColorPointerListIBM)GetAddress("glColorPointerListIBM", typeof(GL.Delegates.ColorPointerListIBM)); + GL.SecondaryColorPointerListIBM = (GL.Delegates.SecondaryColorPointerListIBM)GetAddress("glSecondaryColorPointerListIBM", typeof(GL.Delegates.SecondaryColorPointerListIBM)); + GL.EdgeFlagPointerListIBM = (GL.Delegates.EdgeFlagPointerListIBM)GetAddress("glEdgeFlagPointerListIBM", typeof(GL.Delegates.EdgeFlagPointerListIBM)); + GL.FogCoordPointerListIBM = (GL.Delegates.FogCoordPointerListIBM)GetAddress("glFogCoordPointerListIBM", typeof(GL.Delegates.FogCoordPointerListIBM)); + GL.IndexPointerListIBM = (GL.Delegates.IndexPointerListIBM)GetAddress("glIndexPointerListIBM", typeof(GL.Delegates.IndexPointerListIBM)); + GL.NormalPointerListIBM = (GL.Delegates.NormalPointerListIBM)GetAddress("glNormalPointerListIBM", typeof(GL.Delegates.NormalPointerListIBM)); + GL.TexCoordPointerListIBM = (GL.Delegates.TexCoordPointerListIBM)GetAddress("glTexCoordPointerListIBM", typeof(GL.Delegates.TexCoordPointerListIBM)); + GL.VertexPointerListIBM = (GL.Delegates.VertexPointerListIBM)GetAddress("glVertexPointerListIBM", typeof(GL.Delegates.VertexPointerListIBM)); + GL.TbufferMask3DFX = (GL.Delegates.TbufferMask3DFX)GetAddress("glTbufferMask3DFX", typeof(GL.Delegates.TbufferMask3DFX)); + GL.SampleMaskEXT = (GL.Delegates.SampleMaskEXT)GetAddress("glSampleMaskEXT", typeof(GL.Delegates.SampleMaskEXT)); + GL.SamplePatternEXT = (GL.Delegates.SamplePatternEXT)GetAddress("glSamplePatternEXT", typeof(GL.Delegates.SamplePatternEXT)); + GL.TextureColorMaskSGIS = (GL.Delegates.TextureColorMaskSGIS)GetAddress("glTextureColorMaskSGIS", typeof(GL.Delegates.TextureColorMaskSGIS)); + GL.IglooInterfaceSGIX_ = (GL.Delegates.IglooInterfaceSGIX_)GetAddress("glIglooInterfaceSGIX", typeof(GL.Delegates.IglooInterfaceSGIX_)); + GL.DeleteFencesNV = (GL.Delegates.DeleteFencesNV)GetAddress("glDeleteFencesNV", typeof(GL.Delegates.DeleteFencesNV)); + GL.GenFencesNV = (GL.Delegates.GenFencesNV)GetAddress("glGenFencesNV", typeof(GL.Delegates.GenFencesNV)); + GL.IsFenceNV = (GL.Delegates.IsFenceNV)GetAddress("glIsFenceNV", typeof(GL.Delegates.IsFenceNV)); + GL.TestFenceNV = (GL.Delegates.TestFenceNV)GetAddress("glTestFenceNV", typeof(GL.Delegates.TestFenceNV)); + GL.GetFenceivNV = (GL.Delegates.GetFenceivNV)GetAddress("glGetFenceivNV", typeof(GL.Delegates.GetFenceivNV)); + GL.FinishFenceNV = (GL.Delegates.FinishFenceNV)GetAddress("glFinishFenceNV", typeof(GL.Delegates.FinishFenceNV)); + GL.SetFenceNV = (GL.Delegates.SetFenceNV)GetAddress("glSetFenceNV", typeof(GL.Delegates.SetFenceNV)); + GL.MapControlPointsNV_ = (GL.Delegates.MapControlPointsNV_)GetAddress("glMapControlPointsNV", typeof(GL.Delegates.MapControlPointsNV_)); + GL.MapParameterivNV = (GL.Delegates.MapParameterivNV)GetAddress("glMapParameterivNV", typeof(GL.Delegates.MapParameterivNV)); + GL.MapParameterfvNV = (GL.Delegates.MapParameterfvNV)GetAddress("glMapParameterfvNV", typeof(GL.Delegates.MapParameterfvNV)); + GL.GetMapControlPointsNV_ = (GL.Delegates.GetMapControlPointsNV_)GetAddress("glGetMapControlPointsNV", typeof(GL.Delegates.GetMapControlPointsNV_)); + GL.GetMapParameterivNV = (GL.Delegates.GetMapParameterivNV)GetAddress("glGetMapParameterivNV", typeof(GL.Delegates.GetMapParameterivNV)); + GL.GetMapParameterfvNV = (GL.Delegates.GetMapParameterfvNV)GetAddress("glGetMapParameterfvNV", typeof(GL.Delegates.GetMapParameterfvNV)); + GL.GetMapAttribParameterivNV = (GL.Delegates.GetMapAttribParameterivNV)GetAddress("glGetMapAttribParameterivNV", typeof(GL.Delegates.GetMapAttribParameterivNV)); + GL.GetMapAttribParameterfvNV = (GL.Delegates.GetMapAttribParameterfvNV)GetAddress("glGetMapAttribParameterfvNV", typeof(GL.Delegates.GetMapAttribParameterfvNV)); + GL.EvalMapsNV = (GL.Delegates.EvalMapsNV)GetAddress("glEvalMapsNV", typeof(GL.Delegates.EvalMapsNV)); + GL.CombinerStageParameterfvNV = (GL.Delegates.CombinerStageParameterfvNV)GetAddress("glCombinerStageParameterfvNV", typeof(GL.Delegates.CombinerStageParameterfvNV)); + GL.GetCombinerStageParameterfvNV = (GL.Delegates.GetCombinerStageParameterfvNV)GetAddress("glGetCombinerStageParameterfvNV", typeof(GL.Delegates.GetCombinerStageParameterfvNV)); + GL.AreProgramsResidentNV = (GL.Delegates.AreProgramsResidentNV)GetAddress("glAreProgramsResidentNV", typeof(GL.Delegates.AreProgramsResidentNV)); + GL.BindProgramNV = (GL.Delegates.BindProgramNV)GetAddress("glBindProgramNV", typeof(GL.Delegates.BindProgramNV)); + GL.DeleteProgramsNV = (GL.Delegates.DeleteProgramsNV)GetAddress("glDeleteProgramsNV", typeof(GL.Delegates.DeleteProgramsNV)); + GL.ExecuteProgramNV = (GL.Delegates.ExecuteProgramNV)GetAddress("glExecuteProgramNV", typeof(GL.Delegates.ExecuteProgramNV)); + GL.GenProgramsNV = (GL.Delegates.GenProgramsNV)GetAddress("glGenProgramsNV", typeof(GL.Delegates.GenProgramsNV)); + GL.GetProgramParameterdvNV = (GL.Delegates.GetProgramParameterdvNV)GetAddress("glGetProgramParameterdvNV", typeof(GL.Delegates.GetProgramParameterdvNV)); + GL.GetProgramParameterfvNV = (GL.Delegates.GetProgramParameterfvNV)GetAddress("glGetProgramParameterfvNV", typeof(GL.Delegates.GetProgramParameterfvNV)); + GL.GetProgramivNV = (GL.Delegates.GetProgramivNV)GetAddress("glGetProgramivNV", typeof(GL.Delegates.GetProgramivNV)); + GL.GetProgramStringNV = (GL.Delegates.GetProgramStringNV)GetAddress("glGetProgramStringNV", typeof(GL.Delegates.GetProgramStringNV)); + GL.GetTrackMatrixivNV = (GL.Delegates.GetTrackMatrixivNV)GetAddress("glGetTrackMatrixivNV", typeof(GL.Delegates.GetTrackMatrixivNV)); + GL.GetVertexAttribdvNV = (GL.Delegates.GetVertexAttribdvNV)GetAddress("glGetVertexAttribdvNV", typeof(GL.Delegates.GetVertexAttribdvNV)); + GL.GetVertexAttribfvNV = (GL.Delegates.GetVertexAttribfvNV)GetAddress("glGetVertexAttribfvNV", typeof(GL.Delegates.GetVertexAttribfvNV)); + GL.GetVertexAttribivNV = (GL.Delegates.GetVertexAttribivNV)GetAddress("glGetVertexAttribivNV", typeof(GL.Delegates.GetVertexAttribivNV)); + GL.GetVertexAttribPointervNV = (GL.Delegates.GetVertexAttribPointervNV)GetAddress("glGetVertexAttribPointervNV", typeof(GL.Delegates.GetVertexAttribPointervNV)); + GL.IsProgramNV = (GL.Delegates.IsProgramNV)GetAddress("glIsProgramNV", typeof(GL.Delegates.IsProgramNV)); + GL.LoadProgramNV = (GL.Delegates.LoadProgramNV)GetAddress("glLoadProgramNV", typeof(GL.Delegates.LoadProgramNV)); + GL.ProgramParameter4dNV = (GL.Delegates.ProgramParameter4dNV)GetAddress("glProgramParameter4dNV", typeof(GL.Delegates.ProgramParameter4dNV)); + GL.ProgramParameter4dvNV = (GL.Delegates.ProgramParameter4dvNV)GetAddress("glProgramParameter4dvNV", typeof(GL.Delegates.ProgramParameter4dvNV)); + GL.ProgramParameter4fNV = (GL.Delegates.ProgramParameter4fNV)GetAddress("glProgramParameter4fNV", typeof(GL.Delegates.ProgramParameter4fNV)); + GL.ProgramParameter4fvNV = (GL.Delegates.ProgramParameter4fvNV)GetAddress("glProgramParameter4fvNV", typeof(GL.Delegates.ProgramParameter4fvNV)); + GL.ProgramParameters4dvNV = (GL.Delegates.ProgramParameters4dvNV)GetAddress("glProgramParameters4dvNV", typeof(GL.Delegates.ProgramParameters4dvNV)); + GL.ProgramParameters4fvNV = (GL.Delegates.ProgramParameters4fvNV)GetAddress("glProgramParameters4fvNV", typeof(GL.Delegates.ProgramParameters4fvNV)); + GL.RequestResidentProgramsNV = (GL.Delegates.RequestResidentProgramsNV)GetAddress("glRequestResidentProgramsNV", typeof(GL.Delegates.RequestResidentProgramsNV)); + GL.TrackMatrixNV = (GL.Delegates.TrackMatrixNV)GetAddress("glTrackMatrixNV", typeof(GL.Delegates.TrackMatrixNV)); + GL.VertexAttribPointerNV_ = (GL.Delegates.VertexAttribPointerNV_)GetAddress("glVertexAttribPointerNV", typeof(GL.Delegates.VertexAttribPointerNV_)); + GL.VertexAttrib1dNV = (GL.Delegates.VertexAttrib1dNV)GetAddress("glVertexAttrib1dNV", typeof(GL.Delegates.VertexAttrib1dNV)); + GL.VertexAttrib1dvNV = (GL.Delegates.VertexAttrib1dvNV)GetAddress("glVertexAttrib1dvNV", typeof(GL.Delegates.VertexAttrib1dvNV)); + GL.VertexAttrib1fNV = (GL.Delegates.VertexAttrib1fNV)GetAddress("glVertexAttrib1fNV", typeof(GL.Delegates.VertexAttrib1fNV)); + GL.VertexAttrib1fvNV = (GL.Delegates.VertexAttrib1fvNV)GetAddress("glVertexAttrib1fvNV", typeof(GL.Delegates.VertexAttrib1fvNV)); + GL.VertexAttrib1sNV = (GL.Delegates.VertexAttrib1sNV)GetAddress("glVertexAttrib1sNV", typeof(GL.Delegates.VertexAttrib1sNV)); + GL.VertexAttrib1svNV = (GL.Delegates.VertexAttrib1svNV)GetAddress("glVertexAttrib1svNV", typeof(GL.Delegates.VertexAttrib1svNV)); + GL.VertexAttrib2dNV = (GL.Delegates.VertexAttrib2dNV)GetAddress("glVertexAttrib2dNV", typeof(GL.Delegates.VertexAttrib2dNV)); + GL.VertexAttrib2dvNV = (GL.Delegates.VertexAttrib2dvNV)GetAddress("glVertexAttrib2dvNV", typeof(GL.Delegates.VertexAttrib2dvNV)); + GL.VertexAttrib2fNV = (GL.Delegates.VertexAttrib2fNV)GetAddress("glVertexAttrib2fNV", typeof(GL.Delegates.VertexAttrib2fNV)); + GL.VertexAttrib2fvNV = (GL.Delegates.VertexAttrib2fvNV)GetAddress("glVertexAttrib2fvNV", typeof(GL.Delegates.VertexAttrib2fvNV)); + GL.VertexAttrib2sNV = (GL.Delegates.VertexAttrib2sNV)GetAddress("glVertexAttrib2sNV", typeof(GL.Delegates.VertexAttrib2sNV)); + GL.VertexAttrib2svNV = (GL.Delegates.VertexAttrib2svNV)GetAddress("glVertexAttrib2svNV", typeof(GL.Delegates.VertexAttrib2svNV)); + GL.VertexAttrib3dNV = (GL.Delegates.VertexAttrib3dNV)GetAddress("glVertexAttrib3dNV", typeof(GL.Delegates.VertexAttrib3dNV)); + GL.VertexAttrib3dvNV = (GL.Delegates.VertexAttrib3dvNV)GetAddress("glVertexAttrib3dvNV", typeof(GL.Delegates.VertexAttrib3dvNV)); + GL.VertexAttrib3fNV = (GL.Delegates.VertexAttrib3fNV)GetAddress("glVertexAttrib3fNV", typeof(GL.Delegates.VertexAttrib3fNV)); + GL.VertexAttrib3fvNV = (GL.Delegates.VertexAttrib3fvNV)GetAddress("glVertexAttrib3fvNV", typeof(GL.Delegates.VertexAttrib3fvNV)); + GL.VertexAttrib3sNV = (GL.Delegates.VertexAttrib3sNV)GetAddress("glVertexAttrib3sNV", typeof(GL.Delegates.VertexAttrib3sNV)); + GL.VertexAttrib3svNV = (GL.Delegates.VertexAttrib3svNV)GetAddress("glVertexAttrib3svNV", typeof(GL.Delegates.VertexAttrib3svNV)); + GL.VertexAttrib4dNV = (GL.Delegates.VertexAttrib4dNV)GetAddress("glVertexAttrib4dNV", typeof(GL.Delegates.VertexAttrib4dNV)); + GL.VertexAttrib4dvNV = (GL.Delegates.VertexAttrib4dvNV)GetAddress("glVertexAttrib4dvNV", typeof(GL.Delegates.VertexAttrib4dvNV)); + GL.VertexAttrib4fNV = (GL.Delegates.VertexAttrib4fNV)GetAddress("glVertexAttrib4fNV", typeof(GL.Delegates.VertexAttrib4fNV)); + GL.VertexAttrib4fvNV = (GL.Delegates.VertexAttrib4fvNV)GetAddress("glVertexAttrib4fvNV", typeof(GL.Delegates.VertexAttrib4fvNV)); + GL.VertexAttrib4sNV = (GL.Delegates.VertexAttrib4sNV)GetAddress("glVertexAttrib4sNV", typeof(GL.Delegates.VertexAttrib4sNV)); + GL.VertexAttrib4svNV = (GL.Delegates.VertexAttrib4svNV)GetAddress("glVertexAttrib4svNV", typeof(GL.Delegates.VertexAttrib4svNV)); + GL.VertexAttrib4ubNV = (GL.Delegates.VertexAttrib4ubNV)GetAddress("glVertexAttrib4ubNV", typeof(GL.Delegates.VertexAttrib4ubNV)); + GL.VertexAttrib4ubvNV = (GL.Delegates.VertexAttrib4ubvNV)GetAddress("glVertexAttrib4ubvNV", typeof(GL.Delegates.VertexAttrib4ubvNV)); + GL.VertexAttribs1dvNV = (GL.Delegates.VertexAttribs1dvNV)GetAddress("glVertexAttribs1dvNV", typeof(GL.Delegates.VertexAttribs1dvNV)); + GL.VertexAttribs1fvNV = (GL.Delegates.VertexAttribs1fvNV)GetAddress("glVertexAttribs1fvNV", typeof(GL.Delegates.VertexAttribs1fvNV)); + GL.VertexAttribs1svNV = (GL.Delegates.VertexAttribs1svNV)GetAddress("glVertexAttribs1svNV", typeof(GL.Delegates.VertexAttribs1svNV)); + GL.VertexAttribs2dvNV = (GL.Delegates.VertexAttribs2dvNV)GetAddress("glVertexAttribs2dvNV", typeof(GL.Delegates.VertexAttribs2dvNV)); + GL.VertexAttribs2fvNV = (GL.Delegates.VertexAttribs2fvNV)GetAddress("glVertexAttribs2fvNV", typeof(GL.Delegates.VertexAttribs2fvNV)); + GL.VertexAttribs2svNV = (GL.Delegates.VertexAttribs2svNV)GetAddress("glVertexAttribs2svNV", typeof(GL.Delegates.VertexAttribs2svNV)); + GL.VertexAttribs3dvNV = (GL.Delegates.VertexAttribs3dvNV)GetAddress("glVertexAttribs3dvNV", typeof(GL.Delegates.VertexAttribs3dvNV)); + GL.VertexAttribs3fvNV = (GL.Delegates.VertexAttribs3fvNV)GetAddress("glVertexAttribs3fvNV", typeof(GL.Delegates.VertexAttribs3fvNV)); + GL.VertexAttribs3svNV = (GL.Delegates.VertexAttribs3svNV)GetAddress("glVertexAttribs3svNV", typeof(GL.Delegates.VertexAttribs3svNV)); + GL.VertexAttribs4dvNV = (GL.Delegates.VertexAttribs4dvNV)GetAddress("glVertexAttribs4dvNV", typeof(GL.Delegates.VertexAttribs4dvNV)); + GL.VertexAttribs4fvNV = (GL.Delegates.VertexAttribs4fvNV)GetAddress("glVertexAttribs4fvNV", typeof(GL.Delegates.VertexAttribs4fvNV)); + GL.VertexAttribs4svNV = (GL.Delegates.VertexAttribs4svNV)GetAddress("glVertexAttribs4svNV", typeof(GL.Delegates.VertexAttribs4svNV)); + GL.VertexAttribs4ubvNV = (GL.Delegates.VertexAttribs4ubvNV)GetAddress("glVertexAttribs4ubvNV", typeof(GL.Delegates.VertexAttribs4ubvNV)); + GL.TexBumpParameterivATI = (GL.Delegates.TexBumpParameterivATI)GetAddress("glTexBumpParameterivATI", typeof(GL.Delegates.TexBumpParameterivATI)); + GL.TexBumpParameterfvATI = (GL.Delegates.TexBumpParameterfvATI)GetAddress("glTexBumpParameterfvATI", typeof(GL.Delegates.TexBumpParameterfvATI)); + GL.GetTexBumpParameterivATI = (GL.Delegates.GetTexBumpParameterivATI)GetAddress("glGetTexBumpParameterivATI", typeof(GL.Delegates.GetTexBumpParameterivATI)); + GL.GetTexBumpParameterfvATI = (GL.Delegates.GetTexBumpParameterfvATI)GetAddress("glGetTexBumpParameterfvATI", typeof(GL.Delegates.GetTexBumpParameterfvATI)); + GL.GenFragmentShadersATI = (GL.Delegates.GenFragmentShadersATI)GetAddress("glGenFragmentShadersATI", typeof(GL.Delegates.GenFragmentShadersATI)); + GL.BindFragmentShaderATI = (GL.Delegates.BindFragmentShaderATI)GetAddress("glBindFragmentShaderATI", typeof(GL.Delegates.BindFragmentShaderATI)); + GL.DeleteFragmentShaderATI = (GL.Delegates.DeleteFragmentShaderATI)GetAddress("glDeleteFragmentShaderATI", typeof(GL.Delegates.DeleteFragmentShaderATI)); + GL.BeginFragmentShaderATI = (GL.Delegates.BeginFragmentShaderATI)GetAddress("glBeginFragmentShaderATI", typeof(GL.Delegates.BeginFragmentShaderATI)); + GL.EndFragmentShaderATI = (GL.Delegates.EndFragmentShaderATI)GetAddress("glEndFragmentShaderATI", typeof(GL.Delegates.EndFragmentShaderATI)); + GL.PassTexCoordATI = (GL.Delegates.PassTexCoordATI)GetAddress("glPassTexCoordATI", typeof(GL.Delegates.PassTexCoordATI)); + GL.SampleMapATI = (GL.Delegates.SampleMapATI)GetAddress("glSampleMapATI", typeof(GL.Delegates.SampleMapATI)); + GL.ColorFragmentOp1ATI = (GL.Delegates.ColorFragmentOp1ATI)GetAddress("glColorFragmentOp1ATI", typeof(GL.Delegates.ColorFragmentOp1ATI)); + GL.ColorFragmentOp2ATI = (GL.Delegates.ColorFragmentOp2ATI)GetAddress("glColorFragmentOp2ATI", typeof(GL.Delegates.ColorFragmentOp2ATI)); + GL.ColorFragmentOp3ATI = (GL.Delegates.ColorFragmentOp3ATI)GetAddress("glColorFragmentOp3ATI", typeof(GL.Delegates.ColorFragmentOp3ATI)); + GL.AlphaFragmentOp1ATI = (GL.Delegates.AlphaFragmentOp1ATI)GetAddress("glAlphaFragmentOp1ATI", typeof(GL.Delegates.AlphaFragmentOp1ATI)); + GL.AlphaFragmentOp2ATI = (GL.Delegates.AlphaFragmentOp2ATI)GetAddress("glAlphaFragmentOp2ATI", typeof(GL.Delegates.AlphaFragmentOp2ATI)); + GL.AlphaFragmentOp3ATI = (GL.Delegates.AlphaFragmentOp3ATI)GetAddress("glAlphaFragmentOp3ATI", typeof(GL.Delegates.AlphaFragmentOp3ATI)); + GL.SetFragmentShaderConstantATI = (GL.Delegates.SetFragmentShaderConstantATI)GetAddress("glSetFragmentShaderConstantATI", typeof(GL.Delegates.SetFragmentShaderConstantATI)); + GL.PNTrianglesiATI = (GL.Delegates.PNTrianglesiATI)GetAddress("glPNTrianglesiATI", typeof(GL.Delegates.PNTrianglesiATI)); + GL.PNTrianglesfATI = (GL.Delegates.PNTrianglesfATI)GetAddress("glPNTrianglesfATI", typeof(GL.Delegates.PNTrianglesfATI)); + GL.NewObjectBufferATI_ = (GL.Delegates.NewObjectBufferATI_)GetAddress("glNewObjectBufferATI", typeof(GL.Delegates.NewObjectBufferATI_)); + GL.IsObjectBufferATI = (GL.Delegates.IsObjectBufferATI)GetAddress("glIsObjectBufferATI", typeof(GL.Delegates.IsObjectBufferATI)); + GL.UpdateObjectBufferATI_ = (GL.Delegates.UpdateObjectBufferATI_)GetAddress("glUpdateObjectBufferATI", typeof(GL.Delegates.UpdateObjectBufferATI_)); + GL.GetObjectBufferfvATI = (GL.Delegates.GetObjectBufferfvATI)GetAddress("glGetObjectBufferfvATI", typeof(GL.Delegates.GetObjectBufferfvATI)); + GL.GetObjectBufferivATI = (GL.Delegates.GetObjectBufferivATI)GetAddress("glGetObjectBufferivATI", typeof(GL.Delegates.GetObjectBufferivATI)); + GL.FreeObjectBufferATI = (GL.Delegates.FreeObjectBufferATI)GetAddress("glFreeObjectBufferATI", typeof(GL.Delegates.FreeObjectBufferATI)); + GL.ArrayObjectATI = (GL.Delegates.ArrayObjectATI)GetAddress("glArrayObjectATI", typeof(GL.Delegates.ArrayObjectATI)); + GL.GetArrayObjectfvATI = (GL.Delegates.GetArrayObjectfvATI)GetAddress("glGetArrayObjectfvATI", typeof(GL.Delegates.GetArrayObjectfvATI)); + GL.GetArrayObjectivATI = (GL.Delegates.GetArrayObjectivATI)GetAddress("glGetArrayObjectivATI", typeof(GL.Delegates.GetArrayObjectivATI)); + GL.VariantArrayObjectATI = (GL.Delegates.VariantArrayObjectATI)GetAddress("glVariantArrayObjectATI", typeof(GL.Delegates.VariantArrayObjectATI)); + GL.GetVariantArrayObjectfvATI = (GL.Delegates.GetVariantArrayObjectfvATI)GetAddress("glGetVariantArrayObjectfvATI", typeof(GL.Delegates.GetVariantArrayObjectfvATI)); + GL.GetVariantArrayObjectivATI = (GL.Delegates.GetVariantArrayObjectivATI)GetAddress("glGetVariantArrayObjectivATI", typeof(GL.Delegates.GetVariantArrayObjectivATI)); + GL.BeginVertexShaderEXT = (GL.Delegates.BeginVertexShaderEXT)GetAddress("glBeginVertexShaderEXT", typeof(GL.Delegates.BeginVertexShaderEXT)); + GL.EndVertexShaderEXT = (GL.Delegates.EndVertexShaderEXT)GetAddress("glEndVertexShaderEXT", typeof(GL.Delegates.EndVertexShaderEXT)); + GL.BindVertexShaderEXT = (GL.Delegates.BindVertexShaderEXT)GetAddress("glBindVertexShaderEXT", typeof(GL.Delegates.BindVertexShaderEXT)); + GL.GenVertexShadersEXT = (GL.Delegates.GenVertexShadersEXT)GetAddress("glGenVertexShadersEXT", typeof(GL.Delegates.GenVertexShadersEXT)); + GL.DeleteVertexShaderEXT = (GL.Delegates.DeleteVertexShaderEXT)GetAddress("glDeleteVertexShaderEXT", typeof(GL.Delegates.DeleteVertexShaderEXT)); + GL.ShaderOp1EXT = (GL.Delegates.ShaderOp1EXT)GetAddress("glShaderOp1EXT", typeof(GL.Delegates.ShaderOp1EXT)); + GL.ShaderOp2EXT = (GL.Delegates.ShaderOp2EXT)GetAddress("glShaderOp2EXT", typeof(GL.Delegates.ShaderOp2EXT)); + GL.ShaderOp3EXT = (GL.Delegates.ShaderOp3EXT)GetAddress("glShaderOp3EXT", typeof(GL.Delegates.ShaderOp3EXT)); + GL.SwizzleEXT = (GL.Delegates.SwizzleEXT)GetAddress("glSwizzleEXT", typeof(GL.Delegates.SwizzleEXT)); + GL.WriteMaskEXT = (GL.Delegates.WriteMaskEXT)GetAddress("glWriteMaskEXT", typeof(GL.Delegates.WriteMaskEXT)); + GL.InsertComponentEXT = (GL.Delegates.InsertComponentEXT)GetAddress("glInsertComponentEXT", typeof(GL.Delegates.InsertComponentEXT)); + GL.ExtractComponentEXT = (GL.Delegates.ExtractComponentEXT)GetAddress("glExtractComponentEXT", typeof(GL.Delegates.ExtractComponentEXT)); + GL.GenSymbolsEXT = (GL.Delegates.GenSymbolsEXT)GetAddress("glGenSymbolsEXT", typeof(GL.Delegates.GenSymbolsEXT)); + GL.SetInvariantEXT_ = (GL.Delegates.SetInvariantEXT_)GetAddress("glSetInvariantEXT", typeof(GL.Delegates.SetInvariantEXT_)); + GL.SetLocalConstantEXT_ = (GL.Delegates.SetLocalConstantEXT_)GetAddress("glSetLocalConstantEXT", typeof(GL.Delegates.SetLocalConstantEXT_)); + GL.VariantbvEXT = (GL.Delegates.VariantbvEXT)GetAddress("glVariantbvEXT", typeof(GL.Delegates.VariantbvEXT)); + GL.VariantsvEXT = (GL.Delegates.VariantsvEXT)GetAddress("glVariantsvEXT", typeof(GL.Delegates.VariantsvEXT)); + GL.VariantivEXT = (GL.Delegates.VariantivEXT)GetAddress("glVariantivEXT", typeof(GL.Delegates.VariantivEXT)); + GL.VariantfvEXT = (GL.Delegates.VariantfvEXT)GetAddress("glVariantfvEXT", typeof(GL.Delegates.VariantfvEXT)); + GL.VariantdvEXT = (GL.Delegates.VariantdvEXT)GetAddress("glVariantdvEXT", typeof(GL.Delegates.VariantdvEXT)); + GL.VariantubvEXT = (GL.Delegates.VariantubvEXT)GetAddress("glVariantubvEXT", typeof(GL.Delegates.VariantubvEXT)); + GL.VariantusvEXT = (GL.Delegates.VariantusvEXT)GetAddress("glVariantusvEXT", typeof(GL.Delegates.VariantusvEXT)); + GL.VariantuivEXT = (GL.Delegates.VariantuivEXT)GetAddress("glVariantuivEXT", typeof(GL.Delegates.VariantuivEXT)); + GL.VariantPointerEXT_ = (GL.Delegates.VariantPointerEXT_)GetAddress("glVariantPointerEXT", typeof(GL.Delegates.VariantPointerEXT_)); + GL.EnableVariantClientStateEXT = (GL.Delegates.EnableVariantClientStateEXT)GetAddress("glEnableVariantClientStateEXT", typeof(GL.Delegates.EnableVariantClientStateEXT)); + GL.DisableVariantClientStateEXT = (GL.Delegates.DisableVariantClientStateEXT)GetAddress("glDisableVariantClientStateEXT", typeof(GL.Delegates.DisableVariantClientStateEXT)); + GL.BindLightParameterEXT = (GL.Delegates.BindLightParameterEXT)GetAddress("glBindLightParameterEXT", typeof(GL.Delegates.BindLightParameterEXT)); + GL.BindMaterialParameterEXT = (GL.Delegates.BindMaterialParameterEXT)GetAddress("glBindMaterialParameterEXT", typeof(GL.Delegates.BindMaterialParameterEXT)); + GL.BindTexGenParameterEXT = (GL.Delegates.BindTexGenParameterEXT)GetAddress("glBindTexGenParameterEXT", typeof(GL.Delegates.BindTexGenParameterEXT)); + GL.BindTextureUnitParameterEXT = (GL.Delegates.BindTextureUnitParameterEXT)GetAddress("glBindTextureUnitParameterEXT", typeof(GL.Delegates.BindTextureUnitParameterEXT)); + GL.BindParameterEXT = (GL.Delegates.BindParameterEXT)GetAddress("glBindParameterEXT", typeof(GL.Delegates.BindParameterEXT)); + GL.IsVariantEnabledEXT = (GL.Delegates.IsVariantEnabledEXT)GetAddress("glIsVariantEnabledEXT", typeof(GL.Delegates.IsVariantEnabledEXT)); + GL.GetVariantBooleanvEXT = (GL.Delegates.GetVariantBooleanvEXT)GetAddress("glGetVariantBooleanvEXT", typeof(GL.Delegates.GetVariantBooleanvEXT)); + GL.GetVariantIntegervEXT = (GL.Delegates.GetVariantIntegervEXT)GetAddress("glGetVariantIntegervEXT", typeof(GL.Delegates.GetVariantIntegervEXT)); + GL.GetVariantFloatvEXT = (GL.Delegates.GetVariantFloatvEXT)GetAddress("glGetVariantFloatvEXT", typeof(GL.Delegates.GetVariantFloatvEXT)); + GL.GetVariantPointervEXT = (GL.Delegates.GetVariantPointervEXT)GetAddress("glGetVariantPointervEXT", typeof(GL.Delegates.GetVariantPointervEXT)); + GL.GetInvariantBooleanvEXT = (GL.Delegates.GetInvariantBooleanvEXT)GetAddress("glGetInvariantBooleanvEXT", typeof(GL.Delegates.GetInvariantBooleanvEXT)); + GL.GetInvariantIntegervEXT = (GL.Delegates.GetInvariantIntegervEXT)GetAddress("glGetInvariantIntegervEXT", typeof(GL.Delegates.GetInvariantIntegervEXT)); + GL.GetInvariantFloatvEXT = (GL.Delegates.GetInvariantFloatvEXT)GetAddress("glGetInvariantFloatvEXT", typeof(GL.Delegates.GetInvariantFloatvEXT)); + GL.GetLocalConstantBooleanvEXT = (GL.Delegates.GetLocalConstantBooleanvEXT)GetAddress("glGetLocalConstantBooleanvEXT", typeof(GL.Delegates.GetLocalConstantBooleanvEXT)); + GL.GetLocalConstantIntegervEXT = (GL.Delegates.GetLocalConstantIntegervEXT)GetAddress("glGetLocalConstantIntegervEXT", typeof(GL.Delegates.GetLocalConstantIntegervEXT)); + GL.GetLocalConstantFloatvEXT = (GL.Delegates.GetLocalConstantFloatvEXT)GetAddress("glGetLocalConstantFloatvEXT", typeof(GL.Delegates.GetLocalConstantFloatvEXT)); + GL.VertexStream1sATI = (GL.Delegates.VertexStream1sATI)GetAddress("glVertexStream1sATI", typeof(GL.Delegates.VertexStream1sATI)); + GL.VertexStream1svATI = (GL.Delegates.VertexStream1svATI)GetAddress("glVertexStream1svATI", typeof(GL.Delegates.VertexStream1svATI)); + GL.VertexStream1iATI = (GL.Delegates.VertexStream1iATI)GetAddress("glVertexStream1iATI", typeof(GL.Delegates.VertexStream1iATI)); + GL.VertexStream1ivATI = (GL.Delegates.VertexStream1ivATI)GetAddress("glVertexStream1ivATI", typeof(GL.Delegates.VertexStream1ivATI)); + GL.VertexStream1fATI = (GL.Delegates.VertexStream1fATI)GetAddress("glVertexStream1fATI", typeof(GL.Delegates.VertexStream1fATI)); + GL.VertexStream1fvATI = (GL.Delegates.VertexStream1fvATI)GetAddress("glVertexStream1fvATI", typeof(GL.Delegates.VertexStream1fvATI)); + GL.VertexStream1dATI = (GL.Delegates.VertexStream1dATI)GetAddress("glVertexStream1dATI", typeof(GL.Delegates.VertexStream1dATI)); + GL.VertexStream1dvATI = (GL.Delegates.VertexStream1dvATI)GetAddress("glVertexStream1dvATI", typeof(GL.Delegates.VertexStream1dvATI)); + GL.VertexStream2sATI = (GL.Delegates.VertexStream2sATI)GetAddress("glVertexStream2sATI", typeof(GL.Delegates.VertexStream2sATI)); + GL.VertexStream2svATI = (GL.Delegates.VertexStream2svATI)GetAddress("glVertexStream2svATI", typeof(GL.Delegates.VertexStream2svATI)); + GL.VertexStream2iATI = (GL.Delegates.VertexStream2iATI)GetAddress("glVertexStream2iATI", typeof(GL.Delegates.VertexStream2iATI)); + GL.VertexStream2ivATI = (GL.Delegates.VertexStream2ivATI)GetAddress("glVertexStream2ivATI", typeof(GL.Delegates.VertexStream2ivATI)); + GL.VertexStream2fATI = (GL.Delegates.VertexStream2fATI)GetAddress("glVertexStream2fATI", typeof(GL.Delegates.VertexStream2fATI)); + GL.VertexStream2fvATI = (GL.Delegates.VertexStream2fvATI)GetAddress("glVertexStream2fvATI", typeof(GL.Delegates.VertexStream2fvATI)); + GL.VertexStream2dATI = (GL.Delegates.VertexStream2dATI)GetAddress("glVertexStream2dATI", typeof(GL.Delegates.VertexStream2dATI)); + GL.VertexStream2dvATI = (GL.Delegates.VertexStream2dvATI)GetAddress("glVertexStream2dvATI", typeof(GL.Delegates.VertexStream2dvATI)); + GL.VertexStream3sATI = (GL.Delegates.VertexStream3sATI)GetAddress("glVertexStream3sATI", typeof(GL.Delegates.VertexStream3sATI)); + GL.VertexStream3svATI = (GL.Delegates.VertexStream3svATI)GetAddress("glVertexStream3svATI", typeof(GL.Delegates.VertexStream3svATI)); + GL.VertexStream3iATI = (GL.Delegates.VertexStream3iATI)GetAddress("glVertexStream3iATI", typeof(GL.Delegates.VertexStream3iATI)); + GL.VertexStream3ivATI = (GL.Delegates.VertexStream3ivATI)GetAddress("glVertexStream3ivATI", typeof(GL.Delegates.VertexStream3ivATI)); + GL.VertexStream3fATI = (GL.Delegates.VertexStream3fATI)GetAddress("glVertexStream3fATI", typeof(GL.Delegates.VertexStream3fATI)); + GL.VertexStream3fvATI = (GL.Delegates.VertexStream3fvATI)GetAddress("glVertexStream3fvATI", typeof(GL.Delegates.VertexStream3fvATI)); + GL.VertexStream3dATI = (GL.Delegates.VertexStream3dATI)GetAddress("glVertexStream3dATI", typeof(GL.Delegates.VertexStream3dATI)); + GL.VertexStream3dvATI = (GL.Delegates.VertexStream3dvATI)GetAddress("glVertexStream3dvATI", typeof(GL.Delegates.VertexStream3dvATI)); + GL.VertexStream4sATI = (GL.Delegates.VertexStream4sATI)GetAddress("glVertexStream4sATI", typeof(GL.Delegates.VertexStream4sATI)); + GL.VertexStream4svATI = (GL.Delegates.VertexStream4svATI)GetAddress("glVertexStream4svATI", typeof(GL.Delegates.VertexStream4svATI)); + GL.VertexStream4iATI = (GL.Delegates.VertexStream4iATI)GetAddress("glVertexStream4iATI", typeof(GL.Delegates.VertexStream4iATI)); + GL.VertexStream4ivATI = (GL.Delegates.VertexStream4ivATI)GetAddress("glVertexStream4ivATI", typeof(GL.Delegates.VertexStream4ivATI)); + GL.VertexStream4fATI = (GL.Delegates.VertexStream4fATI)GetAddress("glVertexStream4fATI", typeof(GL.Delegates.VertexStream4fATI)); + GL.VertexStream4fvATI = (GL.Delegates.VertexStream4fvATI)GetAddress("glVertexStream4fvATI", typeof(GL.Delegates.VertexStream4fvATI)); + GL.VertexStream4dATI = (GL.Delegates.VertexStream4dATI)GetAddress("glVertexStream4dATI", typeof(GL.Delegates.VertexStream4dATI)); + GL.VertexStream4dvATI = (GL.Delegates.VertexStream4dvATI)GetAddress("glVertexStream4dvATI", typeof(GL.Delegates.VertexStream4dvATI)); + GL.NormalStream3bATI = (GL.Delegates.NormalStream3bATI)GetAddress("glNormalStream3bATI", typeof(GL.Delegates.NormalStream3bATI)); + GL.NormalStream3bvATI = (GL.Delegates.NormalStream3bvATI)GetAddress("glNormalStream3bvATI", typeof(GL.Delegates.NormalStream3bvATI)); + GL.NormalStream3sATI = (GL.Delegates.NormalStream3sATI)GetAddress("glNormalStream3sATI", typeof(GL.Delegates.NormalStream3sATI)); + GL.NormalStream3svATI = (GL.Delegates.NormalStream3svATI)GetAddress("glNormalStream3svATI", typeof(GL.Delegates.NormalStream3svATI)); + GL.NormalStream3iATI = (GL.Delegates.NormalStream3iATI)GetAddress("glNormalStream3iATI", typeof(GL.Delegates.NormalStream3iATI)); + GL.NormalStream3ivATI = (GL.Delegates.NormalStream3ivATI)GetAddress("glNormalStream3ivATI", typeof(GL.Delegates.NormalStream3ivATI)); + GL.NormalStream3fATI = (GL.Delegates.NormalStream3fATI)GetAddress("glNormalStream3fATI", typeof(GL.Delegates.NormalStream3fATI)); + GL.NormalStream3fvATI = (GL.Delegates.NormalStream3fvATI)GetAddress("glNormalStream3fvATI", typeof(GL.Delegates.NormalStream3fvATI)); + GL.NormalStream3dATI = (GL.Delegates.NormalStream3dATI)GetAddress("glNormalStream3dATI", typeof(GL.Delegates.NormalStream3dATI)); + GL.NormalStream3dvATI = (GL.Delegates.NormalStream3dvATI)GetAddress("glNormalStream3dvATI", typeof(GL.Delegates.NormalStream3dvATI)); + GL.ClientActiveVertexStreamATI = (GL.Delegates.ClientActiveVertexStreamATI)GetAddress("glClientActiveVertexStreamATI", typeof(GL.Delegates.ClientActiveVertexStreamATI)); + GL.VertexBlendEnviATI = (GL.Delegates.VertexBlendEnviATI)GetAddress("glVertexBlendEnviATI", typeof(GL.Delegates.VertexBlendEnviATI)); + GL.VertexBlendEnvfATI = (GL.Delegates.VertexBlendEnvfATI)GetAddress("glVertexBlendEnvfATI", typeof(GL.Delegates.VertexBlendEnvfATI)); + GL.ElementPointerATI_ = (GL.Delegates.ElementPointerATI_)GetAddress("glElementPointerATI", typeof(GL.Delegates.ElementPointerATI_)); + GL.DrawElementArrayATI = (GL.Delegates.DrawElementArrayATI)GetAddress("glDrawElementArrayATI", typeof(GL.Delegates.DrawElementArrayATI)); + GL.DrawRangeElementArrayATI = (GL.Delegates.DrawRangeElementArrayATI)GetAddress("glDrawRangeElementArrayATI", typeof(GL.Delegates.DrawRangeElementArrayATI)); + GL.DrawMeshArraysSUN = (GL.Delegates.DrawMeshArraysSUN)GetAddress("glDrawMeshArraysSUN", typeof(GL.Delegates.DrawMeshArraysSUN)); + GL.GenOcclusionQueriesNV = (GL.Delegates.GenOcclusionQueriesNV)GetAddress("glGenOcclusionQueriesNV", typeof(GL.Delegates.GenOcclusionQueriesNV)); + GL.DeleteOcclusionQueriesNV = (GL.Delegates.DeleteOcclusionQueriesNV)GetAddress("glDeleteOcclusionQueriesNV", typeof(GL.Delegates.DeleteOcclusionQueriesNV)); + GL.IsOcclusionQueryNV = (GL.Delegates.IsOcclusionQueryNV)GetAddress("glIsOcclusionQueryNV", typeof(GL.Delegates.IsOcclusionQueryNV)); + GL.BeginOcclusionQueryNV = (GL.Delegates.BeginOcclusionQueryNV)GetAddress("glBeginOcclusionQueryNV", typeof(GL.Delegates.BeginOcclusionQueryNV)); + GL.EndOcclusionQueryNV = (GL.Delegates.EndOcclusionQueryNV)GetAddress("glEndOcclusionQueryNV", typeof(GL.Delegates.EndOcclusionQueryNV)); + GL.GetOcclusionQueryivNV = (GL.Delegates.GetOcclusionQueryivNV)GetAddress("glGetOcclusionQueryivNV", typeof(GL.Delegates.GetOcclusionQueryivNV)); + GL.GetOcclusionQueryuivNV = (GL.Delegates.GetOcclusionQueryuivNV)GetAddress("glGetOcclusionQueryuivNV", typeof(GL.Delegates.GetOcclusionQueryuivNV)); + GL.PointParameteriNV = (GL.Delegates.PointParameteriNV)GetAddress("glPointParameteriNV", typeof(GL.Delegates.PointParameteriNV)); + GL.PointParameterivNV = (GL.Delegates.PointParameterivNV)GetAddress("glPointParameterivNV", typeof(GL.Delegates.PointParameterivNV)); + GL.ActiveStencilFaceEXT = (GL.Delegates.ActiveStencilFaceEXT)GetAddress("glActiveStencilFaceEXT", typeof(GL.Delegates.ActiveStencilFaceEXT)); + GL.ElementPointerAPPLE_ = (GL.Delegates.ElementPointerAPPLE_)GetAddress("glElementPointerAPPLE", typeof(GL.Delegates.ElementPointerAPPLE_)); + GL.DrawElementArrayAPPLE = (GL.Delegates.DrawElementArrayAPPLE)GetAddress("glDrawElementArrayAPPLE", typeof(GL.Delegates.DrawElementArrayAPPLE)); + GL.DrawRangeElementArrayAPPLE = (GL.Delegates.DrawRangeElementArrayAPPLE)GetAddress("glDrawRangeElementArrayAPPLE", typeof(GL.Delegates.DrawRangeElementArrayAPPLE)); + GL.MultiDrawElementArrayAPPLE = (GL.Delegates.MultiDrawElementArrayAPPLE)GetAddress("glMultiDrawElementArrayAPPLE", typeof(GL.Delegates.MultiDrawElementArrayAPPLE)); + GL.MultiDrawRangeElementArrayAPPLE = (GL.Delegates.MultiDrawRangeElementArrayAPPLE)GetAddress("glMultiDrawRangeElementArrayAPPLE", typeof(GL.Delegates.MultiDrawRangeElementArrayAPPLE)); + GL.GenFencesAPPLE = (GL.Delegates.GenFencesAPPLE)GetAddress("glGenFencesAPPLE", typeof(GL.Delegates.GenFencesAPPLE)); + GL.DeleteFencesAPPLE = (GL.Delegates.DeleteFencesAPPLE)GetAddress("glDeleteFencesAPPLE", typeof(GL.Delegates.DeleteFencesAPPLE)); + GL.SetFenceAPPLE = (GL.Delegates.SetFenceAPPLE)GetAddress("glSetFenceAPPLE", typeof(GL.Delegates.SetFenceAPPLE)); + GL.IsFenceAPPLE = (GL.Delegates.IsFenceAPPLE)GetAddress("glIsFenceAPPLE", typeof(GL.Delegates.IsFenceAPPLE)); + GL.TestFenceAPPLE = (GL.Delegates.TestFenceAPPLE)GetAddress("glTestFenceAPPLE", typeof(GL.Delegates.TestFenceAPPLE)); + GL.FinishFenceAPPLE = (GL.Delegates.FinishFenceAPPLE)GetAddress("glFinishFenceAPPLE", typeof(GL.Delegates.FinishFenceAPPLE)); + GL.TestObjectAPPLE = (GL.Delegates.TestObjectAPPLE)GetAddress("glTestObjectAPPLE", typeof(GL.Delegates.TestObjectAPPLE)); + GL.FinishObjectAPPLE = (GL.Delegates.FinishObjectAPPLE)GetAddress("glFinishObjectAPPLE", typeof(GL.Delegates.FinishObjectAPPLE)); + GL.BindVertexArrayAPPLE = (GL.Delegates.BindVertexArrayAPPLE)GetAddress("glBindVertexArrayAPPLE", typeof(GL.Delegates.BindVertexArrayAPPLE)); + GL.DeleteVertexArraysAPPLE = (GL.Delegates.DeleteVertexArraysAPPLE)GetAddress("glDeleteVertexArraysAPPLE", typeof(GL.Delegates.DeleteVertexArraysAPPLE)); + GL.GenVertexArraysAPPLE = (GL.Delegates.GenVertexArraysAPPLE)GetAddress("glGenVertexArraysAPPLE", typeof(GL.Delegates.GenVertexArraysAPPLE)); + GL.IsVertexArrayAPPLE = (GL.Delegates.IsVertexArrayAPPLE)GetAddress("glIsVertexArrayAPPLE", typeof(GL.Delegates.IsVertexArrayAPPLE)); + GL.VertexArrayRangeAPPLE_ = (GL.Delegates.VertexArrayRangeAPPLE_)GetAddress("glVertexArrayRangeAPPLE", typeof(GL.Delegates.VertexArrayRangeAPPLE_)); + GL.FlushVertexArrayRangeAPPLE_ = (GL.Delegates.FlushVertexArrayRangeAPPLE_)GetAddress("glFlushVertexArrayRangeAPPLE", typeof(GL.Delegates.FlushVertexArrayRangeAPPLE_)); + GL.VertexArrayParameteriAPPLE = (GL.Delegates.VertexArrayParameteriAPPLE)GetAddress("glVertexArrayParameteriAPPLE", typeof(GL.Delegates.VertexArrayParameteriAPPLE)); + GL.DrawBuffersATI = (GL.Delegates.DrawBuffersATI)GetAddress("glDrawBuffersATI", typeof(GL.Delegates.DrawBuffersATI)); + GL.ProgramNamedParameter4fNV = (GL.Delegates.ProgramNamedParameter4fNV)GetAddress("glProgramNamedParameter4fNV", typeof(GL.Delegates.ProgramNamedParameter4fNV)); + GL.ProgramNamedParameter4dNV = (GL.Delegates.ProgramNamedParameter4dNV)GetAddress("glProgramNamedParameter4dNV", typeof(GL.Delegates.ProgramNamedParameter4dNV)); + GL.ProgramNamedParameter4fvNV = (GL.Delegates.ProgramNamedParameter4fvNV)GetAddress("glProgramNamedParameter4fvNV", typeof(GL.Delegates.ProgramNamedParameter4fvNV)); + GL.ProgramNamedParameter4dvNV = (GL.Delegates.ProgramNamedParameter4dvNV)GetAddress("glProgramNamedParameter4dvNV", typeof(GL.Delegates.ProgramNamedParameter4dvNV)); + GL.GetProgramNamedParameterfvNV = (GL.Delegates.GetProgramNamedParameterfvNV)GetAddress("glGetProgramNamedParameterfvNV", typeof(GL.Delegates.GetProgramNamedParameterfvNV)); + GL.GetProgramNamedParameterdvNV = (GL.Delegates.GetProgramNamedParameterdvNV)GetAddress("glGetProgramNamedParameterdvNV", typeof(GL.Delegates.GetProgramNamedParameterdvNV)); + GL.Vertex2hNV = (GL.Delegates.Vertex2hNV)GetAddress("glVertex2hNV", typeof(GL.Delegates.Vertex2hNV)); + GL.Vertex2hvNV = (GL.Delegates.Vertex2hvNV)GetAddress("glVertex2hvNV", typeof(GL.Delegates.Vertex2hvNV)); + GL.Vertex3hNV = (GL.Delegates.Vertex3hNV)GetAddress("glVertex3hNV", typeof(GL.Delegates.Vertex3hNV)); + GL.Vertex3hvNV = (GL.Delegates.Vertex3hvNV)GetAddress("glVertex3hvNV", typeof(GL.Delegates.Vertex3hvNV)); + GL.Vertex4hNV = (GL.Delegates.Vertex4hNV)GetAddress("glVertex4hNV", typeof(GL.Delegates.Vertex4hNV)); + GL.Vertex4hvNV = (GL.Delegates.Vertex4hvNV)GetAddress("glVertex4hvNV", typeof(GL.Delegates.Vertex4hvNV)); + GL.Normal3hNV = (GL.Delegates.Normal3hNV)GetAddress("glNormal3hNV", typeof(GL.Delegates.Normal3hNV)); + GL.Normal3hvNV = (GL.Delegates.Normal3hvNV)GetAddress("glNormal3hvNV", typeof(GL.Delegates.Normal3hvNV)); + GL.Color3hNV = (GL.Delegates.Color3hNV)GetAddress("glColor3hNV", typeof(GL.Delegates.Color3hNV)); + GL.Color3hvNV = (GL.Delegates.Color3hvNV)GetAddress("glColor3hvNV", typeof(GL.Delegates.Color3hvNV)); + GL.Color4hNV = (GL.Delegates.Color4hNV)GetAddress("glColor4hNV", typeof(GL.Delegates.Color4hNV)); + GL.Color4hvNV = (GL.Delegates.Color4hvNV)GetAddress("glColor4hvNV", typeof(GL.Delegates.Color4hvNV)); + GL.TexCoord1hNV = (GL.Delegates.TexCoord1hNV)GetAddress("glTexCoord1hNV", typeof(GL.Delegates.TexCoord1hNV)); + GL.TexCoord1hvNV = (GL.Delegates.TexCoord1hvNV)GetAddress("glTexCoord1hvNV", typeof(GL.Delegates.TexCoord1hvNV)); + GL.TexCoord2hNV = (GL.Delegates.TexCoord2hNV)GetAddress("glTexCoord2hNV", typeof(GL.Delegates.TexCoord2hNV)); + GL.TexCoord2hvNV = (GL.Delegates.TexCoord2hvNV)GetAddress("glTexCoord2hvNV", typeof(GL.Delegates.TexCoord2hvNV)); + GL.TexCoord3hNV = (GL.Delegates.TexCoord3hNV)GetAddress("glTexCoord3hNV", typeof(GL.Delegates.TexCoord3hNV)); + GL.TexCoord3hvNV = (GL.Delegates.TexCoord3hvNV)GetAddress("glTexCoord3hvNV", typeof(GL.Delegates.TexCoord3hvNV)); + GL.TexCoord4hNV = (GL.Delegates.TexCoord4hNV)GetAddress("glTexCoord4hNV", typeof(GL.Delegates.TexCoord4hNV)); + GL.TexCoord4hvNV = (GL.Delegates.TexCoord4hvNV)GetAddress("glTexCoord4hvNV", typeof(GL.Delegates.TexCoord4hvNV)); + GL.MultiTexCoord1hNV = (GL.Delegates.MultiTexCoord1hNV)GetAddress("glMultiTexCoord1hNV", typeof(GL.Delegates.MultiTexCoord1hNV)); + GL.MultiTexCoord1hvNV = (GL.Delegates.MultiTexCoord1hvNV)GetAddress("glMultiTexCoord1hvNV", typeof(GL.Delegates.MultiTexCoord1hvNV)); + GL.MultiTexCoord2hNV = (GL.Delegates.MultiTexCoord2hNV)GetAddress("glMultiTexCoord2hNV", typeof(GL.Delegates.MultiTexCoord2hNV)); + GL.MultiTexCoord2hvNV = (GL.Delegates.MultiTexCoord2hvNV)GetAddress("glMultiTexCoord2hvNV", typeof(GL.Delegates.MultiTexCoord2hvNV)); + GL.MultiTexCoord3hNV = (GL.Delegates.MultiTexCoord3hNV)GetAddress("glMultiTexCoord3hNV", typeof(GL.Delegates.MultiTexCoord3hNV)); + GL.MultiTexCoord3hvNV = (GL.Delegates.MultiTexCoord3hvNV)GetAddress("glMultiTexCoord3hvNV", typeof(GL.Delegates.MultiTexCoord3hvNV)); + GL.MultiTexCoord4hNV = (GL.Delegates.MultiTexCoord4hNV)GetAddress("glMultiTexCoord4hNV", typeof(GL.Delegates.MultiTexCoord4hNV)); + GL.MultiTexCoord4hvNV = (GL.Delegates.MultiTexCoord4hvNV)GetAddress("glMultiTexCoord4hvNV", typeof(GL.Delegates.MultiTexCoord4hvNV)); + GL.FogCoordhNV = (GL.Delegates.FogCoordhNV)GetAddress("glFogCoordhNV", typeof(GL.Delegates.FogCoordhNV)); + GL.FogCoordhvNV = (GL.Delegates.FogCoordhvNV)GetAddress("glFogCoordhvNV", typeof(GL.Delegates.FogCoordhvNV)); + GL.SecondaryColor3hNV = (GL.Delegates.SecondaryColor3hNV)GetAddress("glSecondaryColor3hNV", typeof(GL.Delegates.SecondaryColor3hNV)); + GL.SecondaryColor3hvNV = (GL.Delegates.SecondaryColor3hvNV)GetAddress("glSecondaryColor3hvNV", typeof(GL.Delegates.SecondaryColor3hvNV)); + GL.VertexWeighthNV = (GL.Delegates.VertexWeighthNV)GetAddress("glVertexWeighthNV", typeof(GL.Delegates.VertexWeighthNV)); + GL.VertexWeighthvNV = (GL.Delegates.VertexWeighthvNV)GetAddress("glVertexWeighthvNV", typeof(GL.Delegates.VertexWeighthvNV)); + GL.VertexAttrib1hNV = (GL.Delegates.VertexAttrib1hNV)GetAddress("glVertexAttrib1hNV", typeof(GL.Delegates.VertexAttrib1hNV)); + GL.VertexAttrib1hvNV = (GL.Delegates.VertexAttrib1hvNV)GetAddress("glVertexAttrib1hvNV", typeof(GL.Delegates.VertexAttrib1hvNV)); + GL.VertexAttrib2hNV = (GL.Delegates.VertexAttrib2hNV)GetAddress("glVertexAttrib2hNV", typeof(GL.Delegates.VertexAttrib2hNV)); + GL.VertexAttrib2hvNV = (GL.Delegates.VertexAttrib2hvNV)GetAddress("glVertexAttrib2hvNV", typeof(GL.Delegates.VertexAttrib2hvNV)); + GL.VertexAttrib3hNV = (GL.Delegates.VertexAttrib3hNV)GetAddress("glVertexAttrib3hNV", typeof(GL.Delegates.VertexAttrib3hNV)); + GL.VertexAttrib3hvNV = (GL.Delegates.VertexAttrib3hvNV)GetAddress("glVertexAttrib3hvNV", typeof(GL.Delegates.VertexAttrib3hvNV)); + GL.VertexAttrib4hNV = (GL.Delegates.VertexAttrib4hNV)GetAddress("glVertexAttrib4hNV", typeof(GL.Delegates.VertexAttrib4hNV)); + GL.VertexAttrib4hvNV = (GL.Delegates.VertexAttrib4hvNV)GetAddress("glVertexAttrib4hvNV", typeof(GL.Delegates.VertexAttrib4hvNV)); + GL.VertexAttribs1hvNV = (GL.Delegates.VertexAttribs1hvNV)GetAddress("glVertexAttribs1hvNV", typeof(GL.Delegates.VertexAttribs1hvNV)); + GL.VertexAttribs2hvNV = (GL.Delegates.VertexAttribs2hvNV)GetAddress("glVertexAttribs2hvNV", typeof(GL.Delegates.VertexAttribs2hvNV)); + GL.VertexAttribs3hvNV = (GL.Delegates.VertexAttribs3hvNV)GetAddress("glVertexAttribs3hvNV", typeof(GL.Delegates.VertexAttribs3hvNV)); + GL.VertexAttribs4hvNV = (GL.Delegates.VertexAttribs4hvNV)GetAddress("glVertexAttribs4hvNV", typeof(GL.Delegates.VertexAttribs4hvNV)); + GL.PixelDataRangeNV_ = (GL.Delegates.PixelDataRangeNV_)GetAddress("glPixelDataRangeNV", typeof(GL.Delegates.PixelDataRangeNV_)); + GL.FlushPixelDataRangeNV = (GL.Delegates.FlushPixelDataRangeNV)GetAddress("glFlushPixelDataRangeNV", typeof(GL.Delegates.FlushPixelDataRangeNV)); + GL.PrimitiveRestartNV = (GL.Delegates.PrimitiveRestartNV)GetAddress("glPrimitiveRestartNV", typeof(GL.Delegates.PrimitiveRestartNV)); + GL.PrimitiveRestartIndexNV = (GL.Delegates.PrimitiveRestartIndexNV)GetAddress("glPrimitiveRestartIndexNV", typeof(GL.Delegates.PrimitiveRestartIndexNV)); + GL.MapObjectBufferATI_ = (GL.Delegates.MapObjectBufferATI_)GetAddress("glMapObjectBufferATI", typeof(GL.Delegates.MapObjectBufferATI_)); + GL.UnmapObjectBufferATI = (GL.Delegates.UnmapObjectBufferATI)GetAddress("glUnmapObjectBufferATI", typeof(GL.Delegates.UnmapObjectBufferATI)); + GL.StencilOpSeparateATI = (GL.Delegates.StencilOpSeparateATI)GetAddress("glStencilOpSeparateATI", typeof(GL.Delegates.StencilOpSeparateATI)); + GL.StencilFuncSeparateATI = (GL.Delegates.StencilFuncSeparateATI)GetAddress("glStencilFuncSeparateATI", typeof(GL.Delegates.StencilFuncSeparateATI)); + GL.VertexAttribArrayObjectATI = (GL.Delegates.VertexAttribArrayObjectATI)GetAddress("glVertexAttribArrayObjectATI", typeof(GL.Delegates.VertexAttribArrayObjectATI)); + GL.GetVertexAttribArrayObjectfvATI = (GL.Delegates.GetVertexAttribArrayObjectfvATI)GetAddress("glGetVertexAttribArrayObjectfvATI", typeof(GL.Delegates.GetVertexAttribArrayObjectfvATI)); + GL.GetVertexAttribArrayObjectivATI = (GL.Delegates.GetVertexAttribArrayObjectivATI)GetAddress("glGetVertexAttribArrayObjectivATI", typeof(GL.Delegates.GetVertexAttribArrayObjectivATI)); + GL.DepthBoundsEXT = (GL.Delegates.DepthBoundsEXT)GetAddress("glDepthBoundsEXT", typeof(GL.Delegates.DepthBoundsEXT)); + GL.BlendEquationSeparateEXT = (GL.Delegates.BlendEquationSeparateEXT)GetAddress("glBlendEquationSeparateEXT", typeof(GL.Delegates.BlendEquationSeparateEXT)); + GL.IsRenderbufferEXT = (GL.Delegates.IsRenderbufferEXT)GetAddress("glIsRenderbufferEXT", typeof(GL.Delegates.IsRenderbufferEXT)); + GL.BindRenderbufferEXT = (GL.Delegates.BindRenderbufferEXT)GetAddress("glBindRenderbufferEXT", typeof(GL.Delegates.BindRenderbufferEXT)); + GL.DeleteRenderbuffersEXT = (GL.Delegates.DeleteRenderbuffersEXT)GetAddress("glDeleteRenderbuffersEXT", typeof(GL.Delegates.DeleteRenderbuffersEXT)); + GL.GenRenderbuffersEXT = (GL.Delegates.GenRenderbuffersEXT)GetAddress("glGenRenderbuffersEXT", typeof(GL.Delegates.GenRenderbuffersEXT)); + GL.RenderbufferStorageEXT = (GL.Delegates.RenderbufferStorageEXT)GetAddress("glRenderbufferStorageEXT", typeof(GL.Delegates.RenderbufferStorageEXT)); + GL.GetRenderbufferParameterivEXT = (GL.Delegates.GetRenderbufferParameterivEXT)GetAddress("glGetRenderbufferParameterivEXT", typeof(GL.Delegates.GetRenderbufferParameterivEXT)); + GL.IsFramebufferEXT = (GL.Delegates.IsFramebufferEXT)GetAddress("glIsFramebufferEXT", typeof(GL.Delegates.IsFramebufferEXT)); + GL.BindFramebufferEXT = (GL.Delegates.BindFramebufferEXT)GetAddress("glBindFramebufferEXT", typeof(GL.Delegates.BindFramebufferEXT)); + GL.DeleteFramebuffersEXT = (GL.Delegates.DeleteFramebuffersEXT)GetAddress("glDeleteFramebuffersEXT", typeof(GL.Delegates.DeleteFramebuffersEXT)); + GL.GenFramebuffersEXT = (GL.Delegates.GenFramebuffersEXT)GetAddress("glGenFramebuffersEXT", typeof(GL.Delegates.GenFramebuffersEXT)); + GL.CheckFramebufferStatusEXT = (GL.Delegates.CheckFramebufferStatusEXT)GetAddress("glCheckFramebufferStatusEXT", typeof(GL.Delegates.CheckFramebufferStatusEXT)); + GL.FramebufferTexture1DEXT = (GL.Delegates.FramebufferTexture1DEXT)GetAddress("glFramebufferTexture1DEXT", typeof(GL.Delegates.FramebufferTexture1DEXT)); + GL.FramebufferTexture2DEXT = (GL.Delegates.FramebufferTexture2DEXT)GetAddress("glFramebufferTexture2DEXT", typeof(GL.Delegates.FramebufferTexture2DEXT)); + GL.FramebufferTexture3DEXT = (GL.Delegates.FramebufferTexture3DEXT)GetAddress("glFramebufferTexture3DEXT", typeof(GL.Delegates.FramebufferTexture3DEXT)); + GL.FramebufferRenderbufferEXT = (GL.Delegates.FramebufferRenderbufferEXT)GetAddress("glFramebufferRenderbufferEXT", typeof(GL.Delegates.FramebufferRenderbufferEXT)); + GL.GetFramebufferAttachmentParameterivEXT = (GL.Delegates.GetFramebufferAttachmentParameterivEXT)GetAddress("glGetFramebufferAttachmentParameterivEXT", typeof(GL.Delegates.GetFramebufferAttachmentParameterivEXT)); + GL.GenerateMipmapEXT = (GL.Delegates.GenerateMipmapEXT)GetAddress("glGenerateMipmapEXT", typeof(GL.Delegates.GenerateMipmapEXT)); + GL.StringMarkerGREMEDY_ = (GL.Delegates.StringMarkerGREMEDY_)GetAddress("glStringMarkerGREMEDY", typeof(GL.Delegates.StringMarkerGREMEDY_)); + } + #endregion + } +} + diff --git a/Source/OpenGL/OpenGL/Bindings/GL.cs b/Source/OpenGL/OpenGL/Bindings/GL.cs new file mode 100644 index 00000000..9007d16f --- /dev/null +++ b/Source/OpenGL/OpenGL/Bindings/GL.cs @@ -0,0 +1,9487 @@ +using System; +using System.Runtime.InteropServices; + +namespace OpenTK.OpenGL +{ + #region Types + using GLsizeiptrARB = System.IntPtr; + using GLintptrARB = System.IntPtr; + using GLhandleARB = System.Int32; + using GLhalfARB = System.Int16; + using GLhalfNV = System.Int16; + using GLcharARB = System.Char; + using GLsizeiptr = System.IntPtr; + using GLintptr = System.IntPtr; + using GLenum = System.Int32; + using GLboolean = System.Boolean; + using GLbitfield = System.Int32; + using GLchar = System.Char; + using GLbyte = System.SByte; + using GLshort = System.Int16; + using GLint = System.Int32; + using GLubyte = System.SByte; + using GLushort = System.Int16; + using GLuint = System.Int32; + using GLsizei = System.Int32; + using GLfloat = System.Single; + using GLclampf = System.Single; + using GLdouble = System.Double; + using GLclampd = System.Double; + using GLstring = System.String; + #endregion + + #region Enums + public struct Enums + { + #region Missing Constants + + const uint GL_FOG_COORDINATE_SOURCE = 0x8450; + const uint GL_FOG_COORDINATE = 0x8451; + const uint GL_CURRENT_FOG_COORDINATE = 0x8453; + const uint GL_FOG_COORDINATE_ARRAY_TYPE = 0x8454; + const uint GL_FOG_COORDINATE_ARRAY_STRIDE = 0x8455; + const uint GL_FOG_COORDINATE_ARRAY_POINTER = 0x8456; + const uint GL_FOG_COORDINATE_ARRAY = 0x8457; + const uint GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D; + const uint GL_SOURCE0_RGB = 0x8580; + const uint GL_SOURCE1_RGB = 0x8581; + const uint GL_SOURCE2_RGB = 0x8582; + const uint GL_SOURCE0_ALPHA = 0x8588; + const uint GL_SOURCE1_ALPHA = 0x8589; + const uint GL_SOURCE2_ALPHA = 0x858A; + const uint GL_BLEND_EQUATION = 0x8009; + const uint GL_MODELVIEW_MATRIX = 0x0BA6; + const uint GL_MODELVIEW = 0x1700; + const uint GL_MODELVIEW_STACK_DEPTH = 0x0BA3; + const uint GL_OFFSET_TEXTURE_MATRIX_NV = 0x86E1; + const uint GL_OFFSET_TEXTURE_SCALE_NV = 0x86E2; + const uint GL_OFFSET_TEXTURE_BIAS_NV = 0x86E3; + + #endregion + + public enum PixelStoreParameter : uint + { + UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS, + UNPACK_LSB_FIRST = GetPName.UNPACK_LSB_FIRST, + UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX, + PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX, + UNPACK_ROW_LENGTH = GetPName.UNPACK_ROW_LENGTH, + UNPACK_ALIGNMENT = GetPName.UNPACK_ALIGNMENT, + UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT, + PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX, + PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX, + PACK_SKIP_ROWS = GetPName.PACK_SKIP_ROWS, + PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS, + UNPACK_SKIP_ROWS = GetPName.UNPACK_SKIP_ROWS, + UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT, + UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX, + PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX, + PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX, + PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX, + PACK_SKIP_PIXELS = GetPName.PACK_SKIP_PIXELS, + PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS, + PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX, + PACK_SWAP_BYTES = GetPName.PACK_SWAP_BYTES, + UNPACK_SWAP_BYTES = GetPName.UNPACK_SWAP_BYTES, + PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT, + UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS, + PACK_LSB_FIRST = GetPName.PACK_LSB_FIRST, + PACK_ALIGNMENT = GetPName.PACK_ALIGNMENT, + PACK_ROW_LENGTH = GetPName.PACK_ROW_LENGTH, + UNPACK_SKIP_PIXELS = GetPName.UNPACK_SKIP_PIXELS, + PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX, + PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT, + } + + public enum HintMode : uint + { + DONT_CARE = 0x1100, + NICEST = 0x1102, + FASTEST = 0x1101, + } + + public enum ATI_pixel_format_float : uint + { + COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835, + TYPE_RGBA_FLOAT_ATI = 0x8820, + } + + public enum INTEL_parallel_arrays : uint + { + VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5, + NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6, + COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7, + PARALLEL_ARRAYS_INTEL = 0x83F4, + TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8, + } + + public enum HistogramTargetEXT : uint + { + HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT, + PROXY_HISTOGRAM_EXT = EXT_histogram.PROXY_HISTOGRAM_EXT, + } + + public enum ARB_pixel_buffer_object : uint + { + PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED, + PIXEL_PACK_BUFFER_ARB = 0x88EB, + PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF, + PIXEL_UNPACK_BUFFER_ARB = 0x88EC, + } + + public enum ColorTableTargetSGI : uint + { + TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI, + POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI, + PROXY_TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.PROXY_TEXTURE_COLOR_TABLE_SGI, + COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI, + PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI, + PROXY_COLOR_TABLE_SGI = SGI_color_table.PROXY_COLOR_TABLE_SGI, + PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI, + POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI, + } + + public enum SGI_texture_color_table : uint + { + TEXTURE_COLOR_TABLE_SGI = 0x80BC, + PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD, + } + + public enum OML_resample : uint + { + PACK_RESAMPLE_OML = 0x8984, + RESAMPLE_AVERAGE_OML = 0x8988, + RESAMPLE_REPLICATE_OML = 0x8986, + RESAMPLE_DECIMATE_OML = 0x8989, + UNPACK_RESAMPLE_OML = 0x8985, + RESAMPLE_ZERO_FILL_OML = 0x8987, + } + + public enum WIN_phong_shading : uint + { + PHONG_WIN = 0x80EA, + PHONG_HINT_WIN = 0x80EB, + } + + public enum SGIX_sprite : uint + { + SPRITE_SGIX = 0x8148, + SPRITE_MODE_SGIX = 0x8149, + SPRITE_TRANSLATION_SGIX = 0x814B, + SPRITE_AXIS_SGIX = 0x814A, + SPRITE_AXIAL_SGIX = 0x814C, + SPRITE_OBJECT_ALIGNED_SGIX = 0x814D, + SPRITE_EYE_ALIGNED_SGIX = 0x814E, + } + + public enum EXT_pixel_transform_color_table : uint + { + } + + public enum SGIX_async_pixel : uint + { + ASYNC_TEX_IMAGE_SGIX = 0x835C, + MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F, + ASYNC_DRAW_PIXELS_SGIX = 0x835D, + ASYNC_READ_PIXELS_SGIX = 0x835E, + MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360, + MAX_ASYNC_READ_PIXELS_SGIX = 0x8361, + } + + public enum BeginMode : uint + { + QUAD_STRIP = 0x0008, + POLYGON = 0x0009, + LINES = 0x0001, + TRIANGLES = 0x0004, + TRIANGLE_STRIP = 0x0005, + LINE_LOOP = 0x0002, + LINE_STRIP = 0x0003, + QUADS = 0x0007, + TRIANGLE_FAN = 0x0006, + POINTS = 0x0000, + } + + public enum ListMode : uint + { + COMPILE = 0x1300, + COMPILE_AND_EXECUTE = 0x1301, + } + + public enum GetMapQuery : uint + { + ORDER = 0x0A01, + DOMAIN = 0x0A02, + COEFF = 0x0A00, + } + + public enum ARB_matrix_palette : uint + { + MAX_PALETTE_MATRICES_ARB = 0x8842, + CURRENT_MATRIX_INDEX_ARB = 0x8845, + MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849, + MATRIX_INDEX_ARRAY_ARB = 0x8844, + MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846, + CURRENT_PALETTE_MATRIX_ARB = 0x8843, + MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841, + MATRIX_PALETTE_ARB = 0x8840, + MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848, + MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847, + } + + public enum TextureParameterName : uint + { + TEXTURE_BORDER_COLOR = GetTextureParameter.TEXTURE_BORDER_COLOR, + TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX, + TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX, + POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX, + TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX, + GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS, + TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX, + TEXTURE_COMPARE_OPERATOR_SGIX = SGIX_shadow.TEXTURE_COMPARE_OPERATOR_SGIX, + QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS, + TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX, + TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX, + TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX, + TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX, + TEXTURE_MAG_FILTER = 0x2800, + SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX, + TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS, + DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS, + TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX, + DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS, + TEXTURE_WRAP_S = 0x2802, + TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX, + POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX, + DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS, + TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT, + TEXTURE_MIN_FILTER = 0x2801, + TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX, + TEXTURE_WRAP_T = 0x2803, + TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX, + TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX, + TEXTURE_PRIORITY = GetTextureParameter.TEXTURE_PRIORITY, + } + + public enum SGI_depth_pass_instrument : uint + { + DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311, + DEPTH_PASS_INSTRUMENT_SGIX = 0x8310, + DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312, + } + + public enum FrontFaceDirection : uint + { + CCW = 0x0901, + CW = 0x0900, + } + + public enum NV_point_sprite : uint + { + COORD_REPLACE_NV = 0x8862, + POINT_SPRITE_R_MODE_NV = 0x8863, + POINT_SPRITE_NV = 0x8861, + } + + public enum INGR_palette_buffer : uint + { + } + + public enum PolygonMode : uint + { + FILL = 0x1B02, + LINE = 0x1B01, + POINT = 0x1B00, + } + + public enum NV_fog_distance : uint + { + EYE_PLANE = TextureGenParameter.EYE_PLANE, + FOG_DISTANCE_MODE_NV = 0x855A, + EYE_RADIAL_NV = 0x855B, + EYE_PLANE_ABSOLUTE_NV = 0x855C, + } + + public enum MaterialFace : uint + { + BACK = DrawBufferMode.BACK, + FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK, + FRONT = DrawBufferMode.FRONT, + } + + public enum BlendingFactorDest : uint + { + ZERO = 0, + ONE_MINUS_SRC_ALPHA = 0x0303, + ONE_MINUS_DST_ALPHA = 0x0305, + CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT, + DST_ALPHA = 0x0304, + CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT, + ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT, + ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT, + SRC_ALPHA = 0x0302, + SRC_COLOR = 0x0300, + ONE_MINUS_SRC_COLOR = 0x0301, + ONE = 1, + } + + public enum MatrixMode : uint + { + PROJECTION = 0x1701, + MODELVIEW = 0x1700, + TEXTURE = 0x1702, + } + + public enum TextureMagFilter : uint + { + LINEAR = 0x2601, + PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX, + FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS, + LINEAR_SHARPEN_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_SGIS, + PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX, + LINEAR_DETAIL_SGIS = SGIS_detail_texture.LINEAR_DETAIL_SGIS, + PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX, + NEAREST = 0x2600, + LINEAR_SHARPEN_COLOR_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_COLOR_SGIS, + LINEAR_SHARPEN_ALPHA_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_ALPHA_SGIS, + LINEAR_DETAIL_ALPHA_SGIS = SGIS_detail_texture.LINEAR_DETAIL_ALPHA_SGIS, + LINEAR_DETAIL_COLOR_SGIS = SGIS_detail_texture.LINEAR_DETAIL_COLOR_SGIS, + } + + public enum NV_evaluators : uint + { + EVAL_VERTEX_ATTRIB4_NV = 0x86CA, + EVAL_VERTEX_ATTRIB5_NV = 0x86CB, + EVAL_VERTEX_ATTRIB15_NV = 0x86D5, + MAX_MAP_TESSELLATION_NV = 0x86D6, + EVAL_VERTEX_ATTRIB3_NV = 0x86C9, + EVAL_VERTEX_ATTRIB12_NV = 0x86D2, + EVAL_VERTEX_ATTRIB14_NV = 0x86D4, + EVAL_VERTEX_ATTRIB13_NV = 0x86D3, + MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7, + MAP_TESSELLATION_NV = 0x86C2, + MAP_ATTRIB_U_ORDER_NV = 0x86C3, + EVAL_VERTEX_ATTRIB8_NV = 0x86CE, + EVAL_VERTEX_ATTRIB11_NV = 0x86D1, + EVAL_VERTEX_ATTRIB9_NV = 0x86CF, + EVAL_VERTEX_ATTRIB7_NV = 0x86CD, + EVAL_VERTEX_ATTRIB10_NV = 0x86D0, + EVAL_VERTEX_ATTRIB2_NV = 0x86C8, + EVAL_VERTEX_ATTRIB0_NV = 0x86C6, + EVAL_2D_NV = 0x86C0, + EVAL_VERTEX_ATTRIB1_NV = 0x86C7, + MAP_ATTRIB_V_ORDER_NV = 0x86C4, + EVAL_TRIANGULAR_2D_NV = 0x86C1, + EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5, + EVAL_VERTEX_ATTRIB6_NV = 0x86CC, + } + + public enum GetHistogramParameterPNameEXT : uint + { + HISTOGRAM_BLUE_SIZE_EXT = EXT_histogram.HISTOGRAM_BLUE_SIZE_EXT, + HISTOGRAM_FORMAT_EXT = EXT_histogram.HISTOGRAM_FORMAT_EXT, + HISTOGRAM_GREEN_SIZE_EXT = EXT_histogram.HISTOGRAM_GREEN_SIZE_EXT, + HISTOGRAM_ALPHA_SIZE_EXT = EXT_histogram.HISTOGRAM_ALPHA_SIZE_EXT, + HISTOGRAM_LUMINANCE_SIZE_EXT = EXT_histogram.HISTOGRAM_LUMINANCE_SIZE_EXT, + HISTOGRAM_RED_SIZE_EXT = EXT_histogram.HISTOGRAM_RED_SIZE_EXT, + HISTOGRAM_SINK_EXT = EXT_histogram.HISTOGRAM_SINK_EXT, + HISTOGRAM_WIDTH_EXT = EXT_histogram.HISTOGRAM_WIDTH_EXT, + } + + public enum CullFaceMode : uint + { + BACK = DrawBufferMode.BACK, + FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK, + FRONT = DrawBufferMode.FRONT, + } + + public enum ARB_color_buffer_float : uint + { + CLAMP_READ_COLOR_ARB = 0x891C, + CLAMP_FRAGMENT_COLOR_ARB = 0x891B, + FIXED_ONLY_ARB = 0x891D, + CLAMP_VERTEX_COLOR_ARB = 0x891A, + RGBA_FLOAT_MODE_ARB = 0x8820, + } + + public enum ConvolutionBorderModeEXT : uint + { + REDUCE_EXT = EXT_convolution.REDUCE_EXT, + } + + public enum SGIX_blend_alpha_minmax : uint + { + ALPHA_MAX_SGIX = 0x8321, + ALPHA_MIN_SGIX = 0x8320, + } + + public enum MinmaxTargetEXT : uint + { + MINMAX_EXT = EXT_histogram.MINMAX_EXT, + } + + public enum FfdMaskSGIX : uint + { + GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002, + TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001, + } + + public enum TextureEnvParameter : uint + { + TEXTURE_ENV_COLOR = 0x2201, + TEXTURE_ENV_MODE = 0x2200, + } + + public enum ARB_shading_language_100 : uint + { + SHADING_LANGUAGE_VERSION_ARB = 0x8B8C, + } + + public enum _3DFX_multisample : uint + { + SAMPLE_BUFFERS_3DFX = 0x86B3, + MULTISAMPLE_BIT_3DFX = 0x20000000, + MULTISAMPLE_3DFX = 0x86B2, + SAMPLES_3DFX = 0x86B4, + } + + public enum DrawBufferMode : uint + { + FRONT_RIGHT = 0x0401, + AUX3 = 0x040C, + AUX1 = 0x040A, + FRONT_AND_BACK = 0x0408, + LEFT = 0x0406, + NONE = 0, + RIGHT = 0x0407, + BACK_RIGHT = 0x0403, + AUX2 = 0x040B, + AUX0 = 0x0409, + FRONT_LEFT = 0x0400, + BACK = 0x0405, + FRONT = 0x0404, + BACK_LEFT = 0x0402, + } + + public enum ShadingModel : uint + { + SMOOTH = 0x1D01, + FLAT = 0x1D00, + } + + public enum EXT_coordinate_frame : uint + { + BINORMAL_ARRAY_STRIDE_EXT = 0x8441, + BINORMAL_ARRAY_TYPE_EXT = 0x8440, + MAP1_TANGENT_EXT = 0x8444, + TANGENT_ARRAY_POINTER_EXT = 0x8442, + CURRENT_TANGENT_EXT = 0x843B, + MAP1_BINORMAL_EXT = 0x8446, + TANGENT_ARRAY_TYPE_EXT = 0x843E, + CURRENT_BINORMAL_EXT = 0x843C, + MAP2_TANGENT_EXT = 0x8445, + MAP2_BINORMAL_EXT = 0x8447, + BINORMAL_ARRAY_EXT = 0x843A, + TANGENT_ARRAY_STRIDE_EXT = 0x843F, + TANGENT_ARRAY_EXT = 0x8439, + BINORMAL_ARRAY_POINTER_EXT = 0x8443, + } + + public enum EXT_texture3D : uint + { + TEXTURE_WRAP_R = 0x8072, + UNPACK_IMAGE_HEIGHT_EXT = 0x806E, + PROXY_TEXTURE_3D = 0x8070, + UNPACK_SKIP_IMAGES_EXT = 0x806D, + MAX_3D_TEXTURE_SIZE = 0x8073, + TEXTURE_3D_EXT = 0x806F, + PACK_SKIP_IMAGES = 0x806B, + PACK_IMAGE_HEIGHT = 0x806C, + PROXY_TEXTURE_3D_EXT = 0x8070, + MAX_3D_TEXTURE_SIZE_EXT = 0x8073, + TEXTURE_DEPTH_EXT = 0x8071, + TEXTURE_DEPTH = 0x8071, + PACK_SKIP_IMAGES_EXT = 0x806B, + TEXTURE_WRAP_R_EXT = 0x8072, + UNPACK_SKIP_IMAGES = 0x806D, + UNPACK_IMAGE_HEIGHT = 0x806E, + TEXTURE_3D = 0x806F, + PACK_IMAGE_HEIGHT_EXT = 0x806C, + } + + public enum ColorMaterialParameter : uint + { + EMISSION = MaterialParameter.EMISSION, + DIFFUSE = LightParameter.DIFFUSE, + AMBIENT_AND_DIFFUSE = MaterialParameter.AMBIENT_AND_DIFFUSE, + SPECULAR = LightParameter.SPECULAR, + AMBIENT = LightParameter.AMBIENT, + } + + public enum TextureWrapMode : uint + { + CLAMP_TO_BORDER_SGIS = SGIS_texture_border_clamp.CLAMP_TO_BORDER_SGIS, + CLAMP = 0x2900, + REPEAT = 0x2901, + CLAMP_TO_EDGE_SGIS = SGIS_texture_edge_clamp.CLAMP_TO_EDGE_SGIS, + } + + public enum SGIX_interlace : uint + { + INTERLACE_SGIX = 0x8094, + } + + public enum EXT_vertex_array : uint + { + TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092, + NORMAL_ARRAY_COUNT_EXT = 0x8080, + INDEX_ARRAY_TYPE_EXT = 0x8085, + VERTEX_ARRAY_TYPE_EXT = 0x807B, + INDEX_ARRAY_COUNT_EXT = 0x8087, + TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088, + COLOR_ARRAY_POINTER_EXT = 0x8090, + INDEX_ARRAY_POINTER_EXT = 0x8091, + COLOR_ARRAY_TYPE_EXT = 0x8082, + NORMAL_ARRAY_POINTER_EXT = 0x808F, + TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B, + VERTEX_ARRAY_SIZE_EXT = 0x807A, + VERTEX_ARRAY_STRIDE_EXT = 0x807C, + VERTEX_ARRAY_POINTER_EXT = 0x808E, + INDEX_ARRAY_STRIDE_EXT = 0x8086, + VERTEX_ARRAY_COUNT_EXT = 0x807D, + EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093, + TEXTURE_COORD_ARRAY_EXT = 0x8078, + VERTEX_ARRAY_EXT = 0x8074, + TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A, + COLOR_ARRAY_EXT = 0x8076, + COLOR_ARRAY_SIZE_EXT = 0x8081, + TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089, + NORMAL_ARRAY_TYPE_EXT = 0x807E, + NORMAL_ARRAY_STRIDE_EXT = 0x807F, + COLOR_ARRAY_COUNT_EXT = 0x8084, + EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C, + EDGE_FLAG_ARRAY_EXT = 0x8079, + INDEX_ARRAY_EXT = 0x8077, + NORMAL_ARRAY_EXT = 0x8075, + EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D, + COLOR_ARRAY_STRIDE_EXT = 0x8083, + } + + public enum NV_texture_env_combine4 : uint + { + COMBINE4_NV = 0x8503, + SOURCE3_RGB_NV = 0x8583, + SOURCE3_ALPHA_NV = 0x858B, + OPERAND3_RGB_NV = 0x8593, + OPERAND3_ALPHA_NV = 0x859B, + } + + public enum PixelCopyType : uint + { + DEPTH = 0x1801, + COLOR = 0x1800, + STENCIL = 0x1802, + } + + public enum LightParameter : uint + { + POSITION = 0x1203, + SPOT_DIRECTION = 0x1204, + LINEAR_ATTENUATION = 0x1208, + SPOT_CUTOFF = 0x1206, + SPOT_EXPONENT = 0x1205, + CONSTANT_ATTENUATION = 0x1207, + QUADRATIC_ATTENUATION = 0x1209, + SPECULAR = 0x1202, + DIFFUSE = 0x1201, + AMBIENT = 0x1200, + } + + public enum GetMinmaxParameterPNameEXT : uint + { + MINMAX_SINK_EXT = EXT_histogram.MINMAX_SINK_EXT, + MINMAX_FORMAT_EXT = EXT_histogram.MINMAX_FORMAT_EXT, + } + + public enum IBM_multimode_draw_arrays : uint + { + } + + public enum NV_vertex_program2_option : uint + { + MAX_PROGRAM_CALL_DEPTH_NV = NV_fragment_program2.MAX_PROGRAM_CALL_DEPTH_NV, + MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = NV_fragment_program2.MAX_PROGRAM_EXEC_INSTRUCTIONS_NV, + } + + public enum NV_primitive_restart : uint + { + PRIMITIVE_RESTART_NV = 0x8558, + PRIMITIVE_RESTART_INDEX_NV = 0x8559, + } + + public enum NV_vertex_program : uint + { + VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643, + MAP1_VERTEX_ATTRIB12_4_NV = 0x866C, + ATTRIB_ARRAY_SIZE_NV = 0x8623, + MATRIX7_NV = 0x8637, + MAP2_VERTEX_ATTRIB14_4_NV = 0x867E, + VERTEX_ATTRIB_ARRAY2_NV = 0x8652, + MAP2_VERTEX_ATTRIB15_4_NV = 0x867F, + VERTEX_ATTRIB_ARRAY9_NV = 0x8659, + MAP2_VERTEX_ATTRIB12_4_NV = 0x867C, + MAP2_VERTEX_ATTRIB3_4_NV = 0x8673, + VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642, + MODELVIEW_PROJECTION_NV = 0x8629, + MAP2_VERTEX_ATTRIB2_4_NV = 0x8672, + MAP2_VERTEX_ATTRIB11_4_NV = 0x867B, + VERTEX_ATTRIB_ARRAY8_NV = 0x8658, + CURRENT_MATRIX_NV = 0x8641, + VERTEX_PROGRAM_BINDING_NV = 0x864A, + VERTEX_ATTRIB_ARRAY0_NV = 0x8650, + MAP2_VERTEX_ATTRIB1_4_NV = 0x8671, + VERTEX_ATTRIB_ARRAY7_NV = 0x8657, + PROGRAM_PARAMETER_NV = 0x8644, + VERTEX_PROGRAM_NV = 0x8620, + ATTRIB_ARRAY_POINTER_NV = 0x8645, + PROGRAM_STRING_NV = 0x8628, + MAP2_VERTEX_ATTRIB0_4_NV = 0x8670, + VERTEX_ATTRIB_ARRAY4_NV = 0x8654, + MAP1_VERTEX_ATTRIB7_4_NV = 0x8667, + PROGRAM_TARGET_NV = 0x8646, + MAP1_VERTEX_ATTRIB11_4_NV = 0x866B, + MAP2_VERTEX_ATTRIB7_4_NV = 0x8677, + VERTEX_ATTRIB_ARRAY6_NV = 0x8656, + MAP1_VERTEX_ATTRIB8_4_NV = 0x8668, + VERTEX_ATTRIB_ARRAY5_NV = 0x8655, + VERTEX_STATE_PROGRAM_NV = 0x8621, + MAP1_VERTEX_ATTRIB9_4_NV = 0x8669, + IDENTITY_NV = 0x862A, + MAP2_VERTEX_ATTRIB6_4_NV = 0x8676, + MATRIX4_NV = 0x8634, + PROGRAM_RESIDENT_NV = 0x8647, + MAP1_VERTEX_ATTRIB5_4_NV = 0x8665, + MAP2_VERTEX_ATTRIB4_4_NV = 0x8674, + MAP1_VERTEX_ATTRIB6_4_NV = 0x8666, + MAP1_VERTEX_ATTRIB13_4_NV = 0x866D, + MAP2_VERTEX_ATTRIB5_4_NV = 0x8675, + MAP1_VERTEX_ATTRIB10_4_NV = 0x866A, + MAP1_VERTEX_ATTRIB1_4_NV = 0x8661, + MAP2_VERTEX_ATTRIB13_4_NV = 0x867D, + VERTEX_ATTRIB_ARRAY3_NV = 0x8653, + ATTRIB_ARRAY_TYPE_NV = 0x8625, + MAP1_VERTEX_ATTRIB14_4_NV = 0x866E, + MAP1_VERTEX_ATTRIB2_4_NV = 0x8662, + TRACK_MATRIX_TRANSFORM_NV = 0x8649, + MATRIX0_NV = 0x8630, + MAP1_VERTEX_ATTRIB3_4_NV = 0x8663, + MAP2_VERTEX_ATTRIB10_4_NV = 0x867A, + INVERSE_NV = 0x862B, + VERTEX_ATTRIB_ARRAY14_NV = 0x865E, + VERTEX_ATTRIB_ARRAY15_NV = 0x865F, + VERTEX_ATTRIB_ARRAY12_NV = 0x865C, + MAX_TRACK_MATRICES_NV = 0x862F, + MAP1_VERTEX_ATTRIB4_4_NV = 0x8664, + VERTEX_ATTRIB_ARRAY11_NV = 0x865B, + VERTEX_ATTRIB_ARRAY13_NV = 0x865D, + VERTEX_ATTRIB_ARRAY10_NV = 0x865A, + MATRIX6_NV = 0x8636, + PROGRAM_LENGTH_NV = 0x8627, + MAP1_VERTEX_ATTRIB0_4_NV = 0x8660, + VERTEX_ATTRIB_ARRAY1_NV = 0x8651, + MAP1_VERTEX_ATTRIB15_4_NV = 0x866F, + MAP2_VERTEX_ATTRIB9_4_NV = 0x8679, + INVERSE_TRANSPOSE_NV = 0x862D, + PROGRAM_ERROR_POSITION_NV = 0x864B, + TRACK_MATRIX_NV = 0x8648, + MAP2_VERTEX_ATTRIB8_4_NV = 0x8678, + CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640, + MATRIX1_NV = 0x8631, + ATTRIB_ARRAY_STRIDE_NV = 0x8624, + MATRIX3_NV = 0x8633, + MATRIX5_NV = 0x8635, + TRANSPOSE_NV = 0x862C, + MATRIX2_NV = 0x8632, + CURRENT_ATTRIB_NV = 0x8626, + MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E, + } + + public enum ARB_shadow_ambient : uint + { + TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF, + } + + public enum FragmentLightModelParameterSGIX : uint + { + FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX, + FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX, + FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX, + FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX, + } + + public enum StringName : uint + { + EXTENSIONS = 0x1F03, + VERSION = 0x1F02, + RENDERER = 0x1F01, + VENDOR = 0x1F00, + } + + public enum MESA_pack_invert : uint + { + PACK_INVERT_MESA = 0x8758, + } + + public enum NV_texgen_reflection : uint + { + NORMAL_MAP_NV = 0x8511, + REFLECTION_MAP_NV = 0x8512, + } + + public enum FfdTargetSGIX : uint + { + GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX, + TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX, + } + + public enum EnableCap : uint + { + MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3, + MAP2_NORMAL = GetPName.MAP2_NORMAL, + FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX, + CLIP_PLANE4 = GetPName.CLIP_PLANE4, + ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX, + FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX, + HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT, + LIGHT3 = GetPName.LIGHT3, + POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI, + CLIP_PLANE3 = GetPName.CLIP_PLANE3, + TEXTURE_COORD_ARRAY = GetPName.TEXTURE_COORD_ARRAY, + FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX, + CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT, + ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX, + LIGHT4 = GetPName.LIGHT4, + MAP2_INDEX = GetPName.MAP2_INDEX, + MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1, + POLYGON_OFFSET_POINT = GetPName.POLYGON_OFFSET_POINT, + ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX, + TEXTURE_1D = GetPName.TEXTURE_1D, + CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT, + TEXTURE_2D = GetPName.TEXTURE_2D, + MAP1_COLOR_4 = GetPName.MAP1_COLOR_4, + INDEX_LOGIC_OP = GetPName.INDEX_LOGIC_OP, + RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT, + FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX, + SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS, + LINE_STIPPLE = GetPName.LINE_STIPPLE, + POLYGON_OFFSET_FILL = GetPName.POLYGON_OFFSET_FILL, + LIGHT0 = GetPName.LIGHT0, + FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX, + CLIP_PLANE2 = GetPName.CLIP_PLANE2, + LIGHT5 = GetPName.LIGHT5, + FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX, + REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX, + SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS, + CLIP_PLANE1 = GetPName.CLIP_PLANE1, + COLOR_LOGIC_OP = GetPName.COLOR_LOGIC_OP, + FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX, + ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX, + MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4, + MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2, + NORMAL_ARRAY = GetPName.NORMAL_ARRAY, + FOG = GetPName.FOG, + CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX, + POINT_SMOOTH = GetPName.POINT_SMOOTH, + SCISSOR_TEST = GetPName.SCISSOR_TEST, + INDEX_ARRAY = GetPName.INDEX_ARRAY, + TEXTURE_GEN_S = GetPName.TEXTURE_GEN_S, + TEXTURE_GEN_R = GetPName.TEXTURE_GEN_R, + TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT, + NORMALIZE = GetPName.NORMALIZE, + CULL_FACE = GetPName.CULL_FACE, + LIGHT1 = GetPName.LIGHT1, + MAP1_NORMAL = GetPName.MAP1_NORMAL, + DEPTH_TEST = GetPName.DEPTH_TEST, + FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX, + MINMAX_EXT = EXT_histogram.MINMAX_EXT, + POLYGON_OFFSET_LINE = GetPName.POLYGON_OFFSET_LINE, + COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI, + MAP1_INDEX = GetPName.MAP1_INDEX, + AUTO_NORMAL = GetPName.AUTO_NORMAL, + POLYGON_SMOOTH = GetPName.POLYGON_SMOOTH, + POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI, + PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX, + CLIP_PLANE0 = GetPName.CLIP_PLANE0, + SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT, + POLYGON_STIPPLE = GetPName.POLYGON_STIPPLE, + SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS, + MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3, + MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3, + IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX, + TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS, + FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX, + PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS, + LIGHT6 = GetPName.LIGHT6, + ALPHA_TEST = GetPName.ALPHA_TEST, + STENCIL_TEST = GetPName.STENCIL_TEST, + BLEND = GetPName.BLEND, + MAP2_COLOR_4 = GetPName.MAP2_COLOR_4, + FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX, + FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX, + LIGHTING = GetPName.LIGHTING, + TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI, + CLIP_PLANE5 = GetPName.CLIP_PLANE5, + LINE_SMOOTH = GetPName.LINE_SMOOTH, + SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT, + DITHER = GetPName.DITHER, + INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX, + LIGHT2 = GetPName.LIGHT2, + TEXTURE_GEN_Q = GetPName.TEXTURE_GEN_Q, + EDGE_FLAG_ARRAY = GetPName.EDGE_FLAG_ARRAY, + COLOR_ARRAY = GetPName.COLOR_ARRAY, + TEXTURE_GEN_T = GetPName.TEXTURE_GEN_T, + MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4, + MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2, + MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4, + LIGHT7 = GetPName.LIGHT7, + SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX, + FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX, + MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3, + MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1, + MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4, + MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS, + VERTEX_ARRAY = GetPName.VERTEX_ARRAY, + COLOR_MATERIAL = GetPName.COLOR_MATERIAL, + } + + public enum EXT_bgra : uint + { + BGRA = 0x80E1, + BGR_EXT = 0x80E0, + BGRA_EXT = 0x80E1, + BGR = 0x80E0, + } + + public enum SGIS_point_line_texgen : uint + { + EYE_DISTANCE_TO_LINE_SGIS = 0x81F2, + EYE_LINE_SGIS = 0x81F6, + OBJECT_LINE_SGIS = 0x81F7, + OBJECT_POINT_SGIS = 0x81F5, + OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1, + EYE_POINT_SGIS = 0x81F4, + OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3, + EYE_DISTANCE_TO_POINT_SGIS = 0x81F0, + } + + public enum EXT_texture_env_dot3 : uint + { + DOT3_RGB_EXT = 0x8740, + DOT3_RGBA_EXT = 0x8741, + } + + public enum _3DFX_texture_compression_FXT1 : uint + { + COMPRESSED_RGBA_FXT1_3DFX = 0x86B1, + COMPRESSED_RGB_FXT1_3DFX = 0x86B0, + } + + public enum REND_screen_coordinates : uint + { + SCREEN_COORDINATES_REND = 0x8490, + INVERTED_SCREEN_W_REND = 0x8491, + } + + public enum SUN_triangle_list : uint + { + R1UI_N3F_V3F_SUN = 0x85C7, + REPLACE_MIDDLE_SUN = 0x0002, + REPLACE_OLDEST_SUN = 0x0003, + R1UI_V3F_SUN = 0x85C4, + REPLACEMENT_CODE_SUN = 0x81D8, + R1UI_T2F_N3F_V3F_SUN = 0x85CA, + RESTART_SUN = 0x0001, + REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2, + R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB, + R1UI_C4F_N3F_V3F_SUN = 0x85C8, + R1UI_T2F_V3F_SUN = 0x85C9, + TRIANGLE_LIST_SUN = 0x81D7, + REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1, + R1UI_C3F_V3F_SUN = 0x85C6, + R1UI_C4UB_V3F_SUN = 0x85C5, + REPLACEMENT_CODE_ARRAY_SUN = 0x85C0, + REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3, + } + + public enum WIN_specular_fog : uint + { + FOG_SPECULAR_TEXTURE_WIN = 0x80EC, + } + + public enum EXT_paletted_texture : uint + { + COLOR_INDEX1_EXT = 0x80E2, + TEXTURE_INDEX_SIZE_EXT = 0x80ED, + COLOR_INDEX8_EXT = 0x80E5, + COLOR_INDEX4_EXT = 0x80E4, + COLOR_INDEX12_EXT = 0x80E6, + COLOR_INDEX2_EXT = 0x80E3, + COLOR_INDEX16_EXT = 0x80E7, + } + + public enum LogicOp : uint + { + SET = 0x150F, + EQUIV = 0x1509, + NAND = 0x150E, + NOR = 0x1508, + XOR = 0x1506, + OR = 0x1507, + COPY_INVERTED = 0x150C, + AND_INVERTED = 0x1504, + INVERT = 0x150A, + AND_REVERSE = 0x1502, + NOOP = 0x1505, + CLEAR = 0x1500, + OR_REVERSE = 0x150B, + OR_INVERTED = 0x150D, + AND = 0x1501, + COPY = 0x1503, + } + + public enum EXT_index_func : uint + { + INDEX_TEST_FUNC_EXT = 0x81B6, + INDEX_TEST_EXT = 0x81B5, + INDEX_TEST_REF_EXT = 0x81B7, + } + + public enum MESA_window_pos : uint + { + } + + public enum DepthFunction : uint + { + NEVER = AlphaFunction.NEVER, + GEQUAL = AlphaFunction.GEQUAL, + GREATER = AlphaFunction.GREATER, + ALWAYS = AlphaFunction.ALWAYS, + LEQUAL = AlphaFunction.LEQUAL, + NOTEQUAL = AlphaFunction.NOTEQUAL, + EQUAL = AlphaFunction.EQUAL, + LESS = AlphaFunction.LESS, + } + + public enum ARB_texture_non_power_of_two : uint + { + } + + public enum SGIX_resample : uint + { + UNPACK_RESAMPLE_SGIX = 0x842D, + RESAMPLE_DECIMATE_SGIX = 0x8430, + RESAMPLE_REPLICATE_SGIX = 0x842E, + PACK_RESAMPLE_SGIX = 0x842C, + RESAMPLE_ZERO_FILL_SGIX = 0x842F, + } + + public enum TextureFilterFuncSGIS : uint + { + FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS, + } + + public enum ARB_fragment_program : uint + { + MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E, + PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805, + MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C, + MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810, + MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B, + MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872, + MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F, + MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D, + PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809, + PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806, + PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807, + PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A, + FRAGMENT_PROGRAM_ARB = 0x8804, + PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808, + MAX_TEXTURE_COORDS_ARB = 0x8871, + } + + public enum SGIX_ycrcba : uint + { + YCRCBA_SGIX = 0x8319, + YCRCB_SGIX = 0x8318, + } + + public enum EXT_convolution : uint + { + CONVOLUTION_WIDTH = 0x8018, + CONVOLUTION_1D = 0x8010, + CONVOLUTION_FILTER_SCALE_EXT = 0x8014, + CONVOLUTION_2D = 0x8011, + CONVOLUTION_WIDTH_EXT = 0x8018, + POST_CONVOLUTION_ALPHA_BIAS = 0x8023, + POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F, + POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022, + CONVOLUTION_FILTER_SCALE = 0x8014, + POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D, + SEPARABLE_2D = 0x8012, + CONVOLUTION_FORMAT = 0x8017, + POST_CONVOLUTION_BLUE_SCALE = 0x801E, + CONVOLUTION_BORDER_MODE_EXT = 0x8013, + POST_CONVOLUTION_GREEN_SCALE = 0x801D, + POST_CONVOLUTION_RED_SCALE_EXT = 0x801C, + REDUCE_EXT = 0x8016, + CONVOLUTION_1D_EXT = 0x8010, + MAX_CONVOLUTION_WIDTH_EXT = 0x801A, + CONVOLUTION_FORMAT_EXT = 0x8017, + POST_CONVOLUTION_BLUE_BIAS = 0x8022, + CONVOLUTION_HEIGHT = 0x8019, + SEPARABLE_2D_EXT = 0x8012, + CONVOLUTION_2D_EXT = 0x8011, + MAX_CONVOLUTION_WIDTH = 0x801A, + POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023, + POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021, + POST_CONVOLUTION_RED_BIAS_EXT = 0x8020, + REDUCE = 0x8016, + MAX_CONVOLUTION_HEIGHT_EXT = 0x801B, + CONVOLUTION_BORDER_MODE = 0x8013, + POST_CONVOLUTION_ALPHA_SCALE = 0x801F, + POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E, + POST_CONVOLUTION_RED_BIAS = 0x8020, + CONVOLUTION_FILTER_BIAS_EXT = 0x8015, + POST_CONVOLUTION_RED_SCALE = 0x801C, + CONVOLUTION_HEIGHT_EXT = 0x8019, + MAX_CONVOLUTION_HEIGHT = 0x801B, + CONVOLUTION_FILTER_BIAS = 0x8015, + POST_CONVOLUTION_GREEN_BIAS = 0x8021, + } + + public enum EXT_depth_bounds_test : uint + { + DEPTH_BOUNDS_EXT = 0x8891, + DEPTH_BOUNDS_TEST_EXT = 0x8890, + } + + public enum MaterialParameter : uint + { + EMISSION = 0x1600, + DIFFUSE = LightParameter.DIFFUSE, + AMBIENT_AND_DIFFUSE = 0x1602, + SHININESS = 0x1601, + SPECULAR = LightParameter.SPECULAR, + AMBIENT = LightParameter.AMBIENT, + COLOR_INDEXES = 0x1603, + } + + public enum EXT_index_texture : uint + { + } + + public enum SeparableTargetEXT : uint + { + SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT, + } + + public enum HP_convolution_border_modes : uint + { + IGNORE_BORDER_HP = 0x8150, + CONVOLUTION_BORDER_COLOR = 0x8154, + CONVOLUTION_BORDER_COLOR_HP = 0x8154, + REPLICATE_BORDER_HP = 0x8153, + CONSTANT_BORDER = 0x8151, + CONSTANT_BORDER_HP = 0x8151, + REPLICATE_BORDER = 0x8153, + } + + public enum APPLE_vertex_array_range : uint + { + STORAGE_SHARED_APPLE = 0x85BF, + VERTEX_ARRAY_RANGE_APPLE = 0x851D, + VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F, + VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E, + VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521, + STORAGE_CACHED_APPLE = 0x85BE, + } + + public enum NV_blend_square : uint + { + } + + public enum PointParameterNameSGIS : uint + { + DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS, + POINT_SIZE_MAX_SGIS = SGIS_point_parameters.POINT_SIZE_MAX_SGIS, + POINT_FADE_THRESHOLD_SIZE_SGIS = SGIS_point_parameters.POINT_FADE_THRESHOLD_SIZE_SGIS, + POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_SGIS, + } + + public enum EXT_texture_mirror_clamp : uint + { + MIRROR_CLAMP_TO_BORDER_EXT = 0x8912, + MIRROR_CLAMP_TO_EDGE_EXT = 0x8743, + MIRROR_CLAMP_EXT = 0x8742, + } + + public enum NV_pixel_data_range : uint + { + READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B, + WRITE_PIXEL_DATA_RANGE_NV = 0x8878, + WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C, + READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D, + WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A, + READ_PIXEL_DATA_RANGE_NV = 0x8879, + } + + public enum PixelInternalFormat : uint + { + LUMINANCE12_ALPHA12 = 0x8047, + DUAL_LUMINANCE16_SGIS = SGIS_texture_select.DUAL_LUMINANCE16_SGIS, + QUAD_LUMINANCE8_SGIS = SGIS_texture_select.QUAD_LUMINANCE8_SGIS, + RGBA16 = 0x805B, + ALPHA_ICC_SGIX = SGIX_icc_texture.ALPHA_ICC_SGIX, + LUMINANCE12 = 0x8041, + DUAL_ALPHA4_SGIS = SGIS_texture_select.DUAL_ALPHA4_SGIS, + INTENSITY4 = 0x804A, + RGBA12 = 0x805A, + INTENSITY8 = 0x804B, + DUAL_ALPHA8_SGIS = SGIS_texture_select.DUAL_ALPHA8_SGIS, + DEPTH_COMPONENT16_SGIX = SGIX_depth_texture.DEPTH_COMPONENT16_SGIX, + ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX, + DUAL_INTENSITY12_SGIS = SGIS_texture_select.DUAL_INTENSITY12_SGIS, + LUMINANCE16 = 0x8042, + LUMINANCE_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ICC_SGIX, + DEPTH_COMPONENT24_SGIX = SGIX_depth_texture.DEPTH_COMPONENT24_SGIX, + INTENSITY = 0x8049, + QUAD_ALPHA4_SGIS = SGIS_texture_select.QUAD_ALPHA4_SGIS, + ALPHA12 = 0x803D, + INTENSITY_ICC_SGIX = SGIX_icc_texture.INTENSITY_ICC_SGIX, + LUMINANCE4 = 0x803F, + LUMINANCE_ALPHA_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ALPHA_ICC_SGIX, + RGB_ICC_SGIX = SGIX_icc_texture.RGB_ICC_SGIX, + LUMINANCE4_ALPHA4 = 0x8043, + INTENSITY16_ICC_SGIX = SGIX_icc_texture.INTENSITY16_ICC_SGIX, + RGBA_ICC_SGIX = SGIX_icc_texture.RGBA_ICC_SGIX, + DUAL_LUMINANCE12_SGIS = SGIS_texture_select.DUAL_LUMINANCE12_SGIS, + ALPHA16 = 0x803E, + DUAL_ALPHA16_SGIS = SGIS_texture_select.DUAL_ALPHA16_SGIS, + DUAL_ALPHA12_SGIS = SGIS_texture_select.DUAL_ALPHA12_SGIS, + RGB2_EXT = EXT_texture.RGB2_EXT, + LUMINANCE8 = 0x8040, + QUAD_INTENSITY8_SGIS = SGIS_texture_select.QUAD_INTENSITY8_SGIS, + DUAL_LUMINANCE_ALPHA4_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA4_SGIS, + LUMINANCE12_ALPHA4 = 0x8046, + QUAD_LUMINANCE4_SGIS = SGIS_texture_select.QUAD_LUMINANCE4_SGIS, + RGB5 = 0x8050, + DUAL_LUMINANCE_ALPHA8_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA8_SGIS, + LUMINANCE8_ALPHA8 = 0x8045, + DUAL_INTENSITY8_SGIS = SGIS_texture_select.DUAL_INTENSITY8_SGIS, + RGB8 = 0x8051, + R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX, + QUAD_ALPHA8_SGIS = SGIS_texture_select.QUAD_ALPHA8_SGIS, + DUAL_INTENSITY4_SGIS = SGIS_texture_select.DUAL_INTENSITY4_SGIS, + RGB10_A2 = 0x8059, + INTENSITY12 = 0x804C, + RGBA4 = 0x8056, + RGB5_A1 = 0x8057, + R3_G3_B2 = 0x2A10, + R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX, + RGBA2 = 0x8055, + DUAL_INTENSITY16_SGIS = SGIS_texture_select.DUAL_INTENSITY16_SGIS, + QUAD_INTENSITY4_SGIS = SGIS_texture_select.QUAD_INTENSITY4_SGIS, + DUAL_LUMINANCE8_SGIS = SGIS_texture_select.DUAL_LUMINANCE8_SGIS, + RGB16 = 0x8054, + ALPHA4 = 0x803B, + RGBA8 = 0x8058, + INTENSITY16 = 0x804D, + LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX, + LUMINANCE16_ALPHA16 = 0x8048, + LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX, + ALPHA8 = 0x803C, + RGB4 = 0x804F, + DEPTH_COMPONENT32_SGIX = SGIX_depth_texture.DEPTH_COMPONENT32_SGIX, + RGB10 = 0x8052, + RGB12 = 0x8053, + LUMINANCE6_ALPHA2 = 0x8044, + DUAL_LUMINANCE4_SGIS = SGIS_texture_select.DUAL_LUMINANCE4_SGIS, + } + + public enum ARB_vertex_blend : uint + { + MODELVIEW5_ARB = 0x8725, + MODELVIEW0_ARB = 0x1700, + ACTIVE_VERTEX_UNITS_ARB = 0x86A5, + MODELVIEW6_ARB = 0x8726, + MODELVIEW4_ARB = 0x8724, + WEIGHT_ARRAY_ARB = 0x86AD, + MODELVIEW15_ARB = 0x872F, + MODELVIEW10_ARB = 0x872A, + MODELVIEW16_ARB = 0x8730, + MODELVIEW21_ARB = 0x8735, + MODELVIEW22_ARB = 0x8736, + WEIGHT_ARRAY_POINTER_ARB = 0x86AC, + WEIGHT_SUM_UNITY_ARB = 0x86A6, + MODELVIEW1_ARB = 0x850A, + MODELVIEW29_ARB = 0x873D, + MODELVIEW11_ARB = 0x872B, + MODELVIEW12_ARB = 0x872C, + MODELVIEW19_ARB = 0x8733, + VERTEX_BLEND_ARB = 0x86A7, + MODELVIEW26_ARB = 0x873A, + MODELVIEW17_ARB = 0x8731, + CURRENT_WEIGHT_ARB = 0x86A8, + MODELVIEW27_ARB = 0x873B, + MODELVIEW23_ARB = 0x8737, + WEIGHT_ARRAY_SIZE_ARB = 0x86AB, + MAX_VERTEX_UNITS_ARB = 0x86A4, + MODELVIEW7_ARB = 0x8727, + MODELVIEW13_ARB = 0x872D, + MODELVIEW28_ARB = 0x873C, + MODELVIEW25_ARB = 0x8739, + WEIGHT_ARRAY_TYPE_ARB = 0x86A9, + MODELVIEW8_ARB = 0x8728, + WEIGHT_ARRAY_STRIDE_ARB = 0x86AA, + MODELVIEW18_ARB = 0x8732, + MODELVIEW9_ARB = 0x8729, + MODELVIEW24_ARB = 0x8738, + MODELVIEW14_ARB = 0x872E, + MODELVIEW20_ARB = 0x8734, + MODELVIEW31_ARB = 0x873F, + MODELVIEW30_ARB = 0x873E, + MODELVIEW2_ARB = 0x8722, + MODELVIEW3_ARB = 0x8723, + } + + public enum AttribMask : uint + { + POLYGON_BIT = 0x00000008, + TRANSFORM_BIT = 0x00001000, + COLOR_BUFFER_BIT = 0x00004000, + LINE_BIT = 0x00000004, + POINT_BIT = 0x00000002, + EVAL_BIT = 0x00010000, + LIST_BIT = 0x00020000, + FOG_BIT = 0x00000080, + HINT_BIT = 0x00008000, + ENABLE_BIT = 0x00002000, + STENCIL_BUFFER_BIT = 0x00000400, + TEXTURE_BIT = 0x00040000, + ACCUM_BUFFER_BIT = 0x00000200, + LIGHTING_BIT = 0x00000040, + CURRENT_BIT = 0x00000001, + ALL_ATTRIB_BITS = 0xFFFFFFFF, + DEPTH_BUFFER_BIT = 0x00000100, + POLYGON_STIPPLE_BIT = 0x00000010, + SCISSOR_BIT = 0x00080000, + VIEWPORT_BIT = 0x00000800, + PIXEL_MODE_BIT = 0x00000020, + } + + public enum SGIX_pixel_texture : uint + { + PIXEL_TEX_GEN_SGIX = 0x8139, + PIXEL_TEX_GEN_MODE_SGIX = 0x832B, + } + + public enum SGIX_framezoom : uint + { + FRAMEZOOM_FACTOR_SGIX = 0x818C, + MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D, + FRAMEZOOM_SGIX = 0x818B, + } + + public enum TextureGenParameter : uint + { + EYE_PLANE = 0x2502, + OBJECT_LINE_SGIS = SGIS_point_line_texgen.OBJECT_LINE_SGIS, + EYE_POINT_SGIS = SGIS_point_line_texgen.EYE_POINT_SGIS, + TEXTURE_GEN_MODE = 0x2500, + EYE_LINE_SGIS = SGIS_point_line_texgen.EYE_LINE_SGIS, + OBJECT_POINT_SGIS = SGIS_point_line_texgen.OBJECT_POINT_SGIS, + OBJECT_PLANE = 0x2501, + } + + public enum ReadBufferMode : uint + { + FRONT_RIGHT = DrawBufferMode.FRONT_RIGHT, + AUX3 = DrawBufferMode.AUX3, + AUX1 = DrawBufferMode.AUX1, + LEFT = DrawBufferMode.LEFT, + RIGHT = DrawBufferMode.RIGHT, + BACK_RIGHT = DrawBufferMode.BACK_RIGHT, + AUX2 = DrawBufferMode.AUX2, + AUX0 = DrawBufferMode.AUX0, + FRONT_LEFT = DrawBufferMode.FRONT_LEFT, + BACK = DrawBufferMode.BACK, + FRONT = DrawBufferMode.FRONT, + BACK_LEFT = DrawBufferMode.BACK_LEFT, + } + + public enum FeedBackToken : uint + { + BITMAP_TOKEN = 0x0704, + LINE_TOKEN = 0x0702, + PASS_THROUGH_TOKEN = 0x0700, + LINE_RESET_TOKEN = 0x0707, + POINT_TOKEN = 0x0701, + COPY_PIXEL_TOKEN = 0x0706, + DRAW_PIXEL_TOKEN = 0x0705, + POLYGON_TOKEN = 0x0703, + } + + public enum TextureMinFilter : uint + { + LINEAR = TextureMagFilter.LINEAR, + PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX, + FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS, + PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX, + NEAREST_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_NEAREST_SGIX, + LINEAR_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_NEAREST_SGIX, + NEAREST_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_LINEAR_SGIX, + NEAREST_MIPMAP_LINEAR = 0x2702, + NEAREST = TextureMagFilter.NEAREST, + NEAREST_MIPMAP_NEAREST = 0x2700, + LINEAR_MIPMAP_NEAREST = 0x2701, + LINEAR_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_LINEAR_SGIX, + LINEAR_MIPMAP_LINEAR = 0x2703, + PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX, + } + + public enum APPLE_element_array : uint + { + ELEMENT_ARRAY_POINTER_APPLE = 0x876A, + ELEMENT_ARRAY_APPLE = 0x8768, + ELEMENT_ARRAY_TYPE_APPLE = 0x8769, + } + + public enum VERSION_1_5 : uint + { + DYNAMIC_READ = 0x88E9, + VERTEX_ARRAY_BUFFER_BINDING = 0x8896, + STREAM_COPY = 0x88E2, + FOG_COORD_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE, + FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D, + READ_WRITE = 0x88BA, + SRC1_ALPHA = GL_SOURCE1_ALPHA, + TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A, + BUFFER_MAP_POINTER = 0x88BD, + QUERY_COUNTER_BITS = 0x8864, + STATIC_COPY = 0x88E6, + STATIC_DRAW = 0x88E4, + SRC2_RGB = GL_SOURCE2_RGB, + SRC2_ALPHA = GL_SOURCE2_ALPHA, + FOG_COORD_ARRAY = GL_FOG_COORDINATE_ARRAY, + FOG_COORD_SRC = GL_FOG_COORDINATE_SOURCE, + DYNAMIC_COPY = 0x88EA, + STATIC_READ = 0x88E5, + FOG_COORD_ARRAY_BUFFER_BINDING = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING, + FOG_COORD_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER, + EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B, + CURRENT_FOG_COORD = GL_CURRENT_FOG_COORDINATE, + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F, + READ_ONLY = 0x88B8, + SRC0_ALPHA = GL_SOURCE0_ALPHA, + ELEMENT_ARRAY_BUFFER = 0x8893, + CURRENT_QUERY = 0x8865, + FOG_COORD = GL_FOG_COORDINATE, + QUERY_RESULT = 0x8866, + BUFFER_USAGE = 0x8765, + BUFFER_ACCESS = 0x88BB, + STREAM_DRAW = 0x88E0, + SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C, + SRC0_RGB = GL_SOURCE0_RGB, + ARRAY_BUFFER_BINDING = 0x8894, + QUERY_RESULT_AVAILABLE = 0x8867, + WRITE_ONLY = 0x88B9, + BUFFER_SIZE = 0x8764, + WEIGHT_ARRAY_BUFFER_BINDING = 0x889E, + SRC1_RGB = GL_SOURCE1_RGB, + SAMPLES_PASSED = 0x8914, + DYNAMIC_DRAW = 0x88E8, + ARRAY_BUFFER = 0x8892, + NORMAL_ARRAY_BUFFER_BINDING = 0x8897, + COLOR_ARRAY_BUFFER_BINDING = 0x8898, + INDEX_ARRAY_BUFFER_BINDING = 0x8899, + BUFFER_MAPPED = 0x88BC, + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895, + STREAM_READ = 0x88E1, + FOG_COORD_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE, + } + + public enum ErrorCode : uint + { + OUT_OF_MEMORY = 0x0505, + TEXTURE_TOO_LARGE_EXT = EXT_texture.TEXTURE_TOO_LARGE_EXT, + STACK_OVERFLOW = 0x0503, + INVALID_ENUM = 0x0500, + INVALID_VALUE = 0x0501, + TABLE_TOO_LARGE_EXT = EXT_histogram.TABLE_TOO_LARGE_EXT, + INVALID_OPERATION = 0x0502, + STACK_UNDERFLOW = 0x0504, + NO_ERROR = 0, + } + + public enum GetPointervPName : uint + { + FEEDBACK_BUFFER_POINTER = 0x0DF0, + EDGE_FLAG_ARRAY_POINTER = 0x8093, + TEXTURE_COORD_ARRAY_POINTER = 0x8092, + INDEX_ARRAY_POINTER = 0x8091, + INSTRUMENT_BUFFER_POINTER_SGIX = SGIX_instruments.INSTRUMENT_BUFFER_POINTER_SGIX, + SELECTION_BUFFER_POINTER = 0x0DF3, + NORMAL_ARRAY_POINTER = 0x808F, + VERTEX_ARRAY_POINTER = 0x808E, + COLOR_ARRAY_POINTER = 0x8090, + } + + public enum BlendingFactorSrc : uint + { + ZERO = BlendingFactorDest.ZERO, + ONE_MINUS_SRC_ALPHA = BlendingFactorDest.ONE_MINUS_SRC_ALPHA, + ONE_MINUS_DST_COLOR = 0x0307, + ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT, + CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT, + DST_ALPHA = BlendingFactorDest.DST_ALPHA, + CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT, + SRC_ALPHA = BlendingFactorDest.SRC_ALPHA, + SRC_ALPHA_SATURATE = 0x0308, + ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT, + ONE_MINUS_DST_ALPHA = BlendingFactorDest.ONE_MINUS_DST_ALPHA, + DST_COLOR = 0x0306, + ONE = BlendingFactorDest.ONE, + } + + public enum APPLE_vertex_array_object : uint + { + VERTEX_ARRAY_BINDING_APPLE = 0x85B5, + } + + public enum ATI_fragment_shader : uint + { + REG_16_ATI = 0x8931, + CON_12_ATI = 0x894D, + REG_14_ATI = 0x892F, + CON_14_ATI = 0x894F, + HALF_BIT_ATI = 0x00000008, + NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973, + REG_25_ATI = 0x893A, + REG_10_ATI = 0x892B, + CON_6_ATI = 0x8947, + REG_15_ATI = 0x8930, + REG_2_ATI = 0x8923, + NUM_FRAGMENT_CONSTANTS_ATI = 0x896F, + QUARTER_BIT_ATI = 0x00000010, + REG_19_ATI = 0x8934, + CON_27_ATI = 0x895C, + NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971, + FRAGMENT_SHADER_ATI = 0x8920, + NUM_PASSES_ATI = 0x8970, + REG_28_ATI = 0x893D, + CON_1_ATI = 0x8942, + REG_3_ATI = 0x8924, + CON_9_ATI = 0x894A, + CON_4_ATI = 0x8945, + CON_18_ATI = 0x8953, + REG_27_ATI = 0x893C, + REG_22_ATI = 0x8937, + REG_21_ATI = 0x8936, + SWIZZLE_STR_DR_ATI = 0x8978, + REG_20_ATI = 0x8935, + CON_21_ATI = 0x8956, + MUL_ATI = 0x8964, + SATURATE_BIT_ATI = 0x00000040, + REG_0_ATI = 0x8921, + MOV_ATI = 0x8961, + SWIZZLE_STQ_DQ_ATI = 0x8979, + SWIZZLE_STQ_ATI = 0x8977, + SWIZZLE_STR_ATI = 0x8976, + REG_8_ATI = 0x8929, + CON_10_ATI = 0x894B, + CON_7_ATI = 0x8948, + DOT2_ADD_ATI = 0x896C, + CON_16_ATI = 0x8951, + CON_22_ATI = 0x8957, + REG_31_ATI = 0x8940, + MAD_ATI = 0x8968, + COLOR_ALPHA_PAIRING_ATI = 0x8975, + CON_24_ATI = 0x8959, + REG_30_ATI = 0x893F, + CON_13_ATI = 0x894E, + REG_1_ATI = 0x8922, + CON_15_ATI = 0x8950, + REG_18_ATI = 0x8933, + SECONDARY_INTERPOLATOR_ATI = 0x896D, + REG_9_ATI = 0x892A, + BLUE_BIT_ATI = 0x00000004, + CON_2_ATI = 0x8943, + LERP_ATI = 0x8969, + REG_17_ATI = 0x8932, + _4X_BIT_ATI = 0x00000002, + REG_12_ATI = 0x892D, + REG_11_ATI = 0x892C, + CND0_ATI = 0x896B, + REG_6_ATI = 0x8927, + REG_23_ATI = 0x8938, + CON_29_ATI = 0x895E, + SWIZZLE_STRQ_DQ_ATI = 0x897B, + NEGATE_BIT_ATI = 0x00000004, + CON_31_ATI = 0x8960, + CON_5_ATI = 0x8946, + _8X_BIT_ATI = 0x00000004, + CON_8_ATI = 0x8949, + COMP_BIT_ATI = 0x00000002, + REG_26_ATI = 0x893B, + CON_26_ATI = 0x895B, + REG_24_ATI = 0x8939, + BIAS_BIT_ATI = 0x00000008, + RED_BIT_ATI = 0x00000001, + CON_28_ATI = 0x895D, + CND_ATI = 0x896A, + CON_17_ATI = 0x8952, + REG_7_ATI = 0x8928, + CON_19_ATI = 0x8954, + EIGHTH_BIT_ATI = 0x00000020, + CON_30_ATI = 0x895F, + NUM_LOOPBACK_COMPONENTS_ATI = 0x8974, + REG_4_ATI = 0x8925, + CON_0_ATI = 0x8941, + ADD_ATI = 0x8963, + GREEN_BIT_ATI = 0x00000002, + DOT3_ATI = 0x8966, + CON_20_ATI = 0x8955, + REG_29_ATI = 0x893E, + CON_11_ATI = 0x894C, + CON_3_ATI = 0x8944, + NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972, + SUB_ATI = 0x8965, + _2X_BIT_ATI = 0x00000001, + NUM_FRAGMENT_REGISTERS_ATI = 0x896E, + REG_13_ATI = 0x892E, + CON_23_ATI = 0x8958, + DOT4_ATI = 0x8967, + SWIZZLE_STRQ_ATI = 0x897A, + REG_5_ATI = 0x8926, + CON_25_ATI = 0x895A, + } + + public enum SGIX_list_priority : uint + { + LIST_PRIORITY_SGIX = 0x8182, + } + + public enum FeedbackType : uint + { + _3D_COLOR_TEXTURE = 0x0603, + _4D_COLOR_TEXTURE = 0x0604, + _3D_COLOR = 0x0602, + _2D = 0x0600, + _3D = 0x0601, + } + + public enum ARB_point_sprite : uint + { + POINT_SPRITE_ARB = 0x8861, + COORD_REPLACE_ARB = 0x8862, + } + + public enum INGR_color_clamp : uint + { + BLUE_MIN_CLAMP_INGR = 0x8562, + RED_MAX_CLAMP_INGR = 0x8564, + ALPHA_MAX_CLAMP_INGR = 0x8567, + ALPHA_MIN_CLAMP_INGR = 0x8563, + GREEN_MAX_CLAMP_INGR = 0x8565, + BLUE_MAX_CLAMP_INGR = 0x8566, + GREEN_MIN_CLAMP_INGR = 0x8561, + RED_MIN_CLAMP_INGR = 0x8560, + } + + public enum PGI_misc_hints : uint + { + FULL_STIPPLE_HINT_PGI = 0x1A219, + BACK_NORMALS_HINT_PGI = 0x1A223, + ALLOW_DRAW_MEM_HINT_PGI = 0x1A211, + ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F, + ALWAYS_FAST_HINT_PGI = 0x1A20C, + NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202, + CONSERVE_MEMORY_HINT_PGI = 0x1A1FD, + PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8, + STRICT_LIGHTING_HINT_PGI = 0x1A217, + CLIP_FAR_HINT_PGI = 0x1A221, + CLIP_NEAR_HINT_PGI = 0x1A220, + STRICT_SCISSOR_HINT_PGI = 0x1A218, + ALLOW_DRAW_FRG_HINT_PGI = 0x1A210, + ALWAYS_SOFT_HINT_PGI = 0x1A20D, + NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203, + ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E, + NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204, + RECLAIM_MEMORY_HINT_PGI = 0x1A1FE, + STRICT_DEPTHFUNC_HINT_PGI = 0x1A216, + WIDE_LINE_HINT_PGI = 0x1A222, + } + + public enum SGIS_pixel_texture : uint + { + PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354, + PIXEL_TEXTURE_SGIS = 0x8353, + PIXEL_GROUP_COLOR_SGIS = 0x8356, + PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355, + } + + public enum SUNX_constant_data : uint + { + TEXTURE_CONSTANT_DATA_SUNX = 0x81D6, + UNPACK_CONSTANT_DATA_SUNX = 0x81D5, + } + + public enum APPLE_ycbcr_422 : uint + { + UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB, + YCBCR_422_APPLE = 0x85B9, + UNSIGNED_SHORT_8_8_APPLE = 0x85BA, + } + + public enum ARB_vertex_shader : uint + { + MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D, + VERTEX_SHADER_ARB = 0x8B31, + OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89, + MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C, + MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A, + MAX_VARYING_FLOATS_ARB = 0x8B4B, + OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A, + } + + public enum EXT_shadow_funcs : uint + { + } + + public enum EXT_blend_func_separate : uint + { + BLEND_SRC_ALPHA_EXT = 0x80CB, + BLEND_DST_RGB_EXT = 0x80C8, + BLEND_DST_ALPHA_EXT = 0x80CA, + BLEND_SRC_RGB_EXT = 0x80C9, + } + + public enum SGIS_texture_lod : uint + { + TEXTURE_MAX_LOD_SGIS = 0x813B, + TEXTURE_MAX_LEVEL = 0x813D, + TEXTURE_BASE_LEVEL_SGIS = 0x813C, + TEXTURE_MIN_LOD_SGIS = 0x813A, + TEXTURE_MIN_LOD = 0x813A, + TEXTURE_MAX_LOD = 0x813B, + TEXTURE_BASE_LEVEL = 0x813C, + TEXTURE_MAX_LEVEL_SGIS = 0x813D, + } + + public enum SGIX_depth_texture : uint + { + DEPTH_COMPONENT16_SGIX = 0x81A5, + DEPTH_COMPONENT32_SGIX = 0x81A7, + DEPTH_COMPONENT16 = 0x81A5, + DEPTH_COMPONENT24 = 0x81A6, + DEPTH_COMPONENT24_SGIX = 0x81A6, + DEPTH_COMPONENT32 = 0x81A7, + } + + public enum EXT_texture_perturb_normal : uint + { + TEXTURE_NORMAL_EXT = 0x85AF, + PERTURB_EXT = 0x85AE, + } + + public enum EXT_light_texture : uint + { + ATTENUATION_EXT = 0x834D, + FRAGMENT_DEPTH_EXT = EXT_fog_coord.FRAGMENT_DEPTH_EXT, + TEXTURE_LIGHT_EXT = 0x8350, + FRAGMENT_NORMAL_EXT = 0x834A, + FRAGMENT_MATERIAL_EXT = 0x8349, + TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352, + TEXTURE_MATERIAL_FACE_EXT = 0x8351, + SHADOW_ATTENUATION_EXT = 0x834E, + FRAGMENT_COLOR_EXT = 0x834C, + TEXTURE_APPLICATION_MODE_EXT = 0x834F, + } + + public enum Boolean : uint + { + TRUE = 1, + FALSE = 0, + } + + public enum ARB_texture_rectangle : uint + { + TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6, + TEXTURE_RECTANGLE_ARB = 0x84F5, + MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8, + PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7, + } + + public enum SGIX_reference_plane : uint + { + REFERENCE_PLANE_EQUATION_SGIX = 0x817E, + REFERENCE_PLANE_SGIX = 0x817D, + } + + public enum StencilOp : uint + { + REPLACE = 0x1E01, + DECR = 0x1E03, + INVERT = LogicOp.INVERT, + INCR = 0x1E02, + KEEP = 0x1E00, + ZERO = BlendingFactorDest.ZERO, + } + + public enum EXT_multisample : uint + { + SAMPLE_MASK_EXT = 0x80A0, + MULTISAMPLE_EXT = 0x809D, + _4PASS_3_EXT = 0x80A7, + _4PASS_2_EXT = 0x80A6, + SAMPLE_PATTERN_EXT = 0x80AC, + SAMPLE_ALPHA_TO_MASK_EXT = 0x809E, + _2PASS_1_EXT = 0x80A3, + SAMPLES_EXT = 0x80A9, + SAMPLE_MASK_INVERT_EXT = 0x80AB, + SAMPLE_BUFFERS_EXT = 0x80A8, + MULTISAMPLE_BIT_EXT = 0x20000000, + _4PASS_1_EXT = 0x80A5, + SAMPLE_MASK_VALUE_EXT = 0x80AA, + _2PASS_0_EXT = 0x80A2, + _1PASS_EXT = 0x80A1, + _4PASS_0_EXT = 0x80A4, + SAMPLE_ALPHA_TO_ONE_EXT = 0x809F, + } + + public enum HP_texture_lighting : uint + { + TEXTURE_LIGHTING_MODE_HP = 0x8167, + TEXTURE_PRE_SPECULAR_HP = 0x8169, + TEXTURE_POST_SPECULAR_HP = 0x8168, + } + + public enum SGIS_texture4D : uint + { + TEXTURE_4D_BINDING_SGIS = 0x814F, + PACK_IMAGE_DEPTH_SGIS = 0x8131, + MAX_4D_TEXTURE_SIZE_SGIS = 0x8138, + PACK_SKIP_VOLUMES_SGIS = 0x8130, + TEXTURE_4D_SGIS = 0x8134, + PROXY_TEXTURE_4D_SGIS = 0x8135, + UNPACK_IMAGE_DEPTH_SGIS = 0x8133, + UNPACK_SKIP_VOLUMES_SGIS = 0x8132, + TEXTURE_4DSIZE_SGIS = 0x8136, + TEXTURE_WRAP_Q_SGIS = 0x8137, + } + + public enum ColorPointerType : uint + { + UNSIGNED_INT = DataType.UNSIGNED_INT, + FLOAT = DataType.FLOAT, + UNSIGNED_SHORT = DataType.UNSIGNED_SHORT, + SHORT = DataType.SHORT, + BYTE = DataType.BYTE, + INT = DataType.INT, + UNSIGNED_BYTE = DataType.UNSIGNED_BYTE, + DOUBLE = DataType.DOUBLE, + } + + public enum VertexPointerType : uint + { + DOUBLE = DataType.DOUBLE, + INT = DataType.INT, + SHORT = DataType.SHORT, + FLOAT = DataType.FLOAT, + } + + public enum EXT_shared_texture_palette : uint + { + SHARED_TEXTURE_PALETTE_EXT = 0x81FB, + } + + public enum ATI_vertex_array_object : uint + { + ARRAY_OBJECT_BUFFER_ATI = 0x8766, + PRESERVE_ATI = 0x8762, + DISCARD_ATI = 0x8763, + STATIC_ATI = 0x8760, + ARRAY_OBJECT_OFFSET_ATI = 0x8767, + OBJECT_BUFFER_SIZE_ATI = 0x8764, + OBJECT_BUFFER_USAGE_ATI = 0x8765, + DYNAMIC_ATI = 0x8761, + } + + public enum PixelTexGenParameterNameSGIS : uint + { + PIXEL_FRAGMENT_RGB_SOURCE_SGIS = SGIS_pixel_texture.PIXEL_FRAGMENT_RGB_SOURCE_SGIS, + PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = SGIS_pixel_texture.PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS, + } + + public enum EXT_blend_equation_separate : uint + { + BLEND_EQUATION_RGB_EXT = GL_BLEND_EQUATION, + BLEND_EQUATION_ALPHA_EXT = 0x883D, + } + + public enum PixelStoreResampleMode : uint + { + RESAMPLE_DECIMATE_SGIX = SGIX_resample.RESAMPLE_DECIMATE_SGIX, + RESAMPLE_REPLICATE_SGIX = SGIX_resample.RESAMPLE_REPLICATE_SGIX, + RESAMPLE_ZERO_FILL_SGIX = SGIX_resample.RESAMPLE_ZERO_FILL_SGIX, + } + + public enum SGIX_fragment_lighting : uint + { + FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402, + FRAGMENT_LIGHT1_SGIX = 0x840D, + LIGHT_ENV_MODE_SGIX = 0x8407, + FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408, + CURRENT_RASTER_NORMAL_SGIX = 0x8406, + FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403, + FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B, + MAX_FRAGMENT_LIGHTS_SGIX = 0x8404, + FRAGMENT_LIGHT4_SGIX = 0x8410, + FRAGMENT_LIGHT5_SGIX = 0x8411, + FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A, + FRAGMENT_LIGHTING_SGIX = 0x8400, + FRAGMENT_LIGHT6_SGIX = 0x8412, + MAX_ACTIVE_LIGHTS_SGIX = 0x8405, + FRAGMENT_LIGHT2_SGIX = 0x840E, + FRAGMENT_LIGHT0_SGIX = 0x840C, + FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401, + FRAGMENT_LIGHT3_SGIX = 0x840F, + FRAGMENT_LIGHT7_SGIX = 0x8413, + FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409, + } + + public enum NV_depth_clamp : uint + { + DEPTH_CLAMP_NV = 0x864F, + } + + public enum EXT_blend_subtract : uint + { + FUNC_SUBTRACT = 0x800A, + FUNC_REVERSE_SUBTRACT = 0x800B, + FUNC_REVERSE_SUBTRACT_EXT = 0x800B, + FUNC_SUBTRACT_EXT = 0x800A, + } + + public enum ARB_vertex_program : uint + { + VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A, + MATRIX9_ARB = 0x88C9, + MATRIX24_ARB = 0x88D8, + MATRIX25_ARB = 0x88D9, + TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7, + MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB, + MATRIX22_ARB = 0x88D6, + MAX_PROGRAM_MATRICES_ARB = 0x862F, + PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA, + PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2, + MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3, + PROGRAM_FORMAT_ARB = 0x8876, + MATRIX8_ARB = 0x88C8, + MAX_PROGRAM_PARAMETERS_ARB = 0x88A9, + MATRIX13_ARB = 0x88CD, + MATRIX31_ARB = 0x88DF, + MATRIX6_ARB = 0x88C6, + MATRIX27_ARB = 0x88DB, + MATRIX7_ARB = 0x88C7, + PROGRAM_ERROR_STRING_ARB = 0x8874, + PROGRAM_PARAMETERS_ARB = 0x88A8, + PROGRAM_BINDING_ARB = 0x8677, + VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642, + PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6, + CURRENT_VERTEX_ATTRIB_ARB = 0x8626, + MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4, + MATRIX12_ARB = 0x88CC, + PROGRAM_STRING_ARB = 0x8628, + PROGRAM_INSTRUCTIONS_ARB = 0x88A0, + MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5, + VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623, + MATRIX26_ARB = 0x88DA, + MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3, + MATRIX4_ARB = 0x88C4, + CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640, + VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643, + VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625, + PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0, + MATRIX2_ARB = 0x88C2, + MATRIX5_ARB = 0x88C5, + PROGRAM_ATTRIBS_ARB = 0x88AC, + MATRIX14_ARB = 0x88CE, + VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624, + MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1, + MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E, + MATRIX3_ARB = 0x88C3, + PROGRAM_TEMPORARIES_ARB = 0x88A4, + MATRIX28_ARB = 0x88DC, + MATRIX29_ARB = 0x88DD, + MAX_VERTEX_ATTRIBS_ARB = 0x8869, + MATRIX20_ARB = 0x88D4, + MATRIX21_ARB = 0x88D5, + MAX_PROGRAM_ATTRIBS_ARB = 0x88AD, + PROGRAM_ERROR_POSITION_ARB = 0x864B, + PROGRAM_FORMAT_ASCII_ARB = 0x8875, + MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5, + PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2, + VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622, + VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645, + MATRIX30_ARB = 0x88DE, + MATRIX15_ARB = 0x88CF, + VERTEX_PROGRAM_ARB = 0x8620, + MATRIX0_ARB = 0x88C0, + MATRIX17_ARB = 0x88D1, + PROGRAM_LENGTH_ARB = 0x8627, + COLOR_SUM_ARB = 0x8458, + MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF, + MATRIX1_ARB = 0x88C1, + PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6, + MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1, + MATRIX23_ARB = 0x88D7, + MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7, + PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE, + CURRENT_MATRIX_ARB = 0x8641, + MATRIX18_ARB = 0x88D2, + MATRIX19_ARB = 0x88D3, + MATRIX10_ARB = 0x88CA, + MATRIX11_ARB = 0x88CB, + MATRIX16_ARB = 0x88D0, + } + + public enum SUN_vertex : uint + { + } + + public enum EXT_secondary_color : uint + { + SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A, + SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D, + SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C, + SECONDARY_COLOR_ARRAY_EXT = 0x845E, + COLOR_SUM_EXT = 0x8458, + SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B, + CURRENT_SECONDARY_COLOR_EXT = 0x8459, + } + + public enum SGIX_scalebias_hint : uint + { + SCALEBIAS_HINT_SGIX = 0x8322, + } + + public enum ListNameType : uint + { + UNSIGNED_INT = DataType.UNSIGNED_INT, + _4_BYTES = DataType._4_BYTES, + FLOAT = DataType.FLOAT, + UNSIGNED_SHORT = DataType.UNSIGNED_SHORT, + SHORT = DataType.SHORT, + BYTE = DataType.BYTE, + _3_BYTES = DataType._3_BYTES, + INT = DataType.INT, + UNSIGNED_BYTE = DataType.UNSIGNED_BYTE, + _2_BYTES = DataType._2_BYTES, + } + + public enum RenderingMode : uint + { + SELECT = 0x1C02, + FEEDBACK = 0x1C01, + RENDER = 0x1C00, + } + + public enum EXT_texture_lod_bias : uint + { + MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD, + TEXTURE_FILTER_CONTROL_EXT = 0x8500, + TEXTURE_LOD_BIAS_EXT = 0x8501, + } + + public enum ARB_depth_texture : uint + { + DEPTH_TEXTURE_MODE_ARB = 0x884B, + DEPTH_COMPONENT16_ARB = 0x81A5, + DEPTH_COMPONENT24_ARB = 0x81A6, + DEPTH_COMPONENT32_ARB = 0x81A7, + TEXTURE_DEPTH_SIZE_ARB = 0x884A, + } + + public enum ARB_multisample : uint + { + SAMPLE_COVERAGE_VALUE_ARB = 0x80AA, + SAMPLES_ARB = 0x80A9, + SAMPLE_BUFFERS = 0x80A8, + SAMPLE_COVERAGE = 0x80A0, + MULTISAMPLE_ARB = 0x809D, + SAMPLE_ALPHA_TO_COVERAGE = 0x809E, + SAMPLE_BUFFERS_ARB = 0x80A8, + SAMPLE_COVERAGE_ARB = 0x80A0, + SAMPLE_COVERAGE_INVERT_ARB = 0x80AB, + SAMPLE_COVERAGE_INVERT = 0x80AB, + MULTISAMPLE = 0x809D, + SAMPLE_ALPHA_TO_ONE_ARB = 0x809F, + SAMPLE_ALPHA_TO_ONE = 0x809F, + SAMPLES = 0x80A9, + SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E, + MULTISAMPLE_BIT_ARB = 0x20000000, + SAMPLE_COVERAGE_VALUE = 0x80AA, + } + + public enum ConvolutionTargetEXT : uint + { + CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT, + CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT, + } + + public enum EXT_stencil_wrap : uint + { + DECR_WRAP_EXT = 0x8508, + INCR_WRAP_EXT = 0x8507, + } + + public enum SGIS_fog_function : uint + { + FOG_FUNC_POINTS_SGIS = 0x812B, + MAX_FOG_FUNC_POINTS_SGIS = 0x812C, + FOG_FUNC_SGIS = 0x812A, + } + + public enum SGIX_convolution_accuracy : uint + { + CONVOLUTION_HINT_SGIX = 0x8316, + } + + public enum TextureGenMode : uint + { + EYE_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_LINE_SGIS, + EYE_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_POINT_SGIS, + OBJECT_LINEAR = 0x2401, + OBJECT_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_LINE_SGIS, + OBJECT_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_POINT_SGIS, + EYE_LINEAR = 0x2400, + SPHERE_MAP = 0x2402, + } + + public enum APPLE_client_storage : uint + { + UNPACK_CLIENT_STORAGE_APPLE = 0x85B2, + } + + public enum SUN_slice_accum : uint + { + SLICE_ACCUM_SUN = 0x85CC, + } + + public enum SGIX_polynomial_ffd : uint + { + MAX_DEFORMATION_ORDER_SGIX = 0x8197, + GEOMETRY_DEFORMATION_SGIX = 0x8194, + TEXTURE_DEFORMATION_SGIX = 0x8195, + DEFORMATIONS_MASK_SGIX = 0x8196, + } + + public enum ARB_point_parameters : uint + { + POINT_DISTANCE_ATTENUATION_ARB = 0x8129, + POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128, + POINT_SIZE_MIN_ARB = 0x8126, + POINT_SIZE_MAX_ARB = 0x8127, + } + + public enum ARB_window_pos : uint + { + } + + public enum ATI_map_object_buffer : uint + { + } + + public enum OES_read_format : uint + { + IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A, + IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B, + } + + public enum GetPName : uint + { + FRAGMENT_COLOR_MATERIAL_FACE_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_FACE_SGIX, + POLYGON_MODE = 0x0B40, + STENCIL_FUNC = 0x0B92, + FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX, + HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT, + CULL_FACE_MODE = 0x0B45, + PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX, + POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_RANGE_SGIX, + CURRENT_RASTER_DISTANCE = 0x0B09, + PIXEL_TILE_BEST_ALIGNMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_BEST_ALIGNMENT_SGIX, + POINT_SIZE = 0x0B11, + MODELVIEW_STACK_DEPTH = 0x0BA3, + TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI, + SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS, + PIXEL_MAP_I_TO_R_SIZE = 0x0CB2, + ALPHA_BIAS = 0x0D1D, + MAP1_GRID_DOMAIN = 0x0DD0, + PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT, + MAP2_VERTEX_4 = 0x0DB8, + POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT, + MAP2_VERTEX_3 = 0x0DB7, + DEPTH_RANGE = 0x0B70, + POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI, + MAX_ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_DRAW_PIXELS_SGIX, + PIXEL_MAP_I_TO_I_SIZE = 0x0CB0, + UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX, + CURRENT_RASTER_INDEX = 0x0B05, + LIGHT3 = LightName.LIGHT3, + UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT, + INDEX_ARRAY_COUNT_EXT = EXT_vertex_array.INDEX_ARRAY_COUNT_EXT, + LIST_INDEX = 0x0B33, + FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX, + DEPTH_CLEAR_VALUE = 0x0B73, + CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1, + DETAIL_TEXTURE_2D_BINDING_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_BINDING_SGIS, + STENCIL_VALUE_MASK = 0x0B93, + GREEN_BITS = 0x0D53, + COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.COLOR_MATRIX_STACK_DEPTH_SGI, + POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT, + FOG_END = 0x0B64, + CLIP_PLANE0 = ClipPlaneName.CLIP_PLANE0, + MAX_MODELVIEW_STACK_DEPTH = 0x0D36, + LINE_SMOOTH_HINT = 0x0C52, + POLYGON_OFFSET_FACTOR = 0x8038, + MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS, + FOG_MODE = 0x0B65, + POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT, + PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS, + LIST_BASE = 0x0B32, + TEXTURE_STACK_DEPTH = 0x0BA5, + SCISSOR_TEST = 0x0C11, + CURRENT_NORMAL = 0x0B02, + CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX, + PIXEL_MAP_B_TO_B_SIZE = 0x0CB8, + INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX, + EDGE_FLAG_ARRAY = 0x8079, + MAP1_COLOR_4 = 0x0D90, + TEXTURE_MATRIX = 0x0BA8, + LIGHT4 = LightName.LIGHT4, + MAX_3D_TEXTURE_SIZE_EXT = EXT_texture3D.MAX_3D_TEXTURE_SIZE_EXT, + PIXEL_MAP_G_TO_G_SIZE = 0x0CB7, + SELECTION_BUFFER_SIZE = 0x0DF4, + MAP2_TEXTURE_COORD_3 = 0x0DB5, + SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX, + ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX, + MAX_FRAGMENT_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_FRAGMENT_LIGHTS_SGIX, + PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX, + LIGHT_MODEL_AMBIENT = 0x0B53, + PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX, + ZOOM_X = 0x0D16, + PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS, + CLIP_PLANE3 = ClipPlaneName.CLIP_PLANE3, + COLOR_MATERIAL_FACE = 0x0B55, + SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT, + SMOOTH_POINT_SIZE_RANGE = VERSION_1_2.SMOOTH_POINT_SIZE_RANGE, + ATTRIB_STACK_DEPTH = 0x0BB0, + MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B, + MAP1_GRID_SEGMENTS = 0x0DD1, + FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX, + BLUE_SCALE = 0x0D1A, + POINT_SMOOTH = 0x0B10, + MAX_PROJECTION_STACK_DEPTH = 0x0D38, + INDEX_WRITEMASK = 0x0C21, + TEXTURE_BINDING_3D = 0x806A, + MAP1_TEXTURE_COORD_4 = 0x0D96, + TEXTURE_BINDING_1D = 0x8068, + UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT, + GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS, + POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI, + NORMAL_ARRAY_STRIDE = 0x807F, + FOG = 0x0B60, + CURRENT_RASTER_POSITION_VALID = 0x0B08, + COLOR_ARRAY_TYPE = 0x8082, + POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI, + CLIP_PLANE5 = ClipPlaneName.CLIP_PLANE5, + PACK_SKIP_PIXELS = 0x0D04, + ALPHA_SCALE = 0x0D1C, + SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS, + STEREO = 0x0C33, + READ_BUFFER = 0x0C02, + MAX_4D_TEXTURE_SIZE_SGIS = SGIS_texture4D.MAX_4D_TEXTURE_SIZE_SGIS, + RENDER_MODE = 0x0C40, + POINT_SIZE_RANGE = 0x0B12, + LIST_MODE = 0x0B30, + FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX, + LIGHTING = 0x0B50, + ACCUM_CLEAR_VALUE = 0x0B80, + UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX, + TEXTURE_GEN_Q = 0x0C63, + MAP2_TEXTURE_COORD_2 = 0x0DB4, + TEXTURE_GEN_T = 0x0C61, + ALIASED_LINE_WIDTH_RANGE = VERSION_1_2.ALIASED_LINE_WIDTH_RANGE, + RED_BITS = 0x0D52, + COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI, + SCISSOR_BOX = 0x0C10, + PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX, + INDEX_ARRAY_TYPE = 0x8085, + LIGHT6 = LightName.LIGHT6, + MAX_COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.MAX_COLOR_MATRIX_STACK_DEPTH_SGI, + SAMPLES_SGIS = SGIS_multisample.SAMPLES_SGIS, + BLEND = 0x0BE2, + STENCIL_CLEAR_VALUE = 0x0B91, + FEEDBACK_BUFFER_SIZE = 0x0DF1, + SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT, + LINE_STIPPLE_REPEAT = 0x0B26, + INDEX_MODE = 0x0C30, + TEXTURE_COORD_ARRAY_STRIDE = 0x808A, + SMOOTH_LINE_WIDTH_RANGE = VERSION_1_2.SMOOTH_LINE_WIDTH_RANGE, + STENCIL_REF = 0x0B97, + SMOOTH_POINT_SIZE_GRANULARITY = VERSION_1_2.SMOOTH_POINT_SIZE_GRANULARITY, + BLUE_BITS = 0x0D54, + FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX, + COLOR_LOGIC_OP = 0x0BF2, + POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI, + BLEND_COLOR_EXT = EXT_blend_color.BLEND_COLOR_EXT, + PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS, + MAX_FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.MAX_FRAMEZOOM_FACTOR_SGIX, + MATRIX_MODE = 0x0BA0, + DEPTH_FUNC = 0x0B74, + POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI, + PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX, + FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX, + ACCUM_RED_BITS = 0x0D58, + POLYGON_OFFSET_UNITS = 0x2A00, + TEXTURE_2D = 0x0DE1, + EDGE_FLAG_ARRAY_COUNT_EXT = EXT_vertex_array.EDGE_FLAG_ARRAY_COUNT_EXT, + TEXTURE_COORD_ARRAY_TYPE = 0x8089, + CURRENT_INDEX = 0x0B01, + PACK_SWAP_BYTES = 0x0D00, + INDEX_ARRAY = 0x8077, + GREEN_BIAS = 0x0D19, + SAMPLE_MASK_INVERT_SGIS = SGIS_multisample.SAMPLE_MASK_INVERT_SGIS, + AUTO_NORMAL = 0x0D80, + POINT_SIZE_GRANULARITY = 0x0B13, + POLYGON_SMOOTH = 0x0B41, + FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX, + ALPHA_BITS = 0x0D55, + UNPACK_ALIGNMENT = 0x0CF5, + SAMPLE_PATTERN_SGIS = SGIS_multisample.SAMPLE_PATTERN_SGIS, + INDEX_ARRAY_STRIDE = 0x8086, + POLYGON_OFFSET_BIAS_EXT = EXT_polygon_offset.POLYGON_OFFSET_BIAS_EXT, + RED_SCALE = 0x0D14, + UNPACK_SKIP_ROWS = 0x0CF3, + INDEX_LOGIC_OP = 0x0BF1, + MAP2_COLOR_4 = 0x0DB0, + VERTEX_ARRAY_COUNT_EXT = EXT_vertex_array.VERTEX_ARRAY_COUNT_EXT, + MAP1_NORMAL = 0x0D92, + MAP1_TEXTURE_COORD_2 = 0x0D94, + PIXEL_MAP_I_TO_G_SIZE = 0x0CB3, + ACCUM_BLUE_BITS = 0x0D5A, + ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX, + COLOR_WRITEMASK = 0x0C23, + NAME_STACK_DEPTH = 0x0D70, + POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT, + MAX_NAME_STACK_DEPTH = 0x0D37, + CLIP_PLANE4 = ClipPlaneName.CLIP_PLANE4, + FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX, + PIXEL_MAP_I_TO_A_SIZE = 0x0CB5, + PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT, + LIGHT0 = LightName.LIGHT0, + PIXEL_MAP_R_TO_R_SIZE = 0x0CB6, + FOG_HINT = 0x0C54, + PROJECTION_STACK_DEPTH = 0x0BA4, + PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX, + RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT, + MAP2_GRID_DOMAIN = 0x0DD2, + ALPHA_TEST_FUNC = 0x0BC1, + MAX_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_DEPTH_SGIX, + UNPACK_SKIP_PIXELS = 0x0CF4, + NORMAL_ARRAY_TYPE = 0x807E, + FOG_FUNC_POINTS_SGIS = SGIS_fog_function.FOG_FUNC_POINTS_SGIS, + GREEN_SCALE = 0x0D18, + PACK_ROW_LENGTH = 0x0D02, + CURRENT_COLOR = 0x0B00, + MAX_FOG_FUNC_POINTS_SGIS = SGIS_fog_function.MAX_FOG_FUNC_POINTS_SGIS, + POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT, + COLOR_ARRAY_SIZE = 0x8081, + MAP2_TEXTURE_COORD_4 = 0x0DB6, + COLOR_MATERIAL_PARAMETER = 0x0B56, + FOG_DENSITY = 0x0B62, + FOG_START = 0x0B63, + FRONT_FACE = 0x0B46, + POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI, + SPRITE_AXIS_SGIX = SGIX_sprite.SPRITE_AXIS_SGIX, + UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS, + MAP1_VERTEX_4 = 0x0D98, + ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX, + LIGHT5 = LightName.LIGHT5, + MAP1_VERTEX_3 = 0x0D97, + AUX_BUFFERS = 0x0C00, + UNPACK_LSB_FIRST = 0x0CF1, + VERTEX_ARRAY_SIZE = 0x807A, + COLOR_MATERIAL = 0x0B57, + MAP1_TEXTURE_COORD_3 = 0x0D95, + LINE_STIPPLE_PATTERN = 0x0B25, + PERSPECTIVE_CORRECTION_HINT = 0x0C50, + MAX_ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.MAX_ASYNC_TEX_IMAGE_SGIX, + PIXEL_MAP_A_TO_A_SIZE = 0x0CB9, + UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT, + SPRITE_TRANSLATION_SGIX = SGIX_sprite.SPRITE_TRANSLATION_SGIX, + PIXEL_TILE_CACHE_INCREMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_INCREMENT_SGIX, + SAMPLE_MASK_VALUE_SGIS = SGIS_multisample.SAMPLE_MASK_VALUE_SGIS, + LOGIC_OP = 0x0BF1, + PACK_LSB_FIRST = 0x0D01, + LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX, + MAP2_INDEX = 0x0DB1, + UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS, + FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX, + COLOR_CLEAR_VALUE = 0x0C22, + MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX, + PROJECTION_MATRIX = 0x0BA7, + POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT, + ACCUM_ALPHA_BITS = 0x0D5B, + DEPTH_TEST = 0x0B71, + LINE_STIPPLE = 0x0B24, + MAX_TEXTURE_STACK_DEPTH = 0x0D39, + LINE_WIDTH = 0x0B21, + MAX_LIGHTS = 0x0D31, + STENCIL_PASS_DEPTH_PASS = 0x0B96, + VERTEX_ARRAY_STRIDE = 0x807C, + PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX, + PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT, + EDGE_FLAG = 0x0B43, + POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT, + TEXTURE_1D = 0x0DE0, + POINT_SMOOTH_HINT = 0x0C51, + TEXTURE_GEN_S = 0x0C60, + TEXTURE_GEN_R = 0x0C62, + POINT_FADE_THRESHOLD_SIZE_SGIS = SGIS_point_parameters.POINT_FADE_THRESHOLD_SIZE_SGIS, + PACK_ALIGNMENT = 0x0D05, + DOUBLEBUFFER = 0x0C32, + REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX, + COLOR_ARRAY_COUNT_EXT = EXT_vertex_array.COLOR_ARRAY_COUNT_EXT, + PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX, + MAX_ACTIVE_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_ACTIVE_LIGHTS_SGIX, + BLEND_SRC = 0x0BE1, + DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS, + PACK_SKIP_ROWS = 0x0D03, + FOG_COLOR = 0x0B66, + LINE_SMOOTH = 0x0B20, + MAX_VIEWPORT_DIMS = 0x0D3A, + POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI, + COLOR_ARRAY = 0x8076, + MAX_TEXTURE_SIZE = 0x0D33, + FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX, + LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL, + CLIP_PLANE1 = ClipPlaneName.CLIP_PLANE1, + PIXEL_TEX_GEN_MODE_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_MODE_SGIX, + VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX, + LIGHT7 = LightName.LIGHT7, + COLOR_MATRIX_SGI = SGI_color_matrix.COLOR_MATRIX_SGI, + FEEDBACK_BUFFER_TYPE = 0x0DF2, + RED_BIAS = 0x0D15, + FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.FRAMEZOOM_FACTOR_SGIX, + LINE_WIDTH_GRANULARITY = 0x0B23, + MODELVIEW_MATRIX = 0x0BA6, + MAX_ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.MAX_ASYNC_HISTOGRAM_SGIX, + CULL_FACE = 0x0B44, + DITHER = 0x0BD0, + SMOOTH_LINE_WIDTH_GRANULARITY = VERSION_1_2.SMOOTH_LINE_WIDTH_GRANULARITY, + CURRENT_RASTER_TEXTURE_COORDS = 0x0B06, + POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI, + STENCIL_WRITEMASK = 0x0B98, + SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS, + STENCIL_FAIL = 0x0B94, + PIXEL_MAP_S_TO_S_SIZE = 0x0CB1, + BLUE_BIAS = 0x0D1B, + SHADE_MODEL = 0x0B54, + ASYNC_MARKER_SGIX = SGIX_async.ASYNC_MARKER_SGIX, + INDEX_BITS = 0x0D51, + ACCUM_GREEN_BITS = 0x0D59, + FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX, + SPRITE_MODE_SGIX = SGIX_sprite.SPRITE_MODE_SGIX, + PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX, + UNPACK_ROW_LENGTH = 0x0CF2, + CURRENT_RASTER_COLOR = 0x0B04, + TEXTURE_COORD_ARRAY_COUNT_EXT = EXT_vertex_array.TEXTURE_COORD_ARRAY_COUNT_EXT, + LOGIC_OP_MODE = 0x0BF0, + DEFORMATIONS_MASK_SGIX = SGIX_polynomial_ffd.DEFORMATIONS_MASK_SGIX, + POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_SGIS, + CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX, + CURRENT_RASTER_POSITION = 0x0B07, + SAMPLE_BUFFERS_SGIS = SGIS_multisample.SAMPLE_BUFFERS_SGIS, + DEPTH_WRITEMASK = 0x0B72, + DRAW_BUFFER = 0x0C01, + COLOR_ARRAY_STRIDE = 0x8083, + DEPTH_SCALE = 0x0D1E, + ALPHA_TEST = 0x0BC0, + NORMALIZE = 0x0BA1, + IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX, + MINMAX_EXT = EXT_histogram.MINMAX_EXT, + TEXTURE_BINDING_2D = 0x8069, + MAX_ATTRIB_STACK_DEPTH = 0x0D35, + LIGHT2 = LightName.LIGHT2, + TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT, + CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT, + MAP1_TEXTURE_COORD_1 = 0x0D93, + VIEWPORT = 0x0BA2, + INSTRUMENT_MEASUREMENTS_SGIX = SGIX_instruments.INSTRUMENT_MEASUREMENTS_SGIX, + POLYGON_SMOOTH_HINT = 0x0C53, + LIGHT_MODEL_TWO_SIDE = 0x0B52, + INDEX_OFFSET = 0x0D13, + MAP_COLOR = 0x0D10, + FOG_INDEX = 0x0B61, + ZOOM_Y = 0x0D17, + CLIP_PLANE2 = ClipPlaneName.CLIP_PLANE2, + STENCIL_TEST = 0x0B90, + ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX, + MAX_EVAL_ORDER = 0x0D30, + MAP2_NORMAL = 0x0DB2, + STENCIL_PASS_DEPTH_FAIL = 0x0B95, + VERTEX_ARRAY = 0x8074, + ALIASED_POINT_SIZE_RANGE = VERSION_1_2.ALIASED_POINT_SIZE_RANGE, + REFERENCE_PLANE_EQUATION_SGIX = SGIX_reference_plane.REFERENCE_PLANE_EQUATION_SGIX, + NORMAL_ARRAY = 0x8075, + UNPACK_SWAP_BYTES = 0x0CF0, + INDEX_CLEAR_VALUE = 0x0C20, + TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS, + LIGHT1 = LightName.LIGHT1, + CURRENT_TEXTURE_COORDS = 0x0B03, + MAP2_TEXTURE_COORD_1 = 0x0DB3, + TEXTURE_COORD_ARRAY = 0x8078, + BLEND_EQUATION_EXT = EXT_blend_minmax.BLEND_EQUATION_EXT, + POLYGON_STIPPLE = 0x0B42, + VERTEX_ARRAY_TYPE = 0x807B, + MAP1_INDEX = 0x0D91, + NORMAL_ARRAY_COUNT_EXT = EXT_vertex_array.NORMAL_ARRAY_COUNT_EXT, + CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT, + MAX_LIST_NESTING = 0x0B31, + STENCIL_BITS = 0x0D57, + SUBPIXEL_BITS = 0x0D50, + POLYGON_OFFSET_FILL = 0x8037, + LINE_WIDTH_RANGE = 0x0B22, + POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_RANGE_SGIX, + VERTEX_PRECLIP_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_SGIX, + POLYGON_OFFSET_POINT = 0x2A01, + ALPHA_TEST_REF = 0x0BC2, + RGBA_MODE = 0x0C31, + EDGE_FLAG_ARRAY_STRIDE = 0x808C, + LIGHT_MODEL_LOCAL_VIEWER = 0x0B51, + INDEX_SHIFT = 0x0D12, + MAP_STENCIL = 0x0D11, + TEXTURE_COORD_ARRAY_SIZE = 0x8088, + POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI, + TEXTURE_3D_BINDING_EXT = EXT_texture_object.TEXTURE_3D_BINDING_EXT, + PIXEL_MAP_I_TO_B_SIZE = 0x0CB4, + POLYGON_OFFSET_LINE = 0x2A02, + MAX_PIXEL_MAP_TABLE = 0x0D34, + POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI, + BLEND_DST = 0x0BE0, + TEXTURE_4D_BINDING_SGIS = SGIS_texture4D.TEXTURE_4D_BINDING_SGIS, + DEPTH_BIAS = 0x0D1F, + POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT, + MAP2_GRID_SEGMENTS = 0x0DD3, + MAX_CLIP_PLANES = 0x0D32, + MAX_ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_READ_PIXELS_SGIX, + DEPTH_BITS = 0x0D56, + POINT_SIZE_MAX_SGIS = SGIS_point_parameters.POINT_SIZE_MAX_SGIS, + } + + public enum NV_packed_depth_stencil : uint + { + DEPTH_STENCIL_NV = 0x84F9, + UNSIGNED_INT_24_8_NV = 0x84FA, + } + + public enum ATI_text_fragment_shader : uint + { + TEXT_FRAGMENT_SHADER_ATI = 0x8200, + } + + public enum SGIS_texture_color_mask : uint + { + TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF, + } + + public enum SGIX_ycrcb_subsample : uint + { + PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3, + PACK_SUBSAMPLE_RATE_SGIX = 0x85A0, + PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2, + PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4, + UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1, + } + + public enum SGIX_texture_lod_bias : uint + { + TEXTURE_LOD_BIAS_R_SGIX = 0x8190, + TEXTURE_LOD_BIAS_S_SGIX = 0x818E, + TEXTURE_LOD_BIAS_T_SGIX = 0x818F, + } + + public enum TextureEnvMode : uint + { + REPLACE_EXT = EXT_texture.REPLACE_EXT, + MODULATE = 0x2100, + ADD = AccumOp.ADD, + DECAL = 0x2101, + BLEND = GetPName.BLEND, + TEXTURE_ENV_BIAS_SGIX = SGIX_texture_add_env.TEXTURE_ENV_BIAS_SGIX, + } + + public enum EXT_texture_cube_map : uint + { + TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516, + TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518, + TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517, + TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A, + TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514, + REFLECTION_MAP_EXT = 0x8512, + TEXTURE_CUBE_MAP_EXT = 0x8513, + MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C, + TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519, + PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B, + TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515, + NORMAL_MAP_EXT = 0x8511, + } + + public enum IndexPointerType : uint + { + DOUBLE = DataType.DOUBLE, + INT = DataType.INT, + SHORT = DataType.SHORT, + FLOAT = DataType.FLOAT, + } + + public enum FogParameter : uint + { + FOG_END = GetPName.FOG_END, + FOG_COLOR = GetPName.FOG_COLOR, + FOG_DENSITY = GetPName.FOG_DENSITY, + FOG_START = GetPName.FOG_START, + FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX, + FOG_INDEX = GetPName.FOG_INDEX, + FOG_MODE = GetPName.FOG_MODE, + } + + public enum SGIS_sharpen_texture : uint + { + LINEAR_SHARPEN_SGIS = 0x80AD, + LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE, + LINEAR_SHARPEN_COLOR_SGIS = 0x80AF, + SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0, + } + + public enum AlphaFunction : uint + { + NEVER = 0x0200, + GEQUAL = 0x0206, + GREATER = 0x0204, + ALWAYS = 0x0207, + LEQUAL = 0x0203, + NOTEQUAL = 0x0205, + EQUAL = 0x0202, + LESS = 0x0201, + } + + public enum NV_register_combiners2 : uint + { + PER_STAGE_CONSTANTS_NV = 0x8535, + } + + public enum ARB_texture_env_crossbar : uint + { + } + + public enum NV_texture_shader2 : uint + { + DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF, + } + + public enum ATI_texture_env_combine3 : uint + { + MODULATE_ADD_ATI = 0x8744, + MODULATE_SIGNED_ADD_ATI = 0x8745, + MODULATE_SUBTRACT_ATI = 0x8746, + } + + public enum EXT_misc_attribute : uint + { + } + + public enum SGI_color_matrix : uint + { + POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8, + POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA, + COLOR_MATRIX_SGI = 0x80B1, + POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6, + POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9, + POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6, + POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB, + COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2, + POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9, + POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7, + POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5, + POST_COLOR_MATRIX_RED_BIAS = 0x80B8, + MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3, + POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7, + COLOR_MATRIX_STACK_DEPTH = 0x80B2, + POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA, + COLOR_MATRIX = 0x80B1, + POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5, + POST_COLOR_MATRIX_RED_SCALE = 0x80B4, + MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3, + POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB, + POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4, + } + + public enum SamplePatternSGIS : uint + { + _4PASS_0_SGIS = SGIS_multisample._4PASS_0_SGIS, + _4PASS_1_SGIS = SGIS_multisample._4PASS_1_SGIS, + _1PASS_SGIS = SGIS_multisample._1PASS_SGIS, + _2PASS_0_SGIS = SGIS_multisample._2PASS_0_SGIS, + _4PASS_2_SGIS = SGIS_multisample._4PASS_2_SGIS, + _2PASS_1_SGIS = SGIS_multisample._2PASS_1_SGIS, + _4PASS_3_SGIS = SGIS_multisample._4PASS_3_SGIS, + } + + public enum SGIS_texture_filter4 : uint + { + TEXTURE_FILTER4_SIZE_SGIS = 0x8147, + FILTER4_SGIS = 0x8146, + } + + public enum IBM_vertex_array_lists : uint + { + INDEX_ARRAY_LIST_IBM = 103073, + FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086, + SECONDARY_COLOR_ARRAY_LIST_IBM = 103077, + NORMAL_ARRAY_LIST_IBM = 103071, + COLOR_ARRAY_LIST_STRIDE_IBM = 103082, + TEXTURE_COORD_ARRAY_LIST_IBM = 103074, + EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085, + COLOR_ARRAY_LIST_IBM = 103072, + INDEX_ARRAY_LIST_STRIDE_IBM = 103083, + EDGE_FLAG_ARRAY_LIST_IBM = 103075, + SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087, + TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084, + FOG_COORDINATE_ARRAY_LIST_IBM = 103076, + VERTEX_ARRAY_LIST_IBM = 103070, + VERTEX_ARRAY_LIST_STRIDE_IBM = 103080, + NORMAL_ARRAY_LIST_STRIDE_IBM = 103081, + } + + public enum NV_fence : uint + { + ALL_COMPLETED_NV = 0x84F2, + FENCE_CONDITION_NV = 0x84F4, + FENCE_STATUS_NV = 0x84F3, + } + + public enum SGIX_async_histogram : uint + { + MAX_ASYNC_HISTOGRAM_SGIX = 0x832D, + ASYNC_HISTOGRAM_SGIX = 0x832C, + } + + public enum ARB_shadow : uint + { + TEXTURE_COMPARE_MODE_ARB = 0x884C, + TEXTURE_COMPARE_FUNC_ARB = 0x884D, + COMPARE_R_TO_TEXTURE_ARB = 0x884E, + } + + public enum EXT_clip_volume_hint : uint + { + CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0, + } + + public enum EXT_multi_draw_arrays : uint + { + } + + public enum SUN_mesh_array : uint + { + TRIANGLE_MESH_SUN = 0x8615, + QUAD_MESH_SUN = 0x8614, + } + + public enum LightModelColorControl : uint + { + SEPARATE_SPECULAR_COLOR = VERSION_1_2.SEPARATE_SPECULAR_COLOR, + SINGLE_COLOR = VERSION_1_2.SINGLE_COLOR, + } + + public enum ATI_element_array : uint + { + ELEMENT_ARRAY_POINTER_ATI = 0x876A, + ELEMENT_ARRAY_ATI = 0x8768, + ELEMENT_ARRAY_TYPE_ATI = 0x8769, + } + + public enum NV_fragment_program : uint + { + FRAGMENT_PROGRAM_NV = 0x8870, + MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872, + PROGRAM_ERROR_STRING_NV = 0x8874, + MAX_TEXTURE_COORDS_NV = 0x8871, + FRAGMENT_PROGRAM_BINDING_NV = 0x8873, + MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868, + } + + public enum EXT_subtexture : uint + { + } + + public enum EXT_draw_range_elements : uint + { + MAX_ELEMENTS_INDICES_EXT = 0x80E9, + MAX_ELEMENTS_VERTICES_EXT = 0x80E8, + } + + public enum TextureEnvTarget : uint + { + TEXTURE_ENV = 0x2300, + } + + public enum AccumOp : uint + { + RETURN = 0x0102, + ADD = 0x0104, + LOAD = 0x0101, + ACCUM = 0x0100, + MULT = 0x0103, + } + + public enum EXT_fog_coord : uint + { + FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456, + FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455, + FOG_COORDINATE_SOURCE_EXT = 0x8450, + FOG_COORDINATE_EXT = 0x8451, + FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454, + FOG_COORDINATE_ARRAY_EXT = 0x8457, + CURRENT_FOG_COORDINATE_EXT = 0x8453, + FRAGMENT_DEPTH_EXT = 0x8452, + } + + public enum ATI_separate_stencil : uint + { + STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802, + STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803, + STENCIL_BACK_FAIL_ATI = 0x8801, + STENCIL_BACK_FUNC_ATI = 0x8800, + } + + public enum OML_subsample : uint + { + FORMAT_SUBSAMPLE_24_24_OML = 0x8982, + FORMAT_SUBSAMPLE_244_244_OML = 0x8983, + } + + public enum APPLE_specular_vector : uint + { + LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0, + } + + public enum EXT_abgr : uint + { + ABGR_EXT = 0x8000, + } + + public enum NV_copy_depth_to_color : uint + { + DEPTH_STENCIL_TO_BGRA_NV = 0x886F, + DEPTH_STENCIL_TO_RGBA_NV = 0x886E, + } + + public enum NV_vertex_array_range : uint + { + MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520, + VERTEX_ARRAY_RANGE_VALID_NV = 0x851F, + VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E, + VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521, + VERTEX_ARRAY_RANGE_NV = 0x851D, + } + + public enum GetColorTableParameterPNameSGI : uint + { + COLOR_TABLE_BLUE_SIZE_SGI = SGI_color_table.COLOR_TABLE_BLUE_SIZE_SGI, + COLOR_TABLE_FORMAT_SGI = SGI_color_table.COLOR_TABLE_FORMAT_SGI, + COLOR_TABLE_ALPHA_SIZE_SGI = SGI_color_table.COLOR_TABLE_ALPHA_SIZE_SGI, + COLOR_TABLE_INTENSITY_SIZE_SGI = SGI_color_table.COLOR_TABLE_INTENSITY_SIZE_SGI, + COLOR_TABLE_GREEN_SIZE_SGI = SGI_color_table.COLOR_TABLE_GREEN_SIZE_SGI, + COLOR_TABLE_LUMINANCE_SIZE_SGI = SGI_color_table.COLOR_TABLE_LUMINANCE_SIZE_SGI, + COLOR_TABLE_WIDTH_SGI = SGI_color_table.COLOR_TABLE_WIDTH_SGI, + COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI, + COLOR_TABLE_RED_SIZE_SGI = SGI_color_table.COLOR_TABLE_RED_SIZE_SGI, + COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI, + } + + public enum SGIX_texture_add_env : uint + { + TEXTURE_ENV_BIAS_SGIX = 0x80BE, + } + + public enum PixelMap : uint + { + PIXEL_MAP_B_TO_B = GetPixelMap.PIXEL_MAP_B_TO_B, + PIXEL_MAP_S_TO_S = GetPixelMap.PIXEL_MAP_S_TO_S, + PIXEL_MAP_R_TO_R = GetPixelMap.PIXEL_MAP_R_TO_R, + PIXEL_MAP_I_TO_B = GetPixelMap.PIXEL_MAP_I_TO_B, + PIXEL_MAP_I_TO_G = GetPixelMap.PIXEL_MAP_I_TO_G, + PIXEL_MAP_I_TO_A = GetPixelMap.PIXEL_MAP_I_TO_A, + PIXEL_MAP_A_TO_A = GetPixelMap.PIXEL_MAP_A_TO_A, + PIXEL_MAP_G_TO_G = GetPixelMap.PIXEL_MAP_G_TO_G, + PIXEL_MAP_I_TO_I = GetPixelMap.PIXEL_MAP_I_TO_I, + PIXEL_MAP_I_TO_R = GetPixelMap.PIXEL_MAP_I_TO_R, + } + + public enum ARB_occlusion_query : uint + { + QUERY_RESULT_ARB = 0x8866, + CURRENT_QUERY_ARB = 0x8865, + QUERY_RESULT_AVAILABLE_ARB = 0x8867, + SAMPLES_PASSED_ARB = 0x8914, + QUERY_COUNTER_BITS_ARB = 0x8864, + } + + public enum NV_float_buffer : uint + { + FLOAT_R16_NV = 0x8884, + FLOAT_RG_NV = 0x8881, + FLOAT_RGB_NV = 0x8882, + FLOAT_R32_NV = 0x8885, + FLOAT_RG16_NV = 0x8886, + FLOAT_R_NV = 0x8880, + FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D, + FLOAT_RGB32_NV = 0x8889, + FLOAT_RGBA_MODE_NV = 0x888E, + TEXTURE_FLOAT_COMPONENTS_NV = 0x888C, + FLOAT_RGBA_NV = 0x8883, + FLOAT_RGBA16_NV = 0x888A, + FLOAT_RGBA32_NV = 0x888B, + FLOAT_RGB16_NV = 0x8888, + FLOAT_RG32_NV = 0x8887, + } + + public enum IBM_cull_vertex : uint + { + CULL_VERTEX_IBM = 103050, + } + + public enum NV_texture_rectangle : uint + { + TEXTURE_BINDING_RECTANGLE_NV = 0x84F6, + PROXY_TEXTURE_RECTANGLE_NV = 0x84F7, + MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8, + TEXTURE_RECTANGLE_NV = 0x84F5, + } + + public enum LightEnvModeSGIX : uint + { + REPLACE = StencilOp.REPLACE, + MODULATE = TextureEnvMode.MODULATE, + ADD = AccumOp.ADD, + } + + public enum ARB_fragment_program_shadow : uint + { + } + + public enum SGIX_subsample : uint + { + PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3, + PACK_SUBSAMPLE_RATE_SGIX = 0x85A0, + PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2, + PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4, + UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1, + } + + public enum EXT_stencil_two_side : uint + { + ACTIVE_STENCIL_FACE_EXT = 0x8911, + STENCIL_TEST_TWO_SIDE_EXT = 0x8910, + } + + public enum SGIX_ir_instrument1 : uint + { + IR_INSTRUMENT1_SGIX = 0x817F, + } + + public enum ARB_transpose_matrix : uint + { + TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5, + TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4, + TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6, + TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3, + } + + public enum PixelType : uint + { + UNSIGNED_INT = DataType.UNSIGNED_INT, + UNSIGNED_SHORT_5_5_5_1_EXT = EXT_packed_pixels.UNSIGNED_SHORT_5_5_5_1_EXT, + FLOAT = DataType.FLOAT, + UNSIGNED_SHORT = DataType.UNSIGNED_SHORT, + SHORT = DataType.SHORT, + BYTE = DataType.BYTE, + UNSIGNED_INT_8_8_8_8_EXT = EXT_packed_pixels.UNSIGNED_INT_8_8_8_8_EXT, + UNSIGNED_BYTE_3_3_2_EXT = EXT_packed_pixels.UNSIGNED_BYTE_3_3_2_EXT, + INT = DataType.INT, + BITMAP = 0x1A00, + UNSIGNED_BYTE = DataType.UNSIGNED_BYTE, + UNSIGNED_INT_10_10_10_2_EXT = EXT_packed_pixels.UNSIGNED_INT_10_10_10_2_EXT, + UNSIGNED_SHORT_4_4_4_4_EXT = EXT_packed_pixels.UNSIGNED_SHORT_4_4_4_4_EXT, + } + + public enum EXT_texture_env_combine : uint + { + SOURCE0_RGB_EXT = 0x8580, + COMBINE_RGB_EXT = 0x8571, + SOURCE1_RGB_EXT = 0x8581, + CONSTANT_EXT = 0x8576, + SOURCE1_ALPHA_EXT = 0x8589, + SOURCE2_ALPHA_EXT = 0x858A, + SOURCE2_RGB_EXT = 0x8582, + OPERAND0_RGB_EXT = 0x8590, + OPERAND0_ALPHA_EXT = 0x8598, + RGB_SCALE_EXT = 0x8573, + OPERAND1_RGB_EXT = 0x8591, + SOURCE0_ALPHA_EXT = 0x8588, + OPERAND2_ALPHA_EXT = 0x859A, + INTERPOLATE_EXT = 0x8575, + COMBINE_EXT = 0x8570, + OPERAND1_ALPHA_EXT = 0x8599, + OPERAND2_RGB_EXT = 0x8592, + PREVIOUS_EXT = 0x8578, + ADD_SIGNED_EXT = 0x8574, + PRIMARY_COLOR_EXT = 0x8577, + COMBINE_ALPHA_EXT = 0x8572, + } + + public enum ATI_vertex_streams : uint + { + VERTEX_STREAM6_ATI = 0x8772, + VERTEX_STREAM1_ATI = 0x876D, + VERTEX_STREAM3_ATI = 0x876F, + MAX_VERTEX_STREAMS_ATI = 0x876B, + VERTEX_STREAM4_ATI = 0x8770, + VERTEX_STREAM0_ATI = 0x876C, + VERTEX_STREAM2_ATI = 0x876E, + VERTEX_SOURCE_ATI = 0x8774, + VERTEX_STREAM7_ATI = 0x8773, + VERTEX_STREAM5_ATI = 0x8771, + } + + public enum EXT_point_parameters : uint + { + DISTANCE_ATTENUATION_EXT = 0x8129, + POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128, + POINT_SIZE_MAX_EXT = 0x8127, + POINT_SIZE_MIN_EXT = 0x8126, + } + + public enum SGIX_fog_scale : uint + { + FOG_SCALE_SGIX = 0x81FC, + FOG_SCALE_VALUE_SGIX = 0x81FD, + } + + public enum OML_interlace : uint + { + INTERLACE_READ_OML = 0x8981, + INTERLACE_OML = 0x8980, + } + + public enum SGIS_texture_select : uint + { + DUAL_ALPHA16_SGIS = 0x8113, + QUAD_ALPHA8_SGIS = 0x811F, + DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C, + DUAL_LUMINANCE12_SGIS = 0x8116, + DUAL_ALPHA4_SGIS = 0x8110, + QUAD_TEXTURE_SELECT_SGIS = 0x8125, + DUAL_ALPHA12_SGIS = 0x8112, + QUAD_INTENSITY4_SGIS = 0x8122, + DUAL_INTENSITY16_SGIS = 0x811B, + DUAL_INTENSITY4_SGIS = 0x8118, + DUAL_LUMINANCE4_SGIS = 0x8114, + QUAD_INTENSITY8_SGIS = 0x8123, + DUAL_LUMINANCE16_SGIS = 0x8117, + DUAL_LUMINANCE8_SGIS = 0x8115, + QUAD_LUMINANCE8_SGIS = 0x8121, + DUAL_TEXTURE_SELECT_SGIS = 0x8124, + DUAL_ALPHA8_SGIS = 0x8111, + DUAL_INTENSITY12_SGIS = 0x811A, + DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D, + QUAD_LUMINANCE4_SGIS = 0x8120, + DUAL_INTENSITY8_SGIS = 0x8119, + QUAD_ALPHA4_SGIS = 0x811E, + } + + public enum APPLE_transform_hint : uint + { + TRANSFORM_HINT_APPLE = 0x85B1, + } + + public enum EXT_texture_compression_s3tc : uint + { + COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0, + COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1, + COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3, + COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2, + } + + public enum ARB_draw_buffers : uint + { + DRAW_BUFFER13_ARB = 0x8832, + DRAW_BUFFER4_ARB = 0x8829, + DRAW_BUFFER1_ARB = 0x8826, + MAX_DRAW_BUFFERS_ARB = 0x8824, + DRAW_BUFFER2_ARB = 0x8827, + DRAW_BUFFER0_ARB = 0x8825, + DRAW_BUFFER8_ARB = 0x882D, + DRAW_BUFFER7_ARB = 0x882C, + DRAW_BUFFER10_ARB = 0x882F, + DRAW_BUFFER5_ARB = 0x882A, + DRAW_BUFFER15_ARB = 0x8834, + DRAW_BUFFER14_ARB = 0x8833, + DRAW_BUFFER3_ARB = 0x8828, + DRAW_BUFFER6_ARB = 0x882B, + DRAW_BUFFER12_ARB = 0x8831, + DRAW_BUFFER11_ARB = 0x8830, + DRAW_BUFFER9_ARB = 0x882E, + } + + public enum EXT_index_material : uint + { + INDEX_MATERIAL_FACE_EXT = 0x81BA, + INDEX_MATERIAL_EXT = 0x81B8, + INDEX_MATERIAL_PARAMETER_EXT = 0x81B9, + } + + public enum EXT_framebuffer_object : uint + { + FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC, + COLOR_ATTACHMENT3_EXT = 0x8CE3, + COLOR_ATTACHMENT1_EXT = 0x8CE1, + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0, + FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4, + RENDERBUFFER_EXT = 0x8D41, + COLOR_ATTACHMENT15_EXT = 0x8CEF, + COLOR_ATTACHMENT13_EXT = 0x8CED, + RENDERBUFFER_HEIGHT_EXT = 0x8D43, + COLOR_ATTACHMENT14_EXT = 0x8CEE, + FRAMEBUFFER_COMPLETE_EXT = 0x8CD5, + RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44, + FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9, + FRAMEBUFFER_STATUS_ERROR_EXT = 0x8CDE, + STENCIL_INDEX4_EXT = 0x8D47, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2, + COLOR_ATTACHMENT6_EXT = 0x8CE6, + STENCIL_INDEX_EXT = 0x8D45, + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7, + FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA, + FRAMEBUFFER_BINDING_EXT = 0x8CA6, + COLOR_ATTACHMENT8_EXT = 0x8CE8, + COLOR_ATTACHMENT2_EXT = 0x8CE2, + COLOR_ATTACHMENT9_EXT = 0x8CE9, + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3, + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB, + COLOR_ATTACHMENT12_EXT = 0x8CEC, + MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF, + STENCIL_INDEX8_EXT = 0x8D48, + COLOR_ATTACHMENT7_EXT = 0x8CE7, + MAX_RENDERBUFFER_SIZE_EXT = 0x84E8, + STENCIL_INDEX1_EXT = 0x8D46, + DEPTH_ATTACHMENT_EXT = 0x8D00, + COLOR_ATTACHMENT0_EXT = 0x8CE0, + INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506, + FRAMEBUFFER_EXT = 0x8D40, + RENDERBUFFER_WIDTH_EXT = 0x8D42, + FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = 0x8CD8, + FRAMEBUFFER_INCOMPLETE_ATTACHMENTS_EXT = 0x8CD6, + COLOR_ATTACHMENT5_EXT = 0x8CE5, + FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD, + COLOR_ATTACHMENT11_EXT = 0x8CEB, + STENCIL_INDEX16_EXT = 0x8D49, + COLOR_ATTACHMENT4_EXT = 0x8CE4, + COLOR_ATTACHMENT10_EXT = 0x8CEA, + RENDERBUFFER_BINDING_EXT = 0x8CA7, + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1, + STENCIL_ATTACHMENT_EXT = 0x8D20, + } + + public enum SGIX_async : uint + { + ASYNC_MARKER_SGIX = 0x8329, + } + + public enum EXT_texture_env_add : uint + { + } + + public enum PixelTransferParameter : uint + { + POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT, + DEPTH_BIAS = GetPName.DEPTH_BIAS, + POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI, + POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT, + BLUE_SCALE = GetPName.BLUE_SCALE, + POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI, + BLUE_BIAS = GetPName.BLUE_BIAS, + POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI, + INDEX_OFFSET = GetPName.INDEX_OFFSET, + POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT, + POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI, + MAP_COLOR = GetPName.MAP_COLOR, + POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI, + MAP_STENCIL = GetPName.MAP_STENCIL, + POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT, + INDEX_SHIFT = GetPName.INDEX_SHIFT, + POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI, + POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT, + POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT, + POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI, + POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI, + RED_SCALE = GetPName.RED_SCALE, + GREEN_BIAS = GetPName.GREEN_BIAS, + RED_BIAS = GetPName.RED_BIAS, + POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT, + GREEN_SCALE = GetPName.GREEN_SCALE, + ALPHA_SCALE = GetPName.ALPHA_SCALE, + ALPHA_BIAS = GetPName.ALPHA_BIAS, + DEPTH_SCALE = GetPName.DEPTH_SCALE, + POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT, + } + + public enum VERSION_1_3 : uint + { + TEXTURE14 = 0x84CE, + TEXTURE17 = 0x84D1, + TEXTURE16 = 0x84D0, + TEXTURE11 = 0x84CB, + TEXTURE10 = 0x84CA, + TEXTURE13 = 0x84CD, + TEXTURE12 = 0x84CC, + SAMPLE_ALPHA_TO_ONE = 0x809F, + TEXTURE_BINDING_CUBE_MAP = 0x8514, + TEXTURE19 = 0x84D3, + TEXTURE18 = 0x84D2, + PRIMARY_COLOR = 0x8577, + MULTISAMPLE = 0x809D, + TRANSPOSE_COLOR_MATRIX = 0x84E6, + TRANSPOSE_PROJECTION_MATRIX = 0x84E4, + CONSTANT = 0x8576, + COMBINE = 0x8570, + MULTISAMPLE_BIT = 0x20000000, + SOURCE2_ALPHA = 0x858A, + SAMPLES = 0x80A9, + COMPRESSED_ALPHA = 0x84E9, + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517, + SAMPLE_COVERAGE = 0x80A0, + TRANSPOSE_MODELVIEW_MATRIX = 0x84E3, + SAMPLE_ALPHA_TO_COVERAGE = 0x809E, + SUBTRACT = 0x84E7, + SAMPLE_BUFFERS = 0x80A8, + DOT3_RGBA = 0x86AF, + DOT3_RGB = 0x86AE, + SOURCE1_ALPHA = 0x8589, + TEXTURE6 = 0x84C6, + TEXTURE2 = 0x84C2, + COMPRESSED_RGB = 0x84ED, + COMPRESSED_RGBA = 0x84EE, + TEXTURE9 = 0x84C9, + TEXTURE31 = 0x84DF, + TEXTURE30 = 0x84DE, + OPERAND1_ALPHA = 0x8599, + CLIENT_ACTIVE_TEXTURE = 0x84E1, + INTERPOLATE = 0x8575, + OPERAND1_RGB = 0x8591, + SOURCE2_RGB = 0x8582, + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C, + TEXTURE_COMPRESSED = 0x86A1, + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A, + RGB_SCALE = 0x8573, + SAMPLE_COVERAGE_INVERT = 0x80AB, + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519, + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2, + COMPRESSED_TEXTURE_FORMATS = 0x86A3, + TEXTURE5 = 0x84C5, + TEXTURE1 = 0x84C1, + COMBINE_RGB = 0x8571, + TEXTURE25 = 0x84D9, + TEXTURE8 = 0x84C8, + TEXTURE27 = 0x84DB, + TEXTURE26 = 0x84DA, + TEXTURE21 = 0x84D5, + TEXTURE20 = 0x84D4, + TEXTURE23 = 0x84D7, + TEXTURE22 = 0x84D6, + SAMPLE_COVERAGE_VALUE = 0x80AA, + TEXTURE29 = 0x84DD, + TEXTURE28 = 0x84DC, + TEXTURE_CUBE_MAP = 0x8513, + SOURCE0_ALPHA = 0x8588, + TEXTURE24 = 0x84D8, + SOURCE0_RGB = 0x8580, + ADD_SIGNED = 0x8574, + OPERAND0_ALPHA = 0x8598, + REFLECTION_MAP = 0x8512, + ACTIVE_TEXTURE = 0x84E0, + TRANSPOSE_TEXTURE_MATRIX = 0x84E5, + SOURCE1_RGB = 0x8581, + TEXTURE15 = 0x84CF, + COMPRESSED_LUMINANCE = 0x84EA, + CLAMP_TO_BORDER = 0x812D, + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516, + OPERAND2_ALPHA = 0x859A, + COMPRESSED_INTENSITY = 0x84EC, + TEXTURE0 = 0x84C0, + NORMAL_MAP = 0x8511, + COMPRESSED_LUMINANCE_ALPHA = 0x84EB, + PROXY_TEXTURE_CUBE_MAP = 0x851B, + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0, + OPERAND2_RGB = 0x8592, + TEXTURE4 = 0x84C4, + OPERAND0_RGB = 0x8590, + MAX_TEXTURE_UNITS = 0x84E2, + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515, + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518, + TEXTURE_COMPRESSION_HINT = 0x84EF, + COMBINE_ALPHA = 0x8572, + PREVIOUS = 0x8578, + TEXTURE7 = 0x84C7, + TEXTURE3 = 0x84C3, + } + + public enum NV_vertex_program2 : uint + { + } + + public enum EXT_polygon_offset : uint + { + POLYGON_OFFSET_BIAS_EXT = 0x8039, + POLYGON_OFFSET_EXT = 0x8037, + POLYGON_OFFSET_FACTOR_EXT = 0x8038, + } + + public enum SGIX_texture_coordinate_clamp : uint + { + FOG_FACTOR_TO_ALPHA_SGIX = 0x836F, + TEXTURE_MAX_CLAMP_S_SGIX = 0x8369, + TEXTURE_MAX_CLAMP_R_SGIX = 0x836B, + TEXTURE_MAX_CLAMP_T_SGIX = 0x836A, + } + + public enum SGIX_instruments : uint + { + INSTRUMENT_MEASUREMENTS_SGIX = 0x8181, + INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180, + } + + public enum VERSION_2_0 : uint + { + MAX_VARYING_FLOATS = 0x8B4B, + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645, + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622, + DRAW_BUFFER13 = 0x8832, + VERTEX_PROGRAM_POINT_SIZE = 0x8642, + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C, + MAX_TEXTURE_COORDS = 0x8871, + FLOAT_MAT4 = 0x8B5C, + SAMPLER_3D = 0x8B5F, + SAMPLER_1D_SHADOW = 0x8B61, + SAMPLER_1D = 0x8B5D, + ATTACHED_SHADERS = 0x8B85, + ACTIVE_ATTRIBUTES = 0x8B89, + LINK_STATUS = 0x8B82, + FLOAT_VEC4 = 0x8B52, + DRAW_BUFFER4 = 0x8829, + DRAW_BUFFER8 = 0x882D, + MAX_DRAW_BUFFERS = 0x8824, + INT_VEC2 = 0x8B53, + POINT_SPRITE_COORD_ORIGIN = 0x8CA0, + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49, + SAMPLER_CUBE = 0x8B60, + DRAW_BUFFER12 = 0x8831, + DRAW_BUFFER11 = 0x8830, + DRAW_BUFFER10 = 0x882F, + FRAGMENT_SHADER = 0x8B30, + STENCIL_BACK_REF = 0x8CA3, + DRAW_BUFFER15 = 0x8834, + DRAW_BUFFER14 = 0x8833, + BOOL = 0x8B56, + CURRENT_VERTEX_ATTRIB = 0x8626, + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A, + FLOAT_MAT2 = 0x8B5A, + ACTIVE_UNIFORMS = 0x8B86, + SAMPLER_2D = 0x8B5E, + INFO_LOG_LENGTH = 0x8B84, + MAX_VERTEX_ATTRIBS = 0x8869, + DRAW_BUFFER0 = 0x8825, + CURRENT_PROGRAM = 0x8B8D, + SHADING_LANGUAGE_VERSION = 0x8B8C, + FLOAT_VEC3 = 0x8B51, + DRAW_BUFFER5 = 0x882A, + DRAW_BUFFER9 = 0x882E, + STENCIL_BACK_FUNC = 0x8800, + COMPILE_STATUS = 0x8B81, + INT_VEC3 = 0x8B54, + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802, + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623, + BLEND_EQUATION_ALPHA = 0x883D, + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803, + UPPER_LEFT = 0x8CA2, + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624, + FLOAT_MAT3 = 0x8B5B, + SAMPLER_2D_SHADOW = 0x8B62, + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A, + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B, + BLEND_EQUATION_RGB = GL_BLEND_EQUATION, + DRAW_BUFFER2 = 0x8827, + SHADER_SOURCE_LENGTH = 0x8B88, + DRAW_BUFFER7 = 0x882C, + SHADER_TYPE = 0x8B4F, + DRAW_BUFFER1 = 0x8826, + MAX_TEXTURE_IMAGE_UNITS = 0x8872, + POINT_SPRITE = 0x8861, + DRAW_BUFFER6 = 0x882B, + STENCIL_BACK_WRITEMASK = 0x8CA5, + STENCIL_BACK_VALUE_MASK = 0x8CA4, + COORD_REPLACE = 0x8862, + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625, + LOWER_LEFT = 0x8CA1, + INT_VEC4 = 0x8B55, + FLOAT_VEC2 = 0x8B50, + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A, + VALIDATE_STATUS = 0x8B83, + VERTEX_SHADER = 0x8B31, + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D, + VERTEX_PROGRAM_TWO_SIDE = 0x8643, + DELETE_STATUS = 0x8B80, + STENCIL_BACK_FAIL = 0x8801, + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87, + DRAW_BUFFER3 = 0x8828, + BOOL_VEC4 = 0x8B59, + BOOL_VEC3 = 0x8B58, + BOOL_VEC2 = 0x8B57, + } + + public enum ARB_multitexture : uint + { + TEXTURE13_ARB = 0x84CD, + TEXTURE7_ARB = 0x84C7, + TEXTURE21_ARB = 0x84D5, + TEXTURE24_ARB = 0x84D8, + TEXTURE19_ARB = 0x84D3, + TEXTURE5_ARB = 0x84C5, + TEXTURE16_ARB = 0x84D0, + TEXTURE27_ARB = 0x84DB, + TEXTURE17_ARB = 0x84D1, + MAX_TEXTURE_UNITS_ARB = 0x84E2, + TEXTURE2_ARB = 0x84C2, + TEXTURE20_ARB = 0x84D4, + TEXTURE31_ARB = 0x84DF, + TEXTURE12_ARB = 0x84CC, + TEXTURE18_ARB = 0x84D2, + TEXTURE15_ARB = 0x84CF, + TEXTURE10_ARB = 0x84CA, + ACTIVE_TEXTURE_ARB = 0x84E0, + TEXTURE23_ARB = 0x84D7, + TEXTURE0_ARB = 0x84C0, + TEXTURE29_ARB = 0x84DD, + TEXTURE26_ARB = 0x84DA, + TEXTURE8_ARB = 0x84C8, + TEXTURE3_ARB = 0x84C3, + TEXTURE30_ARB = 0x84DE, + TEXTURE11_ARB = 0x84CB, + TEXTURE9_ARB = 0x84C9, + CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1, + TEXTURE14_ARB = 0x84CE, + TEXTURE6_ARB = 0x84C6, + TEXTURE22_ARB = 0x84D6, + TEXTURE28_ARB = 0x84DC, + TEXTURE25_ARB = 0x84D9, + TEXTURE1_ARB = 0x84C1, + TEXTURE4_ARB = 0x84C4, + } + + public enum EXT_histogram : uint + { + HISTOGRAM_WIDTH = 0x8026, + PROXY_HISTOGRAM = 0x8025, + MINMAX_EXT = 0x802E, + MINMAX_SINK_EXT = 0x8030, + MINMAX_FORMAT_EXT = 0x802F, + HISTOGRAM_BLUE_SIZE = 0x802A, + HISTOGRAM_SINK_EXT = 0x802D, + HISTOGRAM_LUMINANCE_SIZE = 0x802C, + HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C, + HISTOGRAM_EXT = 0x8024, + HISTOGRAM_ALPHA_SIZE = 0x802B, + HISTOGRAM_FORMAT_EXT = 0x8027, + HISTOGRAM_RED_SIZE_EXT = 0x8028, + MINMAX = 0x802E, + MINMAX_SINK = 0x8030, + PROXY_HISTOGRAM_EXT = 0x8025, + HISTOGRAM_RED_SIZE = 0x8028, + HISTOGRAM_ALPHA_SIZE_EXT = 0x802B, + HISTOGRAM_BLUE_SIZE_EXT = 0x802A, + MINMAX_FORMAT = 0x802F, + HISTOGRAM_WIDTH_EXT = 0x8026, + HISTOGRAM_FORMAT = 0x8027, + TABLE_TOO_LARGE = 0x8031, + HISTOGRAM_SINK = 0x802D, + HISTOGRAM_GREEN_SIZE_EXT = 0x8029, + TABLE_TOO_LARGE_EXT = 0x8031, + HISTOGRAM = 0x8024, + HISTOGRAM_GREEN_SIZE = 0x8029, + } + + public enum PixelFormat : uint + { + CMYK_EXT = EXT_cmyka.CMYK_EXT, + YCRCB_444_SGIX = SGIX_ycrcb.YCRCB_444_SGIX, + R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX, + ALPHA = 0x1906, + RGBA = 0x1908, + GREEN = 0x1904, + R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX, + LUMINANCE_ALPHA = 0x190A, + STENCIL_INDEX = 0x1901, + RED = 0x1903, + BLUE = 0x1905, + CMYKA_EXT = EXT_cmyka.CMYKA_EXT, + ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX, + LUMINANCE = 0x1909, + LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX, + YCRCB_422_SGIX = SGIX_ycrcb.YCRCB_422_SGIX, + ABGR_EXT = EXT_abgr.ABGR_EXT, + COLOR_INDEX = 0x1900, + RGB = 0x1907, + LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX, + DEPTH_COMPONENT = 0x1902, + } + + public enum NV_occlusion_query : uint + { + CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865, + PIXEL_COUNT_NV = 0x8866, + PIXEL_COUNTER_BITS_NV = 0x8864, + PIXEL_COUNT_AVAILABLE_NV = 0x8867, + } + + public enum MapTarget : uint + { + MAP2_COLOR_4 = GetPName.MAP2_COLOR_4, + MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4, + MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3, + GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX, + MAP2_INDEX = GetPName.MAP2_INDEX, + MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1, + TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX, + MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1, + MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4, + MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3, + MAP1_INDEX = GetPName.MAP1_INDEX, + MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4, + MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2, + MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2, + MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3, + MAP1_COLOR_4 = GetPName.MAP1_COLOR_4, + MAP2_NORMAL = GetPName.MAP2_NORMAL, + MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4, + MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3, + MAP1_NORMAL = GetPName.MAP1_NORMAL, + } + + public enum ListParameterName : uint + { + LIST_PRIORITY_SGIX = SGIX_list_priority.LIST_PRIORITY_SGIX, + } + + public enum IBM_texture_mirrored_repeat : uint + { + MIRRORED_REPEAT_IBM = 0x8370, + } + + public enum SGIX_vertex_preclip : uint + { + VERTEX_PRECLIP_HINT_SGIX = 0x83EF, + VERTEX_PRECLIP_SGIX = 0x83EE, + } + + public enum PixelStoreSubsampleRate : uint + { + PIXEL_SUBSAMPLE_2424_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_2424_SGIX, + PIXEL_SUBSAMPLE_4444_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4444_SGIX, + PIXEL_SUBSAMPLE_4242_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4242_SGIX, + } + + public enum SUN_convolution_border_modes : uint + { + WRAP_BORDER_SUN = 0x81D4, + } + + public enum SGIS_generate_mipmap : uint + { + GENERATE_MIPMAP_HINT = 0x8192, + TEXTURE_DEFORMATION_SGIX = 0x8195, + GENERATE_MIPMAP = 0x8191, + GEOMETRY_DEFORMATION_SGIX = 0x8194, + GENERATE_MIPMAP_HINT_SGIS = 0x8192, + GENERATE_MIPMAP_SGIS = 0x8191, + DEFORMATIONS_MASK_SGIX = 0x8196, + MAX_DEFORMATION_ORDER_SGIX = 0x8197, + } + + public enum EXT_index_array_formats : uint + { + IUI_N3F_V2F_EXT = 0x81AF, + T2F_IUI_V3F_EXT = 0x81B2, + T2F_IUI_V2F_EXT = 0x81B1, + IUI_N3F_V3F_EXT = 0x81B0, + T2F_IUI_N3F_V3F_EXT = 0x81B4, + T2F_IUI_N3F_V2F_EXT = 0x81B3, + IUI_V3F_EXT = 0x81AE, + IUI_V2F_EXT = 0x81AD, + } + + public enum BlendEquationModeEXT : uint + { + MAX_EXT = EXT_blend_minmax.MAX_EXT, + LOGIC_OP = GetPName.LOGIC_OP, + FUNC_ADD_EXT = EXT_blend_minmax.FUNC_ADD_EXT, + FUNC_SUBTRACT_EXT = EXT_blend_subtract.FUNC_SUBTRACT_EXT, + ALPHA_MAX_SGIX = SGIX_blend_alpha_minmax.ALPHA_MAX_SGIX, + FUNC_REVERSE_SUBTRACT_EXT = EXT_blend_subtract.FUNC_REVERSE_SUBTRACT_EXT, + ALPHA_MIN_SGIX = SGIX_blend_alpha_minmax.ALPHA_MIN_SGIX, + MIN_EXT = EXT_blend_minmax.MIN_EXT, + } + + public enum NV_multisample_filter_hint : uint + { + MULTISAMPLE_FILTER_HINT_NV = 0x8534, + } + + public enum NV_texgen_emboss : uint + { + EMBOSS_CONSTANT_NV = 0x855E, + EMBOSS_LIGHT_NV = 0x855D, + EMBOSS_MAP_NV = 0x855F, + } + + public enum NV_fragment_program_option : uint + { + } + + public enum HP_image_transform : uint + { + IMAGE_TRANSFORM_2D_HP = 0x8161, + IMAGE_MIN_FILTER_HP = 0x815D, + IMAGE_TRANSLATE_Y_HP = 0x8158, + IMAGE_TRANSLATE_X_HP = 0x8157, + AVERAGE_HP = 0x8160, + POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162, + IMAGE_SCALE_Y_HP = 0x8156, + IMAGE_SCALE_X_HP = 0x8155, + CUBIC_HP = 0x815F, + IMAGE_MAG_FILTER_HP = 0x815C, + IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B, + IMAGE_ROTATE_ORIGIN_X_HP = 0x815A, + PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163, + IMAGE_CUBIC_WEIGHT_HP = 0x815E, + IMAGE_ROTATE_ANGLE_HP = 0x8159, + } + + public enum NV_half_float : uint + { + HALF_FLOAT_NV = 0x140B, + } + + public enum ARB_imaging : uint + { + CONVOLUTION_WIDTH = 0x8018, + COLOR_MATRIX_STACK_DEPTH = 0x80B2, + BLEND_EQUATION = 0x8009, + COLOR_TABLE_BIAS = 0x80D7, + CONSTANT_BORDER = 0x8151, + HISTOGRAM = 0x8024, + COLOR_TABLE_GREEN_SIZE = 0x80DB, + HISTOGRAM_RED_SIZE = 0x8028, + CONSTANT_ALPHA = 0x8003, + TABLE_TOO_LARGE = 0x8031, + POST_CONVOLUTION_GREEN_SCALE = 0x801D, + MINMAX_SINK = 0x8030, + PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5, + COLOR_TABLE_SCALE = 0x80D6, + COLOR_MATRIX = 0x80B1, + CONVOLUTION_FILTER_SCALE = 0x8014, + BLEND_COLOR = 0x8005, + MIN = 0x8007, + HISTOGRAM_SINK = 0x802D, + POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5, + SEPARABLE_2D = 0x8012, + FUNC_REVERSE_SUBTRACT = 0x800B, + CONVOLUTION_FORMAT = 0x8017, + REPLICATE_BORDER = 0x8153, + CONSTANT_COLOR = 0x8001, + COLOR_TABLE = 0x80D0, + POST_CONVOLUTION_BLUE_SCALE = 0x801E, + FUNC_ADD = 0x8006, + CONVOLUTION_2D = 0x8011, + POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB, + POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7, + MINMAX = 0x802E, + POST_CONVOLUTION_ALPHA_BIAS = 0x8023, + POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6, + POST_COLOR_MATRIX_RED_BIAS = 0x80B8, + HISTOGRAM_BLUE_SIZE = 0x802A, + POST_CONVOLUTION_BLUE_BIAS = 0x8022, + COLOR_TABLE_FORMAT = 0x80D8, + POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2, + CONVOLUTION_HEIGHT = 0x8019, + POST_CONVOLUTION_COLOR_TABLE = 0x80D1, + MINMAX_FORMAT = 0x802F, + COLOR_TABLE_ALPHA_SIZE = 0x80DD, + POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA, + PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4, + PROXY_COLOR_TABLE = 0x80D3, + HISTOGRAM_ALPHA_SIZE = 0x802B, + MAX_CONVOLUTION_WIDTH = 0x801A, + POST_COLOR_MATRIX_RED_SCALE = 0x80B4, + POST_CONVOLUTION_ALPHA_SCALE = 0x801F, + CONVOLUTION_BORDER_COLOR = 0x8154, + COLOR_TABLE_BLUE_SIZE = 0x80DC, + ONE_MINUS_CONSTANT_COLOR = 0x8002, + COLOR_TABLE_LUMINANCE_SIZE = 0x80DE, + POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9, + ONE_MINUS_CONSTANT_ALPHA = 0x8004, + FUNC_SUBTRACT = 0x800A, + COLOR_TABLE_INTENSITY_SIZE = 0x80DF, + REDUCE = 0x8016, + COLOR_TABLE_RED_SIZE = 0x80DA, + CONVOLUTION_BORDER_MODE = 0x8013, + HISTOGRAM_GREEN_SIZE = 0x8029, + POST_CONVOLUTION_GREEN_BIAS = 0x8021, + HISTOGRAM_FORMAT = 0x8027, + CONVOLUTION_1D = 0x8010, + POST_CONVOLUTION_RED_BIAS = 0x8020, + MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3, + COLOR_TABLE_WIDTH = 0x80D9, + POST_CONVOLUTION_RED_SCALE = 0x801C, + MAX = 0x8008, + PROXY_HISTOGRAM = 0x8025, + MAX_CONVOLUTION_HEIGHT = 0x801B, + CONVOLUTION_FILTER_BIAS = 0x8015, + HISTOGRAM_WIDTH = 0x8026, + HISTOGRAM_LUMINANCE_SIZE = 0x802C, + } + + public enum NV_texture_compression_vtc : uint + { + } + + public enum NV_texture_expand_normal : uint + { + TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F, + } + + public enum S3_s3tc : uint + { + RGB4_S3TC = 0x83A1, + RGBA_S3TC = 0x83A2, + RGB_S3TC = 0x83A0, + RGBA4_S3TC = 0x83A3, + } + + public enum ARB_fragment_shader : uint + { + MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49, + FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B, + FRAGMENT_SHADER_ARB = 0x8B30, + } + + public enum TexCoordPointerType : uint + { + DOUBLE = DataType.DOUBLE, + INT = DataType.INT, + SHORT = DataType.SHORT, + FLOAT = DataType.FLOAT, + } + + public enum ClearBufferMask : uint + { + STENCIL_BUFFER_BIT = AttribMask.STENCIL_BUFFER_BIT, + ACCUM_BUFFER_BIT = AttribMask.ACCUM_BUFFER_BIT, + COLOR_BUFFER_BIT = AttribMask.COLOR_BUFFER_BIT, + DEPTH_BUFFER_BIT = AttribMask.DEPTH_BUFFER_BIT, + } + + public enum SGIX_ycrcb : uint + { + YCRCB_422_SGIX = 0x81BB, + YCRCB_444_SGIX = 0x81BC, + } + + public enum EXT_rescale_normal : uint + { + RESCALE_NORMAL_EXT = 0x803A, + RESCALE_NORMAL = 0x803A, + } + + public enum ARB_shader_objects : uint + { + OBJECT_VALIDATE_STATUS_ARB = 0x8B83, + BOOL_VEC3_ARB = 0x8B58, + SAMPLER_2D_RECT_ARB = 0x8B63, + OBJECT_COMPILE_STATUS_ARB = 0x8B81, + OBJECT_DELETE_STATUS_ARB = 0x8B80, + OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87, + FLOAT_MAT2_ARB = 0x8B5A, + BOOL_ARB = 0x8B56, + FLOAT_MAT4_ARB = 0x8B5C, + OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88, + SAMPLER_3D_ARB = 0x8B5F, + OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84, + INT_VEC4_ARB = 0x8B55, + FLOAT_MAT3_ARB = 0x8B5B, + PROGRAM_OBJECT_ARB = 0x8B40, + SAMPLER_1D_SHADOW_ARB = 0x8B61, + OBJECT_TYPE_ARB = 0x8B4E, + BOOL_VEC4_ARB = 0x8B59, + BOOL_VEC2_ARB = 0x8B57, + OBJECT_SUBTYPE_ARB = 0x8B4F, + SAMPLER_1D_ARB = 0x8B5D, + SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64, + SHADER_OBJECT_ARB = 0x8B48, + FLOAT_VEC2_ARB = 0x8B50, + SAMPLER_2D_SHADOW_ARB = 0x8B62, + OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85, + FLOAT_VEC4_ARB = 0x8B52, + OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86, + SAMPLER_CUBE_ARB = 0x8B60, + SAMPLER_2D_ARB = 0x8B5E, + INT_VEC2_ARB = 0x8B53, + OBJECT_LINK_STATUS_ARB = 0x8B82, + INT_VEC3_ARB = 0x8B54, + FLOAT_VEC3_ARB = 0x8B51, + } + + public enum SGIX_shadow_ambient : uint + { + SHADOW_AMBIENT_SGIX = 0x80BF, + } + + public enum NV_vertex_program3 : uint + { + MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = ARB_vertex_shader.MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, + } + + public enum EXT_blend_minmax : uint + { + MAX_EXT = 0x8008, + BLEND_EQUATION_EXT = 0x8009, + MIN = 0x8007, + FUNC_ADD_EXT = 0x8006, + FUNC_ADD = 0x8006, + MAX = 0x8008, + MIN_EXT = 0x8007, + BLEND_EQUATION = 0x8009, + } + + public enum EXT_packed_pixels : uint + { + UNSIGNED_BYTE_3_3_2 = 0x8032, + UNSIGNED_INT_2_10_10_10_REV = 0x8368, + UNSIGNED_INT_10_10_10_2 = 0x8036, + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365, + UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364, + UNSIGNED_INT_8_8_8_8 = 0x8035, + UNSIGNED_SHORT_5_6_5 = 0x8363, + UNSIGNED_INT_8_8_8_8_REV = 0x8367, + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366, + UNSIGNED_INT_8_8_8_8_EXT = 0x8035, + UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366, + UNSIGNED_SHORT_5_6_5_REV = 0x8364, + UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365, + UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368, + UNSIGNED_BYTE_2_3_3_REV = 0x8362, + UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362, + UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033, + UNSIGNED_INT_10_10_10_2_EXT = 0x8036, + UNSIGNED_SHORT_5_6_5_EXT = 0x8363, + UNSIGNED_SHORT_5_5_5_1 = 0x8034, + UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367, + UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034, + UNSIGNED_BYTE_3_3_2_EXT = 0x8032, + UNSIGNED_SHORT_4_4_4_4 = 0x8033, + } + + public enum LightEnvParameterSGIX : uint + { + LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX, + } + + public enum EXT_blend_color : uint + { + CONSTANT_COLOR_EXT = 0x8001, + CONSTANT_ALPHA = 0x8003, + BLEND_COLOR_EXT = 0x8005, + CONSTANT_ALPHA_EXT = 0x8003, + ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002, + ONE_MINUS_CONSTANT_COLOR = 0x8002, + ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004, + CONSTANT_COLOR = 0x8001, + BLEND_COLOR = 0x8005, + ONE_MINUS_CONSTANT_ALPHA = 0x8004, + } + + public enum INTEL_texture_scissor : uint + { + } + + public enum PixelTexGenMode : uint + { + RGB = PixelFormat.RGB, + NONE = DrawBufferMode.NONE, + LUMINANCE = PixelFormat.LUMINANCE, + PIXEL_TEX_GEN_ALPHA_MS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_MS_SGIX, + PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX, + PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX, + LUMINANCE_ALPHA = PixelFormat.LUMINANCE_ALPHA, + PIXEL_TEX_GEN_ALPHA_LS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_LS_SGIX, + RGBA = PixelFormat.RGBA, + } + + public enum EXT_copy_texture : uint + { + } + + public enum NV_light_max_exponent : uint + { + MAX_SPOT_EXPONENT_NV = 0x8505, + MAX_SHININESS_NV = 0x8504, + } + + public enum SGIX_icc_texture : uint + { + RGBA_ICC_SGIX = 0x8461, + INTENSITY_ICC_SGIX = 0x8464, + ALPHA_ICC_SGIX = 0x8462, + LUMINANCE_ICC_SGIX = 0x8463, + LUMINANCE16_ICC_SGIX = 0x8469, + R5_G6_B5_ICC_SGIX = 0x8466, + ALPHA16_ICC_SGIX = 0x8468, + INTENSITY16_ICC_SGIX = 0x846A, + RGB_ICC_SGIX = 0x8460, + LUMINANCE_ALPHA_ICC_SGIX = 0x8465, + R5_G6_B5_A8_ICC_SGIX = 0x8467, + LUMINANCE16_ALPHA8_ICC_SGIX = 0x846B, + } + + public enum ARB_texture_float : uint + { + TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14, + TEXTURE_BLUE_TYPE_ARB = 0x8C12, + LUMINANCE_ALPHA32F_ARB = 0x8819, + TEXTURE_DEPTH_TYPE_ARB = 0x8C16, + RGB32F_ARB = 0x8815, + LUMINANCE16F_ARB = 0x881E, + TEXTURE_RED_TYPE_ARB = 0x8C10, + TEXTURE_GREEN_TYPE_ARB = 0x8C11, + ALPHA16F_ARB = 0x881C, + TEXTURE_INTENSITY_TYPE_ARB = 0x8C15, + INTENSITY32F_ARB = 0x8817, + TEXTURE_ALPHA_TYPE_ARB = 0x8C13, + INTENSITY16F_ARB = 0x881D, + LUMINANCE32F_ARB = 0x8818, + LUMINANCE_ALPHA16F_ARB = 0x881F, + RGBA16F_ARB = 0x881A, + RGB16F_ARB = 0x881B, + ALPHA32F_ARB = 0x8816, + UNSIGNED_NORMALIZED_ARB = 0x8C17, + RGBA32F_ARB = 0x8814, + } + + public enum FogMode : uint + { + EXP2 = 0x0801, + EXP = 0x0800, + LINEAR = TextureMagFilter.LINEAR, + FOG_FUNC_SGIS = SGIS_fog_function.FOG_FUNC_SGIS, + } + + public enum EXT_422_pixels : uint + { + _422_REV_EXT = 0x80CD, + _422_EXT = 0x80CC, + _422_REV_AVERAGE_EXT = 0x80CF, + _422_AVERAGE_EXT = 0x80CE, + } + + public enum ColorTableParameterPNameSGI : uint + { + COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI, + COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI, + } + + public enum SGIX_calligraphic_fragment : uint + { + CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183, + } + + public enum SGIS_texture_border_clamp : uint + { + CLAMP_TO_BORDER_SGIS = 0x812D, + CLAMP_TO_BORDER_ARB = 0x812D, + CLAMP_TO_BORDER = 0x812D, + } + + public enum ARB_texture_env_dot3 : uint + { + DOT3_RGB_ARB = 0x86AE, + DOT3_RGBA_ARB = 0x86AF, + } + + public enum HintTarget : uint + { + GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS, + POLYGON_SMOOTH_HINT = GetPName.POLYGON_SMOOTH_HINT, + VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX, + LINE_SMOOTH_HINT = GetPName.LINE_SMOOTH_HINT, + POINT_SMOOTH_HINT = GetPName.POINT_SMOOTH_HINT, + PERSPECTIVE_CORRECTION_HINT = GetPName.PERSPECTIVE_CORRECTION_HINT, + UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT, + FOG_HINT = GetPName.FOG_HINT, + CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX, + TEXTURE_MULTI_BUFFER_HINT_SGIX = SGIX_texture_multi_buffer.TEXTURE_MULTI_BUFFER_HINT_SGIX, + PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT, + } + + public enum MESA_resize_buffers : uint + { + } + + public enum VERSION_1_4 : uint + { + DECR_WRAP = 0x8508, + GENERATE_MIPMAP = 0x8191, + FRAGMENT_DEPTH = 0x8452, + MAX_TEXTURE_LOD_BIAS = 0x84FD, + FOG_COORDINATE_ARRAY = 0x8457, + BLEND_DST_RGB = 0x80C8, + GENERATE_MIPMAP_HINT = 0x8192, + BLEND_SRC_ALPHA = 0x80CB, + TEXTURE_COMPARE_MODE = 0x884C, + FOG_COORDINATE_ARRAY_STRIDE = 0x8455, + TEXTURE_FILTER_CONTROL = 0x8500, + DEPTH_COMPONENT24 = 0x81A6, + FOG_COORDINATE_SOURCE = 0x8450, + POINT_SIZE_MAX = 0x8127, + POINT_DISTANCE_ATTENUATION = 0x8129, + SECONDARY_COLOR_ARRAY_SIZE = 0x845A, + DEPTH_TEXTURE_MODE = 0x884B, + DEPTH_COMPONENT16 = 0x81A5, + FOG_COORDINATE_ARRAY_TYPE = 0x8454, + MIRRORED_REPEAT = 0x8370, + CURRENT_SECONDARY_COLOR = 0x8459, + SECONDARY_COLOR_ARRAY_POINTER = 0x845D, + SECONDARY_COLOR_ARRAY_STRIDE = 0x845C, + DEPTH_COMPONENT32 = 0x81A7, + TEXTURE_COMPARE_FUNC = 0x884D, + TEXTURE_DEPTH_SIZE = 0x884A, + BLEND_DST_ALPHA = 0x80CA, + CURRENT_FOG_COORDINATE = 0x8453, + POINT_FADE_THRESHOLD_SIZE = 0x8128, + COMPARE_R_TO_TEXTURE = 0x884E, + TEXTURE_LOD_BIAS = 0x8501, + FOG_COORDINATE_ARRAY_POINTER = 0x8456, + BLEND_SRC_RGB = 0x80C9, + COLOR_SUM = 0x8458, + FOG_COORDINATE = 0x8451, + SECONDARY_COLOR_ARRAY_TYPE = 0x845B, + POINT_SIZE_MIN = 0x8126, + INCR_WRAP = 0x8507, + SECONDARY_COLOR_ARRAY = 0x845E, + } + + public enum LightName : uint + { + FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX, + FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX, + LIGHT4 = 0x4004, + LIGHT3 = 0x4003, + FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX, + LIGHT6 = 0x4006, + FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX, + LIGHT5 = 0x4005, + LIGHT0 = 0x4000, + FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX, + FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX, + LIGHT7 = 0x4007, + LIGHT2 = 0x4002, + FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX, + LIGHT1 = 0x4001, + FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX, + } + + public enum SGIS_point_parameters : uint + { + POINT_SIZE_MIN_SGIS = 0x8126, + POINT_SIZE_MAX_SGIS = 0x8127, + POINT_DISTANCE_ATTENUATION = 0x8129, + DISTANCE_ATTENUATION_EXT = 0x8129, + POINT_FADE_THRESHOLD_SIZE = 0x8128, + POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128, + POINT_SIZE_MIN_EXT = 0x8126, + POINT_SIZE_MAX = 0x8127, + POINT_DISTANCE_ATTENUATION_ARB = 0x8129, + POINT_SIZE_MIN = 0x8126, + POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128, + DISTANCE_ATTENUATION_SGIS = 0x8129, + POINT_SIZE_MAX_EXT = 0x8127, + POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128, + POINT_SIZE_MAX_ARB = 0x8127, + POINT_SIZE_MIN_ARB = 0x8126, + } + + public enum ARB_texture_env_add : uint + { + } + + public enum EXT_color_subtable : uint + { + } + + public enum MESA_ycbcr_texture : uint + { + UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB, + YCBCR_MESA = 0x8757, + UNSIGNED_SHORT_8_8_MESA = 0x85BA, + } + + public enum SGIX_shadow : uint + { + TEXTURE_LEQUAL_R_SGIX = 0x819C, + TEXTURE_COMPARE_SGIX = 0x819A, + TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B, + TEXTURE_GEQUAL_R_SGIX = 0x819D, + } + + public enum ARB_texture_mirrored_repeat : uint + { + MIRRORED_REPEAT_ARB = 0x8370, + } + + public enum EXT_texture_object : uint + { + TEXTURE_2D_BINDING_EXT = 0x8069, + TEXTURE_1D_BINDING_EXT = 0x8068, + TEXTURE_PRIORITY_EXT = 0x8066, + TEXTURE_3D_BINDING_EXT = 0x806A, + TEXTURE_RESIDENT_EXT = 0x8067, + } + + public enum EXT_texture_filter_anisotropic : uint + { + TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE, + MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF, + } + + public enum SGIS_multisample : uint + { + SAMPLE_PATTERN_SGIS = 0x80AC, + _1PASS_SGIS = 0x80A1, + _2PASS_1_SGIS = 0x80A3, + _2PASS_0_SGIS = 0x80A2, + _4PASS_3_SGIS = 0x80A7, + _4PASS_0_SGIS = 0x80A4, + SAMPLE_MASK_SGIS = 0x80A0, + _4PASS_1_SGIS = 0x80A5, + SAMPLES_SGIS = 0x80A9, + MULTISAMPLE_SGIS = 0x809D, + SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E, + _4PASS_2_SGIS = 0x80A6, + SAMPLE_MASK_INVERT_SGIS = 0x80AB, + SAMPLE_BUFFERS_SGIS = 0x80A8, + SAMPLE_MASK_VALUE_SGIS = 0x80AA, + SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F, + } + + public enum GetPixelMap : uint + { + PIXEL_MAP_B_TO_B = 0x0C78, + PIXEL_MAP_S_TO_S = 0x0C71, + PIXEL_MAP_R_TO_R = 0x0C76, + PIXEL_MAP_I_TO_B = 0x0C74, + PIXEL_MAP_I_TO_G = 0x0C73, + PIXEL_MAP_I_TO_A = 0x0C75, + PIXEL_MAP_A_TO_A = 0x0C79, + PIXEL_MAP_G_TO_G = 0x0C77, + PIXEL_MAP_I_TO_I = 0x0C70, + PIXEL_MAP_I_TO_R = 0x0C72, + } + + public enum EXT_pixel_transform : uint + { + PIXEL_MIN_FILTER_EXT = 0x8332, + PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336, + PIXEL_TRANSFORM_2D_EXT = 0x8330, + MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337, + CUBIC_EXT = 0x8334, + PIXEL_CUBIC_WEIGHT_EXT = 0x8333, + AVERAGE_EXT = 0x8335, + PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338, + PIXEL_MAG_FILTER_EXT = 0x8331, + } + + public enum PGI_vertex_hints : uint + { + MAT_SPECULAR_BIT_PGI = 0x04000000, + TEXCOORD2_BIT_PGI = 0x20000000, + VERTEX_CONSISTENT_HINT_PGI = 0x1A22B, + MAT_SHININESS_BIT_PGI = 0x02000000, + MAT_AMBIENT_BIT_PGI = 0x00100000, + MATERIAL_SIDE_HINT_PGI = 0x1A22C, + TEXCOORD3_BIT_PGI = 0x40000000, + TEXCOORD4_BIT_PGI = 0x80000000, + MAT_COLOR_INDEXES_BIT_PGI = 0x01000000, + MAX_VERTEX_HINT_PGI = 0x1A22D, + VERTEX23_BIT_PGI = 0x00000004, + TEXCOORD1_BIT_PGI = 0x10000000, + INDEX_BIT_PGI = 0x00080000, + EDGEFLAG_BIT_PGI = 0x00040000, + COLOR3_BIT_PGI = 0x00010000, + VERTEX_DATA_HINT_PGI = 0x1A22A, + MAT_DIFFUSE_BIT_PGI = 0x00400000, + NORMAL_BIT_PGI = 0x08000000, + MAT_EMISSION_BIT_PGI = 0x00800000, + COLOR4_BIT_PGI = 0x00020000, + VERTEX4_BIT_PGI = 0x00000008, + MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000, + } + + public enum LightModelParameter : uint + { + LIGHT_MODEL_LOCAL_VIEWER = GetPName.LIGHT_MODEL_LOCAL_VIEWER, + LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL, + LIGHT_MODEL_AMBIENT = GetPName.LIGHT_MODEL_AMBIENT, + LIGHT_MODEL_TWO_SIDE = GetPName.LIGHT_MODEL_TWO_SIDE, + } + + public enum NV_register_combiners : uint + { + COMBINER_MAPPING_NV = 0x8543, + SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532, + COMBINER_CD_OUTPUT_NV = 0x854B, + ZERO = BlendingFactorDest.ZERO, + COMBINER_INPUT_NV = 0x8542, + COMBINER5_NV = 0x8555, + SIGNED_NEGATE_NV = 0x853D, + COMBINER_SUM_OUTPUT_NV = 0x854C, + SCALE_BY_TWO_NV = 0x853E, + REGISTER_COMBINERS_NV = 0x8522, + COMBINER6_NV = 0x8556, + SCALE_BY_FOUR_NV = 0x853F, + E_TIMES_F_NV = 0x8531, + PRIMARY_COLOR_NV = 0x852C, + COMBINER2_NV = 0x8552, + COMBINER3_NV = 0x8553, + COMBINER0_NV = 0x8550, + COMBINER1_NV = 0x8551, + VARIABLE_F_NV = 0x8528, + FOG = GetPName.FOG, + SIGNED_IDENTITY_NV = 0x853C, + SECONDARY_COLOR_NV = 0x852D, + SCALE_BY_ONE_HALF_NV = 0x8540, + COMBINER_AB_OUTPUT_NV = 0x854A, + NONE = DrawBufferMode.NONE, + CONSTANT_COLOR0_NV = 0x852A, + COMBINER_CD_DOT_PRODUCT_NV = 0x8546, + TEXTURE0_ARB = ARB_multitexture.TEXTURE0_ARB, + UNSIGNED_INVERT_NV = 0x8537, + NUM_GENERAL_COMBINERS_NV = 0x854E, + COMBINER_BIAS_NV = 0x8549, + VARIABLE_B_NV = 0x8524, + EXPAND_NORMAL_NV = 0x8538, + VARIABLE_C_NV = 0x8525, + HALF_BIAS_NORMAL_NV = 0x853A, + COMBINER_COMPONENT_USAGE_NV = 0x8544, + COMBINER_SCALE_NV = 0x8548, + VARIABLE_A_NV = 0x8523, + HALF_BIAS_NEGATE_NV = 0x853B, + DISCARD_NV = 0x8530, + COMBINER_AB_DOT_PRODUCT_NV = 0x8545, + UNSIGNED_IDENTITY_NV = 0x8536, + EXPAND_NEGATE_NV = 0x8539, + VARIABLE_D_NV = 0x8526, + BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541, + VARIABLE_E_NV = 0x8527, + COMBINER_MUX_SUM_NV = 0x8547, + MAX_GENERAL_COMBINERS_NV = 0x854D, + COMBINER7_NV = 0x8557, + COMBINER4_NV = 0x8554, + COLOR_SUM_CLAMP_NV = 0x854F, + TEXTURE1_ARB = ARB_multitexture.TEXTURE1_ARB, + SPARE1_NV = 0x852F, + CONSTANT_COLOR1_NV = 0x852B, + SPARE0_NV = 0x852E, + VARIABLE_G_NV = 0x8529, + } + + public enum ATI_vertex_attrib_array_object : uint + { + } + + public enum NV_vertex_array_range2 : uint + { + VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533, + } + + public enum ARB_half_float_pixel : uint + { + HALF_FLOAT_ARB = 0x140B, + } + + public enum EXT_separate_specular_color : uint + { + SINGLE_COLOR_EXT = 0x81F9, + LIGHT_MODEL_COLOR_CONTROL = 0x81F8, + SEPARATE_SPECULAR_COLOR_EXT = 0x81FA, + LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8, + SEPARATE_SPECULAR_COLOR = 0x81FA, + SINGLE_COLOR = 0x81F9, + } + + public enum EXT_blend_logic_op : uint + { + } + + public enum ATI_envmap_bumpmap : uint + { + BUMP_TARGET_ATI = 0x877C, + BUMP_ROT_MATRIX_ATI = 0x8775, + DU8DV8_ATI = 0x877A, + BUMP_NUM_TEX_UNITS_ATI = 0x8777, + BUMP_ROT_MATRIX_SIZE_ATI = 0x8776, + BUMP_ENVMAP_ATI = 0x877B, + BUMP_TEX_UNITS_ATI = 0x8778, + DUDV_ATI = 0x8779, + } + + public enum ATI_draw_buffers : uint + { + DRAW_BUFFER9_ATI = 0x882E, + DRAW_BUFFER10_ATI = 0x882F, + DRAW_BUFFER6_ATI = 0x882B, + DRAW_BUFFER4_ATI = 0x8829, + DRAW_BUFFER14_ATI = 0x8833, + DRAW_BUFFER3_ATI = 0x8828, + DRAW_BUFFER5_ATI = 0x882A, + DRAW_BUFFER0_ATI = 0x8825, + DRAW_BUFFER12_ATI = 0x8831, + DRAW_BUFFER11_ATI = 0x8830, + DRAW_BUFFER8_ATI = 0x882D, + DRAW_BUFFER15_ATI = 0x8834, + DRAW_BUFFER7_ATI = 0x882C, + DRAW_BUFFER13_ATI = 0x8832, + DRAW_BUFFER2_ATI = 0x8827, + DRAW_BUFFER1_ATI = 0x8826, + MAX_DRAW_BUFFERS_ATI = 0x8824, + } + + public enum ColorMaterialFace : uint + { + BACK = DrawBufferMode.BACK, + FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK, + FRONT = DrawBufferMode.FRONT, + } + + public enum GetTextureParameter : uint + { + TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX, + TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT, + TEXTURE_BORDER = 0x1005, + TEXTURE_HEIGHT = 0x1001, + TEXTURE_INTENSITY_SIZE = 0x8061, + TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX, + TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS, + TEXTURE_FILTER4_SIZE_SGIS = SGIS_texture_filter4.TEXTURE_FILTER4_SIZE_SGIS, + TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX, + TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX, + TEXTURE_PRIORITY = 0x8066, + TEXTURE_RED_SIZE = 0x805C, + TEXTURE_MIN_FILTER = TextureParameterName.TEXTURE_MIN_FILTER, + TEXTURE_4DSIZE_SGIS = SGIS_texture4D.TEXTURE_4DSIZE_SGIS, + TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS, + TEXTURE_WIDTH = 0x1000, + TEXTURE_BLUE_SIZE = 0x805E, + TEXTURE_WRAP_T = TextureParameterName.TEXTURE_WRAP_T, + TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS, + POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX, + TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX, + TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX, + TEXTURE_INTERNAL_FORMAT = 0x1003, + TEXTURE_LUMINANCE_SIZE = 0x8060, + TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX, + DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS, + TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX, + TEXTURE_COMPONENTS = 0x1003, + TEXTURE_COMPARE_OPERATOR_SGIX = SGIX_shadow.TEXTURE_COMPARE_OPERATOR_SGIX, + TEXTURE_LEQUAL_R_SGIX = SGIX_shadow.TEXTURE_LEQUAL_R_SGIX, + TEXTURE_GEQUAL_R_SGIX = SGIX_shadow.TEXTURE_GEQUAL_R_SGIX, + TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX, + DETAIL_TEXTURE_FUNC_POINTS_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_FUNC_POINTS_SGIS, + DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS, + TEXTURE_BORDER_COLOR = 0x1004, + SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX, + TEXTURE_MAG_FILTER = TextureParameterName.TEXTURE_MAG_FILTER, + TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS, + TEXTURE_GREEN_SIZE = 0x805D, + TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS, + TEXTURE_WRAP_S = TextureParameterName.TEXTURE_WRAP_S, + TEXTURE_RESIDENT = 0x8067, + TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX, + POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX, + DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS, + TEXTURE_DEPTH_EXT = EXT_texture3D.TEXTURE_DEPTH_EXT, + TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX, + TEXTURE_ALPHA_SIZE = 0x805F, + TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX, + QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS, + GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS, + SHARPEN_TEXTURE_FUNC_POINTS_SGIS = SGIS_sharpen_texture.SHARPEN_TEXTURE_FUNC_POINTS_SGIS, + TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX, + } + + public enum ARB_texture_env_combine : uint + { + SOURCE2_RGB_ARB = 0x8582, + OPERAND0_ALPHA_ARB = 0x8598, + COMBINE_ARB = 0x8570, + SOURCE1_RGB_ARB = 0x8581, + ADD_SIGNED_ARB = 0x8574, + SUBTRACT_ARB = 0x84E7, + PRIMARY_COLOR_ARB = 0x8577, + SOURCE2_ALPHA_ARB = 0x858A, + OPERAND1_RGB_ARB = 0x8591, + OPERAND0_RGB_ARB = 0x8590, + OPERAND2_ALPHA_ARB = 0x859A, + CONSTANT_ARB = 0x8576, + SOURCE0_ALPHA_ARB = 0x8588, + INTERPOLATE_ARB = 0x8575, + PREVIOUS_ARB = 0x8578, + OPERAND2_RGB_ARB = 0x8592, + COMBINE_RGB_ARB = 0x8571, + SOURCE1_ALPHA_ARB = 0x8589, + SOURCE0_RGB_ARB = 0x8580, + COMBINE_ALPHA_ARB = 0x8572, + OPERAND1_ALPHA_ARB = 0x8599, + RGB_SCALE_ARB = 0x8573, + } + + public enum SUN_global_alpha : uint + { + GLOBAL_ALPHA_SUN = 0x81D9, + GLOBAL_ALPHA_FACTOR_SUN = 0x81DA, + } + + public enum NV_texture_shader : uint + { + DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA, + DS_SCALE_NV = 0x8710, + DSDT_MAG_INTENSITY_NV = 0x86DC, + SIGNED_HILO_NV = 0x86F9, + DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9, + OFFSET_TEXTURE_SCALE_NV = 0x86E2, + MAGNITUDE_SCALE_NV = 0x8712, + CULL_FRAGMENT_NV = 0x86E7, + OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV, + TEXTURE_DT_SIZE_NV = 0x871E, + OFFSET_TEXTURE_2D_NV = 0x86E8, + UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA, + VIBRANCE_SCALE_NV = 0x8713, + PREVIOUS_TEXTURE_INPUT_NV = 0x86E4, + SIGNED_LUMINANCE_NV = 0x8701, + DS_BIAS_NV = 0x8716, + SIGNED_RGB8_NV = 0x86FF, + DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1, + DSDT8_MAG8_INTENSITY8_NV = 0x870B, + VIBRANCE_BIAS_NV = 0x8719, + SIGNED_ALPHA8_NV = 0x8706, + LO_BIAS_NV = 0x8715, + UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB, + DOT_PRODUCT_NV = 0x86EC, + DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE, + SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D, + DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E, + DT_BIAS_NV = 0x8717, + SIGNED_LUMINANCE_ALPHA_NV = 0x8703, + OFFSET_TEXTURE_BIAS_NV = 0x86E3, + OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV, + HILO16_NV = 0x86F8, + TEXTURE_BORDER_VALUES_NV = 0x871A, + SIGNED_ALPHA_NV = 0x8705, + OFFSET_TEXTURE_MATRIX_NV = 0x86E1, + TEXTURE_SHADER_NV = 0x86DE, + OFFSET_TEXTURE_RECTANGLE_NV = 0x864C, + HI_BIAS_NV = 0x8714, + DSDT8_NV = 0x8709, + SHADER_CONSISTENT_NV = 0x86DD, + DSDT_MAG_NV = 0x86F6, + TEXTURE_LO_SIZE_NV = 0x871C, + DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2, + DSDT8_MAG8_NV = 0x870A, + SIGNED_RGBA8_NV = 0x86FC, + DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0, + CULL_MODES_NV = 0x86E0, + SIGNED_RGB_NV = 0x86FE, + OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D, + DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED, + CONST_EYE_NV = 0x86E5, + SIGNED_RGBA_NV = 0x86FB, + RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9, + SIGNED_INTENSITY8_NV = 0x8708, + SHADER_OPERATION_NV = 0x86DF, + PASS_THROUGH_NV = 0x86E6, + DSDT_NV = 0x86F5, + SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C, + OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV, + TEXTURE_MAG_SIZE_NV = 0x871F, + SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704, + SIGNED_HILO16_NV = 0x86FA, + SIGNED_INTENSITY_NV = 0x8707, + HILO_NV = 0x86F4, + DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3, + LO_SCALE_NV = 0x870F, + MAGNITUDE_BIAS_NV = 0x8718, + HI_SCALE_NV = 0x870E, + TEXTURE_DS_SIZE_NV = 0x871D, + DT_SCALE_NV = 0x8711, + SIGNED_LUMINANCE8_NV = 0x8702, + DSDT_MAG_VIB_NV = 0x86F7, + TEXTURE_HI_SIZE_NV = 0x871B, + } + + public enum EXT_cull_vertex : uint + { + CULL_VERTEX_EXT = 0x81AA, + CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC, + CULL_VERTEX_EYE_POSITION_EXT = 0x81AB, + } + + public enum ARB_texture_border_clamp : uint + { + CLAMP_TO_BORDER_ARB = 0x812D, + } + + public enum SGIX_clipmap : uint + { + TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175, + NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E, + LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170, + TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172, + NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D, + TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174, + MAX_CLIPMAP_DEPTH_SGIX = 0x8177, + TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173, + TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176, + TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171, + LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F, + MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178, + } + + public enum ConvolutionParameterEXT : uint + { + CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT, + CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT, + CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT, + } + + public enum GetConvolutionParameter : uint + { + MAX_CONVOLUTION_WIDTH_EXT = EXT_convolution.MAX_CONVOLUTION_WIDTH_EXT, + CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT, + CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT, + CONVOLUTION_HEIGHT_EXT = EXT_convolution.CONVOLUTION_HEIGHT_EXT, + CONVOLUTION_WIDTH_EXT = EXT_convolution.CONVOLUTION_WIDTH_EXT, + MAX_CONVOLUTION_HEIGHT_EXT = EXT_convolution.MAX_CONVOLUTION_HEIGHT_EXT, + CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT, + CONVOLUTION_FORMAT_EXT = EXT_convolution.CONVOLUTION_FORMAT_EXT, + } + + public enum SGIX_tag_sample_buffer : uint + { + } + + public enum ClientAttribMask : uint + { + CLIENT_PIXEL_STORE_BIT = 0x00000001, + CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF, + CLIENT_VERTEX_ARRAY_BIT = 0x00000002, + } + + public enum INGR_interlace_read : uint + { + INTERLACE_READ_INGR = 0x8568, + } + + public enum ARB_texture_compression : uint + { + COMPRESSED_LUMINANCE_ARB = 0x84EA, + COMPRESSED_INTENSITY_ARB = 0x84EC, + TEXTURE_COMPRESSION_HINT_ARB = 0x84EF, + TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0, + COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3, + COMPRESSED_RGB_ARB = 0x84ED, + NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2, + COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB, + TEXTURE_COMPRESSED_ARB = 0x86A1, + COMPRESSED_ALPHA_ARB = 0x84E9, + COMPRESSED_RGBA_ARB = 0x84EE, + } + + public enum TextureCoordName : uint + { + Q = 0x2003, + R = 0x2002, + S = 0x2000, + T = 0x2001, + } + + public enum InterleavedArrayFormat : uint + { + T2F_C4UB_V3F = 0x2A29, + T2F_N3F_V3F = 0x2A2B, + T4F_V4F = 0x2A28, + T2F_V3F = 0x2A27, + V2F = 0x2A20, + T2F_C4F_N3F_V3F = 0x2A2C, + T4F_C4F_N3F_V4F = 0x2A2D, + T2F_C3F_V3F = 0x2A2A, + C3F_V3F = 0x2A24, + C4F_N3F_V3F = 0x2A26, + V3F = 0x2A21, + N3F_V3F = 0x2A25, + C4UB_V2F = 0x2A22, + C4UB_V3F = 0x2A23, + } + + public enum NV_texture_shader3 : uint + { + DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859, + DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D, + SIGNED_HILO8_NV = 0x885F, + FORCE_BLUE_TO_ONE_NV = 0x8860, + OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857, + OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853, + DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858, + HILO8_NV = 0x885E, + OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850, + DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A, + OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856, + OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851, + OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855, + OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852, + OFFSET_HILO_TEXTURE_2D_NV = 0x8854, + DOT_PRODUCT_PASS_THROUGH_NV = 0x885B, + DOT_PRODUCT_TEXTURE_1D_NV = 0x885C, + } + + public enum ARB_vertex_buffer_object : uint + { + NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897, + READ_ONLY_ARB = 0x88B8, + STATIC_DRAW_ARB = 0x88E4, + STATIC_COPY_ARB = 0x88E6, + BUFFER_MAP_POINTER_ARB = 0x88BD, + STREAM_COPY_ARB = 0x88E2, + STATIC_READ_ARB = 0x88E5, + READ_WRITE_ARB = 0x88BA, + TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A, + ARRAY_BUFFER_ARB = 0x8892, + BUFFER_SIZE_ARB = 0x8764, + BUFFER_ACCESS_ARB = 0x88BB, + DYNAMIC_DRAW_ARB = 0x88E8, + WRITE_ONLY_ARB = 0x88B9, + VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896, + FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D, + DYNAMIC_READ_ARB = 0x88E9, + DYNAMIC_COPY_ARB = 0x88EA, + STREAM_DRAW_ARB = 0x88E0, + WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E, + STREAM_READ_ARB = 0x88E1, + COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898, + BUFFER_MAPPED_ARB = 0x88BC, + INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899, + ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895, + EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B, + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F, + ARRAY_BUFFER_BINDING_ARB = 0x8894, + SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C, + BUFFER_USAGE_ARB = 0x8765, + ELEMENT_ARRAY_BUFFER_ARB = 0x8893, + } + + public enum SGIX_pixel_tiles : uint + { + PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F, + PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142, + PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143, + PIXEL_TILE_HEIGHT_SGIX = 0x8141, + PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145, + PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E, + PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144, + PIXEL_TILE_WIDTH_SGIX = 0x8140, + } + + public enum NV_fragment_program2 : uint + { + MAX_PROGRAM_IF_DEPTH_NV = 0x88F6, + MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7, + MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5, + MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4, + MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8, + } + + public enum EXT_vertex_weighting : uint + { + CURRENT_VERTEX_WEIGHT_EXT = 0x850B, + MODELVIEW0_MATRIX_EXT = GL_MODELVIEW_MATRIX, + VERTEX_WEIGHT_ARRAY_EXT = 0x850C, + MODELVIEW1_MATRIX_EXT = 0x8506, + VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E, + VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F, + MODELVIEW1_EXT = 0x850A, + VERTEX_WEIGHTING_EXT = 0x8509, + MODELVIEW0_EXT = GL_MODELVIEW, + MODELVIEW1_STACK_DEPTH_EXT = 0x8502, + VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510, + VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D, + MODELVIEW0_STACK_DEPTH_EXT = GL_MODELVIEW_STACK_DEPTH, + } + + public enum ATI_pn_triangles : uint + { + PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4, + PN_TRIANGLES_POINT_MODE_ATI = 0x87F2, + PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8, + PN_TRIANGLES_ATI = 0x87F0, + PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7, + PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6, + PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3, + MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1, + PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5, + } + + public enum SGIX_texture_scale_bias : uint + { + POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B, + POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179, + POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A, + POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C, + } + + public enum SGIX_fog_offset : uint + { + FOG_OFFSET_VALUE_SGIX = 0x8199, + FOG_OFFSET_SGIX = 0x8198, + } + + public enum EXT_texture : uint + { + LUMINANCE8_ALPHA8_EXT = 0x8045, + RGBA12_EXT = 0x805A, + INTENSITY12_EXT = 0x804C, + RGB16_EXT = 0x8054, + REPLACE_EXT = 0x8062, + RGB5_A1_EXT = 0x8057, + RGB5_EXT = 0x8050, + TEXTURE_INTENSITY_SIZE_EXT = 0x8061, + ALPHA12_EXT = 0x803D, + RGB4_EXT = 0x804F, + TEXTURE_LUMINANCE_SIZE_EXT = 0x8060, + RGBA16_EXT = 0x805B, + RGB8_EXT = 0x8051, + RGBA8_EXT = 0x8058, + RGB12_EXT = 0x8053, + LUMINANCE12_ALPHA12_EXT = 0x8047, + INTENSITY4_EXT = 0x804A, + INTENSITY8_EXT = 0x804B, + RGB10_A2_EXT = 0x8059, + RGB10_EXT = 0x8052, + LUMINANCE8_EXT = 0x8040, + TEXTURE_RED_SIZE_EXT = 0x805C, + LUMINANCE12_EXT = 0x8041, + PROXY_TEXTURE_2D_EXT = 0x8064, + LUMINANCE4_EXT = 0x803F, + INTENSITY16_EXT = 0x804D, + TEXTURE_GREEN_SIZE_EXT = 0x805D, + LUMINANCE16_ALPHA16_EXT = 0x8048, + TEXTURE_ALPHA_SIZE_EXT = 0x805F, + LUMINANCE16_EXT = 0x8042, + PROXY_TEXTURE_1D_EXT = 0x8063, + RGBA4_EXT = 0x8056, + INTENSITY_EXT = 0x8049, + RGBA2_EXT = 0x8055, + ALPHA16_EXT = 0x803E, + TEXTURE_TOO_LARGE_EXT = 0x8065, + ALPHA8_EXT = 0x803C, + ALPHA4_EXT = 0x803B, + LUMINANCE4_ALPHA4_EXT = 0x8043, + LUMINANCE6_ALPHA2_EXT = 0x8044, + TEXTURE_BLUE_SIZE_EXT = 0x805E, + RGB2_EXT = 0x804E, + LUMINANCE12_ALPHA4_EXT = 0x8046, + } + + public enum IBM_rasterpos_clip : uint + { + RASTER_POSITION_UNCLIPPED_IBM = 0x19262, + } + + public enum SGIS_texture_edge_clamp : uint + { + CLAMP_TO_EDGE_SGIS = 0x812F, + CLAMP_TO_EDGE = 0x812F, + } + + public enum DataType : uint + { + DOUBLE = 0x140A, + DOUBLE_EXT = 0x140A, + UNSIGNED_INT = 0x1405, + _4_BYTES = 0x1409, + FLOAT = 0x1406, + UNSIGNED_SHORT = 0x1403, + SHORT = 0x1402, + BYTE = 0x1400, + _3_BYTES = 0x1408, + INT = 0x1404, + UNSIGNED_BYTE = 0x1401, + _2_BYTES = 0x1407, + } + + public enum APPLE_fence : uint + { + DRAW_PIXELS_APPLE = 0x8A0A, + FENCE_APPLE = 0x8A0B, + } + + public enum MeshMode1 : uint + { + LINE = PolygonMode.LINE, + POINT = PolygonMode.POINT, + } + + public enum TextureTarget : uint + { + TEXTURE_1D = GetPName.TEXTURE_1D, + TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS, + TEXTURE_2D = GetPName.TEXTURE_2D, + TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS, + PROXY_TEXTURE_4D_SGIS = SGIS_texture4D.PROXY_TEXTURE_4D_SGIS, + PROXY_TEXTURE_2D = 0x8064, + TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS, + DETAIL_TEXTURE_2D_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_SGIS, + PROXY_TEXTURE_1D = 0x8063, + TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS, + TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS, + TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT, + PROXY_TEXTURE_3D_EXT = EXT_texture3D.PROXY_TEXTURE_3D_EXT, + } + + public enum MeshMode2 : uint + { + FILL = PolygonMode.FILL, + LINE = PolygonMode.LINE, + POINT = PolygonMode.POINT, + } + + public enum EXT_pixel_buffer_object : uint + { + PIXEL_UNPACK_BUFFER_EXT = 0x88EC, + PIXEL_PACK_BUFFER_EXT = 0x88EB, + PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF, + PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED, + } + + public enum ATI_texture_mirror_once : uint + { + MIRROR_CLAMP_ATI = 0x8742, + MIRROR_CLAMP_TO_EDGE_ATI = 0x8743, + } + + public enum SGI_color_table : uint + { + COLOR_TABLE_SGI = 0x80D0, + COLOR_TABLE_FORMAT_SGI = 0x80D8, + COLOR_TABLE_SCALE = 0x80D6, + COLOR_TABLE_SCALE_SGI = 0x80D6, + PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5, + COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF, + COLOR_TABLE_WIDTH_SGI = 0x80D9, + COLOR_TABLE_BIAS = 0x80D7, + COLOR_TABLE_BLUE_SIZE = 0x80DC, + POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2, + COLOR_TABLE_FORMAT = 0x80D8, + PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5, + PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4, + PROXY_COLOR_TABLE_SGI = 0x80D3, + COLOR_TABLE_GREEN_SIZE = 0x80DB, + PROXY_COLOR_TABLE = 0x80D3, + COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE, + COLOR_TABLE_ALPHA_SIZE = 0x80DD, + POST_CONVOLUTION_COLOR_TABLE = 0x80D1, + COLOR_TABLE_BIAS_SGI = 0x80D7, + COLOR_TABLE_WIDTH = 0x80D9, + POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2, + COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC, + COLOR_TABLE = 0x80D0, + PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4, + COLOR_TABLE_RED_SIZE_SGI = 0x80DA, + COLOR_TABLE_LUMINANCE_SIZE = 0x80DE, + POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1, + COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB, + COLOR_TABLE_RED_SIZE = 0x80DA, + COLOR_TABLE_INTENSITY_SIZE = 0x80DF, + COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD, + } + + public enum SGIS_detail_texture : uint + { + DETAIL_TEXTURE_MODE_SGIS = 0x809B, + DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096, + DETAIL_TEXTURE_LEVEL_SGIS = 0x809A, + DETAIL_TEXTURE_2D_SGIS = 0x8095, + LINEAR_DETAIL_SGIS = 0x8097, + DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C, + LINEAR_DETAIL_ALPHA_SGIS = 0x8098, + LINEAR_DETAIL_COLOR_SGIS = 0x8099, + } + + public enum HP_occlusion_test : uint + { + OCCLUSION_TEST_HP = 0x8165, + OCCLUSION_TEST_RESULT_HP = 0x8166, + } + + public enum ATI_texture_float : uint + { + ALPHA_FLOAT32_ATI = 0x8816, + INTENSITY_FLOAT32_ATI = 0x8817, + LUMINANCE_FLOAT32_ATI = 0x8818, + LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F, + ALPHA_FLOAT16_ATI = 0x881C, + LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819, + RGBA_FLOAT16_ATI = 0x881A, + RGBA_FLOAT32_ATI = 0x8814, + LUMINANCE_FLOAT16_ATI = 0x881E, + RGB_FLOAT32_ATI = 0x8815, + INTENSITY_FLOAT16_ATI = 0x881D, + RGB_FLOAT16_ATI = 0x881B, + } + + public enum SGIX_texture_multi_buffer : uint + { + TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E, + } + + public enum _3DFX_tbuffer : uint + { + } + + public enum EXT_vertex_shader : uint + { + OP_INDEX_EXT = 0x8782, + OP_MOV_EXT = 0x8799, + OP_MULTIPLY_MATRIX_EXT = 0x8798, + VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF, + VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4, + OUTPUT_FOG_EXT = 0x87BD, + Y_EXT = 0x87D6, + OP_ROUND_EXT = 0x8790, + OUTPUT_TEXTURE_COORD28_EXT = 0x87B9, + INVARIANT_EXT = 0x87C2, + MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6, + OP_POWER_EXT = 0x8793, + CURRENT_VERTEX_EXT = 0x87E2, + OUTPUT_TEXTURE_COORD1_EXT = 0x879E, + OUTPUT_TEXTURE_COORD29_EXT = 0x87BA, + LOCAL_EXT = 0x87C4, + OUTPUT_TEXTURE_COORD4_EXT = 0x87A1, + OUTPUT_TEXTURE_COORD20_EXT = 0x87B1, + VARIANT_ARRAY_POINTER_EXT = 0x87E9, + Z_EXT = 0x87D7, + VARIANT_ARRAY_STRIDE_EXT = 0x87E6, + VARIANT_VALUE_EXT = 0x87E4, + MVP_MATRIX_EXT = 0x87E3, + VERTEX_SHADER_BINDING_EXT = 0x8781, + OUTPUT_TEXTURE_COORD19_EXT = 0x87B0, + INVARIANT_VALUE_EXT = 0x87EA, + OUTPUT_TEXTURE_COORD21_EXT = 0x87B2, + MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8, + OUTPUT_TEXTURE_COORD3_EXT = 0x87A0, + OUTPUT_TEXTURE_COORD10_EXT = 0x87A7, + OP_MUL_EXT = 0x8786, + NEGATIVE_ONE_EXT = 0x87DF, + OP_CROSS_PRODUCT_EXT = 0x8797, + VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2, + OUTPUT_TEXTURE_COORD18_EXT = 0x87AF, + OP_NEGATE_EXT = 0x8783, + OUTPUT_TEXTURE_COORD6_EXT = 0x87A3, + VERTEX_SHADER_INVARIANTS_EXT = 0x87D1, + OUTPUT_TEXTURE_COORD11_EXT = 0x87A8, + W_EXT = 0x87D8, + OP_SET_LT_EXT = 0x878D, + ONE_EXT = 0x87DE, + VARIANT_ARRAY_EXT = 0x87E8, + OUTPUT_COLOR1_EXT = 0x879C, + OUTPUT_TEXTURE_COORD13_EXT = 0x87AA, + OUTPUT_TEXTURE_COORD24_EXT = 0x87B5, + X_EXT = 0x87D5, + ZERO_EXT = 0x87DD, + LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED, + SCALAR_EXT = 0x87BE, + OUTPUT_TEXTURE_COORD30_EXT = 0x87BB, + VARIANT_ARRAY_TYPE_EXT = 0x87E7, + VERTEX_SHADER_VARIANTS_EXT = 0x87D0, + OUTPUT_TEXTURE_COORD5_EXT = 0x87A2, + NEGATIVE_W_EXT = 0x87DC, + OUTPUT_TEXTURE_COORD25_EXT = 0x87B6, + MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD, + OP_FLOOR_EXT = 0x878F, + NEGATIVE_Y_EXT = 0x87DA, + MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7, + OUTPUT_TEXTURE_COORD8_EXT = 0x87A5, + OP_RECIP_EXT = 0x8794, + OUTPUT_TEXTURE_COORD31_EXT = 0x87BC, + OUTPUT_TEXTURE_COORD14_EXT = 0x87AB, + NEGATIVE_X_EXT = 0x87D9, + MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5, + VARIANT_DATATYPE_EXT = 0x87E5, + OUTPUT_VERTEX_EXT = 0x879A, + OP_ADD_EXT = 0x8787, + OUTPUT_TEXTURE_COORD0_EXT = 0x879D, + OUTPUT_TEXTURE_COORD15_EXT = 0x87AC, + OP_MADD_EXT = 0x8788, + OP_DOT3_EXT = 0x8784, + MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE, + OUTPUT_TEXTURE_COORD7_EXT = 0x87A4, + LOCAL_CONSTANT_EXT = 0x87C3, + VECTOR_EXT = 0x87BF, + VERTEX_SHADER_EXT = 0x8780, + NORMALIZED_RANGE_EXT = 0x87E0, + VARIANT_EXT = 0x87C1, + OUTPUT_TEXTURE_COORD26_EXT = 0x87B7, + OP_MAX_EXT = 0x878A, + OP_CLAMP_EXT = 0x878E, + INVARIANT_DATATYPE_EXT = 0x87EB, + MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9, + OUTPUT_TEXTURE_COORD22_EXT = 0x87B3, + OP_SET_GE_EXT = 0x878C, + OP_FRAC_EXT = 0x8789, + VERTEX_SHADER_LOCALS_EXT = 0x87D3, + MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA, + LOCAL_CONSTANT_VALUE_EXT = 0x87EC, + OUTPUT_TEXTURE_COORD27_EXT = 0x87B8, + NEGATIVE_Z_EXT = 0x87DB, + OP_RECIP_SQRT_EXT = 0x8795, + MATRIX_EXT = 0x87C0, + OP_EXP_BASE_2_EXT = 0x8791, + OUTPUT_TEXTURE_COORD16_EXT = 0x87AD, + OUTPUT_TEXTURE_COORD23_EXT = 0x87B4, + OUTPUT_COLOR0_EXT = 0x879B, + OP_MIN_EXT = 0x878B, + OP_DOT4_EXT = 0x8785, + OUTPUT_TEXTURE_COORD12_EXT = 0x87A9, + OP_SUB_EXT = 0x8796, + MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB, + MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC, + OUTPUT_TEXTURE_COORD2_EXT = 0x879F, + OUTPUT_TEXTURE_COORD17_EXT = 0x87AE, + OP_LOG_BASE_2_EXT = 0x8792, + OUTPUT_TEXTURE_COORD9_EXT = 0x87A6, + FULL_RANGE_EXT = 0x87E1, + } + + public enum ClipPlaneName : uint + { + CLIP_PLANE3 = 0x3003, + CLIP_PLANE2 = 0x3002, + CLIP_PLANE5 = 0x3005, + CLIP_PLANE1 = 0x3001, + CLIP_PLANE0 = 0x3000, + CLIP_PLANE4 = 0x3004, + } + + public enum NormalPointerType : uint + { + DOUBLE = DataType.DOUBLE, + BYTE = DataType.BYTE, + SHORT = DataType.SHORT, + INT = DataType.INT, + FLOAT = DataType.FLOAT, + } + + public enum ARB_texture_cube_map : uint + { + TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517, + TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516, + TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518, + TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515, + TEXTURE_CUBE_MAP_ARB = 0x8513, + TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A, + MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C, + REFLECTION_MAP_ARB = 0x8512, + TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514, + NORMAL_MAP_ARB = 0x8511, + PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B, + TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519, + } + + public enum SGIX_impact_pixel_texture : uint + { + PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188, + PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185, + PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184, + PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186, + PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A, + PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187, + PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189, + } + + public enum EXT_cmyka : uint + { + UNPACK_CMYK_HINT_EXT = 0x800F, + PACK_CMYK_HINT_EXT = 0x800E, + CMYKA_EXT = 0x800D, + CMYK_EXT = 0x800C, + } + + public enum StencilFunction : uint + { + NEVER = AlphaFunction.NEVER, + GEQUAL = AlphaFunction.GEQUAL, + GREATER = AlphaFunction.GREATER, + ALWAYS = AlphaFunction.ALWAYS, + LEQUAL = AlphaFunction.LEQUAL, + NOTEQUAL = AlphaFunction.NOTEQUAL, + EQUAL = AlphaFunction.EQUAL, + LESS = AlphaFunction.LESS, + } + + public enum VERSION_1_2 : uint + { + TEXTURE_BASE_LEVEL = 0x813C, + UNSIGNED_SHORT_5_6_5_REV = 0x8364, + PACK_IMAGE_HEIGHT = 0x806C, + MAX_ELEMENTS_INDICES = 0x80E9, + UNPACK_SKIP_IMAGES = 0x806D, + LIGHT_MODEL_COLOR_CONTROL = 0x81F8, + UNSIGNED_INT_8_8_8_8_REV = 0x8367, + SMOOTH_LINE_WIDTH_RANGE = 0x0B22, + TEXTURE_WRAP_R = 0x8072, + PACK_SKIP_IMAGES = 0x806B, + UNSIGNED_BYTE_2_3_3_REV = 0x8362, + UNSIGNED_SHORT_5_6_5 = 0x8363, + UNSIGNED_INT_8_8_8_8 = 0x8035, + PROXY_TEXTURE_3D = 0x8070, + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13, + UNSIGNED_SHORT_5_5_5_1 = 0x8034, + TEXTURE_MAX_LOD = 0x813B, + UNSIGNED_BYTE_3_3_2 = 0x8032, + TEXTURE_MAX_LEVEL = 0x813D, + BGRA = 0x80E1, + SEPARATE_SPECULAR_COLOR = 0x81FA, + ALIASED_POINT_SIZE_RANGE = 0x846D, + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23, + SINGLE_COLOR = 0x81F9, + RESCALE_NORMAL = 0x803A, + UNSIGNED_INT_10_10_10_2 = 0x8036, + ALIASED_LINE_WIDTH_RANGE = 0x846E, + UNPACK_IMAGE_HEIGHT = 0x806E, + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366, + TEXTURE_MIN_LOD = 0x813A, + MAX_3D_TEXTURE_SIZE = 0x8073, + TEXTURE_3D = 0x806F, + SMOOTH_POINT_SIZE_RANGE = 0x0B12, + MAX_ELEMENTS_VERTICES = 0x80E8, + TEXTURE_DEPTH = 0x8071, + UNSIGNED_INT_2_10_10_10_REV = 0x8368, + TEXTURE_BINDING_3D = 0x806A, + UNSIGNED_SHORT_4_4_4_4 = 0x8033, + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365, + BGR = 0x80E0, + CLAMP_TO_EDGE = 0x812F, + } + + public enum NV_vertex_program1_1 : uint + { + } + + public enum EXT_compiled_vertex_array : uint + { + ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9, + ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8, + } + + public enum SGIX_flush_raster : uint + { + } + + } + #endregion + + public static partial class GL + { + #region Function signatures + + public static class Delegates + { + public delegate void NewList(GLuint list, Enums.ListMode mode); + public delegate void EndList(); + public delegate void CallList(GLuint list); + public delegate void CallLists_(GLsizei n, Enums.ListNameType type, IntPtr lists); + public delegate void DeleteLists(GLuint list, GLsizei range); + public delegate GLuint GenLists(GLsizei range); + public delegate void ListBase(GLuint @base); + public delegate void Begin(Enums.BeginMode mode); + public delegate void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] bitmap); + public delegate void Color3b(GLbyte red, GLbyte green, GLbyte blue); + public delegate void Color3bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void Color3d(GLdouble red, GLdouble green, GLdouble blue); + public delegate void Color3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Color3f(GLfloat red, GLfloat green, GLfloat blue); + public delegate void Color3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Color3i(GLint red, GLint green, GLint blue); + public delegate void Color3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Color3s(GLshort red, GLshort green, GLshort blue); + public delegate void Color3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void Color3ub(GLubyte red, GLubyte green, GLubyte blue); + public delegate void Color3ubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void Color3ui(GLuint red, GLuint green, GLuint blue); + public delegate void Color3uiv([MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void Color3us(GLushort red, GLushort green, GLushort blue); + public delegate void Color3usv([MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); + public delegate void Color4bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); + public delegate void Color4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + public delegate void Color4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Color4i(GLint red, GLint green, GLint blue, GLint alpha); + public delegate void Color4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha); + public delegate void Color4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); + public delegate void Color4ubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha); + public delegate void Color4uiv([MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha); + public delegate void Color4usv([MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void EdgeFlag(Enums.Boolean flag); + public delegate void EdgeFlagv(Enums.Boolean[] flag); + public delegate void End(); + public delegate void Indexd(GLdouble c); + public delegate void Indexdv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] c); + public delegate void Indexf(GLfloat c); + public delegate void Indexfv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] c); + public delegate void Indexi(GLint c); + public delegate void Indexiv([MarshalAs(UnmanagedType.LPArray)] GLint[] c); + public delegate void Indexs(GLshort c); + public delegate void Indexsv([MarshalAs(UnmanagedType.LPArray)] GLshort[] c); + public delegate void Normal3b(GLbyte nx, GLbyte ny, GLbyte nz); + public delegate void Normal3bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void Normal3d(GLdouble nx, GLdouble ny, GLdouble nz); + public delegate void Normal3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz); + public delegate void Normal3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Normal3i(GLint nx, GLint ny, GLint nz); + public delegate void Normal3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Normal3s(GLshort nx, GLshort ny, GLshort nz); + public delegate void Normal3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void RasterPos2d(GLdouble x, GLdouble y); + public delegate void RasterPos2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void RasterPos2f(GLfloat x, GLfloat y); + public delegate void RasterPos2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void RasterPos2i(GLint x, GLint y); + public delegate void RasterPos2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void RasterPos2s(GLshort x, GLshort y); + public delegate void RasterPos2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void RasterPos3d(GLdouble x, GLdouble y, GLdouble z); + public delegate void RasterPos3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void RasterPos3f(GLfloat x, GLfloat y, GLfloat z); + public delegate void RasterPos3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void RasterPos3i(GLint x, GLint y, GLint z); + public delegate void RasterPos3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void RasterPos3s(GLshort x, GLshort y, GLshort z); + public delegate void RasterPos3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void RasterPos4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void RasterPos4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void RasterPos4i(GLint x, GLint y, GLint z, GLint w); + public delegate void RasterPos4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w); + public delegate void RasterPos4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); + public delegate void Rectdv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v1, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v2); + public delegate void Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); + public delegate void Rectfv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v1, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v2); + public delegate void Recti(GLint x1, GLint y1, GLint x2, GLint y2); + public delegate void Rectiv([MarshalAs(UnmanagedType.LPArray)] GLint[] v1, [MarshalAs(UnmanagedType.LPArray)] GLint[] v2); + public delegate void Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2); + public delegate void Rectsv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v1, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v2); + public delegate void TexCoord1d(GLdouble s); + public delegate void TexCoord1dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void TexCoord1f(GLfloat s); + public delegate void TexCoord1fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord1i(GLint s); + public delegate void TexCoord1iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void TexCoord1s(GLshort s); + public delegate void TexCoord1sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void TexCoord2d(GLdouble s, GLdouble t); + public delegate void TexCoord2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void TexCoord2f(GLfloat s, GLfloat t); + public delegate void TexCoord2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord2i(GLint s, GLint t); + public delegate void TexCoord2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void TexCoord2s(GLshort s, GLshort t); + public delegate void TexCoord2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void TexCoord3d(GLdouble s, GLdouble t, GLdouble r); + public delegate void TexCoord3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void TexCoord3f(GLfloat s, GLfloat t, GLfloat r); + public delegate void TexCoord3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord3i(GLint s, GLint t, GLint r); + public delegate void TexCoord3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void TexCoord3s(GLshort s, GLshort t, GLshort r); + public delegate void TexCoord3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q); + public delegate void TexCoord4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q); + public delegate void TexCoord4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord4i(GLint s, GLint t, GLint r, GLint q); + public delegate void TexCoord4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q); + public delegate void TexCoord4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void Vertex2d(GLdouble x, GLdouble y); + public delegate void Vertex2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Vertex2f(GLfloat x, GLfloat y); + public delegate void Vertex2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Vertex2i(GLint x, GLint y); + public delegate void Vertex2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Vertex2s(GLshort x, GLshort y); + public delegate void Vertex2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void Vertex3d(GLdouble x, GLdouble y, GLdouble z); + public delegate void Vertex3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Vertex3f(GLfloat x, GLfloat y, GLfloat z); + public delegate void Vertex3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Vertex3i(GLint x, GLint y, GLint z); + public delegate void Vertex3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Vertex3s(GLshort x, GLshort y, GLshort z); + public delegate void Vertex3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void Vertex4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void Vertex4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Vertex4i(GLint x, GLint y, GLint z, GLint w); + public delegate void Vertex4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w); + public delegate void Vertex4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void ClipPlane(Enums.ClipPlaneName plane, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] equation); + public delegate void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode); + public delegate void CullFace(Enums.CullFaceMode mode); + public delegate void Fogf(Enums.FogParameter pname, GLfloat param); + public delegate void Fogfv(Enums.FogParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void Fogi(Enums.FogParameter pname, GLint param); + public delegate void Fogiv(Enums.FogParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void FrontFace(Enums.FrontFaceDirection mode); + public delegate void Hint(Enums.HintTarget target, Enums.HintMode mode); + public delegate void Lightf(Enums.LightName light, Enums.LightParameter pname, GLfloat param); + public delegate void Lightfv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void Lighti(Enums.LightName light, Enums.LightParameter pname, GLint param); + public delegate void Lightiv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void LightModelf(Enums.LightModelParameter pname, GLfloat param); + public delegate void LightModelfv(Enums.LightModelParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void LightModeli(Enums.LightModelParameter pname, GLint param); + public delegate void LightModeliv(Enums.LightModelParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void LineStipple(GLint factor, GLushort pattern); + public delegate void LineWidth(GLfloat width); + public delegate void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param); + public delegate void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param); + public delegate void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void PointSize(GLfloat size); + public delegate void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode); + public delegate void PolygonStipple([MarshalAs(UnmanagedType.LPArray)] GLubyte[] mask); + public delegate void Scissor(GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void ShadeModel(Enums.ShadingModel mode); + public delegate void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, GLfloat param); + public delegate void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, GLint param); + public delegate void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void TexImage1D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void TexImage2D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLfloat param); + public delegate void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLint param); + public delegate void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLdouble param); + public delegate void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLfloat param); + public delegate void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLint param); + public delegate void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void FeedbackBuffer(GLsizei size, Enums.FeedbackType type, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] buffer); + public delegate void SelectBuffer(GLsizei size, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffer); + public delegate GLint RenderMode(Enums.RenderingMode mode); + public delegate void InitNames(); + public delegate void LoadName(GLuint name); + public delegate void PassThrough(GLfloat token); + public delegate void PopName(); + public delegate void PushName(GLuint name); + public delegate void DrawBuffer(Enums.DrawBufferMode mode); + public delegate void Clear(Enums.ClearBufferMask mask); + public delegate void ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + public delegate void ClearIndex(GLfloat c); + public delegate void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + public delegate void ClearStencil(GLint s); + public delegate void ClearDepth(GLclampd depth); + public delegate void StencilMask(GLuint mask); + public delegate void ColorMask(Enums.Boolean red, Enums.Boolean green, Enums.Boolean blue, Enums.Boolean alpha); + public delegate void DepthMask(Enums.Boolean flag); + public delegate void IndexMask(GLuint mask); + public delegate void Accum(Enums.AccumOp op, GLfloat value); + public delegate void Disable(Enums.EnableCap cap); + public delegate void Enable(Enums.EnableCap cap); + public delegate void Finish(); + public delegate void Flush(); + public delegate void PopAttrib(); + public delegate void PushAttrib(Enums.AttribMask mask); + public delegate void Map1d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] points); + public delegate void Map1f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void Map2d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] points); + public delegate void Map2f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void MapGrid1d(GLint un, GLdouble u1, GLdouble u2); + public delegate void MapGrid1f(GLint un, GLfloat u1, GLfloat u2); + public delegate void MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); + public delegate void MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); + public delegate void EvalCoord1d(GLdouble u); + public delegate void EvalCoord1dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] u); + public delegate void EvalCoord1f(GLfloat u); + public delegate void EvalCoord1fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] u); + public delegate void EvalCoord2d(GLdouble u, GLdouble v); + public delegate void EvalCoord2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] u); + public delegate void EvalCoord2f(GLfloat u, GLfloat v); + public delegate void EvalCoord2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] u); + public delegate void EvalMesh1(Enums.MeshMode1 mode, GLint i1, GLint i2); + public delegate void EvalPoint1(GLint i); + public delegate void EvalMesh2(Enums.MeshMode2 mode, GLint i1, GLint i2, GLint j1, GLint j2); + public delegate void EvalPoint2(GLint i, GLint j); + public delegate void AlphaFunc(Enums.AlphaFunction func, GLclampf reference); + public delegate void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor); + public delegate void LogicOp(Enums.LogicOp opcode); + public delegate void StencilFunc(Enums.StencilFunction func, GLint reference, GLuint mask); + public delegate void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass); + public delegate void DepthFunc(Enums.DepthFunction func); + public delegate void PixelZoom(GLfloat xfactor, GLfloat yfactor); + public delegate void PixelTransferf(Enums.PixelTransferParameter pname, GLfloat param); + public delegate void PixelTransferi(Enums.PixelTransferParameter pname, GLint param); + public delegate void PixelStoref(Enums.PixelStoreParameter pname, GLfloat param); + public delegate void PixelStorei(Enums.PixelStoreParameter pname, GLint param); + public delegate void PixelMapfv(Enums.PixelMap map, GLint mapsize, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] values); + public delegate void PixelMapuiv(Enums.PixelMap map, GLint mapsize, [MarshalAs(UnmanagedType.LPArray)] GLuint[] values); + public delegate void PixelMapusv(Enums.PixelMap map, GLint mapsize, [MarshalAs(UnmanagedType.LPArray)] GLushort[] values); + public delegate void ReadBuffer(Enums.ReadBufferMode mode); + public delegate void CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelCopyType type); + public delegate void ReadPixels_(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, out IntPtr pixels); + public delegate void DrawPixels_(GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void GetBooleanv(Enums.GetPName pname, Enums.Boolean[] parameters); + public delegate void GetClipPlane(Enums.ClipPlaneName plane, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] equation); + public delegate void GetDoublev(Enums.GetPName pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate GLenum GetError(); + public delegate void GetFloatv(Enums.GetPName pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetIntegerv(Enums.GetPName pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetLightfv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetLightiv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetPixelMapfv(Enums.PixelMap map, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] values); + public delegate void GetPixelMapuiv(Enums.PixelMap map, [MarshalAs(UnmanagedType.LPArray)] GLuint[] values); + public delegate void GetPixelMapusv(Enums.PixelMap map, [MarshalAs(UnmanagedType.LPArray)] GLushort[] values); + public delegate void GetPolygonStipple([MarshalAs(UnmanagedType.LPArray)] GLubyte[] mask); + public delegate GLstring GetString(Enums.StringName name); + public delegate void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetTexImage(Enums.TextureTarget target, GLint level, Enums.PixelFormat format, Enums.PixelType type, out IntPtr pixels); + public delegate void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetTexLevelParameterfv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetTexLevelParameteriv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate GLboolean IsEnabled(Enums.EnableCap cap); + public delegate GLboolean IsList(GLuint list); + public delegate void DepthRange(GLclampd near, GLclampd far); + public delegate void Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + public delegate void LoadIdentity(); + public delegate void LoadMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + public delegate void LoadMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + public delegate void MatrixMode(Enums.MatrixMode mode); + public delegate void MultMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + public delegate void MultMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + public delegate void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + public delegate void PopMatrix(); + public delegate void PushMatrix(); + public delegate void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); + public delegate void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); + public delegate void Scaled(GLdouble x, GLdouble y, GLdouble z); + public delegate void Scalef(GLfloat x, GLfloat y, GLfloat z); + public delegate void Translated(GLdouble x, GLdouble y, GLdouble z); + public delegate void Translatef(GLfloat x, GLfloat y, GLfloat z); + public delegate void Viewport(GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void ArrayElement(GLint i); + public delegate void ColorPointer_(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer); + public delegate void DisableClientState(Enums.EnableCap array); + public delegate void DrawArrays(Enums.BeginMode mode, GLint first, GLsizei count); + public delegate void DrawElements_(Enums.BeginMode mode, GLsizei count, GLenum type, IntPtr indices); + public delegate void EdgeFlagPointer_(GLsizei stride, IntPtr pointer); + public delegate void EnableClientState(Enums.EnableCap array); + public delegate void GetPointerv(Enums.GetPointervPName pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] parameters); + public delegate void IndexPointer_(Enums.IndexPointerType type, GLsizei stride, IntPtr pointer); + public delegate void InterleavedArrays_(Enums.InterleavedArrayFormat format, GLsizei stride, IntPtr pointer); + public delegate void NormalPointer_(Enums.NormalPointerType type, GLsizei stride, IntPtr pointer); + public delegate void TexCoordPointer_(GLint size, Enums.TexCoordPointerType type, GLsizei stride, IntPtr pointer); + public delegate void VertexPointer_(GLint size, Enums.VertexPointerType type, GLsizei stride, IntPtr pointer); + public delegate void PolygonOffset(GLfloat factor, GLfloat units); + public delegate void CopyTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border); + public delegate void CopyTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + public delegate void CopyTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + public delegate void CopyTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void TexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void TexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate GLboolean AreTexturesResident(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures, Enums.Boolean[] residences); + public delegate void BindTexture(Enums.TextureTarget target, GLuint texture); + public delegate void DeleteTextures(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures); + public delegate void GenTextures(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures); + public delegate GLboolean IsTexture(GLuint texture); + public delegate void PrioritizeTextures(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures, [MarshalAs(UnmanagedType.LPArray)] GLclampf[] priorities); + public delegate void Indexub(GLubyte c); + public delegate void Indexubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] c); + public delegate void PopClientAttrib(); + public delegate void PushClientAttrib(Enums.ClientAttribMask mask); + public delegate void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + public delegate void BlendEquation(GLenum mode); + public delegate void DrawRangeElements_(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices); + public delegate void ColorTable_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table); + public delegate void ColorTableParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void ColorTableParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void CopyColorTable(GLenum target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width); + public delegate void GetColorTable_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr table); + public delegate void GetColorTableParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetColorTableParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void ColorSubTable_(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data); + public delegate void CopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + public delegate void ConvolutionFilter1D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image); + public delegate void ConvolutionFilter2D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image); + public delegate void ConvolutionParameterf(GLenum target, GLenum pname, GLfloat parameters); + public delegate void ConvolutionParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void ConvolutionParameteri(GLenum target, GLenum pname, GLint parameters); + public delegate void ConvolutionParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void CopyConvolutionFilter1D(GLenum target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width); + public delegate void CopyConvolutionFilter2D(GLenum target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void GetConvolutionFilter_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr image); + public delegate void GetConvolutionParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetConvolutionParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetSeparableFilter_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr row, out IntPtr column, out IntPtr span); + public delegate void SeparableFilter2D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column); + public delegate void GetHistogram_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, out IntPtr values); + public delegate void GetHistogramParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetHistogramParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetMinmax_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, out IntPtr values); + public delegate void GetMinmaxParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetMinmaxParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void Histogram(GLenum target, GLsizei width, Enums.PixelInternalFormat internalformat, Enums.Boolean sink); + public delegate void Minmax(GLenum target, Enums.PixelInternalFormat internalformat, Enums.Boolean sink); + public delegate void ResetHistogram(GLenum target); + public delegate void ResetMinmax(GLenum target); + public delegate void TexImage3D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void TexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void CopyTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void ActiveTexture(GLenum texture); + public delegate void ClientActiveTexture(GLenum texture); + public delegate void MultiTexCoord1d(GLenum target, GLdouble s); + public delegate void MultiTexCoord1dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord1f(GLenum target, GLfloat s); + public delegate void MultiTexCoord1fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord1i(GLenum target, GLint s); + public delegate void MultiTexCoord1iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord1s(GLenum target, GLshort s); + public delegate void MultiTexCoord1sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void MultiTexCoord2d(GLenum target, GLdouble s, GLdouble t); + public delegate void MultiTexCoord2dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord2f(GLenum target, GLfloat s, GLfloat t); + public delegate void MultiTexCoord2fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord2i(GLenum target, GLint s, GLint t); + public delegate void MultiTexCoord2iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord2s(GLenum target, GLshort s, GLshort t); + public delegate void MultiTexCoord2sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void MultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r); + public delegate void MultiTexCoord3dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r); + public delegate void MultiTexCoord3fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r); + public delegate void MultiTexCoord3iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r); + public delegate void MultiTexCoord3sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void MultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); + public delegate void MultiTexCoord4dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); + public delegate void MultiTexCoord4fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q); + public delegate void MultiTexCoord4iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); + public delegate void MultiTexCoord4sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void LoadTransposeMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + public delegate void LoadTransposeMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + public delegate void MultTransposeMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + public delegate void MultTransposeMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + public delegate void SampleCoverage(GLclampf value, Enums.Boolean invert); + public delegate void CompressedTexImage3D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + public delegate void GetCompressedTexImage(Enums.TextureTarget target, GLint level, out IntPtr img); + public delegate void BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + public delegate void FogCoordf(GLfloat coord); + public delegate void FogCoordfv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] coord); + public delegate void FogCoordd(GLdouble coord); + public delegate void FogCoorddv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] coord); + public delegate void FogCoordPointer_(GLenum type, GLsizei stride, IntPtr pointer); + public delegate void MultiDrawArrays(Enums.BeginMode mode, [MarshalAs(UnmanagedType.LPArray)] GLint[] first, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLsizei primcount); + public delegate void MultiDrawElements(Enums.BeginMode mode, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLenum type, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] indices, GLsizei primcount); + public delegate void PointParameterf(GLenum pname, GLfloat param); + public delegate void PointParameterfv(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void PointParameteri(GLenum pname, GLint param); + public delegate void PointParameteriv(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue); + public delegate void SecondaryColor3bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue); + public delegate void SecondaryColor3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue); + public delegate void SecondaryColor3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void SecondaryColor3i(GLint red, GLint green, GLint blue); + public delegate void SecondaryColor3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void SecondaryColor3s(GLshort red, GLshort green, GLshort blue); + public delegate void SecondaryColor3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue); + public delegate void SecondaryColor3ubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue); + public delegate void SecondaryColor3uiv([MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void SecondaryColor3us(GLushort red, GLushort green, GLushort blue); + public delegate void SecondaryColor3usv([MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void SecondaryColorPointer_(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer); + public delegate void WindowPos2d(GLdouble x, GLdouble y); + public delegate void WindowPos2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void WindowPos2f(GLfloat x, GLfloat y); + public delegate void WindowPos2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void WindowPos2i(GLint x, GLint y); + public delegate void WindowPos2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void WindowPos2s(GLshort x, GLshort y); + public delegate void WindowPos2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void WindowPos3d(GLdouble x, GLdouble y, GLdouble z); + public delegate void WindowPos3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void WindowPos3f(GLfloat x, GLfloat y, GLfloat z); + public delegate void WindowPos3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void WindowPos3i(GLint x, GLint y, GLint z); + public delegate void WindowPos3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void WindowPos3s(GLshort x, GLshort y, GLshort z); + public delegate void WindowPos3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void GenQueries(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + public delegate void DeleteQueries(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + public delegate GLboolean IsQuery(GLuint id); + public delegate void BeginQuery(GLenum target, GLuint id); + public delegate void EndQuery(GLenum target); + public delegate void GetQueryiv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetQueryObjectiv(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetQueryObjectuiv(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLuint[] parameters); + public delegate void BindBuffer(GLenum target, GLuint buffer); + public delegate void DeleteBuffers(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffers); + public delegate void GenBuffers(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffers); + public delegate GLboolean IsBuffer(GLuint buffer); + public delegate void BufferData_(GLenum target, GLsizeiptr size, IntPtr data, GLenum usage); + public delegate void BufferSubData_(GLenum target, GLintptr offset, GLsizeiptr size, IntPtr data); + public delegate void GetBufferSubData_(GLenum target, GLintptr offset, GLsizeiptr size, out IntPtr data); + public delegate IntPtr MapBuffer_(GLenum target, GLenum access); + public delegate GLboolean UnmapBuffer(GLenum target); + public delegate void GetBufferParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetBufferPointerv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] parameters); + public delegate void BlendEquationSeparate(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha); + public delegate void DrawBuffers(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLenum[] bufs); + public delegate void StencilOpSeparate(GLenum face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass); + public delegate void StencilFuncSeparate(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint reference, GLuint mask); + public delegate void StencilMaskSeparate(GLenum face, GLuint mask); + public delegate void AttachShader(GLuint program, GLuint shader); + public delegate void BindAttribLocation(GLuint program, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + public delegate void CompileShader(GLuint shader); + public delegate GLuint CreateProgram(); + public delegate GLuint CreateShader(GLenum type); + public delegate void DeleteProgram(GLuint program); + public delegate void DeleteShader(GLuint shader); + public delegate void DetachShader(GLuint program, GLuint shader); + public delegate void DisableVertexAttribArray(GLuint index); + public delegate void EnableVertexAttribArray(GLuint index); + public delegate void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLint[] size, [MarshalAs(UnmanagedType.LPArray)] GLenum[] type, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + public delegate void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLint[] size, [MarshalAs(UnmanagedType.LPArray)] GLenum[] type, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + public delegate void GetAttachedShaders(GLuint program, GLsizei maxCount, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, [MarshalAs(UnmanagedType.LPArray)] GLuint[] obj); + public delegate GLint GetAttribLocation(GLuint program, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + public delegate void GetProgramiv(GLuint program, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetProgramInfoLog(GLuint program, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLchar[] infoLog); + public delegate void GetShaderiv(GLuint shader, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetShaderInfoLog(GLuint shader, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLchar[] infoLog); + public delegate void GetShaderSource(GLuint shader, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLchar[] source); + public delegate GLint GetUniformLocation(GLuint program, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + public delegate void GetUniformfv(GLuint program, GLint location, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetUniformiv(GLuint program, GLint location, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetVertexAttribdv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void GetVertexAttribfv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetVertexAttribiv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetVertexAttribPointerv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate GLboolean IsProgram(GLuint program); + public delegate GLboolean IsShader(GLuint shader); + public delegate void LinkProgram(GLuint program); + public delegate void ShaderSource(GLuint shader, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] string[] @string, [MarshalAs(UnmanagedType.LPArray)] GLint[] length); + public delegate void UseProgram(GLuint program); + public delegate void Uniform1f(GLint location, GLfloat v0); + public delegate void Uniform2f(GLint location, GLfloat v0, GLfloat v1); + public delegate void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); + public delegate void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + public delegate void Uniform1i(GLint location, GLint v0); + public delegate void Uniform2i(GLint location, GLint v0, GLint v1); + public delegate void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2); + public delegate void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); + public delegate void Uniform1fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform1iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void Uniform2iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void Uniform3iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void Uniform4iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void ValidateProgram(GLuint program); + public delegate void VertexAttrib1d(GLuint index, GLdouble x); + public delegate void VertexAttrib1dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib1f(GLuint index, GLfloat x); + public delegate void VertexAttrib1fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib1s(GLuint index, GLshort x); + public delegate void VertexAttrib1sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y); + public delegate void VertexAttrib2dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y); + public delegate void VertexAttrib2fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib2s(GLuint index, GLshort x, GLshort y); + public delegate void VertexAttrib2sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z); + public delegate void VertexAttrib3dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z); + public delegate void VertexAttrib3fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z); + public delegate void VertexAttrib3sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4Nbv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void VertexAttrib4Niv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void VertexAttrib4Nsv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); + public delegate void VertexAttrib4Nubv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void VertexAttrib4Nuiv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void VertexAttrib4Nusv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void VertexAttrib4bv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void VertexAttrib4dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void VertexAttrib4fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib4iv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); + public delegate void VertexAttrib4sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4ubv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void VertexAttrib4uiv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void VertexAttrib4usv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void VertexAttribPointer_(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer); + public delegate void ActiveTextureARB(GLenum texture); + public delegate void ClientActiveTextureARB(GLenum texture); + public delegate void MultiTexCoord1dARB(GLenum target, GLdouble s); + public delegate void MultiTexCoord1dvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord1fARB(GLenum target, GLfloat s); + public delegate void MultiTexCoord1fvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord1iARB(GLenum target, GLint s); + public delegate void MultiTexCoord1ivARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord1sARB(GLenum target, GLshort s); + public delegate void MultiTexCoord1svARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void MultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t); + public delegate void MultiTexCoord2dvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t); + public delegate void MultiTexCoord2fvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord2iARB(GLenum target, GLint s, GLint t); + public delegate void MultiTexCoord2ivARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord2sARB(GLenum target, GLshort s, GLshort t); + public delegate void MultiTexCoord2svARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void MultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r); + public delegate void MultiTexCoord3dvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r); + public delegate void MultiTexCoord3fvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r); + public delegate void MultiTexCoord3ivARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r); + public delegate void MultiTexCoord3svARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void MultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); + public delegate void MultiTexCoord4dvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); + public delegate void MultiTexCoord4fvARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void MultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q); + public delegate void MultiTexCoord4ivARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void MultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); + public delegate void MultiTexCoord4svARB(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void LoadTransposeMatrixfARB([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + public delegate void LoadTransposeMatrixdARB([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + public delegate void MultTransposeMatrixfARB([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + public delegate void MultTransposeMatrixdARB([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + public delegate void SampleCoverageARB(GLclampf value, Enums.Boolean invert); + public delegate void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + public delegate void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + public delegate void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, out IntPtr img); + public delegate void PointParameterfARB(GLenum pname, GLfloat param); + public delegate void PointParameterfvARB(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void WeightbvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] weights); + public delegate void WeightsvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLshort[] weights); + public delegate void WeightivARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLint[] weights); + public delegate void WeightfvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] weights); + public delegate void WeightdvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] weights); + public delegate void WeightubvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] weights); + public delegate void WeightusvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLushort[] weights); + public delegate void WeightuivARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLuint[] weights); + public delegate void WeightPointerARB_(GLint size, GLenum type, GLsizei stride, IntPtr pointer); + public delegate void VertexBlendARB(GLint count); + public delegate void CurrentPaletteMatrixARB(GLint index); + public delegate void MatrixIndexubvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] indices); + public delegate void MatrixIndexusvARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLushort[] indices); + public delegate void MatrixIndexuivARB(GLint size, [MarshalAs(UnmanagedType.LPArray)] GLuint[] indices); + public delegate void MatrixIndexPointerARB_(GLint size, GLenum type, GLsizei stride, IntPtr pointer); + public delegate void WindowPos2dARB(GLdouble x, GLdouble y); + public delegate void WindowPos2dvARB([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void WindowPos2fARB(GLfloat x, GLfloat y); + public delegate void WindowPos2fvARB([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void WindowPos2iARB(GLint x, GLint y); + public delegate void WindowPos2ivARB([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void WindowPos2sARB(GLshort x, GLshort y); + public delegate void WindowPos2svARB([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void WindowPos3dARB(GLdouble x, GLdouble y, GLdouble z); + public delegate void WindowPos3dvARB([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void WindowPos3fARB(GLfloat x, GLfloat y, GLfloat z); + public delegate void WindowPos3fvARB([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void WindowPos3iARB(GLint x, GLint y, GLint z); + public delegate void WindowPos3ivARB([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void WindowPos3sARB(GLshort x, GLshort y, GLshort z); + public delegate void WindowPos3svARB([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib1dARB(GLuint index, GLdouble x); + public delegate void VertexAttrib1dvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib1fARB(GLuint index, GLfloat x); + public delegate void VertexAttrib1fvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib1sARB(GLuint index, GLshort x); + public delegate void VertexAttrib1svARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y); + public delegate void VertexAttrib2dvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y); + public delegate void VertexAttrib2fvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib2sARB(GLuint index, GLshort x, GLshort y); + public delegate void VertexAttrib2svARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z); + public delegate void VertexAttrib3dvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z); + public delegate void VertexAttrib3fvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z); + public delegate void VertexAttrib3svARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4NbvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void VertexAttrib4NivARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void VertexAttrib4NsvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); + public delegate void VertexAttrib4NubvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void VertexAttrib4NuivARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void VertexAttrib4NusvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void VertexAttrib4bvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void VertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void VertexAttrib4dvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void VertexAttrib4fvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib4ivARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void VertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); + public delegate void VertexAttrib4svARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4ubvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void VertexAttrib4uivARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void VertexAttrib4usvARB(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void VertexAttribPointerARB_(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer); + public delegate void EnableVertexAttribArrayARB(GLuint index); + public delegate void DisableVertexAttribArrayARB(GLuint index); + public delegate void ProgramStringARB_(GLenum target, GLenum format, GLsizei len, IntPtr @string); + public delegate void BindProgramARB(GLenum target, GLuint program); + public delegate void DeleteProgramsARB(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] programs); + public delegate void GenProgramsARB(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] programs); + public delegate void ProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void ProgramEnvParameter4dvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void ProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void ProgramEnvParameter4fvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void ProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void ProgramLocalParameter4dvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void ProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void ProgramLocalParameter4fvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetProgramEnvParameterdvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void GetProgramEnvParameterfvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetProgramLocalParameterdvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void GetProgramLocalParameterfvARB(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetProgramivARB(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetProgramStringARB_(GLenum target, GLenum pname, out IntPtr @string); + public delegate void GetVertexAttribdvARB(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void GetVertexAttribfvARB(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetVertexAttribivARB(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetVertexAttribPointervARB(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate GLboolean IsProgramARB(GLuint program); + public delegate void BindBufferARB(GLenum target, GLuint buffer); + public delegate void DeleteBuffersARB(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffers); + public delegate void GenBuffersARB(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffers); + public delegate GLboolean IsBufferARB(GLuint buffer); + public delegate void BufferDataARB_(GLenum target, GLsizeiptrARB size, IntPtr data, GLenum usage); + public delegate void BufferSubDataARB_(GLenum target, GLintptrARB offset, GLsizeiptrARB size, IntPtr data); + public delegate void GetBufferSubDataARB_(GLenum target, GLintptrARB offset, GLsizeiptrARB size, out IntPtr data); + public delegate IntPtr MapBufferARB_(GLenum target, GLenum access); + public delegate GLboolean UnmapBufferARB(GLenum target); + public delegate void GetBufferParameterivARB(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetBufferPointervARB(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] parameters); + public delegate void GenQueriesARB(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + public delegate void DeleteQueriesARB(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + public delegate GLboolean IsQueryARB(GLuint id); + public delegate void BeginQueryARB(GLenum target, GLuint id); + public delegate void EndQueryARB(GLenum target); + public delegate void GetQueryivARB(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetQueryObjectivARB(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetQueryObjectuivARB(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLuint[] parameters); + public delegate void DeleteObjectARB(GLhandleARB obj); + public delegate GLhandleARB GetHandleARB(GLenum pname); + public delegate void DetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj); + public delegate GLhandleARB CreateShaderObjectARB(GLenum shaderType); + public delegate void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] @string, [MarshalAs(UnmanagedType.LPArray)] GLint[] length); + public delegate void CompileShaderARB(GLhandleARB shaderObj); + public delegate GLhandleARB CreateProgramObjectARB(); + public delegate void AttachObjectARB(GLhandleARB containerObj, GLhandleARB obj); + public delegate void LinkProgramARB(GLhandleARB programObj); + public delegate void UseProgramObjectARB(GLhandleARB programObj); + public delegate void ValidateProgramARB(GLhandleARB programObj); + public delegate void Uniform1fARB(GLint location, GLfloat v0); + public delegate void Uniform2fARB(GLint location, GLfloat v0, GLfloat v1); + public delegate void Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); + public delegate void Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + public delegate void Uniform1iARB(GLint location, GLint v0); + public delegate void Uniform2iARB(GLint location, GLint v0, GLint v1); + public delegate void Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2); + public delegate void Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); + public delegate void Uniform1fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform2fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform3fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform4fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void Uniform1ivARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void Uniform2ivARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void Uniform3ivARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void Uniform4ivARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + public delegate void UniformMatrix2fvARB(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void UniformMatrix3fvARB(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void UniformMatrix4fvARB(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void GetObjectParameterfvARB(GLhandleARB obj, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetObjectParameterivARB(GLhandleARB obj, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] infoLog); + public delegate void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, [MarshalAs(UnmanagedType.LPArray)] GLhandleARB[] obj); + public delegate GLint GetUniformLocationARB(GLhandleARB programObj, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] name); + public delegate void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLint[] size, [MarshalAs(UnmanagedType.LPArray)] GLenum[] type, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] name); + public delegate void GetUniformfvARB(GLhandleARB programObj, GLint location, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetUniformivARB(GLhandleARB programObj, GLint location, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] source); + public delegate void BindAttribLocationARB(GLhandleARB programObj, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] name); + public delegate void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLint[] size, [MarshalAs(UnmanagedType.LPArray)] GLenum[] type, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] name); + public delegate GLint GetAttribLocationARB(GLhandleARB programObj, [MarshalAs(UnmanagedType.LPArray)] GLcharARB[] name); + public delegate void DrawBuffersARB(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLenum[] bufs); + public delegate void ClampColorARB(GLenum target, GLenum clamp); + public delegate void BlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + public delegate void PolygonOffsetEXT(GLfloat factor, GLfloat bias); + public delegate void TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void TexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void GetTexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] weights); + public delegate void TexFilterFuncSGIS(Enums.TextureTarget target, GLenum filter, GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] weights); + public delegate void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void CopyTexImage1DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border); + public delegate void CopyTexImage2DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + public delegate void CopyTexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + public delegate void CopyTexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void CopyTexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void GetHistogramEXT_(Enums.HistogramTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, out IntPtr values); + public delegate void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetMinmaxEXT_(Enums.MinmaxTargetEXT target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, out IntPtr values); + public delegate void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void HistogramEXT(Enums.HistogramTargetEXT target, GLsizei width, Enums.PixelInternalFormat internalformat, Enums.Boolean sink); + public delegate void MinmaxEXT(Enums.MinmaxTargetEXT target, Enums.PixelInternalFormat internalformat, Enums.Boolean sink); + public delegate void ResetHistogramEXT(Enums.HistogramTargetEXT target); + public delegate void ResetMinmaxEXT(Enums.MinmaxTargetEXT target); + public delegate void ConvolutionFilter1DEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image); + public delegate void ConvolutionFilter2DEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image); + public delegate void ConvolutionParameterfEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat parameters); + public delegate void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void ConvolutionParameteriEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint parameters); + public delegate void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void CopyConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width); + public delegate void CopyConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height); + public delegate void GetConvolutionFilterEXT_(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr image); + public delegate void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetSeparableFilterEXT_(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr row, out IntPtr column, out IntPtr span); + public delegate void SeparableFilter2DEXT_(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column); + public delegate void ColorTableSGI_(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table); + public delegate void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void CopyColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width); + public delegate void GetColorTableSGI_(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr table); + public delegate void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void PixelTexGenSGIX(GLenum mode); + public delegate void PixelTexGenParameteriSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint param); + public delegate void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void PixelTexGenParameterfSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat param); + public delegate void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void TexImage4DSGIS(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate void TexSubImage4DSGIS(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + public delegate GLboolean AreTexturesResidentEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures, Enums.Boolean[] residences); + public delegate void BindTextureEXT(Enums.TextureTarget target, GLuint texture); + public delegate void DeleteTexturesEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures); + public delegate void GenTexturesEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures); + public delegate GLboolean IsTextureEXT(GLuint texture); + public delegate void PrioritizeTexturesEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures, [MarshalAs(UnmanagedType.LPArray)] GLclampf[] priorities); + public delegate void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void GetDetailTexFuncSGIS(Enums.TextureTarget target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void GetSharpenTexFuncSGIS(Enums.TextureTarget target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void SampleMaskSGIS(GLclampf value, Enums.Boolean invert); + public delegate void SamplePatternSGIS(Enums.SamplePatternSGIS pattern); + public delegate void ArrayElementEXT(GLint i); + public delegate void ColorPointerEXT_(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, IntPtr pointer); + public delegate void DrawArraysEXT(Enums.BeginMode mode, GLint first, GLsizei count); + public delegate void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, Enums.Boolean[] pointer); + public delegate void GetPointervEXT(Enums.GetPointervPName pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] parameters); + public delegate void IndexPointerEXT_(Enums.IndexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer); + public delegate void NormalPointerEXT_(Enums.NormalPointerType type, GLsizei stride, GLsizei count, IntPtr pointer); + public delegate void TexCoordPointerEXT_(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, IntPtr pointer); + public delegate void VertexPointerEXT_(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, IntPtr pointer); + public delegate void BlendEquationEXT(Enums.BlendEquationModeEXT mode); + public delegate void SpriteParameterfSGIX(GLenum pname, GLfloat param); + public delegate void SpriteParameterfvSGIX(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void SpriteParameteriSGIX(GLenum pname, GLint param); + public delegate void SpriteParameterivSGIX(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void PointParameterfEXT(GLenum pname, GLfloat param); + public delegate void PointParameterfvEXT(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void PointParameterfSGIS(GLenum pname, GLfloat param); + public delegate void PointParameterfvSGIS(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate GLint GetInstrumentsSGIX(); + public delegate void InstrumentsBufferSGIX(GLsizei size, [MarshalAs(UnmanagedType.LPArray)] GLint[] buffer); + public delegate GLint PollInstrumentsSGIX([MarshalAs(UnmanagedType.LPArray)] GLint[] marker_p); + public delegate void ReadInstrumentsSGIX(GLint marker); + public delegate void StartInstrumentsSGIX(); + public delegate void StopInstrumentsSGIX(GLint marker); + public delegate void FrameZoomSGIX(GLint factor); + public delegate void TagSampleBufferSGIX(); + public delegate void DeformationMap3dSGIX(Enums.FfdTargetSGIX target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] points); + public delegate void DeformationMap3fSGIX(Enums.FfdTargetSGIX target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void DeformSGIX(Enums.FfdMaskSGIX mask); + public delegate void LoadIdentityDeformationMapSGIX(Enums.FfdMaskSGIX mask); + public delegate void ReferencePlaneSGIX([MarshalAs(UnmanagedType.LPArray)] GLdouble[] equation); + public delegate void FlushRasterSGIX(); + public delegate void FogFuncSGIS(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void GetFogFuncSGIS([MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + public delegate void ImageTransformParameteriHP(GLenum target, GLenum pname, GLint param); + public delegate void ImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param); + public delegate void ImageTransformParameterivHP(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void ImageTransformParameterfvHP(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetImageTransformParameterivHP(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetImageTransformParameterfvHP(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void ColorSubTableEXT_(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data); + public delegate void CopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + public delegate void HintPGI(GLenum target, GLint mode); + public delegate void ColorTableEXT_(GLenum target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table); + public delegate void GetColorTableEXT_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr data); + public delegate void GetColorTableParameterivEXT(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetColorTableParameterfvEXT(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void ListParameterfSGIX(GLuint list, Enums.ListParameterName pname, GLfloat param); + public delegate void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void ListParameteriSGIX(GLuint list, Enums.ListParameterName pname, GLint param); + public delegate void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void IndexMaterialEXT(Enums.MaterialFace face, GLenum mode); + public delegate void IndexFuncEXT(GLenum func, GLclampf reference); + public delegate void LockArraysEXT(GLint first, GLsizei count); + public delegate void UnlockArraysEXT(); + public delegate void CullParameterdvEXT(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void CullParameterfvEXT(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void FragmentColorMaterialSGIX(Enums.MaterialFace face, Enums.MaterialParameter mode); + public delegate void FragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param); + public delegate void FragmentLightfvSGIX(GLenum light, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void FragmentLightiSGIX(GLenum light, GLenum pname, GLint param); + public delegate void FragmentLightivSGIX(GLenum light, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void FragmentLightModelfSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat param); + public delegate void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void FragmentLightModeliSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint param); + public delegate void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void FragmentMaterialfSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param); + public delegate void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void FragmentMaterialiSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param); + public delegate void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetFragmentLightfvSGIX(GLenum light, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetFragmentLightivSGIX(GLenum light, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void LightEnviSGIX(Enums.LightEnvParameterSGIX pname, GLint param); + public delegate void DrawRangeElementsEXT_(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices); + public delegate void ApplyTextureEXT(GLenum mode); + public delegate void TextureLightEXT(GLenum pname); + public delegate void TextureMaterialEXT(Enums.MaterialFace face, Enums.MaterialParameter mode); + public delegate void AsyncMarkerSGIX(GLuint marker); + public delegate GLint FinishAsyncSGIX([MarshalAs(UnmanagedType.LPArray)] GLuint[] markerp); + public delegate GLint PollAsyncSGIX([MarshalAs(UnmanagedType.LPArray)] GLuint[] markerp); + public delegate GLuint GenAsyncMarkersSGIX(GLsizei range); + public delegate void DeleteAsyncMarkersSGIX(GLuint marker, GLsizei range); + public delegate GLboolean IsAsyncMarkerSGIX(GLuint marker); + public delegate void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate void NormalPointervINTEL(Enums.NormalPointerType type, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate void PixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param); + public delegate void PixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param); + public delegate void PixelTransformParameterivEXT(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void PixelTransformParameterfvEXT(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void SecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue); + public delegate void SecondaryColor3bvEXT([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void SecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue); + public delegate void SecondaryColor3dvEXT([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void SecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue); + public delegate void SecondaryColor3fvEXT([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void SecondaryColor3iEXT(GLint red, GLint green, GLint blue); + public delegate void SecondaryColor3ivEXT([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void SecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue); + public delegate void SecondaryColor3svEXT([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void SecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue); + public delegate void SecondaryColor3ubvEXT([MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void SecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue); + public delegate void SecondaryColor3uivEXT([MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + public delegate void SecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue); + public delegate void SecondaryColor3usvEXT([MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + public delegate void SecondaryColorPointerEXT_(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer); + public delegate void TextureNormalEXT(GLenum mode); + public delegate void MultiDrawArraysEXT(Enums.BeginMode mode, [MarshalAs(UnmanagedType.LPArray)] GLint[] first, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLsizei primcount); + public delegate void MultiDrawElementsEXT(Enums.BeginMode mode, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLenum type, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] indices, GLsizei primcount); + public delegate void FogCoordfEXT(GLfloat coord); + public delegate void FogCoordfvEXT([MarshalAs(UnmanagedType.LPArray)] GLfloat[] coord); + public delegate void FogCoorddEXT(GLdouble coord); + public delegate void FogCoorddvEXT([MarshalAs(UnmanagedType.LPArray)] GLdouble[] coord); + public delegate void FogCoordPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer); + public delegate void Tangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz); + public delegate void Tangent3bvEXT([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void Tangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz); + public delegate void Tangent3dvEXT([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Tangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz); + public delegate void Tangent3fvEXT([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Tangent3iEXT(GLint tx, GLint ty, GLint tz); + public delegate void Tangent3ivEXT([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Tangent3sEXT(GLshort tx, GLshort ty, GLshort tz); + public delegate void Tangent3svEXT([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void Binormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz); + public delegate void Binormal3bvEXT([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + public delegate void Binormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz); + public delegate void Binormal3dvEXT([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void Binormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz); + public delegate void Binormal3fvEXT([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Binormal3iEXT(GLint bx, GLint by, GLint bz); + public delegate void Binormal3ivEXT([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void Binormal3sEXT(GLshort bx, GLshort by, GLshort bz); + public delegate void Binormal3svEXT([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void TangentPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer); + public delegate void BinormalPointerEXT_(GLenum type, GLsizei stride, IntPtr pointer); + public delegate void FinishTextureSUNX(); + public delegate void GlobalAlphaFactorbSUN(GLbyte factor); + public delegate void GlobalAlphaFactorsSUN(GLshort factor); + public delegate void GlobalAlphaFactoriSUN(GLint factor); + public delegate void GlobalAlphaFactorfSUN(GLfloat factor); + public delegate void GlobalAlphaFactordSUN(GLdouble factor); + public delegate void GlobalAlphaFactorubSUN(GLubyte factor); + public delegate void GlobalAlphaFactorusSUN(GLushort factor); + public delegate void GlobalAlphaFactoruiSUN(GLuint factor); + public delegate void ReplacementCodeuiSUN(GLuint code); + public delegate void ReplacementCodeusSUN(GLushort code); + public delegate void ReplacementCodeubSUN(GLubyte code); + public delegate void ReplacementCodeuivSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] code); + public delegate void ReplacementCodeusvSUN([MarshalAs(UnmanagedType.LPArray)] GLushort[] code); + public delegate void ReplacementCodeubvSUN([MarshalAs(UnmanagedType.LPArray)] GLubyte[] code); + public delegate void ReplacementCodePointerSUN(GLenum type, GLsizei stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate void Color4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y); + public delegate void Color4ubVertex2fvSUN([MarshalAs(UnmanagedType.LPArray)] GLubyte[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Color4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); + public delegate void Color4ubVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLubyte[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Color3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); + public delegate void Color3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Normal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void Normal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void Color4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void Color4fNormal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); + public delegate void TexCoord2fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void TexCoord4fVertex4fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); + public delegate void TexCoord2fColor4ubVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); + public delegate void TexCoord2fColor3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void TexCoord2fNormal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void TexCoord2fColor4fNormal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void TexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void TexCoord4fColor4fNormal3fVertex4fvSUN([MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiColor4ubVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiColor3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiNormal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiColor4fNormal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiTexCoord2fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); + public delegate void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN([MarshalAs(UnmanagedType.LPArray)] GLuint[] rc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] tc, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] c, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] n, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void BlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + public delegate void BlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + public delegate void VertexWeightfEXT(GLfloat weight); + public delegate void VertexWeightfvEXT([MarshalAs(UnmanagedType.LPArray)] GLfloat[] weight); + public delegate void VertexWeightPointerEXT_(GLsizei size, GLenum type, GLsizei stride, IntPtr pointer); + public delegate void FlushVertexArrayRangeNV(); + public delegate void VertexArrayRangeNV_(GLsizei length, IntPtr pointer); + public delegate void CombinerParameterfvNV(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void CombinerParameterfNV(GLenum pname, GLfloat param); + public delegate void CombinerParameterivNV(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void CombinerParameteriNV(GLenum pname, GLint param); + public delegate void CombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); + public delegate void CombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, Enums.Boolean abDotProduct, Enums.Boolean cdDotProduct, Enums.Boolean muxSum); + public delegate void FinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); + public delegate void GetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void ResizeBuffersMESA(); + public delegate void WindowPos2dMESA(GLdouble x, GLdouble y); + public delegate void WindowPos2dvMESA([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void WindowPos2fMESA(GLfloat x, GLfloat y); + public delegate void WindowPos2fvMESA([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void WindowPos2iMESA(GLint x, GLint y); + public delegate void WindowPos2ivMESA([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void WindowPos2sMESA(GLshort x, GLshort y); + public delegate void WindowPos2svMESA([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z); + public delegate void WindowPos3dvMESA([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z); + public delegate void WindowPos3fvMESA([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void WindowPos3iMESA(GLint x, GLint y, GLint z); + public delegate void WindowPos3ivMESA([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void WindowPos3sMESA(GLshort x, GLshort y, GLshort z); + public delegate void WindowPos3svMESA([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void WindowPos4dvMESA([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void WindowPos4fvMESA([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w); + public delegate void WindowPos4ivMESA([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + public delegate void WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w); + public delegate void WindowPos4svMESA([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, [MarshalAs(UnmanagedType.LPArray)] GLint[] first, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLsizei primcount, GLint modestride); + public delegate void MultiModeDrawElementsIBM_(Enums.BeginMode[] mode, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLenum type, IntPtr indices, GLsizei primcount, GLint modestride); + public delegate void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer, GLint ptrstride); + public delegate void SecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer, GLint ptrstride); + public delegate void EdgeFlagPointerListIBM(GLint stride, [MarshalAs(UnmanagedType.LPArray)] GLboolean[] pointer, GLint ptrstride); + public delegate void FogCoordPointerListIBM(GLenum type, GLint stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer, GLint ptrstride); + public delegate void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer, GLint ptrstride); + public delegate void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer, GLint ptrstride); + public delegate void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer, GLint ptrstride); + public delegate void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer, GLint ptrstride); + public delegate void TbufferMask3DFX(GLuint mask); + public delegate void SampleMaskEXT(GLclampf value, Enums.Boolean invert); + public delegate void SamplePatternEXT(GLenum pattern); + public delegate void TextureColorMaskSGIS(Enums.Boolean red, Enums.Boolean green, Enums.Boolean blue, Enums.Boolean alpha); + public delegate void IglooInterfaceSGIX_(GLenum pname, IntPtr parameters); + public delegate void DeleteFencesNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] fences); + public delegate void GenFencesNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] fences); + public delegate GLboolean IsFenceNV(GLuint fence); + public delegate GLboolean TestFenceNV(GLuint fence); + public delegate void GetFenceivNV(GLuint fence, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void FinishFenceNV(GLuint fence); + public delegate void SetFenceNV(GLuint fence, GLenum condition); + public delegate void MapControlPointsNV_(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, Enums.Boolean packed, IntPtr points); + public delegate void MapParameterivNV(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void MapParameterfvNV(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetMapControlPointsNV_(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, Enums.Boolean packed, out IntPtr points); + public delegate void GetMapParameterivNV(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetMapParameterfvNV(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void EvalMapsNV(GLenum target, GLenum mode); + public delegate void CombinerStageParameterfvNV(GLenum stage, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetCombinerStageParameterfvNV(GLenum stage, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate GLboolean AreProgramsResidentNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] programs, Enums.Boolean[] residences); + public delegate void BindProgramNV(GLenum target, GLuint id); + public delegate void DeleteProgramsNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] programs); + public delegate void ExecuteProgramNV(GLenum target, GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GenProgramsNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] programs); + public delegate void GetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void GetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetProgramivNV(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetProgramStringNV(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] program); + public delegate void GetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetVertexAttribdvNV(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void GetVertexAttribfvNV(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetVertexAttribivNV(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetVertexAttribPointervNV(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + public delegate GLboolean IsProgramNV(GLuint id); + public delegate void LoadProgramNV(GLenum target, GLuint id, GLsizei len, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] program); + public delegate void ProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void ProgramParameter4dvNV(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void ProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void ProgramParameter4fvNV(GLenum target, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void ProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void RequestResidentProgramsNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] programs); + public delegate void TrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform); + public delegate void VertexAttribPointerNV_(GLuint index, GLint fsize, GLenum type, GLsizei stride, IntPtr pointer); + public delegate void VertexAttrib1dNV(GLuint index, GLdouble x); + public delegate void VertexAttrib1dvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib1fNV(GLuint index, GLfloat x); + public delegate void VertexAttrib1fvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib1sNV(GLuint index, GLshort x); + public delegate void VertexAttrib1svNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y); + public delegate void VertexAttrib2dvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y); + public delegate void VertexAttrib2fvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib2sNV(GLuint index, GLshort x, GLshort y); + public delegate void VertexAttrib2svNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z); + public delegate void VertexAttrib3dvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z); + public delegate void VertexAttrib3fvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z); + public delegate void VertexAttrib3svNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void VertexAttrib4dvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void VertexAttrib4fvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); + public delegate void VertexAttrib4svNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); + public delegate void VertexAttrib4ubvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void VertexAttribs1dvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttribs1fvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttribs1svNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttribs2dvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttribs2fvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttribs2svNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttribs3dvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttribs3fvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttribs3svNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttribs4dvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void VertexAttribs4fvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void VertexAttribs4svNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + public delegate void VertexAttribs4ubvNV(GLuint index, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + public delegate void TexBumpParameterivATI(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] param); + public delegate void TexBumpParameterfvATI(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] param); + public delegate void GetTexBumpParameterivATI(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] param); + public delegate void GetTexBumpParameterfvATI(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] param); + public delegate GLuint GenFragmentShadersATI(GLuint range); + public delegate void BindFragmentShaderATI(GLuint id); + public delegate void DeleteFragmentShaderATI(GLuint id); + public delegate void BeginFragmentShaderATI(); + public delegate void EndFragmentShaderATI(); + public delegate void PassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle); + public delegate void SampleMapATI(GLuint dst, GLuint interp, GLenum swizzle); + public delegate void ColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); + public delegate void ColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); + public delegate void ColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); + public delegate void AlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); + public delegate void AlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); + public delegate void AlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); + public delegate void SetFragmentShaderConstantATI(GLuint dst, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + public delegate void PNTrianglesiATI(GLenum pname, GLint param); + public delegate void PNTrianglesfATI(GLenum pname, GLfloat param); + public delegate GLuint NewObjectBufferATI_(GLsizei size, IntPtr pointer, GLenum usage); + public delegate GLboolean IsObjectBufferATI(GLuint buffer); + public delegate void UpdateObjectBufferATI_(GLuint buffer, GLuint offset, GLsizei size, IntPtr pointer, GLenum preserve); + public delegate void GetObjectBufferfvATI(GLuint buffer, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetObjectBufferivATI(GLuint buffer, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void FreeObjectBufferATI(GLuint buffer); + public delegate void ArrayObjectATI(Enums.EnableCap array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); + public delegate void GetArrayObjectfvATI(Enums.EnableCap array, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetArrayObjectivATI(Enums.EnableCap array, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void VariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); + public delegate void GetVariantArrayObjectfvATI(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetVariantArrayObjectivATI(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void BeginVertexShaderEXT(); + public delegate void EndVertexShaderEXT(); + public delegate void BindVertexShaderEXT(GLuint id); + public delegate GLuint GenVertexShadersEXT(GLuint range); + public delegate void DeleteVertexShaderEXT(GLuint id); + public delegate void ShaderOp1EXT(GLenum op, GLuint res, GLuint arg1); + public delegate void ShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2); + public delegate void ShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3); + public delegate void SwizzleEXT(GLuint res, GLuint @in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); + public delegate void WriteMaskEXT(GLuint res, GLuint @in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); + public delegate void InsertComponentEXT(GLuint res, GLuint src, GLuint num); + public delegate void ExtractComponentEXT(GLuint res, GLuint src, GLuint num); + public delegate GLuint GenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components); + public delegate void SetInvariantEXT_(GLuint id, GLenum type, IntPtr addr); + public delegate void SetLocalConstantEXT_(GLuint id, GLenum type, IntPtr addr); + public delegate void VariantbvEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] addr); + public delegate void VariantsvEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLshort[] addr); + public delegate void VariantivEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLint[] addr); + public delegate void VariantfvEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] addr); + public delegate void VariantdvEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] addr); + public delegate void VariantubvEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] addr); + public delegate void VariantusvEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLushort[] addr); + public delegate void VariantuivEXT(GLuint id, [MarshalAs(UnmanagedType.LPArray)] GLuint[] addr); + public delegate void VariantPointerEXT_(GLuint id, GLenum type, GLuint stride, IntPtr addr); + public delegate void EnableVariantClientStateEXT(GLuint id); + public delegate void DisableVariantClientStateEXT(GLuint id); + public delegate GLuint BindLightParameterEXT(Enums.LightName light, Enums.LightParameter value); + public delegate GLuint BindMaterialParameterEXT(Enums.MaterialFace face, Enums.MaterialParameter value); + public delegate GLuint BindTexGenParameterEXT(GLenum unit, Enums.TextureCoordName coord, Enums.TextureGenParameter value); + public delegate GLuint BindTextureUnitParameterEXT(GLenum unit, GLenum value); + public delegate GLuint BindParameterEXT(GLenum value); + public delegate GLboolean IsVariantEnabledEXT(GLuint id, GLenum cap); + public delegate void GetVariantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data); + public delegate void GetVariantIntegervEXT(GLuint id, GLenum value, [MarshalAs(UnmanagedType.LPArray)] GLint[] data); + public delegate void GetVariantFloatvEXT(GLuint id, GLenum value, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] data); + public delegate void GetVariantPointervEXT(GLuint id, GLenum value, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] data); + public delegate void GetInvariantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data); + public delegate void GetInvariantIntegervEXT(GLuint id, GLenum value, [MarshalAs(UnmanagedType.LPArray)] GLint[] data); + public delegate void GetInvariantFloatvEXT(GLuint id, GLenum value, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] data); + public delegate void GetLocalConstantBooleanvEXT(GLuint id, GLenum value, Enums.Boolean[] data); + public delegate void GetLocalConstantIntegervEXT(GLuint id, GLenum value, [MarshalAs(UnmanagedType.LPArray)] GLint[] data); + public delegate void GetLocalConstantFloatvEXT(GLuint id, GLenum value, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] data); + public delegate void VertexStream1sATI(GLenum stream, GLshort x); + public delegate void VertexStream1svATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLshort[] coords); + public delegate void VertexStream1iATI(GLenum stream, GLint x); + public delegate void VertexStream1ivATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLint[] coords); + public delegate void VertexStream1fATI(GLenum stream, GLfloat x); + public delegate void VertexStream1fvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] coords); + public delegate void VertexStream1dATI(GLenum stream, GLdouble x); + public delegate void VertexStream1dvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] coords); + public delegate void VertexStream2sATI(GLenum stream, GLshort x, GLshort y); + public delegate void VertexStream2svATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLshort[] coords); + public delegate void VertexStream2iATI(GLenum stream, GLint x, GLint y); + public delegate void VertexStream2ivATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLint[] coords); + public delegate void VertexStream2fATI(GLenum stream, GLfloat x, GLfloat y); + public delegate void VertexStream2fvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] coords); + public delegate void VertexStream2dATI(GLenum stream, GLdouble x, GLdouble y); + public delegate void VertexStream2dvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] coords); + public delegate void VertexStream3sATI(GLenum stream, GLshort x, GLshort y, GLshort z); + public delegate void VertexStream3svATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLshort[] coords); + public delegate void VertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z); + public delegate void VertexStream3ivATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLint[] coords); + public delegate void VertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z); + public delegate void VertexStream3fvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] coords); + public delegate void VertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z); + public delegate void VertexStream3dvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] coords); + public delegate void VertexStream4sATI(GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w); + public delegate void VertexStream4svATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLshort[] coords); + public delegate void VertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w); + public delegate void VertexStream4ivATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLint[] coords); + public delegate void VertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void VertexStream4fvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] coords); + public delegate void VertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void VertexStream4dvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] coords); + public delegate void NormalStream3bATI(GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz); + public delegate void NormalStream3bvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] coords); + public delegate void NormalStream3sATI(GLenum stream, GLshort nx, GLshort ny, GLshort nz); + public delegate void NormalStream3svATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLshort[] coords); + public delegate void NormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz); + public delegate void NormalStream3ivATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLint[] coords); + public delegate void NormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz); + public delegate void NormalStream3fvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] coords); + public delegate void NormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz); + public delegate void NormalStream3dvATI(GLenum stream, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] coords); + public delegate void ClientActiveVertexStreamATI(GLenum stream); + public delegate void VertexBlendEnviATI(GLenum pname, GLint param); + public delegate void VertexBlendEnvfATI(GLenum pname, GLfloat param); + public delegate void ElementPointerATI_(GLenum type, IntPtr pointer); + public delegate void DrawElementArrayATI(Enums.BeginMode mode, GLsizei count); + public delegate void DrawRangeElementArrayATI(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count); + public delegate void DrawMeshArraysSUN(Enums.BeginMode mode, GLint first, GLsizei count, GLsizei width); + public delegate void GenOcclusionQueriesNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + public delegate void DeleteOcclusionQueriesNV(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + public delegate GLboolean IsOcclusionQueryNV(GLuint id); + public delegate void BeginOcclusionQueryNV(GLuint id); + public delegate void EndOcclusionQueryNV(); + public delegate void GetOcclusionQueryivNV(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GetOcclusionQueryuivNV(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLuint[] parameters); + public delegate void PointParameteriNV(GLenum pname, GLint param); + public delegate void PointParameterivNV(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void ActiveStencilFaceEXT(GLenum face); + public delegate void ElementPointerAPPLE_(GLenum type, IntPtr pointer); + public delegate void DrawElementArrayAPPLE(Enums.BeginMode mode, GLint first, GLsizei count); + public delegate void DrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint first, GLsizei count); + public delegate void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, [MarshalAs(UnmanagedType.LPArray)] GLint[] first, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLsizei primcount); + public delegate void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, [MarshalAs(UnmanagedType.LPArray)] GLint[] first, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLsizei primcount); + public delegate void GenFencesAPPLE(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] fences); + public delegate void DeleteFencesAPPLE(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] fences); + public delegate void SetFenceAPPLE(GLuint fence); + public delegate GLboolean IsFenceAPPLE(GLuint fence); + public delegate GLboolean TestFenceAPPLE(GLuint fence); + public delegate void FinishFenceAPPLE(GLuint fence); + public delegate GLboolean TestObjectAPPLE(GLenum @object, GLuint name); + public delegate void FinishObjectAPPLE(GLenum @object, GLint name); + public delegate void BindVertexArrayAPPLE(GLuint array); + public delegate void DeleteVertexArraysAPPLE(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] arrays); + public delegate void GenVertexArraysAPPLE(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] arrays); + public delegate GLboolean IsVertexArrayAPPLE(GLuint array); + public delegate void VertexArrayRangeAPPLE_(GLsizei length, out IntPtr pointer); + public delegate void FlushVertexArrayRangeAPPLE_(GLsizei length, out IntPtr pointer); + public delegate void VertexArrayParameteriAPPLE(GLenum pname, GLint param); + public delegate void DrawBuffersATI(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLenum[] bufs); + public delegate void ProgramNamedParameter4fNV(GLuint id, GLsizei len, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + public delegate void ProgramNamedParameter4dNV(GLuint id, GLsizei len, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + public delegate void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] name, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + public delegate void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] name, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + public delegate void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] name, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] name, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + public delegate void Vertex2hNV(GLhalfNV x, GLhalfNV y); + public delegate void Vertex2hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void Vertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z); + public delegate void Vertex3hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void Vertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); + public delegate void Vertex4hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void Normal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz); + public delegate void Normal3hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void Color3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue); + public delegate void Color3hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void Color4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha); + public delegate void Color4hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void TexCoord1hNV(GLhalfNV s); + public delegate void TexCoord1hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void TexCoord2hNV(GLhalfNV s, GLhalfNV t); + public delegate void TexCoord2hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void TexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r); + public delegate void TexCoord3hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void TexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); + public delegate void TexCoord4hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void MultiTexCoord1hNV(GLenum target, GLhalfNV s); + public delegate void MultiTexCoord1hvNV(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void MultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t); + public delegate void MultiTexCoord2hvNV(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void MultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r); + public delegate void MultiTexCoord3hvNV(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void MultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); + public delegate void MultiTexCoord4hvNV(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void FogCoordhNV(GLhalfNV fog); + public delegate void FogCoordhvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] fog); + public delegate void SecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue); + public delegate void SecondaryColor3hvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexWeighthNV(GLhalfNV weight); + public delegate void VertexWeighthvNV([MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] weight); + public delegate void VertexAttrib1hNV(GLuint index, GLhalfNV x); + public delegate void VertexAttrib1hvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y); + public delegate void VertexAttrib2hvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z); + public delegate void VertexAttrib3hvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); + public delegate void VertexAttrib4hvNV(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexAttribs1hvNV(GLuint index, GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexAttribs2hvNV(GLuint index, GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexAttribs3hvNV(GLuint index, GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void VertexAttribs4hvNV(GLuint index, GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLhalfNV[] v); + public delegate void PixelDataRangeNV_(GLenum target, GLsizei length, out IntPtr pointer); + public delegate void FlushPixelDataRangeNV(GLenum target); + public delegate void PrimitiveRestartNV(); + public delegate void PrimitiveRestartIndexNV(GLuint index); + public delegate IntPtr MapObjectBufferATI_(GLuint buffer); + public delegate void UnmapObjectBufferATI(GLuint buffer); + public delegate void StencilOpSeparateATI(GLenum face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass); + public delegate void StencilFuncSeparateATI(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint reference, GLuint mask); + public delegate void VertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, GLuint buffer, GLuint offset); + public delegate void GetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + public delegate void GetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void DepthBoundsEXT(GLclampd zmin, GLclampd zmax); + public delegate void BlendEquationSeparateEXT(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha); + public delegate GLboolean IsRenderbufferEXT(GLuint renderbuffer); + public delegate void BindRenderbufferEXT(GLenum target, GLuint renderbuffer); + public delegate void DeleteRenderbuffersEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] renderbuffers); + public delegate void GenRenderbuffersEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] renderbuffers); + public delegate void RenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + public delegate void GetRenderbufferParameterivEXT(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate GLboolean IsFramebufferEXT(GLuint framebuffer); + public delegate void BindFramebufferEXT(GLenum target, GLuint framebuffer); + public delegate void DeleteFramebuffersEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] framebuffers); + public delegate void GenFramebuffersEXT(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] framebuffers); + public delegate GLenum CheckFramebufferStatusEXT(GLenum target); + public delegate void FramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + public delegate void FramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + public delegate void FramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); + public delegate void FramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + public delegate void GetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + public delegate void GenerateMipmapEXT(GLenum target); + public delegate void StringMarkerGREMEDY_(GLsizei len, IntPtr @string); + } + #endregion + + #region Imports + + internal class Imports + { + [DllImport("opengl32", EntryPoint = "glNewList")] + public static extern void NewList(GLuint list, Enums.ListMode mode); + [DllImport("opengl32", EntryPoint = "glEndList")] + public static extern void EndList(); + [DllImport("opengl32", EntryPoint = "glCallList")] + public static extern void CallList(GLuint list); + [DllImport("opengl32", EntryPoint = "glCallLists")] + public static extern void CallLists_(GLsizei n, Enums.ListNameType type, IntPtr lists); + [DllImport("opengl32", EntryPoint = "glDeleteLists")] + public static extern void DeleteLists(GLuint list, GLsizei range); + [DllImport("opengl32", EntryPoint = "glGenLists")] + public static extern GLuint GenLists(GLsizei range); + [DllImport("opengl32", EntryPoint = "glListBase")] + public static extern void ListBase(GLuint @base); + [DllImport("opengl32", EntryPoint = "glBegin")] + public static extern void Begin(Enums.BeginMode mode); + [DllImport("opengl32", EntryPoint = "glBitmap")] + public static extern void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] bitmap); + [DllImport("opengl32", EntryPoint = "glColor3b")] + public static extern void Color3b(GLbyte red, GLbyte green, GLbyte blue); + [DllImport("opengl32", EntryPoint = "glColor3bv")] + public static extern void Color3bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + [DllImport("opengl32", EntryPoint = "glColor3d")] + public static extern void Color3d(GLdouble red, GLdouble green, GLdouble blue); + [DllImport("opengl32", EntryPoint = "glColor3dv")] + public static extern void Color3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glColor3f")] + public static extern void Color3f(GLfloat red, GLfloat green, GLfloat blue); + [DllImport("opengl32", EntryPoint = "glColor3fv")] + public static extern void Color3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glColor3i")] + public static extern void Color3i(GLint red, GLint green, GLint blue); + [DllImport("opengl32", EntryPoint = "glColor3iv")] + public static extern void Color3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glColor3s")] + public static extern void Color3s(GLshort red, GLshort green, GLshort blue); + [DllImport("opengl32", EntryPoint = "glColor3sv")] + public static extern void Color3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glColor3ub")] + public static extern void Color3ub(GLubyte red, GLubyte green, GLubyte blue); + [DllImport("opengl32", EntryPoint = "glColor3ubv")] + public static extern void Color3ubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + [DllImport("opengl32", EntryPoint = "glColor3ui")] + public static extern void Color3ui(GLuint red, GLuint green, GLuint blue); + [DllImport("opengl32", EntryPoint = "glColor3uiv")] + public static extern void Color3uiv([MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + [DllImport("opengl32", EntryPoint = "glColor3us")] + public static extern void Color3us(GLushort red, GLushort green, GLushort blue); + [DllImport("opengl32", EntryPoint = "glColor3usv")] + public static extern void Color3usv([MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + [DllImport("opengl32", EntryPoint = "glColor4b")] + public static extern void Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); + [DllImport("opengl32", EntryPoint = "glColor4bv")] + public static extern void Color4bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + [DllImport("opengl32", EntryPoint = "glColor4d")] + public static extern void Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); + [DllImport("opengl32", EntryPoint = "glColor4dv")] + public static extern void Color4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glColor4f")] + public static extern void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + [DllImport("opengl32", EntryPoint = "glColor4fv")] + public static extern void Color4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glColor4i")] + public static extern void Color4i(GLint red, GLint green, GLint blue, GLint alpha); + [DllImport("opengl32", EntryPoint = "glColor4iv")] + public static extern void Color4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glColor4s")] + public static extern void Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha); + [DllImport("opengl32", EntryPoint = "glColor4sv")] + public static extern void Color4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glColor4ub")] + public static extern void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); + [DllImport("opengl32", EntryPoint = "glColor4ubv")] + public static extern void Color4ubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + [DllImport("opengl32", EntryPoint = "glColor4ui")] + public static extern void Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha); + [DllImport("opengl32", EntryPoint = "glColor4uiv")] + public static extern void Color4uiv([MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + [DllImport("opengl32", EntryPoint = "glColor4us")] + public static extern void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha); + [DllImport("opengl32", EntryPoint = "glColor4usv")] + public static extern void Color4usv([MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + [DllImport("opengl32", EntryPoint = "glEdgeFlag")] + public static extern void EdgeFlag(Enums.Boolean flag); + [DllImport("opengl32", EntryPoint = "glEdgeFlagv")] + public static extern void EdgeFlagv(Enums.Boolean[] flag); + [DllImport("opengl32", EntryPoint = "glEnd")] + public static extern void End(); + [DllImport("opengl32", EntryPoint = "glIndexd")] + public static extern void Indexd(GLdouble c); + [DllImport("opengl32", EntryPoint = "glIndexdv")] + public static extern void Indexdv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] c); + [DllImport("opengl32", EntryPoint = "glIndexf")] + public static extern void Indexf(GLfloat c); + [DllImport("opengl32", EntryPoint = "glIndexfv")] + public static extern void Indexfv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] c); + [DllImport("opengl32", EntryPoint = "glIndexi")] + public static extern void Indexi(GLint c); + [DllImport("opengl32", EntryPoint = "glIndexiv")] + public static extern void Indexiv([MarshalAs(UnmanagedType.LPArray)] GLint[] c); + [DllImport("opengl32", EntryPoint = "glIndexs")] + public static extern void Indexs(GLshort c); + [DllImport("opengl32", EntryPoint = "glIndexsv")] + public static extern void Indexsv([MarshalAs(UnmanagedType.LPArray)] GLshort[] c); + [DllImport("opengl32", EntryPoint = "glNormal3b")] + public static extern void Normal3b(GLbyte nx, GLbyte ny, GLbyte nz); + [DllImport("opengl32", EntryPoint = "glNormal3bv")] + public static extern void Normal3bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + [DllImport("opengl32", EntryPoint = "glNormal3d")] + public static extern void Normal3d(GLdouble nx, GLdouble ny, GLdouble nz); + [DllImport("opengl32", EntryPoint = "glNormal3dv")] + public static extern void Normal3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glNormal3f")] + public static extern void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz); + [DllImport("opengl32", EntryPoint = "glNormal3fv")] + public static extern void Normal3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glNormal3i")] + public static extern void Normal3i(GLint nx, GLint ny, GLint nz); + [DllImport("opengl32", EntryPoint = "glNormal3iv")] + public static extern void Normal3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glNormal3s")] + public static extern void Normal3s(GLshort nx, GLshort ny, GLshort nz); + [DllImport("opengl32", EntryPoint = "glNormal3sv")] + public static extern void Normal3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos2d")] + public static extern void RasterPos2d(GLdouble x, GLdouble y); + [DllImport("opengl32", EntryPoint = "glRasterPos2dv")] + public static extern void RasterPos2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos2f")] + public static extern void RasterPos2f(GLfloat x, GLfloat y); + [DllImport("opengl32", EntryPoint = "glRasterPos2fv")] + public static extern void RasterPos2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos2i")] + public static extern void RasterPos2i(GLint x, GLint y); + [DllImport("opengl32", EntryPoint = "glRasterPos2iv")] + public static extern void RasterPos2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos2s")] + public static extern void RasterPos2s(GLshort x, GLshort y); + [DllImport("opengl32", EntryPoint = "glRasterPos2sv")] + public static extern void RasterPos2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos3d")] + public static extern void RasterPos3d(GLdouble x, GLdouble y, GLdouble z); + [DllImport("opengl32", EntryPoint = "glRasterPos3dv")] + public static extern void RasterPos3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos3f")] + public static extern void RasterPos3f(GLfloat x, GLfloat y, GLfloat z); + [DllImport("opengl32", EntryPoint = "glRasterPos3fv")] + public static extern void RasterPos3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos3i")] + public static extern void RasterPos3i(GLint x, GLint y, GLint z); + [DllImport("opengl32", EntryPoint = "glRasterPos3iv")] + public static extern void RasterPos3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos3s")] + public static extern void RasterPos3s(GLshort x, GLshort y, GLshort z); + [DllImport("opengl32", EntryPoint = "glRasterPos3sv")] + public static extern void RasterPos3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos4d")] + public static extern void RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + [DllImport("opengl32", EntryPoint = "glRasterPos4dv")] + public static extern void RasterPos4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos4f")] + public static extern void RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + [DllImport("opengl32", EntryPoint = "glRasterPos4fv")] + public static extern void RasterPos4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos4i")] + public static extern void RasterPos4i(GLint x, GLint y, GLint z, GLint w); + [DllImport("opengl32", EntryPoint = "glRasterPos4iv")] + public static extern void RasterPos4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glRasterPos4s")] + public static extern void RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w); + [DllImport("opengl32", EntryPoint = "glRasterPos4sv")] + public static extern void RasterPos4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glRectd")] + public static extern void Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); + [DllImport("opengl32", EntryPoint = "glRectdv")] + public static extern void Rectdv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v1, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v2); + [DllImport("opengl32", EntryPoint = "glRectf")] + public static extern void Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); + [DllImport("opengl32", EntryPoint = "glRectfv")] + public static extern void Rectfv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v1, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v2); + [DllImport("opengl32", EntryPoint = "glRecti")] + public static extern void Recti(GLint x1, GLint y1, GLint x2, GLint y2); + [DllImport("opengl32", EntryPoint = "glRectiv")] + public static extern void Rectiv([MarshalAs(UnmanagedType.LPArray)] GLint[] v1, [MarshalAs(UnmanagedType.LPArray)] GLint[] v2); + [DllImport("opengl32", EntryPoint = "glRects")] + public static extern void Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2); + [DllImport("opengl32", EntryPoint = "glRectsv")] + public static extern void Rectsv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v1, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v2); + [DllImport("opengl32", EntryPoint = "glTexCoord1d")] + public static extern void TexCoord1d(GLdouble s); + [DllImport("opengl32", EntryPoint = "glTexCoord1dv")] + public static extern void TexCoord1dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord1f")] + public static extern void TexCoord1f(GLfloat s); + [DllImport("opengl32", EntryPoint = "glTexCoord1fv")] + public static extern void TexCoord1fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord1i")] + public static extern void TexCoord1i(GLint s); + [DllImport("opengl32", EntryPoint = "glTexCoord1iv")] + public static extern void TexCoord1iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord1s")] + public static extern void TexCoord1s(GLshort s); + [DllImport("opengl32", EntryPoint = "glTexCoord1sv")] + public static extern void TexCoord1sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord2d")] + public static extern void TexCoord2d(GLdouble s, GLdouble t); + [DllImport("opengl32", EntryPoint = "glTexCoord2dv")] + public static extern void TexCoord2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord2f")] + public static extern void TexCoord2f(GLfloat s, GLfloat t); + [DllImport("opengl32", EntryPoint = "glTexCoord2fv")] + public static extern void TexCoord2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord2i")] + public static extern void TexCoord2i(GLint s, GLint t); + [DllImport("opengl32", EntryPoint = "glTexCoord2iv")] + public static extern void TexCoord2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord2s")] + public static extern void TexCoord2s(GLshort s, GLshort t); + [DllImport("opengl32", EntryPoint = "glTexCoord2sv")] + public static extern void TexCoord2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord3d")] + public static extern void TexCoord3d(GLdouble s, GLdouble t, GLdouble r); + [DllImport("opengl32", EntryPoint = "glTexCoord3dv")] + public static extern void TexCoord3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord3f")] + public static extern void TexCoord3f(GLfloat s, GLfloat t, GLfloat r); + [DllImport("opengl32", EntryPoint = "glTexCoord3fv")] + public static extern void TexCoord3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord3i")] + public static extern void TexCoord3i(GLint s, GLint t, GLint r); + [DllImport("opengl32", EntryPoint = "glTexCoord3iv")] + public static extern void TexCoord3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord3s")] + public static extern void TexCoord3s(GLshort s, GLshort t, GLshort r); + [DllImport("opengl32", EntryPoint = "glTexCoord3sv")] + public static extern void TexCoord3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord4d")] + public static extern void TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q); + [DllImport("opengl32", EntryPoint = "glTexCoord4dv")] + public static extern void TexCoord4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord4f")] + public static extern void TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q); + [DllImport("opengl32", EntryPoint = "glTexCoord4fv")] + public static extern void TexCoord4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord4i")] + public static extern void TexCoord4i(GLint s, GLint t, GLint r, GLint q); + [DllImport("opengl32", EntryPoint = "glTexCoord4iv")] + public static extern void TexCoord4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glTexCoord4s")] + public static extern void TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q); + [DllImport("opengl32", EntryPoint = "glTexCoord4sv")] + public static extern void TexCoord4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertex2d")] + public static extern void Vertex2d(GLdouble x, GLdouble y); + [DllImport("opengl32", EntryPoint = "glVertex2dv")] + public static extern void Vertex2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glVertex2f")] + public static extern void Vertex2f(GLfloat x, GLfloat y); + [DllImport("opengl32", EntryPoint = "glVertex2fv")] + public static extern void Vertex2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glVertex2i")] + public static extern void Vertex2i(GLint x, GLint y); + [DllImport("opengl32", EntryPoint = "glVertex2iv")] + public static extern void Vertex2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glVertex2s")] + public static extern void Vertex2s(GLshort x, GLshort y); + [DllImport("opengl32", EntryPoint = "glVertex2sv")] + public static extern void Vertex2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertex3d")] + public static extern void Vertex3d(GLdouble x, GLdouble y, GLdouble z); + [DllImport("opengl32", EntryPoint = "glVertex3dv")] + public static extern void Vertex3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glVertex3f")] + public static extern void Vertex3f(GLfloat x, GLfloat y, GLfloat z); + [DllImport("opengl32", EntryPoint = "glVertex3fv")] + public static extern void Vertex3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glVertex3i")] + public static extern void Vertex3i(GLint x, GLint y, GLint z); + [DllImport("opengl32", EntryPoint = "glVertex3iv")] + public static extern void Vertex3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glVertex3s")] + public static extern void Vertex3s(GLshort x, GLshort y, GLshort z); + [DllImport("opengl32", EntryPoint = "glVertex3sv")] + public static extern void Vertex3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertex4d")] + public static extern void Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); + [DllImport("opengl32", EntryPoint = "glVertex4dv")] + public static extern void Vertex4dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glVertex4f")] + public static extern void Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); + [DllImport("opengl32", EntryPoint = "glVertex4fv")] + public static extern void Vertex4fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glVertex4i")] + public static extern void Vertex4i(GLint x, GLint y, GLint z, GLint w); + [DllImport("opengl32", EntryPoint = "glVertex4iv")] + public static extern void Vertex4iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glVertex4s")] + public static extern void Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w); + [DllImport("opengl32", EntryPoint = "glVertex4sv")] + public static extern void Vertex4sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glClipPlane")] + public static extern void ClipPlane(Enums.ClipPlaneName plane, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] equation); + [DllImport("opengl32", EntryPoint = "glColorMaterial")] + public static extern void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode); + [DllImport("opengl32", EntryPoint = "glCullFace")] + public static extern void CullFace(Enums.CullFaceMode mode); + [DllImport("opengl32", EntryPoint = "glFogf")] + public static extern void Fogf(Enums.FogParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glFogfv")] + public static extern void Fogfv(Enums.FogParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glFogi")] + public static extern void Fogi(Enums.FogParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glFogiv")] + public static extern void Fogiv(Enums.FogParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glFrontFace")] + public static extern void FrontFace(Enums.FrontFaceDirection mode); + [DllImport("opengl32", EntryPoint = "glHint")] + public static extern void Hint(Enums.HintTarget target, Enums.HintMode mode); + [DllImport("opengl32", EntryPoint = "glLightf")] + public static extern void Lightf(Enums.LightName light, Enums.LightParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glLightfv")] + public static extern void Lightfv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glLighti")] + public static extern void Lighti(Enums.LightName light, Enums.LightParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glLightiv")] + public static extern void Lightiv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glLightModelf")] + public static extern void LightModelf(Enums.LightModelParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glLightModelfv")] + public static extern void LightModelfv(Enums.LightModelParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glLightModeli")] + public static extern void LightModeli(Enums.LightModelParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glLightModeliv")] + public static extern void LightModeliv(Enums.LightModelParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glLineStipple")] + public static extern void LineStipple(GLint factor, GLushort pattern); + [DllImport("opengl32", EntryPoint = "glLineWidth")] + public static extern void LineWidth(GLfloat width); + [DllImport("opengl32", EntryPoint = "glMaterialf")] + public static extern void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glMaterialfv")] + public static extern void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glMateriali")] + public static extern void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glMaterialiv")] + public static extern void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glPointSize")] + public static extern void PointSize(GLfloat size); + [DllImport("opengl32", EntryPoint = "glPolygonMode")] + public static extern void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode); + [DllImport("opengl32", EntryPoint = "glPolygonStipple")] + public static extern void PolygonStipple([MarshalAs(UnmanagedType.LPArray)] GLubyte[] mask); + [DllImport("opengl32", EntryPoint = "glScissor")] + public static extern void Scissor(GLint x, GLint y, GLsizei width, GLsizei height); + [DllImport("opengl32", EntryPoint = "glShadeModel")] + public static extern void ShadeModel(Enums.ShadingModel mode); + [DllImport("opengl32", EntryPoint = "glTexParameterf")] + public static extern void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glTexParameterfv")] + public static extern void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glTexParameteri")] + public static extern void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, GLint param); + [DllImport("opengl32", EntryPoint = "glTexParameteriv")] + public static extern void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glTexImage1D")] + public static extern void TexImage1D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glTexImage2D")] + public static extern void TexImage2D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glTexEnvf")] + public static extern void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glTexEnvfv")] + public static extern void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glTexEnvi")] + public static extern void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glTexEnviv")] + public static extern void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glTexGend")] + public static extern void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLdouble param); + [DllImport("opengl32", EntryPoint = "glTexGendv")] + public static extern void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + [DllImport("opengl32", EntryPoint = "glTexGenf")] + public static extern void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glTexGenfv")] + public static extern void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glTexGeni")] + public static extern void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glTexGeniv")] + public static extern void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glFeedbackBuffer")] + public static extern void FeedbackBuffer(GLsizei size, Enums.FeedbackType type, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] buffer); + [DllImport("opengl32", EntryPoint = "glSelectBuffer")] + public static extern void SelectBuffer(GLsizei size, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffer); + [DllImport("opengl32", EntryPoint = "glRenderMode")] + public static extern GLint RenderMode(Enums.RenderingMode mode); + [DllImport("opengl32", EntryPoint = "glInitNames")] + public static extern void InitNames(); + [DllImport("opengl32", EntryPoint = "glLoadName")] + public static extern void LoadName(GLuint name); + [DllImport("opengl32", EntryPoint = "glPassThrough")] + public static extern void PassThrough(GLfloat token); + [DllImport("opengl32", EntryPoint = "glPopName")] + public static extern void PopName(); + [DllImport("opengl32", EntryPoint = "glPushName")] + public static extern void PushName(GLuint name); + [DllImport("opengl32", EntryPoint = "glDrawBuffer")] + public static extern void DrawBuffer(Enums.DrawBufferMode mode); + [DllImport("opengl32", EntryPoint = "glClear")] + public static extern void Clear(Enums.ClearBufferMask mask); + [DllImport("opengl32", EntryPoint = "glClearAccum")] + public static extern void ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + [DllImport("opengl32", EntryPoint = "glClearIndex")] + public static extern void ClearIndex(GLfloat c); + [DllImport("opengl32", EntryPoint = "glClearColor")] + public static extern void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + [DllImport("opengl32", EntryPoint = "glClearStencil")] + public static extern void ClearStencil(GLint s); + [DllImport("opengl32", EntryPoint = "glClearDepth")] + public static extern void ClearDepth(GLclampd depth); + [DllImport("opengl32", EntryPoint = "glStencilMask")] + public static extern void StencilMask(GLuint mask); + [DllImport("opengl32", EntryPoint = "glColorMask")] + public static extern void ColorMask(Enums.Boolean red, Enums.Boolean green, Enums.Boolean blue, Enums.Boolean alpha); + [DllImport("opengl32", EntryPoint = "glDepthMask")] + public static extern void DepthMask(Enums.Boolean flag); + [DllImport("opengl32", EntryPoint = "glIndexMask")] + public static extern void IndexMask(GLuint mask); + [DllImport("opengl32", EntryPoint = "glAccum")] + public static extern void Accum(Enums.AccumOp op, GLfloat value); + [DllImport("opengl32", EntryPoint = "glDisable")] + public static extern void Disable(Enums.EnableCap cap); + [DllImport("opengl32", EntryPoint = "glEnable")] + public static extern void Enable(Enums.EnableCap cap); + [DllImport("opengl32", EntryPoint = "glFinish")] + public static extern void Finish(); + [DllImport("opengl32", EntryPoint = "glFlush")] + public static extern void Flush(); + [DllImport("opengl32", EntryPoint = "glPopAttrib")] + public static extern void PopAttrib(); + [DllImport("opengl32", EntryPoint = "glPushAttrib")] + public static extern void PushAttrib(Enums.AttribMask mask); + [DllImport("opengl32", EntryPoint = "glMap1d")] + public static extern void Map1d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] points); + [DllImport("opengl32", EntryPoint = "glMap1f")] + public static extern void Map1f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + [DllImport("opengl32", EntryPoint = "glMap2d")] + public static extern void Map2d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] points); + [DllImport("opengl32", EntryPoint = "glMap2f")] + public static extern void Map2f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] points); + [DllImport("opengl32", EntryPoint = "glMapGrid1d")] + public static extern void MapGrid1d(GLint un, GLdouble u1, GLdouble u2); + [DllImport("opengl32", EntryPoint = "glMapGrid1f")] + public static extern void MapGrid1f(GLint un, GLfloat u1, GLfloat u2); + [DllImport("opengl32", EntryPoint = "glMapGrid2d")] + public static extern void MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); + [DllImport("opengl32", EntryPoint = "glMapGrid2f")] + public static extern void MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); + [DllImport("opengl32", EntryPoint = "glEvalCoord1d")] + public static extern void EvalCoord1d(GLdouble u); + [DllImport("opengl32", EntryPoint = "glEvalCoord1dv")] + public static extern void EvalCoord1dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] u); + [DllImport("opengl32", EntryPoint = "glEvalCoord1f")] + public static extern void EvalCoord1f(GLfloat u); + [DllImport("opengl32", EntryPoint = "glEvalCoord1fv")] + public static extern void EvalCoord1fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] u); + [DllImport("opengl32", EntryPoint = "glEvalCoord2d")] + public static extern void EvalCoord2d(GLdouble u, GLdouble v); + [DllImport("opengl32", EntryPoint = "glEvalCoord2dv")] + public static extern void EvalCoord2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] u); + [DllImport("opengl32", EntryPoint = "glEvalCoord2f")] + public static extern void EvalCoord2f(GLfloat u, GLfloat v); + [DllImport("opengl32", EntryPoint = "glEvalCoord2fv")] + public static extern void EvalCoord2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] u); + [DllImport("opengl32", EntryPoint = "glEvalMesh1")] + public static extern void EvalMesh1(Enums.MeshMode1 mode, GLint i1, GLint i2); + [DllImport("opengl32", EntryPoint = "glEvalPoint1")] + public static extern void EvalPoint1(GLint i); + [DllImport("opengl32", EntryPoint = "glEvalMesh2")] + public static extern void EvalMesh2(Enums.MeshMode2 mode, GLint i1, GLint i2, GLint j1, GLint j2); + [DllImport("opengl32", EntryPoint = "glEvalPoint2")] + public static extern void EvalPoint2(GLint i, GLint j); + [DllImport("opengl32", EntryPoint = "glAlphaFunc")] + public static extern void AlphaFunc(Enums.AlphaFunction func, GLclampf reference); + [DllImport("opengl32", EntryPoint = "glBlendFunc")] + public static extern void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor); + [DllImport("opengl32", EntryPoint = "glLogicOp")] + public static extern void LogicOp(Enums.LogicOp opcode); + [DllImport("opengl32", EntryPoint = "glStencilFunc")] + public static extern void StencilFunc(Enums.StencilFunction func, GLint reference, GLuint mask); + [DllImport("opengl32", EntryPoint = "glStencilOp")] + public static extern void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass); + [DllImport("opengl32", EntryPoint = "glDepthFunc")] + public static extern void DepthFunc(Enums.DepthFunction func); + [DllImport("opengl32", EntryPoint = "glPixelZoom")] + public static extern void PixelZoom(GLfloat xfactor, GLfloat yfactor); + [DllImport("opengl32", EntryPoint = "glPixelTransferf")] + public static extern void PixelTransferf(Enums.PixelTransferParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glPixelTransferi")] + public static extern void PixelTransferi(Enums.PixelTransferParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glPixelStoref")] + public static extern void PixelStoref(Enums.PixelStoreParameter pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glPixelStorei")] + public static extern void PixelStorei(Enums.PixelStoreParameter pname, GLint param); + [DllImport("opengl32", EntryPoint = "glPixelMapfv")] + public static extern void PixelMapfv(Enums.PixelMap map, GLint mapsize, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] values); + [DllImport("opengl32", EntryPoint = "glPixelMapuiv")] + public static extern void PixelMapuiv(Enums.PixelMap map, GLint mapsize, [MarshalAs(UnmanagedType.LPArray)] GLuint[] values); + [DllImport("opengl32", EntryPoint = "glPixelMapusv")] + public static extern void PixelMapusv(Enums.PixelMap map, GLint mapsize, [MarshalAs(UnmanagedType.LPArray)] GLushort[] values); + [DllImport("opengl32", EntryPoint = "glReadBuffer")] + public static extern void ReadBuffer(Enums.ReadBufferMode mode); + [DllImport("opengl32", EntryPoint = "glCopyPixels")] + public static extern void CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelCopyType type); + [DllImport("opengl32", EntryPoint = "glReadPixels")] + public static extern void ReadPixels_(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, out IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glDrawPixels")] + public static extern void DrawPixels_(GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glGetBooleanv")] + public static extern void GetBooleanv(Enums.GetPName pname, Enums.Boolean[] parameters); + [DllImport("opengl32", EntryPoint = "glGetClipPlane")] + public static extern void GetClipPlane(Enums.ClipPlaneName plane, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] equation); + [DllImport("opengl32", EntryPoint = "glGetDoublev")] + public static extern void GetDoublev(Enums.GetPName pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + [DllImport("opengl32", EntryPoint = "glGetError")] + public static extern GLenum GetError(); + [DllImport("opengl32", EntryPoint = "glGetFloatv")] + public static extern void GetFloatv(Enums.GetPName pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetIntegerv")] + public static extern void GetIntegerv(Enums.GetPName pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetLightfv")] + public static extern void GetLightfv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetLightiv")] + public static extern void GetLightiv(Enums.LightName light, Enums.LightParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetMapdv")] + public static extern void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glGetMapfv")] + public static extern void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glGetMapiv")] + public static extern void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glGetMaterialfv")] + public static extern void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetMaterialiv")] + public static extern void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetPixelMapfv")] + public static extern void GetPixelMapfv(Enums.PixelMap map, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] values); + [DllImport("opengl32", EntryPoint = "glGetPixelMapuiv")] + public static extern void GetPixelMapuiv(Enums.PixelMap map, [MarshalAs(UnmanagedType.LPArray)] GLuint[] values); + [DllImport("opengl32", EntryPoint = "glGetPixelMapusv")] + public static extern void GetPixelMapusv(Enums.PixelMap map, [MarshalAs(UnmanagedType.LPArray)] GLushort[] values); + [DllImport("opengl32", EntryPoint = "glGetPolygonStipple")] + public static extern void GetPolygonStipple([MarshalAs(UnmanagedType.LPArray)] GLubyte[] mask); + [DllImport("opengl32", EntryPoint = "glGetString")] + public static extern GLstring GetString(Enums.StringName name); + [DllImport("opengl32", EntryPoint = "glGetTexEnvfv")] + public static extern void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexEnviv")] + public static extern void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexGendv")] + public static extern void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexGenfv")] + public static extern void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexGeniv")] + public static extern void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexImage")] + public static extern void GetTexImage(Enums.TextureTarget target, GLint level, Enums.PixelFormat format, Enums.PixelType type, out IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glGetTexParameterfv")] + public static extern void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexParameteriv")] + public static extern void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexLevelParameterfv")] + public static extern void GetTexLevelParameterfv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetTexLevelParameteriv")] + public static extern void GetTexLevelParameteriv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glIsEnabled")] + public static extern GLboolean IsEnabled(Enums.EnableCap cap); + [DllImport("opengl32", EntryPoint = "glIsList")] + public static extern GLboolean IsList(GLuint list); + [DllImport("opengl32", EntryPoint = "glDepthRange")] + public static extern void DepthRange(GLclampd near, GLclampd far); + [DllImport("opengl32", EntryPoint = "glFrustum")] + public static extern void Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + [DllImport("opengl32", EntryPoint = "glLoadIdentity")] + public static extern void LoadIdentity(); + [DllImport("opengl32", EntryPoint = "glLoadMatrixf")] + public static extern void LoadMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + [DllImport("opengl32", EntryPoint = "glLoadMatrixd")] + public static extern void LoadMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + [DllImport("opengl32", EntryPoint = "glMatrixMode")] + public static extern void MatrixMode(Enums.MatrixMode mode); + [DllImport("opengl32", EntryPoint = "glMultMatrixf")] + public static extern void MultMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + [DllImport("opengl32", EntryPoint = "glMultMatrixd")] + public static extern void MultMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + [DllImport("opengl32", EntryPoint = "glOrtho")] + public static extern void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); + [DllImport("opengl32", EntryPoint = "glPopMatrix")] + public static extern void PopMatrix(); + [DllImport("opengl32", EntryPoint = "glPushMatrix")] + public static extern void PushMatrix(); + [DllImport("opengl32", EntryPoint = "glRotated")] + public static extern void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); + [DllImport("opengl32", EntryPoint = "glRotatef")] + public static extern void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); + [DllImport("opengl32", EntryPoint = "glScaled")] + public static extern void Scaled(GLdouble x, GLdouble y, GLdouble z); + [DllImport("opengl32", EntryPoint = "glScalef")] + public static extern void Scalef(GLfloat x, GLfloat y, GLfloat z); + [DllImport("opengl32", EntryPoint = "glTranslated")] + public static extern void Translated(GLdouble x, GLdouble y, GLdouble z); + [DllImport("opengl32", EntryPoint = "glTranslatef")] + public static extern void Translatef(GLfloat x, GLfloat y, GLfloat z); + [DllImport("opengl32", EntryPoint = "glViewport")] + public static extern void Viewport(GLint x, GLint y, GLsizei width, GLsizei height); + [DllImport("opengl32", EntryPoint = "glArrayElement")] + public static extern void ArrayElement(GLint i); + [DllImport("opengl32", EntryPoint = "glColorPointer")] + public static extern void ColorPointer_(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glDisableClientState")] + public static extern void DisableClientState(Enums.EnableCap array); + [DllImport("opengl32", EntryPoint = "glDrawArrays")] + public static extern void DrawArrays(Enums.BeginMode mode, GLint first, GLsizei count); + [DllImport("opengl32", EntryPoint = "glDrawElements")] + public static extern void DrawElements_(Enums.BeginMode mode, GLsizei count, GLenum type, IntPtr indices); + [DllImport("opengl32", EntryPoint = "glEdgeFlagPointer")] + public static extern void EdgeFlagPointer_(GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glEnableClientState")] + public static extern void EnableClientState(Enums.EnableCap array); + [DllImport("opengl32", EntryPoint = "glGetPointerv")] + public static extern void GetPointerv(Enums.GetPointervPName pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] parameters); + [DllImport("opengl32", EntryPoint = "glIndexPointer")] + public static extern void IndexPointer_(Enums.IndexPointerType type, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glInterleavedArrays")] + public static extern void InterleavedArrays_(Enums.InterleavedArrayFormat format, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glNormalPointer")] + public static extern void NormalPointer_(Enums.NormalPointerType type, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glTexCoordPointer")] + public static extern void TexCoordPointer_(GLint size, Enums.TexCoordPointerType type, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glVertexPointer")] + public static extern void VertexPointer_(GLint size, Enums.VertexPointerType type, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glPolygonOffset")] + public static extern void PolygonOffset(GLfloat factor, GLfloat units); + [DllImport("opengl32", EntryPoint = "glCopyTexImage1D")] + public static extern void CopyTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border); + [DllImport("opengl32", EntryPoint = "glCopyTexImage2D")] + public static extern void CopyTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + [DllImport("opengl32", EntryPoint = "glCopyTexSubImage1D")] + public static extern void CopyTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + [DllImport("opengl32", EntryPoint = "glCopyTexSubImage2D")] + public static extern void CopyTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + [DllImport("opengl32", EntryPoint = "glTexSubImage1D")] + public static extern void TexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glTexSubImage2D")] + public static extern void TexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glAreTexturesResident")] + public static extern GLboolean AreTexturesResident(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures, Enums.Boolean[] residences); + [DllImport("opengl32", EntryPoint = "glBindTexture")] + public static extern void BindTexture(Enums.TextureTarget target, GLuint texture); + [DllImport("opengl32", EntryPoint = "glDeleteTextures")] + public static extern void DeleteTextures(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures); + [DllImport("opengl32", EntryPoint = "glGenTextures")] + public static extern void GenTextures(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures); + [DllImport("opengl32", EntryPoint = "glIsTexture")] + public static extern GLboolean IsTexture(GLuint texture); + [DllImport("opengl32", EntryPoint = "glPrioritizeTextures")] + public static extern void PrioritizeTextures(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] textures, [MarshalAs(UnmanagedType.LPArray)] GLclampf[] priorities); + [DllImport("opengl32", EntryPoint = "glIndexub")] + public static extern void Indexub(GLubyte c); + [DllImport("opengl32", EntryPoint = "glIndexubv")] + public static extern void Indexubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] c); + [DllImport("opengl32", EntryPoint = "glPopClientAttrib")] + public static extern void PopClientAttrib(); + [DllImport("opengl32", EntryPoint = "glPushClientAttrib")] + public static extern void PushClientAttrib(Enums.ClientAttribMask mask); + [DllImport("opengl32", EntryPoint = "glBlendColor")] + public static extern void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + [DllImport("opengl32", EntryPoint = "glBlendEquation")] + public static extern void BlendEquation(GLenum mode); + [DllImport("opengl32", EntryPoint = "glDrawRangeElements")] + public static extern void DrawRangeElements_(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, IntPtr indices); + [DllImport("opengl32", EntryPoint = "glColorTable")] + public static extern void ColorTable_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr table); + [DllImport("opengl32", EntryPoint = "glColorTableParameterfv")] + public static extern void ColorTableParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glColorTableParameteriv")] + public static extern void ColorTableParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glCopyColorTable")] + public static extern void CopyColorTable(GLenum target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width); + [DllImport("opengl32", EntryPoint = "glGetColorTable")] + public static extern void GetColorTable_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr table); + [DllImport("opengl32", EntryPoint = "glGetColorTableParameterfv")] + public static extern void GetColorTableParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetColorTableParameteriv")] + public static extern void GetColorTableParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glColorSubTable")] + public static extern void ColorSubTable_(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, IntPtr data); + [DllImport("opengl32", EntryPoint = "glCopyColorSubTable")] + public static extern void CopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + [DllImport("opengl32", EntryPoint = "glConvolutionFilter1D")] + public static extern void ConvolutionFilter1D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, IntPtr image); + [DllImport("opengl32", EntryPoint = "glConvolutionFilter2D")] + public static extern void ConvolutionFilter2D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr image); + [DllImport("opengl32", EntryPoint = "glConvolutionParameterf")] + public static extern void ConvolutionParameterf(GLenum target, GLenum pname, GLfloat parameters); + [DllImport("opengl32", EntryPoint = "glConvolutionParameterfv")] + public static extern void ConvolutionParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glConvolutionParameteri")] + public static extern void ConvolutionParameteri(GLenum target, GLenum pname, GLint parameters); + [DllImport("opengl32", EntryPoint = "glConvolutionParameteriv")] + public static extern void ConvolutionParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glCopyConvolutionFilter1D")] + public static extern void CopyConvolutionFilter1D(GLenum target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width); + [DllImport("opengl32", EntryPoint = "glCopyConvolutionFilter2D")] + public static extern void CopyConvolutionFilter2D(GLenum target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height); + [DllImport("opengl32", EntryPoint = "glGetConvolutionFilter")] + public static extern void GetConvolutionFilter_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr image); + [DllImport("opengl32", EntryPoint = "glGetConvolutionParameterfv")] + public static extern void GetConvolutionParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetConvolutionParameteriv")] + public static extern void GetConvolutionParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetSeparableFilter")] + public static extern void GetSeparableFilter_(GLenum target, Enums.PixelFormat format, Enums.PixelType type, out IntPtr row, out IntPtr column, out IntPtr span); + [DllImport("opengl32", EntryPoint = "glSeparableFilter2D")] + public static extern void SeparableFilter2D_(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, IntPtr row, IntPtr column); + [DllImport("opengl32", EntryPoint = "glGetHistogram")] + public static extern void GetHistogram_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, out IntPtr values); + [DllImport("opengl32", EntryPoint = "glGetHistogramParameterfv")] + public static extern void GetHistogramParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetHistogramParameteriv")] + public static extern void GetHistogramParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetMinmax")] + public static extern void GetMinmax_(GLenum target, Enums.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, out IntPtr values); + [DllImport("opengl32", EntryPoint = "glGetMinmaxParameterfv")] + public static extern void GetMinmaxParameterfv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetMinmaxParameteriv")] + public static extern void GetMinmaxParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glHistogram")] + public static extern void Histogram(GLenum target, GLsizei width, Enums.PixelInternalFormat internalformat, Enums.Boolean sink); + [DllImport("opengl32", EntryPoint = "glMinmax")] + public static extern void Minmax(GLenum target, Enums.PixelInternalFormat internalformat, Enums.Boolean sink); + [DllImport("opengl32", EntryPoint = "glResetHistogram")] + public static extern void ResetHistogram(GLenum target); + [DllImport("opengl32", EntryPoint = "glResetMinmax")] + public static extern void ResetMinmax(GLenum target); + [DllImport("opengl32", EntryPoint = "glTexImage3D")] + public static extern void TexImage3D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glTexSubImage3D")] + public static extern void TexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, Enums.PixelType type, IntPtr pixels); + [DllImport("opengl32", EntryPoint = "glCopyTexSubImage3D")] + public static extern void CopyTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + [DllImport("opengl32", EntryPoint = "glActiveTexture")] + public static extern void ActiveTexture(GLenum texture); + [DllImport("opengl32", EntryPoint = "glClientActiveTexture")] + public static extern void ClientActiveTexture(GLenum texture); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1d")] + public static extern void MultiTexCoord1d(GLenum target, GLdouble s); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1dv")] + public static extern void MultiTexCoord1dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1f")] + public static extern void MultiTexCoord1f(GLenum target, GLfloat s); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1fv")] + public static extern void MultiTexCoord1fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1i")] + public static extern void MultiTexCoord1i(GLenum target, GLint s); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1iv")] + public static extern void MultiTexCoord1iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1s")] + public static extern void MultiTexCoord1s(GLenum target, GLshort s); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord1sv")] + public static extern void MultiTexCoord1sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2d")] + public static extern void MultiTexCoord2d(GLenum target, GLdouble s, GLdouble t); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2dv")] + public static extern void MultiTexCoord2dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2f")] + public static extern void MultiTexCoord2f(GLenum target, GLfloat s, GLfloat t); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2fv")] + public static extern void MultiTexCoord2fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2i")] + public static extern void MultiTexCoord2i(GLenum target, GLint s, GLint t); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2iv")] + public static extern void MultiTexCoord2iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2s")] + public static extern void MultiTexCoord2s(GLenum target, GLshort s, GLshort t); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord2sv")] + public static extern void MultiTexCoord2sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3d")] + public static extern void MultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3dv")] + public static extern void MultiTexCoord3dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3f")] + public static extern void MultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3fv")] + public static extern void MultiTexCoord3fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3i")] + public static extern void MultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3iv")] + public static extern void MultiTexCoord3iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3s")] + public static extern void MultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord3sv")] + public static extern void MultiTexCoord3sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4d")] + public static extern void MultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4dv")] + public static extern void MultiTexCoord4dv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4f")] + public static extern void MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4fv")] + public static extern void MultiTexCoord4fv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4i")] + public static extern void MultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4iv")] + public static extern void MultiTexCoord4iv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4s")] + public static extern void MultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); + [DllImport("opengl32", EntryPoint = "glMultiTexCoord4sv")] + public static extern void MultiTexCoord4sv(GLenum target, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glLoadTransposeMatrixf")] + public static extern void LoadTransposeMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + [DllImport("opengl32", EntryPoint = "glLoadTransposeMatrixd")] + public static extern void LoadTransposeMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + [DllImport("opengl32", EntryPoint = "glMultTransposeMatrixf")] + public static extern void MultTransposeMatrixf([MarshalAs(UnmanagedType.LPArray)] GLfloat[] m); + [DllImport("opengl32", EntryPoint = "glMultTransposeMatrixd")] + public static extern void MultTransposeMatrixd([MarshalAs(UnmanagedType.LPArray)] GLdouble[] m); + [DllImport("opengl32", EntryPoint = "glSampleCoverage")] + public static extern void SampleCoverage(GLclampf value, Enums.Boolean invert); + [DllImport("opengl32", EntryPoint = "glCompressedTexImage3D")] + public static extern void CompressedTexImage3D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, IntPtr data); + [DllImport("opengl32", EntryPoint = "glCompressedTexImage2D")] + public static extern void CompressedTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, IntPtr data); + [DllImport("opengl32", EntryPoint = "glCompressedTexImage1D")] + public static extern void CompressedTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, IntPtr data); + [DllImport("opengl32", EntryPoint = "glCompressedTexSubImage3D")] + public static extern void CompressedTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + [DllImport("opengl32", EntryPoint = "glCompressedTexSubImage2D")] + public static extern void CompressedTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + [DllImport("opengl32", EntryPoint = "glCompressedTexSubImage1D")] + public static extern void CompressedTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, IntPtr data); + [DllImport("opengl32", EntryPoint = "glGetCompressedTexImage")] + public static extern void GetCompressedTexImage(Enums.TextureTarget target, GLint level, out IntPtr img); + [DllImport("opengl32", EntryPoint = "glBlendFuncSeparate")] + public static extern void BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + [DllImport("opengl32", EntryPoint = "glFogCoordf")] + public static extern void FogCoordf(GLfloat coord); + [DllImport("opengl32", EntryPoint = "glFogCoordfv")] + public static extern void FogCoordfv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] coord); + [DllImport("opengl32", EntryPoint = "glFogCoordd")] + public static extern void FogCoordd(GLdouble coord); + [DllImport("opengl32", EntryPoint = "glFogCoorddv")] + public static extern void FogCoorddv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] coord); + [DllImport("opengl32", EntryPoint = "glFogCoordPointer")] + public static extern void FogCoordPointer_(GLenum type, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glMultiDrawArrays")] + public static extern void MultiDrawArrays(Enums.BeginMode mode, [MarshalAs(UnmanagedType.LPArray)] GLint[] first, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLsizei primcount); + [DllImport("opengl32", EntryPoint = "glMultiDrawElements")] + public static extern void MultiDrawElements(Enums.BeginMode mode, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, GLenum type, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] indices, GLsizei primcount); + [DllImport("opengl32", EntryPoint = "glPointParameterf")] + public static extern void PointParameterf(GLenum pname, GLfloat param); + [DllImport("opengl32", EntryPoint = "glPointParameterfv")] + public static extern void PointParameterfv(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glPointParameteri")] + public static extern void PointParameteri(GLenum pname, GLint param); + [DllImport("opengl32", EntryPoint = "glPointParameteriv")] + public static extern void PointParameteriv(GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3b")] + public static extern void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3bv")] + public static extern void SecondaryColor3bv([MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3d")] + public static extern void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3dv")] + public static extern void SecondaryColor3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3f")] + public static extern void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3fv")] + public static extern void SecondaryColor3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3i")] + public static extern void SecondaryColor3i(GLint red, GLint green, GLint blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3iv")] + public static extern void SecondaryColor3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3s")] + public static extern void SecondaryColor3s(GLshort red, GLshort green, GLshort blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3sv")] + public static extern void SecondaryColor3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3ub")] + public static extern void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3ubv")] + public static extern void SecondaryColor3ubv([MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3ui")] + public static extern void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3uiv")] + public static extern void SecondaryColor3uiv([MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3us")] + public static extern void SecondaryColor3us(GLushort red, GLushort green, GLushort blue); + [DllImport("opengl32", EntryPoint = "glSecondaryColor3usv")] + public static extern void SecondaryColor3usv([MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + [DllImport("opengl32", EntryPoint = "glSecondaryColorPointer")] + public static extern void SecondaryColorPointer_(GLint size, Enums.ColorPointerType type, GLsizei stride, IntPtr pointer); + [DllImport("opengl32", EntryPoint = "glWindowPos2d")] + public static extern void WindowPos2d(GLdouble x, GLdouble y); + [DllImport("opengl32", EntryPoint = "glWindowPos2dv")] + public static extern void WindowPos2dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glWindowPos2f")] + public static extern void WindowPos2f(GLfloat x, GLfloat y); + [DllImport("opengl32", EntryPoint = "glWindowPos2fv")] + public static extern void WindowPos2fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glWindowPos2i")] + public static extern void WindowPos2i(GLint x, GLint y); + [DllImport("opengl32", EntryPoint = "glWindowPos2iv")] + public static extern void WindowPos2iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glWindowPos2s")] + public static extern void WindowPos2s(GLshort x, GLshort y); + [DllImport("opengl32", EntryPoint = "glWindowPos2sv")] + public static extern void WindowPos2sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glWindowPos3d")] + public static extern void WindowPos3d(GLdouble x, GLdouble y, GLdouble z); + [DllImport("opengl32", EntryPoint = "glWindowPos3dv")] + public static extern void WindowPos3dv([MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glWindowPos3f")] + public static extern void WindowPos3f(GLfloat x, GLfloat y, GLfloat z); + [DllImport("opengl32", EntryPoint = "glWindowPos3fv")] + public static extern void WindowPos3fv([MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glWindowPos3i")] + public static extern void WindowPos3i(GLint x, GLint y, GLint z); + [DllImport("opengl32", EntryPoint = "glWindowPos3iv")] + public static extern void WindowPos3iv([MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glWindowPos3s")] + public static extern void WindowPos3s(GLshort x, GLshort y, GLshort z); + [DllImport("opengl32", EntryPoint = "glWindowPos3sv")] + public static extern void WindowPos3sv([MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glGenQueries")] + public static extern void GenQueries(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + [DllImport("opengl32", EntryPoint = "glDeleteQueries")] + public static extern void DeleteQueries(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] ids); + [DllImport("opengl32", EntryPoint = "glIsQuery")] + public static extern GLboolean IsQuery(GLuint id); + [DllImport("opengl32", EntryPoint = "glBeginQuery")] + public static extern void BeginQuery(GLenum target, GLuint id); + [DllImport("opengl32", EntryPoint = "glEndQuery")] + public static extern void EndQuery(GLenum target); + [DllImport("opengl32", EntryPoint = "glGetQueryiv")] + public static extern void GetQueryiv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetQueryObjectiv")] + public static extern void GetQueryObjectiv(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetQueryObjectuiv")] + public static extern void GetQueryObjectuiv(GLuint id, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLuint[] parameters); + [DllImport("opengl32", EntryPoint = "glBindBuffer")] + public static extern void BindBuffer(GLenum target, GLuint buffer); + [DllImport("opengl32", EntryPoint = "glDeleteBuffers")] + public static extern void DeleteBuffers(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffers); + [DllImport("opengl32", EntryPoint = "glGenBuffers")] + public static extern void GenBuffers(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLuint[] buffers); + [DllImport("opengl32", EntryPoint = "glIsBuffer")] + public static extern GLboolean IsBuffer(GLuint buffer); + [DllImport("opengl32", EntryPoint = "glBufferData")] + public static extern void BufferData_(GLenum target, GLsizeiptr size, IntPtr data, GLenum usage); + [DllImport("opengl32", EntryPoint = "glBufferSubData")] + public static extern void BufferSubData_(GLenum target, GLintptr offset, GLsizeiptr size, IntPtr data); + [DllImport("opengl32", EntryPoint = "glGetBufferSubData")] + public static extern void GetBufferSubData_(GLenum target, GLintptr offset, GLsizeiptr size, out IntPtr data); + [DllImport("opengl32", EntryPoint = "glMapBuffer")] + public static extern IntPtr MapBuffer_(GLenum target, GLenum access); + [DllImport("opengl32", EntryPoint = "glUnmapBuffer")] + public static extern GLboolean UnmapBuffer(GLenum target); + [DllImport("opengl32", EntryPoint = "glGetBufferParameteriv")] + public static extern void GetBufferParameteriv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetBufferPointerv")] + public static extern void GetBufferPointerv(GLenum target, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] parameters); + [DllImport("opengl32", EntryPoint = "glBlendEquationSeparate")] + public static extern void BlendEquationSeparate(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha); + [DllImport("opengl32", EntryPoint = "glDrawBuffers")] + public static extern void DrawBuffers(GLsizei n, [MarshalAs(UnmanagedType.LPArray)] GLenum[] bufs); + [DllImport("opengl32", EntryPoint = "glStencilOpSeparate")] + public static extern void StencilOpSeparate(GLenum face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass); + [DllImport("opengl32", EntryPoint = "glStencilFuncSeparate")] + public static extern void StencilFuncSeparate(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint reference, GLuint mask); + [DllImport("opengl32", EntryPoint = "glStencilMaskSeparate")] + public static extern void StencilMaskSeparate(GLenum face, GLuint mask); + [DllImport("opengl32", EntryPoint = "glAttachShader")] + public static extern void AttachShader(GLuint program, GLuint shader); + [DllImport("opengl32", EntryPoint = "glBindAttribLocation")] + public static extern void BindAttribLocation(GLuint program, GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + [DllImport("opengl32", EntryPoint = "glCompileShader")] + public static extern void CompileShader(GLuint shader); + [DllImport("opengl32", EntryPoint = "glCreateProgram")] + public static extern GLuint CreateProgram(); + [DllImport("opengl32", EntryPoint = "glCreateShader")] + public static extern GLuint CreateShader(GLenum type); + [DllImport("opengl32", EntryPoint = "glDeleteProgram")] + public static extern void DeleteProgram(GLuint program); + [DllImport("opengl32", EntryPoint = "glDeleteShader")] + public static extern void DeleteShader(GLuint shader); + [DllImport("opengl32", EntryPoint = "glDetachShader")] + public static extern void DetachShader(GLuint program, GLuint shader); + [DllImport("opengl32", EntryPoint = "glDisableVertexAttribArray")] + public static extern void DisableVertexAttribArray(GLuint index); + [DllImport("opengl32", EntryPoint = "glEnableVertexAttribArray")] + public static extern void EnableVertexAttribArray(GLuint index); + [DllImport("opengl32", EntryPoint = "glGetActiveAttrib")] + public static extern void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLint[] size, [MarshalAs(UnmanagedType.LPArray)] GLenum[] type, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + [DllImport("opengl32", EntryPoint = "glGetActiveUniform")] + public static extern void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLint[] size, [MarshalAs(UnmanagedType.LPArray)] GLenum[] type, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + [DllImport("opengl32", EntryPoint = "glGetAttachedShaders")] + public static extern void GetAttachedShaders(GLuint program, GLsizei maxCount, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] count, [MarshalAs(UnmanagedType.LPArray)] GLuint[] obj); + [DllImport("opengl32", EntryPoint = "glGetAttribLocation")] + public static extern GLint GetAttribLocation(GLuint program, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + [DllImport("opengl32", EntryPoint = "glGetProgramiv")] + public static extern void GetProgramiv(GLuint program, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetProgramInfoLog")] + public static extern void GetProgramInfoLog(GLuint program, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLchar[] infoLog); + [DllImport("opengl32", EntryPoint = "glGetShaderiv")] + public static extern void GetShaderiv(GLuint shader, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetShaderInfoLog")] + public static extern void GetShaderInfoLog(GLuint shader, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLchar[] infoLog); + [DllImport("opengl32", EntryPoint = "glGetShaderSource")] + public static extern void GetShaderSource(GLuint shader, GLsizei bufSize, [MarshalAs(UnmanagedType.LPArray)] GLsizei[] length, [MarshalAs(UnmanagedType.LPArray)] GLchar[] source); + [DllImport("opengl32", EntryPoint = "glGetUniformLocation")] + public static extern GLint GetUniformLocation(GLuint program, [MarshalAs(UnmanagedType.LPArray)] GLchar[] name); + [DllImport("opengl32", EntryPoint = "glGetUniformfv")] + public static extern void GetUniformfv(GLuint program, GLint location, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetUniformiv")] + public static extern void GetUniformiv(GLuint program, GLint location, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetVertexAttribdv")] + public static extern void GetVertexAttribdv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] parameters); + [DllImport("opengl32", EntryPoint = "glGetVertexAttribfv")] + public static extern void GetVertexAttribfv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] parameters); + [DllImport("opengl32", EntryPoint = "glGetVertexAttribiv")] + public static extern void GetVertexAttribiv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] GLint[] parameters); + [DllImport("opengl32", EntryPoint = "glGetVertexAttribPointerv")] + public static extern void GetVertexAttribPointerv(GLuint index, GLenum pname, [MarshalAs(UnmanagedType.LPArray)] IntPtr[] pointer); + [DllImport("opengl32", EntryPoint = "glIsProgram")] + public static extern GLboolean IsProgram(GLuint program); + [DllImport("opengl32", EntryPoint = "glIsShader")] + public static extern GLboolean IsShader(GLuint shader); + [DllImport("opengl32", EntryPoint = "glLinkProgram")] + public static extern void LinkProgram(GLuint program); + [DllImport("opengl32", EntryPoint = "glShaderSource")] + public static extern void ShaderSource(GLuint shader, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] string[] @string, [MarshalAs(UnmanagedType.LPArray)] GLint[] length); + [DllImport("opengl32", EntryPoint = "glUseProgram")] + public static extern void UseProgram(GLuint program); + [DllImport("opengl32", EntryPoint = "glUniform1f")] + public static extern void Uniform1f(GLint location, GLfloat v0); + [DllImport("opengl32", EntryPoint = "glUniform2f")] + public static extern void Uniform2f(GLint location, GLfloat v0, GLfloat v1); + [DllImport("opengl32", EntryPoint = "glUniform3f")] + public static extern void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); + [DllImport("opengl32", EntryPoint = "glUniform4f")] + public static extern void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + [DllImport("opengl32", EntryPoint = "glUniform1i")] + public static extern void Uniform1i(GLint location, GLint v0); + [DllImport("opengl32", EntryPoint = "glUniform2i")] + public static extern void Uniform2i(GLint location, GLint v0, GLint v1); + [DllImport("opengl32", EntryPoint = "glUniform3i")] + public static extern void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2); + [DllImport("opengl32", EntryPoint = "glUniform4i")] + public static extern void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); + [DllImport("opengl32", EntryPoint = "glUniform1fv")] + public static extern void Uniform1fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + [DllImport("opengl32", EntryPoint = "glUniform2fv")] + public static extern void Uniform2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + [DllImport("opengl32", EntryPoint = "glUniform3fv")] + public static extern void Uniform3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + [DllImport("opengl32", EntryPoint = "glUniform4fv")] + public static extern void Uniform4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + [DllImport("opengl32", EntryPoint = "glUniform1iv")] + public static extern void Uniform1iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + [DllImport("opengl32", EntryPoint = "glUniform2iv")] + public static extern void Uniform2iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + [DllImport("opengl32", EntryPoint = "glUniform3iv")] + public static extern void Uniform3iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + [DllImport("opengl32", EntryPoint = "glUniform4iv")] + public static extern void Uniform4iv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.LPArray)] GLint[] value); + [DllImport("opengl32", EntryPoint = "glUniformMatrix2fv")] + public static extern void UniformMatrix2fv(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + [DllImport("opengl32", EntryPoint = "glUniformMatrix3fv")] + public static extern void UniformMatrix3fv(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + [DllImport("opengl32", EntryPoint = "glUniformMatrix4fv")] + public static extern void UniformMatrix4fv(GLint location, GLsizei count, Enums.Boolean transpose, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] value); + [DllImport("opengl32", EntryPoint = "glValidateProgram")] + public static extern void ValidateProgram(GLuint program); + [DllImport("opengl32", EntryPoint = "glVertexAttrib1d")] + public static extern void VertexAttrib1d(GLuint index, GLdouble x); + [DllImport("opengl32", EntryPoint = "glVertexAttrib1dv")] + public static extern void VertexAttrib1dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib1f")] + public static extern void VertexAttrib1f(GLuint index, GLfloat x); + [DllImport("opengl32", EntryPoint = "glVertexAttrib1fv")] + public static extern void VertexAttrib1fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib1s")] + public static extern void VertexAttrib1s(GLuint index, GLshort x); + [DllImport("opengl32", EntryPoint = "glVertexAttrib1sv")] + public static extern void VertexAttrib1sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib2d")] + public static extern void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y); + [DllImport("opengl32", EntryPoint = "glVertexAttrib2dv")] + public static extern void VertexAttrib2dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib2f")] + public static extern void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y); + [DllImport("opengl32", EntryPoint = "glVertexAttrib2fv")] + public static extern void VertexAttrib2fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib2s")] + public static extern void VertexAttrib2s(GLuint index, GLshort x, GLshort y); + [DllImport("opengl32", EntryPoint = "glVertexAttrib2sv")] + public static extern void VertexAttrib2sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib3d")] + public static extern void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z); + [DllImport("opengl32", EntryPoint = "glVertexAttrib3dv")] + public static extern void VertexAttrib3dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib3f")] + public static extern void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z); + [DllImport("opengl32", EntryPoint = "glVertexAttrib3fv")] + public static extern void VertexAttrib3fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib3s")] + public static extern void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z); + [DllImport("opengl32", EntryPoint = "glVertexAttrib3sv")] + public static extern void VertexAttrib3sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4Nbv")] + public static extern void VertexAttrib4Nbv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4Niv")] + public static extern void VertexAttrib4Niv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4Nsv")] + public static extern void VertexAttrib4Nsv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4Nub")] + public static extern void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4Nubv")] + public static extern void VertexAttrib4Nubv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4Nuiv")] + public static extern void VertexAttrib4Nuiv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4Nusv")] + public static extern void VertexAttrib4Nusv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4bv")] + public static extern void VertexAttrib4bv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLbyte[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4d")] + public static extern void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4dv")] + public static extern void VertexAttrib4dv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLdouble[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4f")] + public static extern void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4fv")] + public static extern void VertexAttrib4fv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLfloat[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4iv")] + public static extern void VertexAttrib4iv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLint[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4s")] + public static extern void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4sv")] + public static extern void VertexAttrib4sv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLshort[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4ubv")] + public static extern void VertexAttrib4ubv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLubyte[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4uiv")] + public static extern void VertexAttrib4uiv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLuint[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttrib4usv")] + public static extern void VertexAttrib4usv(GLuint index, [MarshalAs(UnmanagedType.LPArray)] GLushort[] v); + [DllImport("opengl32", EntryPoint = "glVertexAttribPointer")] + public static extern void VertexAttribPointer_(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, IntPtr pointer); + } + #endregion + + #region Function initialisation + + public static Delegates.NewList NewList; + public static Delegates.EndList EndList; + public static Delegates.CallList CallList; + public static Delegates.CallLists_ CallLists_; + public static Delegates.DeleteLists DeleteLists; + public static Delegates.GenLists GenLists; + public static Delegates.ListBase ListBase; + public static Delegates.Begin Begin; + public static Delegates.Bitmap Bitmap; + public static Delegates.Color3b Color3b; + public static Delegates.Color3bv Color3bv; + public static Delegates.Color3d Color3d; + public static Delegates.Color3dv Color3dv; + public static Delegates.Color3f Color3f; + public static Delegates.Color3fv Color3fv; + public static Delegates.Color3i Color3i; + public static Delegates.Color3iv Color3iv; + public static Delegates.Color3s Color3s; + public static Delegates.Color3sv Color3sv; + public static Delegates.Color3ub Color3ub; + public static Delegates.Color3ubv Color3ubv; + public static Delegates.Color3ui Color3ui; + public static Delegates.Color3uiv Color3uiv; + public static Delegates.Color3us Color3us; + public static Delegates.Color3usv Color3usv; + public static Delegates.Color4b Color4b; + public static Delegates.Color4bv Color4bv; + public static Delegates.Color4d Color4d; + public static Delegates.Color4dv Color4dv; + public static Delegates.Color4f Color4f; + public static Delegates.Color4fv Color4fv; + public static Delegates.Color4i Color4i; + public static Delegates.Color4iv Color4iv; + public static Delegates.Color4s Color4s; + public static Delegates.Color4sv Color4sv; + public static Delegates.Color4ub Color4ub; + public static Delegates.Color4ubv Color4ubv; + public static Delegates.Color4ui Color4ui; + public static Delegates.Color4uiv Color4uiv; + public static Delegates.Color4us Color4us; + public static Delegates.Color4usv Color4usv; + public static Delegates.EdgeFlag EdgeFlag; + public static Delegates.EdgeFlagv EdgeFlagv; + public static Delegates.End End; + public static Delegates.Indexd Indexd; + public static Delegates.Indexdv Indexdv; + public static Delegates.Indexf Indexf; + public static Delegates.Indexfv Indexfv; + public static Delegates.Indexi Indexi; + public static Delegates.Indexiv Indexiv; + public static Delegates.Indexs Indexs; + public static Delegates.Indexsv Indexsv; + public static Delegates.Normal3b Normal3b; + public static Delegates.Normal3bv Normal3bv; + public static Delegates.Normal3d Normal3d; + public static Delegates.Normal3dv Normal3dv; + public static Delegates.Normal3f Normal3f; + public static Delegates.Normal3fv Normal3fv; + public static Delegates.Normal3i Normal3i; + public static Delegates.Normal3iv Normal3iv; + public static Delegates.Normal3s Normal3s; + public static Delegates.Normal3sv Normal3sv; + public static Delegates.RasterPos2d RasterPos2d; + public static Delegates.RasterPos2dv RasterPos2dv; + public static Delegates.RasterPos2f RasterPos2f; + public static Delegates.RasterPos2fv RasterPos2fv; + public static Delegates.RasterPos2i RasterPos2i; + public static Delegates.RasterPos2iv RasterPos2iv; + public static Delegates.RasterPos2s RasterPos2s; + public static Delegates.RasterPos2sv RasterPos2sv; + public static Delegates.RasterPos3d RasterPos3d; + public static Delegates.RasterPos3dv RasterPos3dv; + public static Delegates.RasterPos3f RasterPos3f; + public static Delegates.RasterPos3fv RasterPos3fv; + public static Delegates.RasterPos3i RasterPos3i; + public static Delegates.RasterPos3iv RasterPos3iv; + public static Delegates.RasterPos3s RasterPos3s; + public static Delegates.RasterPos3sv RasterPos3sv; + public static Delegates.RasterPos4d RasterPos4d; + public static Delegates.RasterPos4dv RasterPos4dv; + public static Delegates.RasterPos4f RasterPos4f; + public static Delegates.RasterPos4fv RasterPos4fv; + public static Delegates.RasterPos4i RasterPos4i; + public static Delegates.RasterPos4iv RasterPos4iv; + public static Delegates.RasterPos4s RasterPos4s; + public static Delegates.RasterPos4sv RasterPos4sv; + public static Delegates.Rectd Rectd; + public static Delegates.Rectdv Rectdv; + public static Delegates.Rectf Rectf; + public static Delegates.Rectfv Rectfv; + public static Delegates.Recti Recti; + public static Delegates.Rectiv Rectiv; + public static Delegates.Rects Rects; + public static Delegates.Rectsv Rectsv; + public static Delegates.TexCoord1d TexCoord1d; + public static Delegates.TexCoord1dv TexCoord1dv; + public static Delegates.TexCoord1f TexCoord1f; + public static Delegates.TexCoord1fv TexCoord1fv; + public static Delegates.TexCoord1i TexCoord1i; + public static Delegates.TexCoord1iv TexCoord1iv; + public static Delegates.TexCoord1s TexCoord1s; + public static Delegates.TexCoord1sv TexCoord1sv; + public static Delegates.TexCoord2d TexCoord2d; + public static Delegates.TexCoord2dv TexCoord2dv; + public static Delegates.TexCoord2f TexCoord2f; + public static Delegates.TexCoord2fv TexCoord2fv; + public static Delegates.TexCoord2i TexCoord2i; + public static Delegates.TexCoord2iv TexCoord2iv; + public static Delegates.TexCoord2s TexCoord2s; + public static Delegates.TexCoord2sv TexCoord2sv; + public static Delegates.TexCoord3d TexCoord3d; + public static Delegates.TexCoord3dv TexCoord3dv; + public static Delegates.TexCoord3f TexCoord3f; + public static Delegates.TexCoord3fv TexCoord3fv; + public static Delegates.TexCoord3i TexCoord3i; + public static Delegates.TexCoord3iv TexCoord3iv; + public static Delegates.TexCoord3s TexCoord3s; + public static Delegates.TexCoord3sv TexCoord3sv; + public static Delegates.TexCoord4d TexCoord4d; + public static Delegates.TexCoord4dv TexCoord4dv; + public static Delegates.TexCoord4f TexCoord4f; + public static Delegates.TexCoord4fv TexCoord4fv; + public static Delegates.TexCoord4i TexCoord4i; + public static Delegates.TexCoord4iv TexCoord4iv; + public static Delegates.TexCoord4s TexCoord4s; + public static Delegates.TexCoord4sv TexCoord4sv; + public static Delegates.Vertex2d Vertex2d; + public static Delegates.Vertex2dv Vertex2dv; + public static Delegates.Vertex2f Vertex2f; + public static Delegates.Vertex2fv Vertex2fv; + public static Delegates.Vertex2i Vertex2i; + public static Delegates.Vertex2iv Vertex2iv; + public static Delegates.Vertex2s Vertex2s; + public static Delegates.Vertex2sv Vertex2sv; + public static Delegates.Vertex3d Vertex3d; + public static Delegates.Vertex3dv Vertex3dv; + public static Delegates.Vertex3f Vertex3f; + public static Delegates.Vertex3fv Vertex3fv; + public static Delegates.Vertex3i Vertex3i; + public static Delegates.Vertex3iv Vertex3iv; + public static Delegates.Vertex3s Vertex3s; + public static Delegates.Vertex3sv Vertex3sv; + public static Delegates.Vertex4d Vertex4d; + public static Delegates.Vertex4dv Vertex4dv; + public static Delegates.Vertex4f Vertex4f; + public static Delegates.Vertex4fv Vertex4fv; + public static Delegates.Vertex4i Vertex4i; + public static Delegates.Vertex4iv Vertex4iv; + public static Delegates.Vertex4s Vertex4s; + public static Delegates.Vertex4sv Vertex4sv; + public static Delegates.ClipPlane ClipPlane; + public static Delegates.ColorMaterial ColorMaterial; + public static Delegates.CullFace CullFace; + public static Delegates.Fogf Fogf; + public static Delegates.Fogfv Fogfv; + public static Delegates.Fogi Fogi; + public static Delegates.Fogiv Fogiv; + public static Delegates.FrontFace FrontFace; + public static Delegates.Hint Hint; + public static Delegates.Lightf Lightf; + public static Delegates.Lightfv Lightfv; + public static Delegates.Lighti Lighti; + public static Delegates.Lightiv Lightiv; + public static Delegates.LightModelf LightModelf; + public static Delegates.LightModelfv LightModelfv; + public static Delegates.LightModeli LightModeli; + public static Delegates.LightModeliv LightModeliv; + public static Delegates.LineStipple LineStipple; + public static Delegates.LineWidth LineWidth; + public static Delegates.Materialf Materialf; + public static Delegates.Materialfv Materialfv; + public static Delegates.Materiali Materiali; + public static Delegates.Materialiv Materialiv; + public static Delegates.PointSize PointSize; + public static Delegates.PolygonMode PolygonMode; + public static Delegates.PolygonStipple PolygonStipple; + public static Delegates.Scissor Scissor; + public static Delegates.ShadeModel ShadeModel; + public static Delegates.TexParameterf TexParameterf; + public static Delegates.TexParameterfv TexParameterfv; + public static Delegates.TexParameteri TexParameteri; + public static Delegates.TexParameteriv TexParameteriv; + public static Delegates.TexImage1D TexImage1D; + public static Delegates.TexImage2D TexImage2D; + public static Delegates.TexEnvf TexEnvf; + public static Delegates.TexEnvfv TexEnvfv; + public static Delegates.TexEnvi TexEnvi; + public static Delegates.TexEnviv TexEnviv; + public static Delegates.TexGend TexGend; + public static Delegates.TexGendv TexGendv; + public static Delegates.TexGenf TexGenf; + public static Delegates.TexGenfv TexGenfv; + public static Delegates.TexGeni TexGeni; + public static Delegates.TexGeniv TexGeniv; + public static Delegates.FeedbackBuffer FeedbackBuffer; + public static Delegates.SelectBuffer SelectBuffer; + public static Delegates.RenderMode RenderMode; + public static Delegates.InitNames InitNames; + public static Delegates.LoadName LoadName; + public static Delegates.PassThrough PassThrough; + public static Delegates.PopName PopName; + public static Delegates.PushName PushName; + public static Delegates.DrawBuffer DrawBuffer; + public static Delegates.Clear Clear; + public static Delegates.ClearAccum ClearAccum; + public static Delegates.ClearIndex ClearIndex; + public static Delegates.ClearColor ClearColor; + public static Delegates.ClearStencil ClearStencil; + public static Delegates.ClearDepth ClearDepth; + public static Delegates.StencilMask StencilMask; + public static Delegates.ColorMask ColorMask; + public static Delegates.DepthMask DepthMask; + public static Delegates.IndexMask IndexMask; + public static Delegates.Accum Accum; + public static Delegates.Disable Disable; + public static Delegates.Enable Enable; + public static Delegates.Finish Finish; + public static Delegates.Flush Flush; + public static Delegates.PopAttrib PopAttrib; + public static Delegates.PushAttrib PushAttrib; + public static Delegates.Map1d Map1d; + public static Delegates.Map1f Map1f; + public static Delegates.Map2d Map2d; + public static Delegates.Map2f Map2f; + public static Delegates.MapGrid1d MapGrid1d; + public static Delegates.MapGrid1f MapGrid1f; + public static Delegates.MapGrid2d MapGrid2d; + public static Delegates.MapGrid2f MapGrid2f; + public static Delegates.EvalCoord1d EvalCoord1d; + public static Delegates.EvalCoord1dv EvalCoord1dv; + public static Delegates.EvalCoord1f EvalCoord1f; + public static Delegates.EvalCoord1fv EvalCoord1fv; + public static Delegates.EvalCoord2d EvalCoord2d; + public static Delegates.EvalCoord2dv EvalCoord2dv; + public static Delegates.EvalCoord2f EvalCoord2f; + public static Delegates.EvalCoord2fv EvalCoord2fv; + public static Delegates.EvalMesh1 EvalMesh1; + public static Delegates.EvalPoint1 EvalPoint1; + public static Delegates.EvalMesh2 EvalMesh2; + public static Delegates.EvalPoint2 EvalPoint2; + public static Delegates.AlphaFunc AlphaFunc; + public static Delegates.BlendFunc BlendFunc; + public static Delegates.LogicOp LogicOp; + public static Delegates.StencilFunc StencilFunc; + public static Delegates.StencilOp StencilOp; + public static Delegates.DepthFunc DepthFunc; + public static Delegates.PixelZoom PixelZoom; + public static Delegates.PixelTransferf PixelTransferf; + public static Delegates.PixelTransferi PixelTransferi; + public static Delegates.PixelStoref PixelStoref; + public static Delegates.PixelStorei PixelStorei; + public static Delegates.PixelMapfv PixelMapfv; + public static Delegates.PixelMapuiv PixelMapuiv; + public static Delegates.PixelMapusv PixelMapusv; + public static Delegates.ReadBuffer ReadBuffer; + public static Delegates.CopyPixels CopyPixels; + public static Delegates.ReadPixels_ ReadPixels_; + public static Delegates.DrawPixels_ DrawPixels_; + public static Delegates.GetBooleanv GetBooleanv; + public static Delegates.GetClipPlane GetClipPlane; + public static Delegates.GetDoublev GetDoublev; + public static Delegates.GetError GetError; + public static Delegates.GetFloatv GetFloatv; + public static Delegates.GetIntegerv GetIntegerv; + public static Delegates.GetLightfv GetLightfv; + public static Delegates.GetLightiv GetLightiv; + public static Delegates.GetMapdv GetMapdv; + public static Delegates.GetMapfv GetMapfv; + public static Delegates.GetMapiv GetMapiv; + public static Delegates.GetMaterialfv GetMaterialfv; + public static Delegates.GetMaterialiv GetMaterialiv; + public static Delegates.GetPixelMapfv GetPixelMapfv; + public static Delegates.GetPixelMapuiv GetPixelMapuiv; + public static Delegates.GetPixelMapusv GetPixelMapusv; + public static Delegates.GetPolygonStipple GetPolygonStipple; + public static Delegates.GetString GetString; + public static Delegates.GetTexEnvfv GetTexEnvfv; + public static Delegates.GetTexEnviv GetTexEnviv; + public static Delegates.GetTexGendv GetTexGendv; + public static Delegates.GetTexGenfv GetTexGenfv; + public static Delegates.GetTexGeniv GetTexGeniv; + public static Delegates.GetTexImage GetTexImage; + public static Delegates.GetTexParameterfv GetTexParameterfv; + public static Delegates.GetTexParameteriv GetTexParameteriv; + public static Delegates.GetTexLevelParameterfv GetTexLevelParameterfv; + public static Delegates.GetTexLevelParameteriv GetTexLevelParameteriv; + public static Delegates.IsEnabled IsEnabled; + public static Delegates.IsList IsList; + public static Delegates.DepthRange DepthRange; + public static Delegates.Frustum Frustum; + public static Delegates.LoadIdentity LoadIdentity; + public static Delegates.LoadMatrixf LoadMatrixf; + public static Delegates.LoadMatrixd LoadMatrixd; + public static Delegates.MatrixMode MatrixMode; + public static Delegates.MultMatrixf MultMatrixf; + public static Delegates.MultMatrixd MultMatrixd; + public static Delegates.Ortho Ortho; + public static Delegates.PopMatrix PopMatrix; + public static Delegates.PushMatrix PushMatrix; + public static Delegates.Rotated Rotated; + public static Delegates.Rotatef Rotatef; + public static Delegates.Scaled Scaled; + public static Delegates.Scalef Scalef; + public static Delegates.Translated Translated; + public static Delegates.Translatef Translatef; + public static Delegates.Viewport Viewport; + public static Delegates.ArrayElement ArrayElement; + public static Delegates.ColorPointer_ ColorPointer_; + public static Delegates.DisableClientState DisableClientState; + public static Delegates.DrawArrays DrawArrays; + public static Delegates.DrawElements_ DrawElements_; + public static Delegates.EdgeFlagPointer_ EdgeFlagPointer_; + public static Delegates.EnableClientState EnableClientState; + public static Delegates.GetPointerv GetPointerv; + public static Delegates.IndexPointer_ IndexPointer_; + public static Delegates.InterleavedArrays_ InterleavedArrays_; + public static Delegates.NormalPointer_ NormalPointer_; + public static Delegates.TexCoordPointer_ TexCoordPointer_; + public static Delegates.VertexPointer_ VertexPointer_; + public static Delegates.PolygonOffset PolygonOffset; + public static Delegates.CopyTexImage1D CopyTexImage1D; + public static Delegates.CopyTexImage2D CopyTexImage2D; + public static Delegates.CopyTexSubImage1D CopyTexSubImage1D; + public static Delegates.CopyTexSubImage2D CopyTexSubImage2D; + public static Delegates.TexSubImage1D TexSubImage1D; + public static Delegates.TexSubImage2D TexSubImage2D; + public static Delegates.AreTexturesResident AreTexturesResident; + public static Delegates.BindTexture BindTexture; + public static Delegates.DeleteTextures DeleteTextures; + public static Delegates.GenTextures GenTextures; + public static Delegates.IsTexture IsTexture; + public static Delegates.PrioritizeTextures PrioritizeTextures; + public static Delegates.Indexub Indexub; + public static Delegates.Indexubv Indexubv; + public static Delegates.PopClientAttrib PopClientAttrib; + public static Delegates.PushClientAttrib PushClientAttrib; + public static Delegates.BlendColor BlendColor; + public static Delegates.BlendEquation BlendEquation; + public static Delegates.DrawRangeElements_ DrawRangeElements_; + public static Delegates.ColorTable_ ColorTable_; + public static Delegates.ColorTableParameterfv ColorTableParameterfv; + public static Delegates.ColorTableParameteriv ColorTableParameteriv; + public static Delegates.CopyColorTable CopyColorTable; + public static Delegates.GetColorTable_ GetColorTable_; + public static Delegates.GetColorTableParameterfv GetColorTableParameterfv; + public static Delegates.GetColorTableParameteriv GetColorTableParameteriv; + public static Delegates.ColorSubTable_ ColorSubTable_; + public static Delegates.CopyColorSubTable CopyColorSubTable; + public static Delegates.ConvolutionFilter1D_ ConvolutionFilter1D_; + public static Delegates.ConvolutionFilter2D_ ConvolutionFilter2D_; + public static Delegates.ConvolutionParameterf ConvolutionParameterf; + public static Delegates.ConvolutionParameterfv ConvolutionParameterfv; + public static Delegates.ConvolutionParameteri ConvolutionParameteri; + public static Delegates.ConvolutionParameteriv ConvolutionParameteriv; + public static Delegates.CopyConvolutionFilter1D CopyConvolutionFilter1D; + public static Delegates.CopyConvolutionFilter2D CopyConvolutionFilter2D; + public static Delegates.GetConvolutionFilter_ GetConvolutionFilter_; + public static Delegates.GetConvolutionParameterfv GetConvolutionParameterfv; + public static Delegates.GetConvolutionParameteriv GetConvolutionParameteriv; + public static Delegates.GetSeparableFilter_ GetSeparableFilter_; + public static Delegates.SeparableFilter2D_ SeparableFilter2D_; + public static Delegates.GetHistogram_ GetHistogram_; + public static Delegates.GetHistogramParameterfv GetHistogramParameterfv; + public static Delegates.GetHistogramParameteriv GetHistogramParameteriv; + public static Delegates.GetMinmax_ GetMinmax_; + public static Delegates.GetMinmaxParameterfv GetMinmaxParameterfv; + public static Delegates.GetMinmaxParameteriv GetMinmaxParameteriv; + public static Delegates.Histogram Histogram; + public static Delegates.Minmax Minmax; + public static Delegates.ResetHistogram ResetHistogram; + public static Delegates.ResetMinmax ResetMinmax; + public static Delegates.TexImage3D TexImage3D; + public static Delegates.TexSubImage3D TexSubImage3D; + public static Delegates.CopyTexSubImage3D CopyTexSubImage3D; + public static Delegates.ActiveTexture ActiveTexture; + public static Delegates.ClientActiveTexture ClientActiveTexture; + public static Delegates.MultiTexCoord1d MultiTexCoord1d; + public static Delegates.MultiTexCoord1dv MultiTexCoord1dv; + public static Delegates.MultiTexCoord1f MultiTexCoord1f; + public static Delegates.MultiTexCoord1fv MultiTexCoord1fv; + public static Delegates.MultiTexCoord1i MultiTexCoord1i; + public static Delegates.MultiTexCoord1iv MultiTexCoord1iv; + public static Delegates.MultiTexCoord1s MultiTexCoord1s; + public static Delegates.MultiTexCoord1sv MultiTexCoord1sv; + public static Delegates.MultiTexCoord2d MultiTexCoord2d; + public static Delegates.MultiTexCoord2dv MultiTexCoord2dv; + public static Delegates.MultiTexCoord2f MultiTexCoord2f; + public static Delegates.MultiTexCoord2fv MultiTexCoord2fv; + public static Delegates.MultiTexCoord2i MultiTexCoord2i; + public static Delegates.MultiTexCoord2iv MultiTexCoord2iv; + public static Delegates.MultiTexCoord2s MultiTexCoord2s; + public static Delegates.MultiTexCoord2sv MultiTexCoord2sv; + public static Delegates.MultiTexCoord3d MultiTexCoord3d; + public static Delegates.MultiTexCoord3dv MultiTexCoord3dv; + public static Delegates.MultiTexCoord3f MultiTexCoord3f; + public static Delegates.MultiTexCoord3fv MultiTexCoord3fv; + public static Delegates.MultiTexCoord3i MultiTexCoord3i; + public static Delegates.MultiTexCoord3iv MultiTexCoord3iv; + public static Delegates.MultiTexCoord3s MultiTexCoord3s; + public static Delegates.MultiTexCoord3sv MultiTexCoord3sv; + public static Delegates.MultiTexCoord4d MultiTexCoord4d; + public static Delegates.MultiTexCoord4dv MultiTexCoord4dv; + public static Delegates.MultiTexCoord4f MultiTexCoord4f; + public static Delegates.MultiTexCoord4fv MultiTexCoord4fv; + public static Delegates.MultiTexCoord4i MultiTexCoord4i; + public static Delegates.MultiTexCoord4iv MultiTexCoord4iv; + public static Delegates.MultiTexCoord4s MultiTexCoord4s; + public static Delegates.MultiTexCoord4sv MultiTexCoord4sv; + public static Delegates.LoadTransposeMatrixf LoadTransposeMatrixf; + public static Delegates.LoadTransposeMatrixd LoadTransposeMatrixd; + public static Delegates.MultTransposeMatrixf MultTransposeMatrixf; + public static Delegates.MultTransposeMatrixd MultTransposeMatrixd; + public static Delegates.SampleCoverage SampleCoverage; + public static Delegates.CompressedTexImage3D CompressedTexImage3D; + public static Delegates.CompressedTexImage2D CompressedTexImage2D; + public static Delegates.CompressedTexImage1D CompressedTexImage1D; + public static Delegates.CompressedTexSubImage3D CompressedTexSubImage3D; + public static Delegates.CompressedTexSubImage2D CompressedTexSubImage2D; + public static Delegates.CompressedTexSubImage1D CompressedTexSubImage1D; + public static Delegates.GetCompressedTexImage GetCompressedTexImage; + public static Delegates.BlendFuncSeparate BlendFuncSeparate; + public static Delegates.FogCoordf FogCoordf; + public static Delegates.FogCoordfv FogCoordfv; + public static Delegates.FogCoordd FogCoordd; + public static Delegates.FogCoorddv FogCoorddv; + public static Delegates.FogCoordPointer_ FogCoordPointer_; + public static Delegates.MultiDrawArrays MultiDrawArrays; + public static Delegates.MultiDrawElements MultiDrawElements; + public static Delegates.PointParameterf PointParameterf; + public static Delegates.PointParameterfv PointParameterfv; + public static Delegates.PointParameteri PointParameteri; + public static Delegates.PointParameteriv PointParameteriv; + public static Delegates.SecondaryColor3b SecondaryColor3b; + public static Delegates.SecondaryColor3bv SecondaryColor3bv; + public static Delegates.SecondaryColor3d SecondaryColor3d; + public static Delegates.SecondaryColor3dv SecondaryColor3dv; + public static Delegates.SecondaryColor3f SecondaryColor3f; + public static Delegates.SecondaryColor3fv SecondaryColor3fv; + public static Delegates.SecondaryColor3i SecondaryColor3i; + public static Delegates.SecondaryColor3iv SecondaryColor3iv; + public static Delegates.SecondaryColor3s SecondaryColor3s; + public static Delegates.SecondaryColor3sv SecondaryColor3sv; + public static Delegates.SecondaryColor3ub SecondaryColor3ub; + public static Delegates.SecondaryColor3ubv SecondaryColor3ubv; + public static Delegates.SecondaryColor3ui SecondaryColor3ui; + public static Delegates.SecondaryColor3uiv SecondaryColor3uiv; + public static Delegates.SecondaryColor3us SecondaryColor3us; + public static Delegates.SecondaryColor3usv SecondaryColor3usv; + public static Delegates.SecondaryColorPointer_ SecondaryColorPointer_; + public static Delegates.WindowPos2d WindowPos2d; + public static Delegates.WindowPos2dv WindowPos2dv; + public static Delegates.WindowPos2f WindowPos2f; + public static Delegates.WindowPos2fv WindowPos2fv; + public static Delegates.WindowPos2i WindowPos2i; + public static Delegates.WindowPos2iv WindowPos2iv; + public static Delegates.WindowPos2s WindowPos2s; + public static Delegates.WindowPos2sv WindowPos2sv; + public static Delegates.WindowPos3d WindowPos3d; + public static Delegates.WindowPos3dv WindowPos3dv; + public static Delegates.WindowPos3f WindowPos3f; + public static Delegates.WindowPos3fv WindowPos3fv; + public static Delegates.WindowPos3i WindowPos3i; + public static Delegates.WindowPos3iv WindowPos3iv; + public static Delegates.WindowPos3s WindowPos3s; + public static Delegates.WindowPos3sv WindowPos3sv; + public static Delegates.GenQueries GenQueries; + public static Delegates.DeleteQueries DeleteQueries; + public static Delegates.IsQuery IsQuery; + public static Delegates.BeginQuery BeginQuery; + public static Delegates.EndQuery EndQuery; + public static Delegates.GetQueryiv GetQueryiv; + public static Delegates.GetQueryObjectiv GetQueryObjectiv; + public static Delegates.GetQueryObjectuiv GetQueryObjectuiv; + public static Delegates.BindBuffer BindBuffer; + public static Delegates.DeleteBuffers DeleteBuffers; + public static Delegates.GenBuffers GenBuffers; + public static Delegates.IsBuffer IsBuffer; + public static Delegates.BufferData_ BufferData_; + public static Delegates.BufferSubData_ BufferSubData_; + public static Delegates.GetBufferSubData_ GetBufferSubData_; + public static Delegates.MapBuffer_ MapBuffer_; + public static Delegates.UnmapBuffer UnmapBuffer; + public static Delegates.GetBufferParameteriv GetBufferParameteriv; + public static Delegates.GetBufferPointerv GetBufferPointerv; + public static Delegates.BlendEquationSeparate BlendEquationSeparate; + public static Delegates.DrawBuffers DrawBuffers; + public static Delegates.StencilOpSeparate StencilOpSeparate; + public static Delegates.StencilFuncSeparate StencilFuncSeparate; + public static Delegates.StencilMaskSeparate StencilMaskSeparate; + public static Delegates.AttachShader AttachShader; + public static Delegates.BindAttribLocation BindAttribLocation; + public static Delegates.CompileShader CompileShader; + public static Delegates.CreateProgram CreateProgram; + public static Delegates.CreateShader CreateShader; + public static Delegates.DeleteProgram DeleteProgram; + public static Delegates.DeleteShader DeleteShader; + public static Delegates.DetachShader DetachShader; + public static Delegates.DisableVertexAttribArray DisableVertexAttribArray; + public static Delegates.EnableVertexAttribArray EnableVertexAttribArray; + public static Delegates.GetActiveAttrib GetActiveAttrib; + public static Delegates.GetActiveUniform GetActiveUniform; + public static Delegates.GetAttachedShaders GetAttachedShaders; + public static Delegates.GetAttribLocation GetAttribLocation; + public static Delegates.GetProgramiv GetProgramiv; + public static Delegates.GetProgramInfoLog GetProgramInfoLog; + public static Delegates.GetShaderiv GetShaderiv; + public static Delegates.GetShaderInfoLog GetShaderInfoLog; + public static Delegates.GetShaderSource GetShaderSource; + public static Delegates.GetUniformLocation GetUniformLocation; + public static Delegates.GetUniformfv GetUniformfv; + public static Delegates.GetUniformiv GetUniformiv; + public static Delegates.GetVertexAttribdv GetVertexAttribdv; + public static Delegates.GetVertexAttribfv GetVertexAttribfv; + public static Delegates.GetVertexAttribiv GetVertexAttribiv; + public static Delegates.GetVertexAttribPointerv GetVertexAttribPointerv; + public static Delegates.IsProgram IsProgram; + public static Delegates.IsShader IsShader; + public static Delegates.LinkProgram LinkProgram; + public static Delegates.ShaderSource ShaderSource; + public static Delegates.UseProgram UseProgram; + public static Delegates.Uniform1f Uniform1f; + public static Delegates.Uniform2f Uniform2f; + public static Delegates.Uniform3f Uniform3f; + public static Delegates.Uniform4f Uniform4f; + public static Delegates.Uniform1i Uniform1i; + public static Delegates.Uniform2i Uniform2i; + public static Delegates.Uniform3i Uniform3i; + public static Delegates.Uniform4i Uniform4i; + public static Delegates.Uniform1fv Uniform1fv; + public static Delegates.Uniform2fv Uniform2fv; + public static Delegates.Uniform3fv Uniform3fv; + public static Delegates.Uniform4fv Uniform4fv; + public static Delegates.Uniform1iv Uniform1iv; + public static Delegates.Uniform2iv Uniform2iv; + public static Delegates.Uniform3iv Uniform3iv; + public static Delegates.Uniform4iv Uniform4iv; + public static Delegates.UniformMatrix2fv UniformMatrix2fv; + public static Delegates.UniformMatrix3fv UniformMatrix3fv; + public static Delegates.UniformMatrix4fv UniformMatrix4fv; + public static Delegates.ValidateProgram ValidateProgram; + public static Delegates.VertexAttrib1d VertexAttrib1d; + public static Delegates.VertexAttrib1dv VertexAttrib1dv; + public static Delegates.VertexAttrib1f VertexAttrib1f; + public static Delegates.VertexAttrib1fv VertexAttrib1fv; + public static Delegates.VertexAttrib1s VertexAttrib1s; + public static Delegates.VertexAttrib1sv VertexAttrib1sv; + public static Delegates.VertexAttrib2d VertexAttrib2d; + public static Delegates.VertexAttrib2dv VertexAttrib2dv; + public static Delegates.VertexAttrib2f VertexAttrib2f; + public static Delegates.VertexAttrib2fv VertexAttrib2fv; + public static Delegates.VertexAttrib2s VertexAttrib2s; + public static Delegates.VertexAttrib2sv VertexAttrib2sv; + public static Delegates.VertexAttrib3d VertexAttrib3d; + public static Delegates.VertexAttrib3dv VertexAttrib3dv; + public static Delegates.VertexAttrib3f VertexAttrib3f; + public static Delegates.VertexAttrib3fv VertexAttrib3fv; + public static Delegates.VertexAttrib3s VertexAttrib3s; + public static Delegates.VertexAttrib3sv VertexAttrib3sv; + public static Delegates.VertexAttrib4Nbv VertexAttrib4Nbv; + public static Delegates.VertexAttrib4Niv VertexAttrib4Niv; + public static Delegates.VertexAttrib4Nsv VertexAttrib4Nsv; + public static Delegates.VertexAttrib4Nub VertexAttrib4Nub; + public static Delegates.VertexAttrib4Nubv VertexAttrib4Nubv; + public static Delegates.VertexAttrib4Nuiv VertexAttrib4Nuiv; + public static Delegates.VertexAttrib4Nusv VertexAttrib4Nusv; + public static Delegates.VertexAttrib4bv VertexAttrib4bv; + public static Delegates.VertexAttrib4d VertexAttrib4d; + public static Delegates.VertexAttrib4dv VertexAttrib4dv; + public static Delegates.VertexAttrib4f VertexAttrib4f; + public static Delegates.VertexAttrib4fv VertexAttrib4fv; + public static Delegates.VertexAttrib4iv VertexAttrib4iv; + public static Delegates.VertexAttrib4s VertexAttrib4s; + public static Delegates.VertexAttrib4sv VertexAttrib4sv; + public static Delegates.VertexAttrib4ubv VertexAttrib4ubv; + public static Delegates.VertexAttrib4uiv VertexAttrib4uiv; + public static Delegates.VertexAttrib4usv VertexAttrib4usv; + public static Delegates.VertexAttribPointer_ VertexAttribPointer_; + public static Delegates.ActiveTextureARB ActiveTextureARB; + public static Delegates.ClientActiveTextureARB ClientActiveTextureARB; + public static Delegates.MultiTexCoord1dARB MultiTexCoord1dARB; + public static Delegates.MultiTexCoord1dvARB MultiTexCoord1dvARB; + public static Delegates.MultiTexCoord1fARB MultiTexCoord1fARB; + public static Delegates.MultiTexCoord1fvARB MultiTexCoord1fvARB; + public static Delegates.MultiTexCoord1iARB MultiTexCoord1iARB; + public static Delegates.MultiTexCoord1ivARB MultiTexCoord1ivARB; + public static Delegates.MultiTexCoord1sARB MultiTexCoord1sARB; + public static Delegates.MultiTexCoord1svARB MultiTexCoord1svARB; + public static Delegates.MultiTexCoord2dARB MultiTexCoord2dARB; + public static Delegates.MultiTexCoord2dvARB MultiTexCoord2dvARB; + public static Delegates.MultiTexCoord2fARB MultiTexCoord2fARB; + public static Delegates.MultiTexCoord2fvARB MultiTexCoord2fvARB; + public static Delegates.MultiTexCoord2iARB MultiTexCoord2iARB; + public static Delegates.MultiTexCoord2ivARB MultiTexCoord2ivARB; + public static Delegates.MultiTexCoord2sARB MultiTexCoord2sARB; + public static Delegates.MultiTexCoord2svARB MultiTexCoord2svARB; + public static Delegates.MultiTexCoord3dARB MultiTexCoord3dARB; + public static Delegates.MultiTexCoord3dvARB MultiTexCoord3dvARB; + public static Delegates.MultiTexCoord3fARB MultiTexCoord3fARB; + public static Delegates.MultiTexCoord3fvARB MultiTexCoord3fvARB; + public static Delegates.MultiTexCoord3iARB MultiTexCoord3iARB; + public static Delegates.MultiTexCoord3ivARB MultiTexCoord3ivARB; + public static Delegates.MultiTexCoord3sARB MultiTexCoord3sARB; + public static Delegates.MultiTexCoord3svARB MultiTexCoord3svARB; + public static Delegates.MultiTexCoord4dARB MultiTexCoord4dARB; + public static Delegates.MultiTexCoord4dvARB MultiTexCoord4dvARB; + public static Delegates.MultiTexCoord4fARB MultiTexCoord4fARB; + public static Delegates.MultiTexCoord4fvARB MultiTexCoord4fvARB; + public static Delegates.MultiTexCoord4iARB MultiTexCoord4iARB; + public static Delegates.MultiTexCoord4ivARB MultiTexCoord4ivARB; + public static Delegates.MultiTexCoord4sARB MultiTexCoord4sARB; + public static Delegates.MultiTexCoord4svARB MultiTexCoord4svARB; + public static Delegates.LoadTransposeMatrixfARB LoadTransposeMatrixfARB; + public static Delegates.LoadTransposeMatrixdARB LoadTransposeMatrixdARB; + public static Delegates.MultTransposeMatrixfARB MultTransposeMatrixfARB; + public static Delegates.MultTransposeMatrixdARB MultTransposeMatrixdARB; + public static Delegates.SampleCoverageARB SampleCoverageARB; + public static Delegates.CompressedTexImage3DARB CompressedTexImage3DARB; + public static Delegates.CompressedTexImage2DARB CompressedTexImage2DARB; + public static Delegates.CompressedTexImage1DARB CompressedTexImage1DARB; + public static Delegates.CompressedTexSubImage3DARB CompressedTexSubImage3DARB; + public static Delegates.CompressedTexSubImage2DARB CompressedTexSubImage2DARB; + public static Delegates.CompressedTexSubImage1DARB CompressedTexSubImage1DARB; + public static Delegates.GetCompressedTexImageARB GetCompressedTexImageARB; + public static Delegates.PointParameterfARB PointParameterfARB; + public static Delegates.PointParameterfvARB PointParameterfvARB; + public static Delegates.WeightbvARB WeightbvARB; + public static Delegates.WeightsvARB WeightsvARB; + public static Delegates.WeightivARB WeightivARB; + public static Delegates.WeightfvARB WeightfvARB; + public static Delegates.WeightdvARB WeightdvARB; + public static Delegates.WeightubvARB WeightubvARB; + public static Delegates.WeightusvARB WeightusvARB; + public static Delegates.WeightuivARB WeightuivARB; + public static Delegates.WeightPointerARB_ WeightPointerARB_; + public static Delegates.VertexBlendARB VertexBlendARB; + public static Delegates.CurrentPaletteMatrixARB CurrentPaletteMatrixARB; + public static Delegates.MatrixIndexubvARB MatrixIndexubvARB; + public static Delegates.MatrixIndexusvARB MatrixIndexusvARB; + public static Delegates.MatrixIndexuivARB MatrixIndexuivARB; + public static Delegates.MatrixIndexPointerARB_ MatrixIndexPointerARB_; + public static Delegates.WindowPos2dARB WindowPos2dARB; + public static Delegates.WindowPos2dvARB WindowPos2dvARB; + public static Delegates.WindowPos2fARB WindowPos2fARB; + public static Delegates.WindowPos2fvARB WindowPos2fvARB; + public static Delegates.WindowPos2iARB WindowPos2iARB; + public static Delegates.WindowPos2ivARB WindowPos2ivARB; + public static Delegates.WindowPos2sARB WindowPos2sARB; + public static Delegates.WindowPos2svARB WindowPos2svARB; + public static Delegates.WindowPos3dARB WindowPos3dARB; + public static Delegates.WindowPos3dvARB WindowPos3dvARB; + public static Delegates.WindowPos3fARB WindowPos3fARB; + public static Delegates.WindowPos3fvARB WindowPos3fvARB; + public static Delegates.WindowPos3iARB WindowPos3iARB; + public static Delegates.WindowPos3ivARB WindowPos3ivARB; + public static Delegates.WindowPos3sARB WindowPos3sARB; + public static Delegates.WindowPos3svARB WindowPos3svARB; + public static Delegates.VertexAttrib1dARB VertexAttrib1dARB; + public static Delegates.VertexAttrib1dvARB VertexAttrib1dvARB; + public static Delegates.VertexAttrib1fARB VertexAttrib1fARB; + public static Delegates.VertexAttrib1fvARB VertexAttrib1fvARB; + public static Delegates.VertexAttrib1sARB VertexAttrib1sARB; + public static Delegates.VertexAttrib1svARB VertexAttrib1svARB; + public static Delegates.VertexAttrib2dARB VertexAttrib2dARB; + public static Delegates.VertexAttrib2dvARB VertexAttrib2dvARB; + public static Delegates.VertexAttrib2fARB VertexAttrib2fARB; + public static Delegates.VertexAttrib2fvARB VertexAttrib2fvARB; + public static Delegates.VertexAttrib2sARB VertexAttrib2sARB; + public static Delegates.VertexAttrib2svARB VertexAttrib2svARB; + public static Delegates.VertexAttrib3dARB VertexAttrib3dARB; + public static Delegates.VertexAttrib3dvARB VertexAttrib3dvARB; + public static Delegates.VertexAttrib3fARB VertexAttrib3fARB; + public static Delegates.VertexAttrib3fvARB VertexAttrib3fvARB; + public static Delegates.VertexAttrib3sARB VertexAttrib3sARB; + public static Delegates.VertexAttrib3svARB VertexAttrib3svARB; + public static Delegates.VertexAttrib4NbvARB VertexAttrib4NbvARB; + public static Delegates.VertexAttrib4NivARB VertexAttrib4NivARB; + public static Delegates.VertexAttrib4NsvARB VertexAttrib4NsvARB; + public static Delegates.VertexAttrib4NubARB VertexAttrib4NubARB; + public static Delegates.VertexAttrib4NubvARB VertexAttrib4NubvARB; + public static Delegates.VertexAttrib4NuivARB VertexAttrib4NuivARB; + public static Delegates.VertexAttrib4NusvARB VertexAttrib4NusvARB; + public static Delegates.VertexAttrib4bvARB VertexAttrib4bvARB; + public static Delegates.VertexAttrib4dARB VertexAttrib4dARB; + public static Delegates.VertexAttrib4dvARB VertexAttrib4dvARB; + public static Delegates.VertexAttrib4fARB VertexAttrib4fARB; + public static Delegates.VertexAttrib4fvARB VertexAttrib4fvARB; + public static Delegates.VertexAttrib4ivARB VertexAttrib4ivARB; + public static Delegates.VertexAttrib4sARB VertexAttrib4sARB; + public static Delegates.VertexAttrib4svARB VertexAttrib4svARB; + public static Delegates.VertexAttrib4ubvARB VertexAttrib4ubvARB; + public static Delegates.VertexAttrib4uivARB VertexAttrib4uivARB; + public static Delegates.VertexAttrib4usvARB VertexAttrib4usvARB; + public static Delegates.VertexAttribPointerARB_ VertexAttribPointerARB_; + public static Delegates.EnableVertexAttribArrayARB EnableVertexAttribArrayARB; + public static Delegates.DisableVertexAttribArrayARB DisableVertexAttribArrayARB; + public static Delegates.ProgramStringARB_ ProgramStringARB_; + public static Delegates.BindProgramARB BindProgramARB; + public static Delegates.DeleteProgramsARB DeleteProgramsARB; + public static Delegates.GenProgramsARB GenProgramsARB; + public static Delegates.ProgramEnvParameter4dARB ProgramEnvParameter4dARB; + public static Delegates.ProgramEnvParameter4dvARB ProgramEnvParameter4dvARB; + public static Delegates.ProgramEnvParameter4fARB ProgramEnvParameter4fARB; + public static Delegates.ProgramEnvParameter4fvARB ProgramEnvParameter4fvARB; + public static Delegates.ProgramLocalParameter4dARB ProgramLocalParameter4dARB; + public static Delegates.ProgramLocalParameter4dvARB ProgramLocalParameter4dvARB; + public static Delegates.ProgramLocalParameter4fARB ProgramLocalParameter4fARB; + public static Delegates.ProgramLocalParameter4fvARB ProgramLocalParameter4fvARB; + public static Delegates.GetProgramEnvParameterdvARB GetProgramEnvParameterdvARB; + public static Delegates.GetProgramEnvParameterfvARB GetProgramEnvParameterfvARB; + public static Delegates.GetProgramLocalParameterdvARB GetProgramLocalParameterdvARB; + public static Delegates.GetProgramLocalParameterfvARB GetProgramLocalParameterfvARB; + public static Delegates.GetProgramivARB GetProgramivARB; + public static Delegates.GetProgramStringARB_ GetProgramStringARB_; + public static Delegates.GetVertexAttribdvARB GetVertexAttribdvARB; + public static Delegates.GetVertexAttribfvARB GetVertexAttribfvARB; + public static Delegates.GetVertexAttribivARB GetVertexAttribivARB; + public static Delegates.GetVertexAttribPointervARB GetVertexAttribPointervARB; + public static Delegates.IsProgramARB IsProgramARB; + public static Delegates.BindBufferARB BindBufferARB; + public static Delegates.DeleteBuffersARB DeleteBuffersARB; + public static Delegates.GenBuffersARB GenBuffersARB; + public static Delegates.IsBufferARB IsBufferARB; + public static Delegates.BufferDataARB_ BufferDataARB_; + public static Delegates.BufferSubDataARB_ BufferSubDataARB_; + public static Delegates.GetBufferSubDataARB_ GetBufferSubDataARB_; + public static Delegates.MapBufferARB_ MapBufferARB_; + public static Delegates.UnmapBufferARB UnmapBufferARB; + public static Delegates.GetBufferParameterivARB GetBufferParameterivARB; + public static Delegates.GetBufferPointervARB GetBufferPointervARB; + public static Delegates.GenQueriesARB GenQueriesARB; + public static Delegates.DeleteQueriesARB DeleteQueriesARB; + public static Delegates.IsQueryARB IsQueryARB; + public static Delegates.BeginQueryARB BeginQueryARB; + public static Delegates.EndQueryARB EndQueryARB; + public static Delegates.GetQueryivARB GetQueryivARB; + public static Delegates.GetQueryObjectivARB GetQueryObjectivARB; + public static Delegates.GetQueryObjectuivARB GetQueryObjectuivARB; + public static Delegates.DeleteObjectARB DeleteObjectARB; + public static Delegates.GetHandleARB GetHandleARB; + public static Delegates.DetachObjectARB DetachObjectARB; + public static Delegates.CreateShaderObjectARB CreateShaderObjectARB; + public static Delegates.ShaderSourceARB ShaderSourceARB; + public static Delegates.CompileShaderARB CompileShaderARB; + public static Delegates.CreateProgramObjectARB CreateProgramObjectARB; + public static Delegates.AttachObjectARB AttachObjectARB; + public static Delegates.LinkProgramARB LinkProgramARB; + public static Delegates.UseProgramObjectARB UseProgramObjectARB; + public static Delegates.ValidateProgramARB ValidateProgramARB; + public static Delegates.Uniform1fARB Uniform1fARB; + public static Delegates.Uniform2fARB Uniform2fARB; + public static Delegates.Uniform3fARB Uniform3fARB; + public static Delegates.Uniform4fARB Uniform4fARB; + public static Delegates.Uniform1iARB Uniform1iARB; + public static Delegates.Uniform2iARB Uniform2iARB; + public static Delegates.Uniform3iARB Uniform3iARB; + public static Delegates.Uniform4iARB Uniform4iARB; + public static Delegates.Uniform1fvARB Uniform1fvARB; + public static Delegates.Uniform2fvARB Uniform2fvARB; + public static Delegates.Uniform3fvARB Uniform3fvARB; + public static Delegates.Uniform4fvARB Uniform4fvARB; + public static Delegates.Uniform1ivARB Uniform1ivARB; + public static Delegates.Uniform2ivARB Uniform2ivARB; + public static Delegates.Uniform3ivARB Uniform3ivARB; + public static Delegates.Uniform4ivARB Uniform4ivARB; + public static Delegates.UniformMatrix2fvARB UniformMatrix2fvARB; + public static Delegates.UniformMatrix3fvARB UniformMatrix3fvARB; + public static Delegates.UniformMatrix4fvARB UniformMatrix4fvARB; + public static Delegates.GetObjectParameterfvARB GetObjectParameterfvARB; + public static Delegates.GetObjectParameterivARB GetObjectParameterivARB; + public static Delegates.GetInfoLogARB GetInfoLogARB; + public static Delegates.GetAttachedObjectsARB GetAttachedObjectsARB; + public static Delegates.GetUniformLocationARB GetUniformLocationARB; + public static Delegates.GetActiveUniformARB GetActiveUniformARB; + public static Delegates.GetUniformfvARB GetUniformfvARB; + public static Delegates.GetUniformivARB GetUniformivARB; + public static Delegates.GetShaderSourceARB GetShaderSourceARB; + public static Delegates.BindAttribLocationARB BindAttribLocationARB; + public static Delegates.GetActiveAttribARB GetActiveAttribARB; + public static Delegates.GetAttribLocationARB GetAttribLocationARB; + public static Delegates.DrawBuffersARB DrawBuffersARB; + public static Delegates.ClampColorARB ClampColorARB; + public static Delegates.BlendColorEXT BlendColorEXT; + public static Delegates.PolygonOffsetEXT PolygonOffsetEXT; + public static Delegates.TexImage3DEXT TexImage3DEXT; + public static Delegates.TexSubImage3DEXT TexSubImage3DEXT; + public static Delegates.GetTexFilterFuncSGIS GetTexFilterFuncSGIS; + public static Delegates.TexFilterFuncSGIS TexFilterFuncSGIS; + public static Delegates.TexSubImage1DEXT TexSubImage1DEXT; + public static Delegates.TexSubImage2DEXT TexSubImage2DEXT; + public static Delegates.CopyTexImage1DEXT CopyTexImage1DEXT; + public static Delegates.CopyTexImage2DEXT CopyTexImage2DEXT; + public static Delegates.CopyTexSubImage1DEXT CopyTexSubImage1DEXT; + public static Delegates.CopyTexSubImage2DEXT CopyTexSubImage2DEXT; + public static Delegates.CopyTexSubImage3DEXT CopyTexSubImage3DEXT; + public static Delegates.GetHistogramEXT_ GetHistogramEXT_; + public static Delegates.GetHistogramParameterfvEXT GetHistogramParameterfvEXT; + public static Delegates.GetHistogramParameterivEXT GetHistogramParameterivEXT; + public static Delegates.GetMinmaxEXT_ GetMinmaxEXT_; + public static Delegates.GetMinmaxParameterfvEXT GetMinmaxParameterfvEXT; + public static Delegates.GetMinmaxParameterivEXT GetMinmaxParameterivEXT; + public static Delegates.HistogramEXT HistogramEXT; + public static Delegates.MinmaxEXT MinmaxEXT; + public static Delegates.ResetHistogramEXT ResetHistogramEXT; + public static Delegates.ResetMinmaxEXT ResetMinmaxEXT; + public static Delegates.ConvolutionFilter1DEXT_ ConvolutionFilter1DEXT_; + public static Delegates.ConvolutionFilter2DEXT_ ConvolutionFilter2DEXT_; + public static Delegates.ConvolutionParameterfEXT ConvolutionParameterfEXT; + public static Delegates.ConvolutionParameterfvEXT ConvolutionParameterfvEXT; + public static Delegates.ConvolutionParameteriEXT ConvolutionParameteriEXT; + public static Delegates.ConvolutionParameterivEXT ConvolutionParameterivEXT; + public static Delegates.CopyConvolutionFilter1DEXT CopyConvolutionFilter1DEXT; + public static Delegates.CopyConvolutionFilter2DEXT CopyConvolutionFilter2DEXT; + public static Delegates.GetConvolutionFilterEXT_ GetConvolutionFilterEXT_; + public static Delegates.GetConvolutionParameterfvEXT GetConvolutionParameterfvEXT; + public static Delegates.GetConvolutionParameterivEXT GetConvolutionParameterivEXT; + public static Delegates.GetSeparableFilterEXT_ GetSeparableFilterEXT_; + public static Delegates.SeparableFilter2DEXT_ SeparableFilter2DEXT_; + public static Delegates.ColorTableSGI_ ColorTableSGI_; + public static Delegates.ColorTableParameterfvSGI ColorTableParameterfvSGI; + public static Delegates.ColorTableParameterivSGI ColorTableParameterivSGI; + public static Delegates.CopyColorTableSGI CopyColorTableSGI; + public static Delegates.GetColorTableSGI_ GetColorTableSGI_; + public static Delegates.GetColorTableParameterfvSGI GetColorTableParameterfvSGI; + public static Delegates.GetColorTableParameterivSGI GetColorTableParameterivSGI; + public static Delegates.PixelTexGenSGIX PixelTexGenSGIX; + public static Delegates.PixelTexGenParameteriSGIS PixelTexGenParameteriSGIS; + public static Delegates.PixelTexGenParameterivSGIS PixelTexGenParameterivSGIS; + public static Delegates.PixelTexGenParameterfSGIS PixelTexGenParameterfSGIS; + public static Delegates.PixelTexGenParameterfvSGIS PixelTexGenParameterfvSGIS; + public static Delegates.GetPixelTexGenParameterivSGIS GetPixelTexGenParameterivSGIS; + public static Delegates.GetPixelTexGenParameterfvSGIS GetPixelTexGenParameterfvSGIS; + public static Delegates.TexImage4DSGIS TexImage4DSGIS; + public static Delegates.TexSubImage4DSGIS TexSubImage4DSGIS; + public static Delegates.AreTexturesResidentEXT AreTexturesResidentEXT; + public static Delegates.BindTextureEXT BindTextureEXT; + public static Delegates.DeleteTexturesEXT DeleteTexturesEXT; + public static Delegates.GenTexturesEXT GenTexturesEXT; + public static Delegates.IsTextureEXT IsTextureEXT; + public static Delegates.PrioritizeTexturesEXT PrioritizeTexturesEXT; + public static Delegates.DetailTexFuncSGIS DetailTexFuncSGIS; + public static Delegates.GetDetailTexFuncSGIS GetDetailTexFuncSGIS; + public static Delegates.SharpenTexFuncSGIS SharpenTexFuncSGIS; + public static Delegates.GetSharpenTexFuncSGIS GetSharpenTexFuncSGIS; + public static Delegates.SampleMaskSGIS SampleMaskSGIS; + public static Delegates.SamplePatternSGIS SamplePatternSGIS; + public static Delegates.ArrayElementEXT ArrayElementEXT; + public static Delegates.ColorPointerEXT_ ColorPointerEXT_; + public static Delegates.DrawArraysEXT DrawArraysEXT; + public static Delegates.EdgeFlagPointerEXT EdgeFlagPointerEXT; + public static Delegates.GetPointervEXT GetPointervEXT; + public static Delegates.IndexPointerEXT_ IndexPointerEXT_; + public static Delegates.NormalPointerEXT_ NormalPointerEXT_; + public static Delegates.TexCoordPointerEXT_ TexCoordPointerEXT_; + public static Delegates.VertexPointerEXT_ VertexPointerEXT_; + public static Delegates.BlendEquationEXT BlendEquationEXT; + public static Delegates.SpriteParameterfSGIX SpriteParameterfSGIX; + public static Delegates.SpriteParameterfvSGIX SpriteParameterfvSGIX; + public static Delegates.SpriteParameteriSGIX SpriteParameteriSGIX; + public static Delegates.SpriteParameterivSGIX SpriteParameterivSGIX; + public static Delegates.PointParameterfEXT PointParameterfEXT; + public static Delegates.PointParameterfvEXT PointParameterfvEXT; + public static Delegates.PointParameterfSGIS PointParameterfSGIS; + public static Delegates.PointParameterfvSGIS PointParameterfvSGIS; + public static Delegates.GetInstrumentsSGIX GetInstrumentsSGIX; + public static Delegates.InstrumentsBufferSGIX InstrumentsBufferSGIX; + public static Delegates.PollInstrumentsSGIX PollInstrumentsSGIX; + public static Delegates.ReadInstrumentsSGIX ReadInstrumentsSGIX; + public static Delegates.StartInstrumentsSGIX StartInstrumentsSGIX; + public static Delegates.StopInstrumentsSGIX StopInstrumentsSGIX; + public static Delegates.FrameZoomSGIX FrameZoomSGIX; + public static Delegates.TagSampleBufferSGIX TagSampleBufferSGIX; + public static Delegates.DeformationMap3dSGIX DeformationMap3dSGIX; + public static Delegates.DeformationMap3fSGIX DeformationMap3fSGIX; + public static Delegates.DeformSGIX DeformSGIX; + public static Delegates.LoadIdentityDeformationMapSGIX LoadIdentityDeformationMapSGIX; + public static Delegates.ReferencePlaneSGIX ReferencePlaneSGIX; + public static Delegates.FlushRasterSGIX FlushRasterSGIX; + public static Delegates.FogFuncSGIS FogFuncSGIS; + public static Delegates.GetFogFuncSGIS GetFogFuncSGIS; + public static Delegates.ImageTransformParameteriHP ImageTransformParameteriHP; + public static Delegates.ImageTransformParameterfHP ImageTransformParameterfHP; + public static Delegates.ImageTransformParameterivHP ImageTransformParameterivHP; + public static Delegates.ImageTransformParameterfvHP ImageTransformParameterfvHP; + public static Delegates.GetImageTransformParameterivHP GetImageTransformParameterivHP; + public static Delegates.GetImageTransformParameterfvHP GetImageTransformParameterfvHP; + public static Delegates.ColorSubTableEXT_ ColorSubTableEXT_; + public static Delegates.CopyColorSubTableEXT CopyColorSubTableEXT; + public static Delegates.HintPGI HintPGI; + public static Delegates.ColorTableEXT_ ColorTableEXT_; + public static Delegates.GetColorTableEXT_ GetColorTableEXT_; + public static Delegates.GetColorTableParameterivEXT GetColorTableParameterivEXT; + public static Delegates.GetColorTableParameterfvEXT GetColorTableParameterfvEXT; + public static Delegates.GetListParameterfvSGIX GetListParameterfvSGIX; + public static Delegates.GetListParameterivSGIX GetListParameterivSGIX; + public static Delegates.ListParameterfSGIX ListParameterfSGIX; + public static Delegates.ListParameterfvSGIX ListParameterfvSGIX; + public static Delegates.ListParameteriSGIX ListParameteriSGIX; + public static Delegates.ListParameterivSGIX ListParameterivSGIX; + public static Delegates.IndexMaterialEXT IndexMaterialEXT; + public static Delegates.IndexFuncEXT IndexFuncEXT; + public static Delegates.LockArraysEXT LockArraysEXT; + public static Delegates.UnlockArraysEXT UnlockArraysEXT; + public static Delegates.CullParameterdvEXT CullParameterdvEXT; + public static Delegates.CullParameterfvEXT CullParameterfvEXT; + public static Delegates.FragmentColorMaterialSGIX FragmentColorMaterialSGIX; + public static Delegates.FragmentLightfSGIX FragmentLightfSGIX; + public static Delegates.FragmentLightfvSGIX FragmentLightfvSGIX; + public static Delegates.FragmentLightiSGIX FragmentLightiSGIX; + public static Delegates.FragmentLightivSGIX FragmentLightivSGIX; + public static Delegates.FragmentLightModelfSGIX FragmentLightModelfSGIX; + public static Delegates.FragmentLightModelfvSGIX FragmentLightModelfvSGIX; + public static Delegates.FragmentLightModeliSGIX FragmentLightModeliSGIX; + public static Delegates.FragmentLightModelivSGIX FragmentLightModelivSGIX; + public static Delegates.FragmentMaterialfSGIX FragmentMaterialfSGIX; + public static Delegates.FragmentMaterialfvSGIX FragmentMaterialfvSGIX; + public static Delegates.FragmentMaterialiSGIX FragmentMaterialiSGIX; + public static Delegates.FragmentMaterialivSGIX FragmentMaterialivSGIX; + public static Delegates.GetFragmentLightfvSGIX GetFragmentLightfvSGIX; + public static Delegates.GetFragmentLightivSGIX GetFragmentLightivSGIX; + public static Delegates.GetFragmentMaterialfvSGIX GetFragmentMaterialfvSGIX; + public static Delegates.GetFragmentMaterialivSGIX GetFragmentMaterialivSGIX; + public static Delegates.LightEnviSGIX LightEnviSGIX; + public static Delegates.DrawRangeElementsEXT_ DrawRangeElementsEXT_; + public static Delegates.ApplyTextureEXT ApplyTextureEXT; + public static Delegates.TextureLightEXT TextureLightEXT; + public static Delegates.TextureMaterialEXT TextureMaterialEXT; + public static Delegates.AsyncMarkerSGIX AsyncMarkerSGIX; + public static Delegates.FinishAsyncSGIX FinishAsyncSGIX; + public static Delegates.PollAsyncSGIX PollAsyncSGIX; + public static Delegates.GenAsyncMarkersSGIX GenAsyncMarkersSGIX; + public static Delegates.DeleteAsyncMarkersSGIX DeleteAsyncMarkersSGIX; + public static Delegates.IsAsyncMarkerSGIX IsAsyncMarkerSGIX; + public static Delegates.VertexPointervINTEL VertexPointervINTEL; + public static Delegates.NormalPointervINTEL NormalPointervINTEL; + public static Delegates.ColorPointervINTEL ColorPointervINTEL; + public static Delegates.TexCoordPointervINTEL TexCoordPointervINTEL; + public static Delegates.PixelTransformParameteriEXT PixelTransformParameteriEXT; + public static Delegates.PixelTransformParameterfEXT PixelTransformParameterfEXT; + public static Delegates.PixelTransformParameterivEXT PixelTransformParameterivEXT; + public static Delegates.PixelTransformParameterfvEXT PixelTransformParameterfvEXT; + public static Delegates.SecondaryColor3bEXT SecondaryColor3bEXT; + public static Delegates.SecondaryColor3bvEXT SecondaryColor3bvEXT; + public static Delegates.SecondaryColor3dEXT SecondaryColor3dEXT; + public static Delegates.SecondaryColor3dvEXT SecondaryColor3dvEXT; + public static Delegates.SecondaryColor3fEXT SecondaryColor3fEXT; + public static Delegates.SecondaryColor3fvEXT SecondaryColor3fvEXT; + public static Delegates.SecondaryColor3iEXT SecondaryColor3iEXT; + public static Delegates.SecondaryColor3ivEXT SecondaryColor3ivEXT; + public static Delegates.SecondaryColor3sEXT SecondaryColor3sEXT; + public static Delegates.SecondaryColor3svEXT SecondaryColor3svEXT; + public static Delegates.SecondaryColor3ubEXT SecondaryColor3ubEXT; + public static Delegates.SecondaryColor3ubvEXT SecondaryColor3ubvEXT; + public static Delegates.SecondaryColor3uiEXT SecondaryColor3uiEXT; + public static Delegates.SecondaryColor3uivEXT SecondaryColor3uivEXT; + public static Delegates.SecondaryColor3usEXT SecondaryColor3usEXT; + public static Delegates.SecondaryColor3usvEXT SecondaryColor3usvEXT; + public static Delegates.SecondaryColorPointerEXT_ SecondaryColorPointerEXT_; + public static Delegates.TextureNormalEXT TextureNormalEXT; + public static Delegates.MultiDrawArraysEXT MultiDrawArraysEXT; + public static Delegates.MultiDrawElementsEXT MultiDrawElementsEXT; + public static Delegates.FogCoordfEXT FogCoordfEXT; + public static Delegates.FogCoordfvEXT FogCoordfvEXT; + public static Delegates.FogCoorddEXT FogCoorddEXT; + public static Delegates.FogCoorddvEXT FogCoorddvEXT; + public static Delegates.FogCoordPointerEXT_ FogCoordPointerEXT_; + public static Delegates.Tangent3bEXT Tangent3bEXT; + public static Delegates.Tangent3bvEXT Tangent3bvEXT; + public static Delegates.Tangent3dEXT Tangent3dEXT; + public static Delegates.Tangent3dvEXT Tangent3dvEXT; + public static Delegates.Tangent3fEXT Tangent3fEXT; + public static Delegates.Tangent3fvEXT Tangent3fvEXT; + public static Delegates.Tangent3iEXT Tangent3iEXT; + public static Delegates.Tangent3ivEXT Tangent3ivEXT; + public static Delegates.Tangent3sEXT Tangent3sEXT; + public static Delegates.Tangent3svEXT Tangent3svEXT; + public static Delegates.Binormal3bEXT Binormal3bEXT; + public static Delegates.Binormal3bvEXT Binormal3bvEXT; + public static Delegates.Binormal3dEXT Binormal3dEXT; + public static Delegates.Binormal3dvEXT Binormal3dvEXT; + public static Delegates.Binormal3fEXT Binormal3fEXT; + public static Delegates.Binormal3fvEXT Binormal3fvEXT; + public static Delegates.Binormal3iEXT Binormal3iEXT; + public static Delegates.Binormal3ivEXT Binormal3ivEXT; + public static Delegates.Binormal3sEXT Binormal3sEXT; + public static Delegates.Binormal3svEXT Binormal3svEXT; + public static Delegates.TangentPointerEXT_ TangentPointerEXT_; + public static Delegates.BinormalPointerEXT_ BinormalPointerEXT_; + public static Delegates.FinishTextureSUNX FinishTextureSUNX; + public static Delegates.GlobalAlphaFactorbSUN GlobalAlphaFactorbSUN; + public static Delegates.GlobalAlphaFactorsSUN GlobalAlphaFactorsSUN; + public static Delegates.GlobalAlphaFactoriSUN GlobalAlphaFactoriSUN; + public static Delegates.GlobalAlphaFactorfSUN GlobalAlphaFactorfSUN; + public static Delegates.GlobalAlphaFactordSUN GlobalAlphaFactordSUN; + public static Delegates.GlobalAlphaFactorubSUN GlobalAlphaFactorubSUN; + public static Delegates.GlobalAlphaFactorusSUN GlobalAlphaFactorusSUN; + public static Delegates.GlobalAlphaFactoruiSUN GlobalAlphaFactoruiSUN; + public static Delegates.ReplacementCodeuiSUN ReplacementCodeuiSUN; + public static Delegates.ReplacementCodeusSUN ReplacementCodeusSUN; + public static Delegates.ReplacementCodeubSUN ReplacementCodeubSUN; + public static Delegates.ReplacementCodeuivSUN ReplacementCodeuivSUN; + public static Delegates.ReplacementCodeusvSUN ReplacementCodeusvSUN; + public static Delegates.ReplacementCodeubvSUN ReplacementCodeubvSUN; + public static Delegates.ReplacementCodePointerSUN ReplacementCodePointerSUN; + public static Delegates.Color4ubVertex2fSUN Color4ubVertex2fSUN; + public static Delegates.Color4ubVertex2fvSUN Color4ubVertex2fvSUN; + public static Delegates.Color4ubVertex3fSUN Color4ubVertex3fSUN; + public static Delegates.Color4ubVertex3fvSUN Color4ubVertex3fvSUN; + public static Delegates.Color3fVertex3fSUN Color3fVertex3fSUN; + public static Delegates.Color3fVertex3fvSUN Color3fVertex3fvSUN; + public static Delegates.Normal3fVertex3fSUN Normal3fVertex3fSUN; + public static Delegates.Normal3fVertex3fvSUN Normal3fVertex3fvSUN; + public static Delegates.Color4fNormal3fVertex3fSUN Color4fNormal3fVertex3fSUN; + public static Delegates.Color4fNormal3fVertex3fvSUN Color4fNormal3fVertex3fvSUN; + public static Delegates.TexCoord2fVertex3fSUN TexCoord2fVertex3fSUN; + public static Delegates.TexCoord2fVertex3fvSUN TexCoord2fVertex3fvSUN; + public static Delegates.TexCoord4fVertex4fSUN TexCoord4fVertex4fSUN; + public static Delegates.TexCoord4fVertex4fvSUN TexCoord4fVertex4fvSUN; + public static Delegates.TexCoord2fColor4ubVertex3fSUN TexCoord2fColor4ubVertex3fSUN; + public static Delegates.TexCoord2fColor4ubVertex3fvSUN TexCoord2fColor4ubVertex3fvSUN; + public static Delegates.TexCoord2fColor3fVertex3fSUN TexCoord2fColor3fVertex3fSUN; + public static Delegates.TexCoord2fColor3fVertex3fvSUN TexCoord2fColor3fVertex3fvSUN; + public static Delegates.TexCoord2fNormal3fVertex3fSUN TexCoord2fNormal3fVertex3fSUN; + public static Delegates.TexCoord2fNormal3fVertex3fvSUN TexCoord2fNormal3fVertex3fvSUN; + public static Delegates.TexCoord2fColor4fNormal3fVertex3fSUN TexCoord2fColor4fNormal3fVertex3fSUN; + public static Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN TexCoord2fColor4fNormal3fVertex3fvSUN; + public static Delegates.TexCoord4fColor4fNormal3fVertex4fSUN TexCoord4fColor4fNormal3fVertex4fSUN; + public static Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN TexCoord4fColor4fNormal3fVertex4fvSUN; + public static Delegates.ReplacementCodeuiVertex3fSUN ReplacementCodeuiVertex3fSUN; + public static Delegates.ReplacementCodeuiVertex3fvSUN ReplacementCodeuiVertex3fvSUN; + public static Delegates.ReplacementCodeuiColor4ubVertex3fSUN ReplacementCodeuiColor4ubVertex3fSUN; + public static Delegates.ReplacementCodeuiColor4ubVertex3fvSUN ReplacementCodeuiColor4ubVertex3fvSUN; + public static Delegates.ReplacementCodeuiColor3fVertex3fSUN ReplacementCodeuiColor3fVertex3fSUN; + public static Delegates.ReplacementCodeuiColor3fVertex3fvSUN ReplacementCodeuiColor3fVertex3fvSUN; + public static Delegates.ReplacementCodeuiNormal3fVertex3fSUN ReplacementCodeuiNormal3fVertex3fSUN; + public static Delegates.ReplacementCodeuiNormal3fVertex3fvSUN ReplacementCodeuiNormal3fVertex3fvSUN; + public static Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN ReplacementCodeuiColor4fNormal3fVertex3fSUN; + public static Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN ReplacementCodeuiColor4fNormal3fVertex3fvSUN; + public static Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN ReplacementCodeuiTexCoord2fVertex3fSUN; + public static Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN ReplacementCodeuiTexCoord2fVertex3fvSUN; + public static Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; + public static Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; + public static Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; + public static Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; + public static Delegates.BlendFuncSeparateEXT BlendFuncSeparateEXT; + public static Delegates.BlendFuncSeparateINGR BlendFuncSeparateINGR; + public static Delegates.VertexWeightfEXT VertexWeightfEXT; + public static Delegates.VertexWeightfvEXT VertexWeightfvEXT; + public static Delegates.VertexWeightPointerEXT_ VertexWeightPointerEXT_; + public static Delegates.FlushVertexArrayRangeNV FlushVertexArrayRangeNV; + public static Delegates.VertexArrayRangeNV_ VertexArrayRangeNV_; + public static Delegates.CombinerParameterfvNV CombinerParameterfvNV; + public static Delegates.CombinerParameterfNV CombinerParameterfNV; + public static Delegates.CombinerParameterivNV CombinerParameterivNV; + public static Delegates.CombinerParameteriNV CombinerParameteriNV; + public static Delegates.CombinerInputNV CombinerInputNV; + public static Delegates.CombinerOutputNV CombinerOutputNV; + public static Delegates.FinalCombinerInputNV FinalCombinerInputNV; + public static Delegates.GetCombinerInputParameterfvNV GetCombinerInputParameterfvNV; + public static Delegates.GetCombinerInputParameterivNV GetCombinerInputParameterivNV; + public static Delegates.GetCombinerOutputParameterfvNV GetCombinerOutputParameterfvNV; + public static Delegates.GetCombinerOutputParameterivNV GetCombinerOutputParameterivNV; + public static Delegates.GetFinalCombinerInputParameterfvNV GetFinalCombinerInputParameterfvNV; + public static Delegates.GetFinalCombinerInputParameterivNV GetFinalCombinerInputParameterivNV; + public static Delegates.ResizeBuffersMESA ResizeBuffersMESA; + public static Delegates.WindowPos2dMESA WindowPos2dMESA; + public static Delegates.WindowPos2dvMESA WindowPos2dvMESA; + public static Delegates.WindowPos2fMESA WindowPos2fMESA; + public static Delegates.WindowPos2fvMESA WindowPos2fvMESA; + public static Delegates.WindowPos2iMESA WindowPos2iMESA; + public static Delegates.WindowPos2ivMESA WindowPos2ivMESA; + public static Delegates.WindowPos2sMESA WindowPos2sMESA; + public static Delegates.WindowPos2svMESA WindowPos2svMESA; + public static Delegates.WindowPos3dMESA WindowPos3dMESA; + public static Delegates.WindowPos3dvMESA WindowPos3dvMESA; + public static Delegates.WindowPos3fMESA WindowPos3fMESA; + public static Delegates.WindowPos3fvMESA WindowPos3fvMESA; + public static Delegates.WindowPos3iMESA WindowPos3iMESA; + public static Delegates.WindowPos3ivMESA WindowPos3ivMESA; + public static Delegates.WindowPos3sMESA WindowPos3sMESA; + public static Delegates.WindowPos3svMESA WindowPos3svMESA; + public static Delegates.WindowPos4dMESA WindowPos4dMESA; + public static Delegates.WindowPos4dvMESA WindowPos4dvMESA; + public static Delegates.WindowPos4fMESA WindowPos4fMESA; + public static Delegates.WindowPos4fvMESA WindowPos4fvMESA; + public static Delegates.WindowPos4iMESA WindowPos4iMESA; + public static Delegates.WindowPos4ivMESA WindowPos4ivMESA; + public static Delegates.WindowPos4sMESA WindowPos4sMESA; + public static Delegates.WindowPos4svMESA WindowPos4svMESA; + public static Delegates.MultiModeDrawArraysIBM MultiModeDrawArraysIBM; + public static Delegates.MultiModeDrawElementsIBM_ MultiModeDrawElementsIBM_; + public static Delegates.ColorPointerListIBM ColorPointerListIBM; + public static Delegates.SecondaryColorPointerListIBM SecondaryColorPointerListIBM; + public static Delegates.EdgeFlagPointerListIBM EdgeFlagPointerListIBM; + public static Delegates.FogCoordPointerListIBM FogCoordPointerListIBM; + public static Delegates.IndexPointerListIBM IndexPointerListIBM; + public static Delegates.NormalPointerListIBM NormalPointerListIBM; + public static Delegates.TexCoordPointerListIBM TexCoordPointerListIBM; + public static Delegates.VertexPointerListIBM VertexPointerListIBM; + public static Delegates.TbufferMask3DFX TbufferMask3DFX; + public static Delegates.SampleMaskEXT SampleMaskEXT; + public static Delegates.SamplePatternEXT SamplePatternEXT; + public static Delegates.TextureColorMaskSGIS TextureColorMaskSGIS; + public static Delegates.IglooInterfaceSGIX_ IglooInterfaceSGIX_; + public static Delegates.DeleteFencesNV DeleteFencesNV; + public static Delegates.GenFencesNV GenFencesNV; + public static Delegates.IsFenceNV IsFenceNV; + public static Delegates.TestFenceNV TestFenceNV; + public static Delegates.GetFenceivNV GetFenceivNV; + public static Delegates.FinishFenceNV FinishFenceNV; + public static Delegates.SetFenceNV SetFenceNV; + public static Delegates.MapControlPointsNV_ MapControlPointsNV_; + public static Delegates.MapParameterivNV MapParameterivNV; + public static Delegates.MapParameterfvNV MapParameterfvNV; + public static Delegates.GetMapControlPointsNV_ GetMapControlPointsNV_; + public static Delegates.GetMapParameterivNV GetMapParameterivNV; + public static Delegates.GetMapParameterfvNV GetMapParameterfvNV; + public static Delegates.GetMapAttribParameterivNV GetMapAttribParameterivNV; + public static Delegates.GetMapAttribParameterfvNV GetMapAttribParameterfvNV; + public static Delegates.EvalMapsNV EvalMapsNV; + public static Delegates.CombinerStageParameterfvNV CombinerStageParameterfvNV; + public static Delegates.GetCombinerStageParameterfvNV GetCombinerStageParameterfvNV; + public static Delegates.AreProgramsResidentNV AreProgramsResidentNV; + public static Delegates.BindProgramNV BindProgramNV; + public static Delegates.DeleteProgramsNV DeleteProgramsNV; + public static Delegates.ExecuteProgramNV ExecuteProgramNV; + public static Delegates.GenProgramsNV GenProgramsNV; + public static Delegates.GetProgramParameterdvNV GetProgramParameterdvNV; + public static Delegates.GetProgramParameterfvNV GetProgramParameterfvNV; + public static Delegates.GetProgramivNV GetProgramivNV; + public static Delegates.GetProgramStringNV GetProgramStringNV; + public static Delegates.GetTrackMatrixivNV GetTrackMatrixivNV; + public static Delegates.GetVertexAttribdvNV GetVertexAttribdvNV; + public static Delegates.GetVertexAttribfvNV GetVertexAttribfvNV; + public static Delegates.GetVertexAttribivNV GetVertexAttribivNV; + public static Delegates.GetVertexAttribPointervNV GetVertexAttribPointervNV; + public static Delegates.IsProgramNV IsProgramNV; + public static Delegates.LoadProgramNV LoadProgramNV; + public static Delegates.ProgramParameter4dNV ProgramParameter4dNV; + public static Delegates.ProgramParameter4dvNV ProgramParameter4dvNV; + public static Delegates.ProgramParameter4fNV ProgramParameter4fNV; + public static Delegates.ProgramParameter4fvNV ProgramParameter4fvNV; + public static Delegates.ProgramParameters4dvNV ProgramParameters4dvNV; + public static Delegates.ProgramParameters4fvNV ProgramParameters4fvNV; + public static Delegates.RequestResidentProgramsNV RequestResidentProgramsNV; + public static Delegates.TrackMatrixNV TrackMatrixNV; + public static Delegates.VertexAttribPointerNV_ VertexAttribPointerNV_; + public static Delegates.VertexAttrib1dNV VertexAttrib1dNV; + public static Delegates.VertexAttrib1dvNV VertexAttrib1dvNV; + public static Delegates.VertexAttrib1fNV VertexAttrib1fNV; + public static Delegates.VertexAttrib1fvNV VertexAttrib1fvNV; + public static Delegates.VertexAttrib1sNV VertexAttrib1sNV; + public static Delegates.VertexAttrib1svNV VertexAttrib1svNV; + public static Delegates.VertexAttrib2dNV VertexAttrib2dNV; + public static Delegates.VertexAttrib2dvNV VertexAttrib2dvNV; + public static Delegates.VertexAttrib2fNV VertexAttrib2fNV; + public static Delegates.VertexAttrib2fvNV VertexAttrib2fvNV; + public static Delegates.VertexAttrib2sNV VertexAttrib2sNV; + public static Delegates.VertexAttrib2svNV VertexAttrib2svNV; + public static Delegates.VertexAttrib3dNV VertexAttrib3dNV; + public static Delegates.VertexAttrib3dvNV VertexAttrib3dvNV; + public static Delegates.VertexAttrib3fNV VertexAttrib3fNV; + public static Delegates.VertexAttrib3fvNV VertexAttrib3fvNV; + public static Delegates.VertexAttrib3sNV VertexAttrib3sNV; + public static Delegates.VertexAttrib3svNV VertexAttrib3svNV; + public static Delegates.VertexAttrib4dNV VertexAttrib4dNV; + public static Delegates.VertexAttrib4dvNV VertexAttrib4dvNV; + public static Delegates.VertexAttrib4fNV VertexAttrib4fNV; + public static Delegates.VertexAttrib4fvNV VertexAttrib4fvNV; + public static Delegates.VertexAttrib4sNV VertexAttrib4sNV; + public static Delegates.VertexAttrib4svNV VertexAttrib4svNV; + public static Delegates.VertexAttrib4ubNV VertexAttrib4ubNV; + public static Delegates.VertexAttrib4ubvNV VertexAttrib4ubvNV; + public static Delegates.VertexAttribs1dvNV VertexAttribs1dvNV; + public static Delegates.VertexAttribs1fvNV VertexAttribs1fvNV; + public static Delegates.VertexAttribs1svNV VertexAttribs1svNV; + public static Delegates.VertexAttribs2dvNV VertexAttribs2dvNV; + public static Delegates.VertexAttribs2fvNV VertexAttribs2fvNV; + public static Delegates.VertexAttribs2svNV VertexAttribs2svNV; + public static Delegates.VertexAttribs3dvNV VertexAttribs3dvNV; + public static Delegates.VertexAttribs3fvNV VertexAttribs3fvNV; + public static Delegates.VertexAttribs3svNV VertexAttribs3svNV; + public static Delegates.VertexAttribs4dvNV VertexAttribs4dvNV; + public static Delegates.VertexAttribs4fvNV VertexAttribs4fvNV; + public static Delegates.VertexAttribs4svNV VertexAttribs4svNV; + public static Delegates.VertexAttribs4ubvNV VertexAttribs4ubvNV; + public static Delegates.TexBumpParameterivATI TexBumpParameterivATI; + public static Delegates.TexBumpParameterfvATI TexBumpParameterfvATI; + public static Delegates.GetTexBumpParameterivATI GetTexBumpParameterivATI; + public static Delegates.GetTexBumpParameterfvATI GetTexBumpParameterfvATI; + public static Delegates.GenFragmentShadersATI GenFragmentShadersATI; + public static Delegates.BindFragmentShaderATI BindFragmentShaderATI; + public static Delegates.DeleteFragmentShaderATI DeleteFragmentShaderATI; + public static Delegates.BeginFragmentShaderATI BeginFragmentShaderATI; + public static Delegates.EndFragmentShaderATI EndFragmentShaderATI; + public static Delegates.PassTexCoordATI PassTexCoordATI; + public static Delegates.SampleMapATI SampleMapATI; + public static Delegates.ColorFragmentOp1ATI ColorFragmentOp1ATI; + public static Delegates.ColorFragmentOp2ATI ColorFragmentOp2ATI; + public static Delegates.ColorFragmentOp3ATI ColorFragmentOp3ATI; + public static Delegates.AlphaFragmentOp1ATI AlphaFragmentOp1ATI; + public static Delegates.AlphaFragmentOp2ATI AlphaFragmentOp2ATI; + public static Delegates.AlphaFragmentOp3ATI AlphaFragmentOp3ATI; + public static Delegates.SetFragmentShaderConstantATI SetFragmentShaderConstantATI; + public static Delegates.PNTrianglesiATI PNTrianglesiATI; + public static Delegates.PNTrianglesfATI PNTrianglesfATI; + public static Delegates.NewObjectBufferATI_ NewObjectBufferATI_; + public static Delegates.IsObjectBufferATI IsObjectBufferATI; + public static Delegates.UpdateObjectBufferATI_ UpdateObjectBufferATI_; + public static Delegates.GetObjectBufferfvATI GetObjectBufferfvATI; + public static Delegates.GetObjectBufferivATI GetObjectBufferivATI; + public static Delegates.FreeObjectBufferATI FreeObjectBufferATI; + public static Delegates.ArrayObjectATI ArrayObjectATI; + public static Delegates.GetArrayObjectfvATI GetArrayObjectfvATI; + public static Delegates.GetArrayObjectivATI GetArrayObjectivATI; + public static Delegates.VariantArrayObjectATI VariantArrayObjectATI; + public static Delegates.GetVariantArrayObjectfvATI GetVariantArrayObjectfvATI; + public static Delegates.GetVariantArrayObjectivATI GetVariantArrayObjectivATI; + public static Delegates.BeginVertexShaderEXT BeginVertexShaderEXT; + public static Delegates.EndVertexShaderEXT EndVertexShaderEXT; + public static Delegates.BindVertexShaderEXT BindVertexShaderEXT; + public static Delegates.GenVertexShadersEXT GenVertexShadersEXT; + public static Delegates.DeleteVertexShaderEXT DeleteVertexShaderEXT; + public static Delegates.ShaderOp1EXT ShaderOp1EXT; + public static Delegates.ShaderOp2EXT ShaderOp2EXT; + public static Delegates.ShaderOp3EXT ShaderOp3EXT; + public static Delegates.SwizzleEXT SwizzleEXT; + public static Delegates.WriteMaskEXT WriteMaskEXT; + public static Delegates.InsertComponentEXT InsertComponentEXT; + public static Delegates.ExtractComponentEXT ExtractComponentEXT; + public static Delegates.GenSymbolsEXT GenSymbolsEXT; + public static Delegates.SetInvariantEXT_ SetInvariantEXT_; + public static Delegates.SetLocalConstantEXT_ SetLocalConstantEXT_; + public static Delegates.VariantbvEXT VariantbvEXT; + public static Delegates.VariantsvEXT VariantsvEXT; + public static Delegates.VariantivEXT VariantivEXT; + public static Delegates.VariantfvEXT VariantfvEXT; + public static Delegates.VariantdvEXT VariantdvEXT; + public static Delegates.VariantubvEXT VariantubvEXT; + public static Delegates.VariantusvEXT VariantusvEXT; + public static Delegates.VariantuivEXT VariantuivEXT; + public static Delegates.VariantPointerEXT_ VariantPointerEXT_; + public static Delegates.EnableVariantClientStateEXT EnableVariantClientStateEXT; + public static Delegates.DisableVariantClientStateEXT DisableVariantClientStateEXT; + public static Delegates.BindLightParameterEXT BindLightParameterEXT; + public static Delegates.BindMaterialParameterEXT BindMaterialParameterEXT; + public static Delegates.BindTexGenParameterEXT BindTexGenParameterEXT; + public static Delegates.BindTextureUnitParameterEXT BindTextureUnitParameterEXT; + public static Delegates.BindParameterEXT BindParameterEXT; + public static Delegates.IsVariantEnabledEXT IsVariantEnabledEXT; + public static Delegates.GetVariantBooleanvEXT GetVariantBooleanvEXT; + public static Delegates.GetVariantIntegervEXT GetVariantIntegervEXT; + public static Delegates.GetVariantFloatvEXT GetVariantFloatvEXT; + public static Delegates.GetVariantPointervEXT GetVariantPointervEXT; + public static Delegates.GetInvariantBooleanvEXT GetInvariantBooleanvEXT; + public static Delegates.GetInvariantIntegervEXT GetInvariantIntegervEXT; + public static Delegates.GetInvariantFloatvEXT GetInvariantFloatvEXT; + public static Delegates.GetLocalConstantBooleanvEXT GetLocalConstantBooleanvEXT; + public static Delegates.GetLocalConstantIntegervEXT GetLocalConstantIntegervEXT; + public static Delegates.GetLocalConstantFloatvEXT GetLocalConstantFloatvEXT; + public static Delegates.VertexStream1sATI VertexStream1sATI; + public static Delegates.VertexStream1svATI VertexStream1svATI; + public static Delegates.VertexStream1iATI VertexStream1iATI; + public static Delegates.VertexStream1ivATI VertexStream1ivATI; + public static Delegates.VertexStream1fATI VertexStream1fATI; + public static Delegates.VertexStream1fvATI VertexStream1fvATI; + public static Delegates.VertexStream1dATI VertexStream1dATI; + public static Delegates.VertexStream1dvATI VertexStream1dvATI; + public static Delegates.VertexStream2sATI VertexStream2sATI; + public static Delegates.VertexStream2svATI VertexStream2svATI; + public static Delegates.VertexStream2iATI VertexStream2iATI; + public static Delegates.VertexStream2ivATI VertexStream2ivATI; + public static Delegates.VertexStream2fATI VertexStream2fATI; + public static Delegates.VertexStream2fvATI VertexStream2fvATI; + public static Delegates.VertexStream2dATI VertexStream2dATI; + public static Delegates.VertexStream2dvATI VertexStream2dvATI; + public static Delegates.VertexStream3sATI VertexStream3sATI; + public static Delegates.VertexStream3svATI VertexStream3svATI; + public static Delegates.VertexStream3iATI VertexStream3iATI; + public static Delegates.VertexStream3ivATI VertexStream3ivATI; + public static Delegates.VertexStream3fATI VertexStream3fATI; + public static Delegates.VertexStream3fvATI VertexStream3fvATI; + public static Delegates.VertexStream3dATI VertexStream3dATI; + public static Delegates.VertexStream3dvATI VertexStream3dvATI; + public static Delegates.VertexStream4sATI VertexStream4sATI; + public static Delegates.VertexStream4svATI VertexStream4svATI; + public static Delegates.VertexStream4iATI VertexStream4iATI; + public static Delegates.VertexStream4ivATI VertexStream4ivATI; + public static Delegates.VertexStream4fATI VertexStream4fATI; + public static Delegates.VertexStream4fvATI VertexStream4fvATI; + public static Delegates.VertexStream4dATI VertexStream4dATI; + public static Delegates.VertexStream4dvATI VertexStream4dvATI; + public static Delegates.NormalStream3bATI NormalStream3bATI; + public static Delegates.NormalStream3bvATI NormalStream3bvATI; + public static Delegates.NormalStream3sATI NormalStream3sATI; + public static Delegates.NormalStream3svATI NormalStream3svATI; + public static Delegates.NormalStream3iATI NormalStream3iATI; + public static Delegates.NormalStream3ivATI NormalStream3ivATI; + public static Delegates.NormalStream3fATI NormalStream3fATI; + public static Delegates.NormalStream3fvATI NormalStream3fvATI; + public static Delegates.NormalStream3dATI NormalStream3dATI; + public static Delegates.NormalStream3dvATI NormalStream3dvATI; + public static Delegates.ClientActiveVertexStreamATI ClientActiveVertexStreamATI; + public static Delegates.VertexBlendEnviATI VertexBlendEnviATI; + public static Delegates.VertexBlendEnvfATI VertexBlendEnvfATI; + public static Delegates.ElementPointerATI_ ElementPointerATI_; + public static Delegates.DrawElementArrayATI DrawElementArrayATI; + public static Delegates.DrawRangeElementArrayATI DrawRangeElementArrayATI; + public static Delegates.DrawMeshArraysSUN DrawMeshArraysSUN; + public static Delegates.GenOcclusionQueriesNV GenOcclusionQueriesNV; + public static Delegates.DeleteOcclusionQueriesNV DeleteOcclusionQueriesNV; + public static Delegates.IsOcclusionQueryNV IsOcclusionQueryNV; + public static Delegates.BeginOcclusionQueryNV BeginOcclusionQueryNV; + public static Delegates.EndOcclusionQueryNV EndOcclusionQueryNV; + public static Delegates.GetOcclusionQueryivNV GetOcclusionQueryivNV; + public static Delegates.GetOcclusionQueryuivNV GetOcclusionQueryuivNV; + public static Delegates.PointParameteriNV PointParameteriNV; + public static Delegates.PointParameterivNV PointParameterivNV; + public static Delegates.ActiveStencilFaceEXT ActiveStencilFaceEXT; + public static Delegates.ElementPointerAPPLE_ ElementPointerAPPLE_; + public static Delegates.DrawElementArrayAPPLE DrawElementArrayAPPLE; + public static Delegates.DrawRangeElementArrayAPPLE DrawRangeElementArrayAPPLE; + public static Delegates.MultiDrawElementArrayAPPLE MultiDrawElementArrayAPPLE; + public static Delegates.MultiDrawRangeElementArrayAPPLE MultiDrawRangeElementArrayAPPLE; + public static Delegates.GenFencesAPPLE GenFencesAPPLE; + public static Delegates.DeleteFencesAPPLE DeleteFencesAPPLE; + public static Delegates.SetFenceAPPLE SetFenceAPPLE; + public static Delegates.IsFenceAPPLE IsFenceAPPLE; + public static Delegates.TestFenceAPPLE TestFenceAPPLE; + public static Delegates.FinishFenceAPPLE FinishFenceAPPLE; + public static Delegates.TestObjectAPPLE TestObjectAPPLE; + public static Delegates.FinishObjectAPPLE FinishObjectAPPLE; + public static Delegates.BindVertexArrayAPPLE BindVertexArrayAPPLE; + public static Delegates.DeleteVertexArraysAPPLE DeleteVertexArraysAPPLE; + public static Delegates.GenVertexArraysAPPLE GenVertexArraysAPPLE; + public static Delegates.IsVertexArrayAPPLE IsVertexArrayAPPLE; + public static Delegates.VertexArrayRangeAPPLE_ VertexArrayRangeAPPLE_; + public static Delegates.FlushVertexArrayRangeAPPLE_ FlushVertexArrayRangeAPPLE_; + public static Delegates.VertexArrayParameteriAPPLE VertexArrayParameteriAPPLE; + public static Delegates.DrawBuffersATI DrawBuffersATI; + public static Delegates.ProgramNamedParameter4fNV ProgramNamedParameter4fNV; + public static Delegates.ProgramNamedParameter4dNV ProgramNamedParameter4dNV; + public static Delegates.ProgramNamedParameter4fvNV ProgramNamedParameter4fvNV; + public static Delegates.ProgramNamedParameter4dvNV ProgramNamedParameter4dvNV; + public static Delegates.GetProgramNamedParameterfvNV GetProgramNamedParameterfvNV; + public static Delegates.GetProgramNamedParameterdvNV GetProgramNamedParameterdvNV; + public static Delegates.Vertex2hNV Vertex2hNV; + public static Delegates.Vertex2hvNV Vertex2hvNV; + public static Delegates.Vertex3hNV Vertex3hNV; + public static Delegates.Vertex3hvNV Vertex3hvNV; + public static Delegates.Vertex4hNV Vertex4hNV; + public static Delegates.Vertex4hvNV Vertex4hvNV; + public static Delegates.Normal3hNV Normal3hNV; + public static Delegates.Normal3hvNV Normal3hvNV; + public static Delegates.Color3hNV Color3hNV; + public static Delegates.Color3hvNV Color3hvNV; + public static Delegates.Color4hNV Color4hNV; + public static Delegates.Color4hvNV Color4hvNV; + public static Delegates.TexCoord1hNV TexCoord1hNV; + public static Delegates.TexCoord1hvNV TexCoord1hvNV; + public static Delegates.TexCoord2hNV TexCoord2hNV; + public static Delegates.TexCoord2hvNV TexCoord2hvNV; + public static Delegates.TexCoord3hNV TexCoord3hNV; + public static Delegates.TexCoord3hvNV TexCoord3hvNV; + public static Delegates.TexCoord4hNV TexCoord4hNV; + public static Delegates.TexCoord4hvNV TexCoord4hvNV; + public static Delegates.MultiTexCoord1hNV MultiTexCoord1hNV; + public static Delegates.MultiTexCoord1hvNV MultiTexCoord1hvNV; + public static Delegates.MultiTexCoord2hNV MultiTexCoord2hNV; + public static Delegates.MultiTexCoord2hvNV MultiTexCoord2hvNV; + public static Delegates.MultiTexCoord3hNV MultiTexCoord3hNV; + public static Delegates.MultiTexCoord3hvNV MultiTexCoord3hvNV; + public static Delegates.MultiTexCoord4hNV MultiTexCoord4hNV; + public static Delegates.MultiTexCoord4hvNV MultiTexCoord4hvNV; + public static Delegates.FogCoordhNV FogCoordhNV; + public static Delegates.FogCoordhvNV FogCoordhvNV; + public static Delegates.SecondaryColor3hNV SecondaryColor3hNV; + public static Delegates.SecondaryColor3hvNV SecondaryColor3hvNV; + public static Delegates.VertexWeighthNV VertexWeighthNV; + public static Delegates.VertexWeighthvNV VertexWeighthvNV; + public static Delegates.VertexAttrib1hNV VertexAttrib1hNV; + public static Delegates.VertexAttrib1hvNV VertexAttrib1hvNV; + public static Delegates.VertexAttrib2hNV VertexAttrib2hNV; + public static Delegates.VertexAttrib2hvNV VertexAttrib2hvNV; + public static Delegates.VertexAttrib3hNV VertexAttrib3hNV; + public static Delegates.VertexAttrib3hvNV VertexAttrib3hvNV; + public static Delegates.VertexAttrib4hNV VertexAttrib4hNV; + public static Delegates.VertexAttrib4hvNV VertexAttrib4hvNV; + public static Delegates.VertexAttribs1hvNV VertexAttribs1hvNV; + public static Delegates.VertexAttribs2hvNV VertexAttribs2hvNV; + public static Delegates.VertexAttribs3hvNV VertexAttribs3hvNV; + public static Delegates.VertexAttribs4hvNV VertexAttribs4hvNV; + public static Delegates.PixelDataRangeNV_ PixelDataRangeNV_; + public static Delegates.FlushPixelDataRangeNV FlushPixelDataRangeNV; + public static Delegates.PrimitiveRestartNV PrimitiveRestartNV; + public static Delegates.PrimitiveRestartIndexNV PrimitiveRestartIndexNV; + public static Delegates.MapObjectBufferATI_ MapObjectBufferATI_; + public static Delegates.UnmapObjectBufferATI UnmapObjectBufferATI; + public static Delegates.StencilOpSeparateATI StencilOpSeparateATI; + public static Delegates.StencilFuncSeparateATI StencilFuncSeparateATI; + public static Delegates.VertexAttribArrayObjectATI VertexAttribArrayObjectATI; + public static Delegates.GetVertexAttribArrayObjectfvATI GetVertexAttribArrayObjectfvATI; + public static Delegates.GetVertexAttribArrayObjectivATI GetVertexAttribArrayObjectivATI; + public static Delegates.DepthBoundsEXT DepthBoundsEXT; + public static Delegates.BlendEquationSeparateEXT BlendEquationSeparateEXT; + public static Delegates.IsRenderbufferEXT IsRenderbufferEXT; + public static Delegates.BindRenderbufferEXT BindRenderbufferEXT; + public static Delegates.DeleteRenderbuffersEXT DeleteRenderbuffersEXT; + public static Delegates.GenRenderbuffersEXT GenRenderbuffersEXT; + public static Delegates.RenderbufferStorageEXT RenderbufferStorageEXT; + public static Delegates.GetRenderbufferParameterivEXT GetRenderbufferParameterivEXT; + public static Delegates.IsFramebufferEXT IsFramebufferEXT; + public static Delegates.BindFramebufferEXT BindFramebufferEXT; + public static Delegates.DeleteFramebuffersEXT DeleteFramebuffersEXT; + public static Delegates.GenFramebuffersEXT GenFramebuffersEXT; + public static Delegates.CheckFramebufferStatusEXT CheckFramebufferStatusEXT; + public static Delegates.FramebufferTexture1DEXT FramebufferTexture1DEXT; + public static Delegates.FramebufferTexture2DEXT FramebufferTexture2DEXT; + public static Delegates.FramebufferTexture3DEXT FramebufferTexture3DEXT; + public static Delegates.FramebufferRenderbufferEXT FramebufferRenderbufferEXT; + public static Delegates.GetFramebufferAttachmentParameterivEXT GetFramebufferAttachmentParameterivEXT; + public static Delegates.GenerateMipmapEXT GenerateMipmapEXT; + public static Delegates.StringMarkerGREMEDY_ StringMarkerGREMEDY_; + #endregion + + #region Wrappers + + #region CallLists + public static void CallLists(GLsizei n, Enums.ListNameType type, object lists) + { + GCHandle h0 = GCHandle.Alloc(lists, GCHandleType.Pinned); + try + { + CallLists_(n, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region DrawPixels + public static void DrawPixels(GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels) + { + GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned); + try + { + DrawPixels_(width, height, format, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region ColorPointer + public static void ColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + ColorPointer_(size, type, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region DrawElements + public static void DrawElements(Enums.BeginMode mode, GLsizei count, GLenum type, object indices) + { + GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned); + try + { + DrawElements_(mode, count, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region EdgeFlagPointer + public static void EdgeFlagPointer(GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + EdgeFlagPointer_(stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region IndexPointer + public static void IndexPointer(Enums.IndexPointerType type, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + IndexPointer_(type, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region InterleavedArrays + public static void InterleavedArrays(Enums.InterleavedArrayFormat format, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + InterleavedArrays_(format, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region NormalPointer + public static void NormalPointer(Enums.NormalPointerType type, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + NormalPointer_(type, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region TexCoordPointer + public static void TexCoordPointer(GLint size, Enums.TexCoordPointerType type, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + TexCoordPointer_(size, type, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region VertexPointer + public static void VertexPointer(GLint size, Enums.VertexPointerType type, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + VertexPointer_(size, type, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region DrawRangeElements + public static void DrawRangeElements(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, GLenum type, object indices) + { + GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned); + try + { + DrawRangeElements_(mode, start, end, count, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region ColorTable + public static void ColorTable(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table) + { + GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned); + try + { + ColorTable_(target, internalformat, width, format, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region ColorSubTable + public static void ColorSubTable(GLenum target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, object data) + { + GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned); + try + { + ColorSubTable_(target, start, count, format, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region ConvolutionFilter1D + public static void ConvolutionFilter1D(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object image) + { + GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned); + try + { + ConvolutionFilter1D_(target, internalformat, width, format, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region ConvolutionFilter2D + public static void ConvolutionFilter2D(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object image) + { + GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned); + try + { + ConvolutionFilter2D_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region SeparableFilter2D + public static void SeparableFilter2D(GLenum target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, object column) + { + GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned); + GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned); + try + { + SeparableFilter2D_(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject()); + } + finally + { + h1.Free(); + h0.Free(); + } + } + #endregion + + #region FogCoordPointer + public static void FogCoordPointer(GLenum type, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + FogCoordPointer_(type, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region SecondaryColorPointer + public static void SecondaryColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + SecondaryColorPointer_(size, type, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region BufferData + public static void BufferData(GLenum target, GLsizeiptr size, object data, GLenum usage) + { + GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned); + try + { + BufferData_(target, size, h0.AddrOfPinnedObject(), usage); + } + finally + { + h0.Free(); + } + } + #endregion + + #region BufferSubData + public static void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, object data) + { + GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned); + try + { + BufferSubData_(target, offset, size, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #region MapBuffer + #endregion + + #region VertexAttribPointer + public static void VertexAttribPointer(GLuint index, GLint size, GLenum type, Enums.Boolean normalized, GLsizei stride, object pointer) + { + GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned); + try + { + VertexAttribPointer_(index, size, type, normalized, stride, h0.AddrOfPinnedObject()); + } + finally + { + h0.Free(); + } + } + #endregion + + #endregion + + } +} + diff --git a/Source/OpenGL/OpenGL/Bindings/WindowsContextLoad.cs b/Source/OpenGL/OpenGL/Bindings/WindowsContextLoad.cs index 80229d4b..ddbce018 100644 --- a/Source/OpenGL/OpenGL/Bindings/WindowsContextLoad.cs +++ b/Source/OpenGL/OpenGL/Bindings/WindowsContextLoad.cs @@ -1,2472 +1,353 @@ using System; using System.Runtime.InteropServices; -using OpenTK.OpenGL; namespace OpenTK.OpenGL.Platform { public partial class WindowsContext { - #region DllImports + #region OpenGL core and extension function loading - internal class Imports - { - [DllImport(_dll_name, EntryPoint = "glNewList")] - public static extern void NewList(uint list, Enums.ListMode mode); - - [DllImport(_dll_name, EntryPoint = "glEndList")] - public static extern void EndList(); - - [DllImport(_dll_name, EntryPoint = "glCallList")] - public static extern void CallList(uint list); - - [DllImport(_dll_name, EntryPoint = "glCallLists")] - public static extern void CallLists(int n, Enums.ListNameType type, [MarshalAs(UnmanagedType.AsAny)] object lists); - - [DllImport(_dll_name, EntryPoint = "glDeleteLists")] - public static extern void DeleteLists(uint list, int range); - - [DllImport(_dll_name, EntryPoint = "glGenLists")] - public static extern uint GenLists(int range); - - [DllImport(_dll_name, EntryPoint = "glListBase")] - public static extern void ListBase(uint @base); - - [DllImport(_dll_name, EntryPoint = "glBegin")] - public static extern void Begin(Enums.BeginMode mode); - - [DllImport(_dll_name, EntryPoint = "glBitmap")] - public static extern void Bitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, byte[] bitmap); - - [DllImport(_dll_name, EntryPoint = "glColor3b")] - public static extern void Color3b(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glColor3bv")] - public static extern void Color3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3d")] - public static extern void Color3d(double red, double green, double blue); - - [DllImport(_dll_name, EntryPoint = "glColor3dv")] - public static extern void Color3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3f")] - public static extern void Color3f(float red, float green, float blue); - - [DllImport(_dll_name, EntryPoint = "glColor3fv")] - public static extern void Color3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3i")] - public static extern void Color3i(int red, int green, int blue); - - [DllImport(_dll_name, EntryPoint = "glColor3iv")] - public static extern void Color3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3s")] - public static extern void Color3s(short red, short green, short blue); - - [DllImport(_dll_name, EntryPoint = "glColor3sv")] - public static extern void Color3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3ub")] - public static extern void Color3ub(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glColor3ubv")] - public static extern void Color3ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3ui")] - public static extern void Color3ui(uint red, uint green, uint blue); - - [DllImport(_dll_name, EntryPoint = "glColor3uiv")] - public static extern void Color3uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3us")] - public static extern void Color3us(ushort red, ushort green, ushort blue); - - [DllImport(_dll_name, EntryPoint = "glColor3usv")] - public static extern void Color3usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4b")] - public static extern void Color4b(byte red, byte green, byte blue, byte alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4bv")] - public static extern void Color4bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4d")] - public static extern void Color4d(double red, double green, double blue, double alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4dv")] - public static extern void Color4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4f")] - public static extern void Color4f(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4fv")] - public static extern void Color4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4i")] - public static extern void Color4i(int red, int green, int blue, int alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4iv")] - public static extern void Color4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4s")] - public static extern void Color4s(short red, short green, short blue, short alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4sv")] - public static extern void Color4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4ub")] - public static extern void Color4ub(byte red, byte green, byte blue, byte alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4ubv")] - public static extern void Color4ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4ui")] - public static extern void Color4ui(uint red, uint green, uint blue, uint alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4uiv")] - public static extern void Color4uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4us")] - public static extern void Color4us(ushort red, ushort green, ushort blue, ushort alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4usv")] - public static extern void Color4usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlag")] - public static extern void EdgeFlag(bool flag); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlagv")] - public static extern void EdgeFlagv(bool[] flag); - - [DllImport(_dll_name, EntryPoint = "glEnd")] - public static extern void End(); - - [DllImport(_dll_name, EntryPoint = "glIndexd")] - public static extern void Indexd(double c); - - [DllImport(_dll_name, EntryPoint = "glIndexdv")] - public static extern void Indexdv(double[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexf")] - public static extern void Indexf(float c); - - [DllImport(_dll_name, EntryPoint = "glIndexfv")] - public static extern void Indexfv(float[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexi")] - public static extern void Indexi(int c); - - [DllImport(_dll_name, EntryPoint = "glIndexiv")] - public static extern void Indexiv(int[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexs")] - public static extern void Indexs(short c); - - [DllImport(_dll_name, EntryPoint = "glIndexsv")] - public static extern void Indexsv(short[] c); - - [DllImport(_dll_name, EntryPoint = "glNormal3b")] - public static extern void Normal3b(byte nx, byte ny, byte nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3bv")] - public static extern void Normal3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3d")] - public static extern void Normal3d(double nx, double ny, double nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3dv")] - public static extern void Normal3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3f")] - public static extern void Normal3f(float nx, float ny, float nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3fv")] - public static extern void Normal3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3i")] - public static extern void Normal3i(int nx, int ny, int nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3iv")] - public static extern void Normal3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3s")] - public static extern void Normal3s(short nx, short ny, short nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3sv")] - public static extern void Normal3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2d")] - public static extern void RasterPos2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2dv")] - public static extern void RasterPos2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2f")] - public static extern void RasterPos2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2fv")] - public static extern void RasterPos2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2i")] - public static extern void RasterPos2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2iv")] - public static extern void RasterPos2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2s")] - public static extern void RasterPos2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2sv")] - public static extern void RasterPos2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3d")] - public static extern void RasterPos3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3dv")] - public static extern void RasterPos3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3f")] - public static extern void RasterPos3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3fv")] - public static extern void RasterPos3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3i")] - public static extern void RasterPos3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3iv")] - public static extern void RasterPos3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3s")] - public static extern void RasterPos3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3sv")] - public static extern void RasterPos3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4d")] - public static extern void RasterPos4d(double x, double y, double z, double w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4dv")] - public static extern void RasterPos4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4f")] - public static extern void RasterPos4f(float x, float y, float z, float w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4fv")] - public static extern void RasterPos4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4i")] - public static extern void RasterPos4i(int x, int y, int z, int w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4iv")] - public static extern void RasterPos4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4s")] - public static extern void RasterPos4s(short x, short y, short z, short w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4sv")] - public static extern void RasterPos4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRectd")] - public static extern void Rectd(double x1, double y1, double x2, double y2); - - [DllImport(_dll_name, EntryPoint = "glRectdv")] - public static extern void Rectdv(double[] v1, double[] v2); - - [DllImport(_dll_name, EntryPoint = "glRectf")] - public static extern void Rectf(float x1, float y1, float x2, float y2); - - [DllImport(_dll_name, EntryPoint = "glRectfv")] - public static extern void Rectfv(float[] v1, float[] v2); - - [DllImport(_dll_name, EntryPoint = "glRecti")] - public static extern void Recti(int x1, int y1, int x2, int y2); - - [DllImport(_dll_name, EntryPoint = "glRectiv")] - public static extern void Rectiv(int[] v1, int[] v2); - - [DllImport(_dll_name, EntryPoint = "glRects")] - public static extern void Rects(short x1, short y1, short x2, short y2); - - [DllImport(_dll_name, EntryPoint = "glRectsv")] - public static extern void Rectsv(short[] v1, short[] v2); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1d")] - public static extern void TexCoord1d(double s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1dv")] - public static extern void TexCoord1dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1f")] - public static extern void TexCoord1f(float s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1fv")] - public static extern void TexCoord1fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1i")] - public static extern void TexCoord1i(int s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1iv")] - public static extern void TexCoord1iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1s")] - public static extern void TexCoord1s(short s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1sv")] - public static extern void TexCoord1sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2d")] - public static extern void TexCoord2d(double s, double t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2dv")] - public static extern void TexCoord2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2f")] - public static extern void TexCoord2f(float s, float t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2fv")] - public static extern void TexCoord2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2i")] - public static extern void TexCoord2i(int s, int t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2iv")] - public static extern void TexCoord2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2s")] - public static extern void TexCoord2s(short s, short t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2sv")] - public static extern void TexCoord2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3d")] - public static extern void TexCoord3d(double s, double t, double r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3dv")] - public static extern void TexCoord3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3f")] - public static extern void TexCoord3f(float s, float t, float r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3fv")] - public static extern void TexCoord3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3i")] - public static extern void TexCoord3i(int s, int t, int r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3iv")] - public static extern void TexCoord3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3s")] - public static extern void TexCoord3s(short s, short t, short r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3sv")] - public static extern void TexCoord3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4d")] - public static extern void TexCoord4d(double s, double t, double r, double q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4dv")] - public static extern void TexCoord4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4f")] - public static extern void TexCoord4f(float s, float t, float r, float q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4fv")] - public static extern void TexCoord4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4i")] - public static extern void TexCoord4i(int s, int t, int r, int q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4iv")] - public static extern void TexCoord4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4s")] - public static extern void TexCoord4s(short s, short t, short r, short q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4sv")] - public static extern void TexCoord4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2d")] - public static extern void Vertex2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glVertex2dv")] - public static extern void Vertex2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2f")] - public static extern void Vertex2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glVertex2fv")] - public static extern void Vertex2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2i")] - public static extern void Vertex2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glVertex2iv")] - public static extern void Vertex2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2s")] - public static extern void Vertex2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glVertex2sv")] - public static extern void Vertex2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3d")] - public static extern void Vertex3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glVertex3dv")] - public static extern void Vertex3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3f")] - public static extern void Vertex3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glVertex3fv")] - public static extern void Vertex3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3i")] - public static extern void Vertex3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glVertex3iv")] - public static extern void Vertex3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3s")] - public static extern void Vertex3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glVertex3sv")] - public static extern void Vertex3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4d")] - public static extern void Vertex4d(double x, double y, double z, double w); - - [DllImport(_dll_name, EntryPoint = "glVertex4dv")] - public static extern void Vertex4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4f")] - public static extern void Vertex4f(float x, float y, float z, float w); - - [DllImport(_dll_name, EntryPoint = "glVertex4fv")] - public static extern void Vertex4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4i")] - public static extern void Vertex4i(int x, int y, int z, int w); - - [DllImport(_dll_name, EntryPoint = "glVertex4iv")] - public static extern void Vertex4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4s")] - public static extern void Vertex4s(short x, short y, short z, short w); - - [DllImport(_dll_name, EntryPoint = "glVertex4sv")] - public static extern void Vertex4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glClipPlane")] - public static extern void ClipPlane(Enums.ClipPlaneName plane, double[] equation); - - [DllImport(_dll_name, EntryPoint = "glColorMaterial")] - public static extern void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode); - - [DllImport(_dll_name, EntryPoint = "glCullFace")] - public static extern void CullFace(Enums.CullFaceMode mode); - - [DllImport(_dll_name, EntryPoint = "glFogf")] - public static extern void Fogf(Enums.FogParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glFogfv")] - public static extern void Fogfv(Enums.FogParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFogi")] - public static extern void Fogi(Enums.FogParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glFogiv")] - public static extern void Fogiv(Enums.FogParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFrontFace")] - public static extern void FrontFace(Enums.FrontFaceDirection mode); - - [DllImport(_dll_name, EntryPoint = "glHint")] - public static extern void Hint(Enums.HintTarget target, Enums.HintMode mode); - - [DllImport(_dll_name, EntryPoint = "glLightf")] - public static extern void Lightf(Enums.LightName light, Enums.LightParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glLightfv")] - public static extern void Lightfv(Enums.LightName light, Enums.LightParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLighti")] - public static extern void Lighti(Enums.LightName light, Enums.LightParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glLightiv")] - public static extern void Lightiv(Enums.LightName light, Enums.LightParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLightModelf")] - public static extern void LightModelf(Enums.LightModelParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glLightModelfv")] - public static extern void LightModelfv(Enums.LightModelParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLightModeli")] - public static extern void LightModeli(Enums.LightModelParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glLightModeliv")] - public static extern void LightModeliv(Enums.LightModelParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLineStipple")] - public static extern void LineStipple(int factor, ushort pattern); - - [DllImport(_dll_name, EntryPoint = "glLineWidth")] - public static extern void LineWidth(float width); - - [DllImport(_dll_name, EntryPoint = "glMaterialf")] - public static extern void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glMaterialfv")] - public static extern void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glMateriali")] - public static extern void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glMaterialiv")] - public static extern void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glPointSize")] - public static extern void PointSize(float size); - - [DllImport(_dll_name, EntryPoint = "glPolygonMode")] - public static extern void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode); - - [DllImport(_dll_name, EntryPoint = "glPolygonStipple")] - public static extern void PolygonStipple(byte[] mask); - - [DllImport(_dll_name, EntryPoint = "glScissor")] - public static extern void Scissor(int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glShadeModel")] - public static extern void ShadeModel(Enums.ShadingModel mode); - - [DllImport(_dll_name, EntryPoint = "glTexParameterf")] - public static extern void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexParameterfv")] - public static extern void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexParameteri")] - public static extern void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexParameteriv")] - public static extern void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexImage1D")] - public static extern void TexImage1D(Enums.TextureTarget target, int level, int internalformat, int width, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexImage2D")] - public static extern void TexImage2D(Enums.TextureTarget target, int level, int internalformat, int width, int height, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexEnvf")] - public static extern void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexEnvfv")] - public static extern void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexEnvi")] - public static extern void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexEnviv")] - public static extern void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGend")] - public static extern void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, double param); - - [DllImport(_dll_name, EntryPoint = "glTexGendv")] - public static extern void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGenf")] - public static extern void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexGenfv")] - public static extern void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGeni")] - public static extern void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexGeniv")] - public static extern void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFeedbackBuffer")] - public static extern void FeedbackBuffer(int size, Enums.FeedbackType type, out float[] buffer); - - [DllImport(_dll_name, EntryPoint = "glSelectBuffer")] - public static extern void SelectBuffer(int size, out uint[] buffer); - - [DllImport(_dll_name, EntryPoint = "glRenderMode")] - public static extern int RenderMode(Enums.RenderingMode mode); - - [DllImport(_dll_name, EntryPoint = "glInitNames")] - public static extern void InitNames(); - - [DllImport(_dll_name, EntryPoint = "glLoadName")] - public static extern void LoadName(uint name); - - [DllImport(_dll_name, EntryPoint = "glPassThrough")] - public static extern void PassThrough(float token); - - [DllImport(_dll_name, EntryPoint = "glPopName")] - public static extern void PopName(); - - [DllImport(_dll_name, EntryPoint = "glPushName")] - public static extern void PushName(uint name); - - [DllImport(_dll_name, EntryPoint = "glDrawBuffer")] - public static extern void DrawBuffer(Enums.DrawBufferMode mode); - - [DllImport(_dll_name, EntryPoint = "glClear")] - public static extern void Clear(Enums.ClearBufferMask mask); - - [DllImport(_dll_name, EntryPoint = "glClearAccum")] - public static extern void ClearAccum(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glClearIndex")] - public static extern void ClearIndex(float c); - - [DllImport(_dll_name, EntryPoint = "glClearColor")] - public static extern void ClearColor(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glClearStencil")] - public static extern void ClearStencil(int s); - - [DllImport(_dll_name, EntryPoint = "glClearDepth")] - public static extern void ClearDepth(double depth); - - [DllImport(_dll_name, EntryPoint = "glStencilMask")] - public static extern void StencilMask(uint mask); - - [DllImport(_dll_name, EntryPoint = "glColorMask")] - public static extern void ColorMask(bool red, bool green, bool blue, bool alpha); - - [DllImport(_dll_name, EntryPoint = "glDepthMask")] - public static extern void DepthMask(bool flag); - - [DllImport(_dll_name, EntryPoint = "glIndexMask")] - public static extern void IndexMask(uint mask); - - [DllImport(_dll_name, EntryPoint = "glAccum")] - public static extern void Accum(Enums.AccumOp op, float value); - - [DllImport(_dll_name, EntryPoint = "glDisable")] - public static extern void Disable(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glEnable")] - public static extern void Enable(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glFinish")] - public static extern void Finish(); - - [DllImport(_dll_name, EntryPoint = "glFlush")] - public static extern void Flush(); - - [DllImport(_dll_name, EntryPoint = "glPopAttrib")] - public static extern void PopAttrib(); - - [DllImport(_dll_name, EntryPoint = "glPushAttrib")] - public static extern void PushAttrib(Enums.AttribMask mask); - - [DllImport(_dll_name, EntryPoint = "glMap1d")] - public static extern void Map1d(Enums.MapTarget target, double u1, double u2, int stride, int order, double[] points); - - [DllImport(_dll_name, EntryPoint = "glMap1f")] - public static extern void Map1f(Enums.MapTarget target, float u1, float u2, int stride, int order, float[] points); - - [DllImport(_dll_name, EntryPoint = "glMap2d")] - public static extern void Map2d(Enums.MapTarget target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points); - - [DllImport(_dll_name, EntryPoint = "glMap2f")] - public static extern void Map2f(Enums.MapTarget target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points); - - [DllImport(_dll_name, EntryPoint = "glMapGrid1d")] - public static extern void MapGrid1d(int un, double u1, double u2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid1f")] - public static extern void MapGrid1f(int un, float u1, float u2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid2d")] - public static extern void MapGrid2d(int un, double u1, double u2, int vn, double v1, double v2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid2f")] - public static extern void MapGrid2f(int un, float u1, float u2, int vn, float v1, float v2); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1d")] - public static extern void EvalCoord1d(double u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1dv")] - public static extern void EvalCoord1dv(double[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1f")] - public static extern void EvalCoord1f(float u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1fv")] - public static extern void EvalCoord1fv(float[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2d")] - public static extern void EvalCoord2d(double u, double v); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2dv")] - public static extern void EvalCoord2dv(double[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2f")] - public static extern void EvalCoord2f(float u, float v); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2fv")] - public static extern void EvalCoord2fv(float[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalMesh1")] - public static extern void EvalMesh1(Enums.MeshMode1 mode, int i1, int i2); - - [DllImport(_dll_name, EntryPoint = "glEvalPoint1")] - public static extern void EvalPoint1(int i); - - [DllImport(_dll_name, EntryPoint = "glEvalMesh2")] - public static extern void EvalMesh2(Enums.MeshMode2 mode, int i1, int i2, int j1, int j2); - - [DllImport(_dll_name, EntryPoint = "glEvalPoint2")] - public static extern void EvalPoint2(int i, int j); - - [DllImport(_dll_name, EntryPoint = "glAlphaFunc")] - public static extern void AlphaFunc(Enums.AlphaFunction func, float reference); - - [DllImport(_dll_name, EntryPoint = "glBlendFunc")] - public static extern void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor); - - [DllImport(_dll_name, EntryPoint = "glLogicOp")] - public static extern void LogicOp(Enums.LogicOp opcode); - - [DllImport(_dll_name, EntryPoint = "glStencilFunc")] - public static extern void StencilFunc(Enums.StencilFunction func, int reference, uint mask); - - [DllImport(_dll_name, EntryPoint = "glStencilOp")] - public static extern void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass); - - [DllImport(_dll_name, EntryPoint = "glDepthFunc")] - public static extern void DepthFunc(Enums.DepthFunction func); - - [DllImport(_dll_name, EntryPoint = "glPixelZoom")] - public static extern void PixelZoom(float xfactor, float yfactor); - - [DllImport(_dll_name, EntryPoint = "glPixelTransferf")] - public static extern void PixelTransferf(Enums.PixelTransferParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPixelTransferi")] - public static extern void PixelTransferi(Enums.PixelTransferParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPixelStoref")] - public static extern void PixelStoref(Enums.PixelStoreParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPixelStorei")] - public static extern void PixelStorei(Enums.PixelStoreParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPixelMapfv")] - public static extern void PixelMapfv(Enums.PixelMap map, int mapsize, float[] values); - - [DllImport(_dll_name, EntryPoint = "glPixelMapuiv")] - public static extern void PixelMapuiv(Enums.PixelMap map, int mapsize, uint[] values); - - [DllImport(_dll_name, EntryPoint = "glPixelMapusv")] - public static extern void PixelMapusv(Enums.PixelMap map, int mapsize, ushort[] values); - - [DllImport(_dll_name, EntryPoint = "glReadBuffer")] - public static extern void ReadBuffer(Enums.ReadBufferMode mode); - - [DllImport(_dll_name, EntryPoint = "glCopyPixels")] - public static extern void CopyPixels(int x, int y, int width, int height, Enums.PixelCopyType type); - - [DllImport(_dll_name, EntryPoint = "glReadPixels")] - public static extern void ReadPixels(int x, int y, int width, int height, Enums.PixelFormat format, Enums.PixelType type, out object pixels); - - [DllImport(_dll_name, EntryPoint = "glDrawPixels")] - public static extern void DrawPixels(int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glGetBooleanv")] - public static extern void GetBooleanv(Enums.GetPName pname, out bool[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetClipPlane")] - public static extern void GetClipPlane(Enums.ClipPlaneName plane, out double[] equation); - - [DllImport(_dll_name, EntryPoint = "glGetDoublev")] - public static extern void GetDoublev(Enums.GetPName pname, out double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetError")] - public static extern Enums.ErrorCode GetError(); - - [DllImport(_dll_name, EntryPoint = "glGetFloatv")] - public static extern void GetFloatv(Enums.GetPName pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetIntegerv")] - public static extern void GetIntegerv(Enums.GetPName pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetLightfv")] - public static extern void GetLightfv(Enums.LightName light, Enums.LightParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetLightiv")] - public static extern void GetLightiv(Enums.LightName light, Enums.LightParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMapdv")] - public static extern void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, out double[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMapfv")] - public static extern void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, out float[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMapiv")] - public static extern void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, out int[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMaterialfv")] - public static extern void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMaterialiv")] - public static extern void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapfv")] - public static extern void GetPixelMapfv(Enums.PixelMap map, out float[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapuiv")] - public static extern void GetPixelMapuiv(Enums.PixelMap map, out uint[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapusv")] - public static extern void GetPixelMapusv(Enums.PixelMap map, out ushort[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPolygonStipple")] - public static extern void GetPolygonStipple(out byte[] mask); - - [DllImport(_dll_name, EntryPoint = "glGetString")] - public static extern string GetString(Enums.StringName name); - - [DllImport(_dll_name, EntryPoint = "glGetTexEnvfv")] - public static extern void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexEnviv")] - public static extern void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGendv")] - public static extern void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGenfv")] - public static extern void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGeniv")] - public static extern void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexImage")] - public static extern void GetTexImage(Enums.TextureTarget target, int level, Enums.PixelFormat format, Enums.PixelType type, out object pixels); - - [DllImport(_dll_name, EntryPoint = "glGetTexParameterfv")] - public static extern void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexParameteriv")] - public static extern void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexLevelParameterfv")] - public static extern void GetTexLevelParameterfv(Enums.TextureTarget target, int level, Enums.GetTextureParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexLevelParameteriv")] - public static extern void GetTexLevelParameteriv(Enums.TextureTarget target, int level, Enums.GetTextureParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glIsEnabled")] - public static extern bool IsEnabled(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glIsList")] - public static extern bool IsList(uint list); - - [DllImport(_dll_name, EntryPoint = "glDepthRange")] - public static extern void DepthRange(double near, double far); - - [DllImport(_dll_name, EntryPoint = "glFrustum")] - public static extern void Frustum(double left, double right, double bottom, double top, double zNear, double zFar); - - [DllImport(_dll_name, EntryPoint = "glLoadIdentity")] - public static extern void LoadIdentity(); - - [DllImport(_dll_name, EntryPoint = "glLoadMatrixf")] - public static extern void LoadMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glLoadMatrixd")] - public static extern void LoadMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glMatrixMode")] - public static extern void MatrixMode(Enums.MatrixMode mode); - - [DllImport(_dll_name, EntryPoint = "glMultMatrixf")] - public static extern void MultMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glMultMatrixd")] - public static extern void MultMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glOrtho")] - public static extern void Ortho(double left, double right, double bottom, double top, double zNear, double zFar); - - [DllImport(_dll_name, EntryPoint = "glPopMatrix")] - public static extern void PopMatrix(); - - [DllImport(_dll_name, EntryPoint = "glPushMatrix")] - public static extern void PushMatrix(); - - [DllImport(_dll_name, EntryPoint = "glRotated")] - public static extern void Rotated(double angle, double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glRotatef")] - public static extern void Rotatef(float angle, float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glScaled")] - public static extern void Scaled(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glScalef")] - public static extern void Scalef(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glTranslated")] - public static extern void Translated(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glTranslatef")] - public static extern void Translatef(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glViewport")] - public static extern void Viewport(int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glArrayElement")] - public static extern void ArrayElement(int i); - - [DllImport(_dll_name, EntryPoint = "glColorPointer")] - public static extern void ColorPointer(int size, Enums.ColorPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glDisableClientState")] - public static extern void DisableClientState(Enums.EnableCap array); - - [DllImport(_dll_name, EntryPoint = "glDrawArrays")] - public static extern void DrawArrays(Enums.BeginMode mode, int first, int count); - - [DllImport(_dll_name, EntryPoint = "glDrawElements")] - public static extern void DrawElements(Enums.BeginMode mode, int count, uint type, [MarshalAs(UnmanagedType.AsAny)] object indices); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlagPointer")] - public static extern void EdgeFlagPointer(int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glEnableClientState")] - public static extern void EnableClientState(Enums.EnableCap array); - - [DllImport(_dll_name, EntryPoint = "glGetPointerv")] - public static extern void GetPointerv(Enums.GetPointervPName pname, out object parameters); - - [DllImport(_dll_name, EntryPoint = "glIndexPointer")] - public static extern void IndexPointer(Enums.IndexPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glInterleavedArrays")] - public static extern void InterleavedArrays(Enums.InterleavedArrayFormat format, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glNormalPointer")] - public static extern void NormalPointer(Enums.NormalPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glTexCoordPointer")] - public static extern void TexCoordPointer(int size, Enums.TexCoordPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glVertexPointer")] - public static extern void VertexPointer(int size, Enums.VertexPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glPolygonOffset")] - public static extern void PolygonOffset(float factor, float units); - - [DllImport(_dll_name, EntryPoint = "glCopyTexImage1D")] - public static extern void CopyTexImage1D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int x, int y, int width, int border); - - [DllImport(_dll_name, EntryPoint = "glCopyTexImage2D")] - public static extern void CopyTexImage2D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int x, int y, int width, int height, int border); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage1D")] - public static extern void CopyTexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage2D")] - public static extern void CopyTexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage1D")] - public static extern void TexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int width, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage2D")] - public static extern void TexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glAreTexturesResident")] - public static extern bool AreTexturesResident(int n, uint[] textures, out bool[] residences); - - [DllImport(_dll_name, EntryPoint = "glBindTexture")] - public static extern void BindTexture(Enums.TextureTarget target, uint texture); - - [DllImport(_dll_name, EntryPoint = "glDeleteTextures")] - public static extern void DeleteTextures(int n, uint[] textures); - - [DllImport(_dll_name, EntryPoint = "glGenTextures")] - public static extern void GenTextures(int n, out uint[] textures); - - [DllImport(_dll_name, EntryPoint = "glIsTexture")] - public static extern bool IsTexture(uint texture); - - [DllImport(_dll_name, EntryPoint = "glPrioritizeTextures")] - public static extern void PrioritizeTextures(int n, uint[] textures, float[] priorities); - - [DllImport(_dll_name, EntryPoint = "glIndexub")] - public static extern void Indexub(byte c); - - [DllImport(_dll_name, EntryPoint = "glIndexubv")] - public static extern void Indexubv(byte[] c); - - [DllImport(_dll_name, EntryPoint = "glPopClientAttrib")] - public static extern void PopClientAttrib(); - - [DllImport(_dll_name, EntryPoint = "glPushClientAttrib")] - public static extern void PushClientAttrib(Enums.ClientAttribMask mask); - - } - #endregion - - #region Load core - - /// - /// Loads the core opengl functions (versions 1.0-2.0). - /// public override void Load() { - if (GL.CoreLoaded) return; - if (GL.ExtensionsLoaded) return; - GL.NewList = new GL.Delegates.NewList(Imports.NewList); - GL.EndList = new GL.Delegates.EndList(Imports.EndList); - GL.CallList = new GL.Delegates.CallList(Imports.CallList); - GL.CallLists = new GL.Delegates.CallLists(Imports.CallLists); - GL.DeleteLists = new GL.Delegates.DeleteLists(Imports.DeleteLists); - GL.GenLists = new GL.Delegates.GenLists(Imports.GenLists); - GL.ListBase = new GL.Delegates.ListBase(Imports.ListBase); - GL.Begin = new GL.Delegates.Begin(Imports.Begin); - GL.Bitmap = new GL.Delegates.Bitmap(Imports.Bitmap); - GL.Color3b = new GL.Delegates.Color3b(Imports.Color3b); - GL.Color3bv = new GL.Delegates.Color3bv(Imports.Color3bv); - GL.Color3d = new GL.Delegates.Color3d(Imports.Color3d); - GL.Color3dv = new GL.Delegates.Color3dv(Imports.Color3dv); - GL.Color3f = new GL.Delegates.Color3f(Imports.Color3f); - GL.Color3fv = new GL.Delegates.Color3fv(Imports.Color3fv); - GL.Color3i = new GL.Delegates.Color3i(Imports.Color3i); - GL.Color3iv = new GL.Delegates.Color3iv(Imports.Color3iv); - GL.Color3s = new GL.Delegates.Color3s(Imports.Color3s); - GL.Color3sv = new GL.Delegates.Color3sv(Imports.Color3sv); - GL.Color3ub = new GL.Delegates.Color3ub(Imports.Color3ub); - GL.Color3ubv = new GL.Delegates.Color3ubv(Imports.Color3ubv); - GL.Color3ui = new GL.Delegates.Color3ui(Imports.Color3ui); - GL.Color3uiv = new GL.Delegates.Color3uiv(Imports.Color3uiv); - GL.Color3us = new GL.Delegates.Color3us(Imports.Color3us); - GL.Color3usv = new GL.Delegates.Color3usv(Imports.Color3usv); - GL.Color4b = new GL.Delegates.Color4b(Imports.Color4b); - GL.Color4bv = new GL.Delegates.Color4bv(Imports.Color4bv); - GL.Color4d = new GL.Delegates.Color4d(Imports.Color4d); - GL.Color4dv = new GL.Delegates.Color4dv(Imports.Color4dv); - GL.Color4f = new GL.Delegates.Color4f(Imports.Color4f); - GL.Color4fv = new GL.Delegates.Color4fv(Imports.Color4fv); - GL.Color4i = new GL.Delegates.Color4i(Imports.Color4i); - GL.Color4iv = new GL.Delegates.Color4iv(Imports.Color4iv); - GL.Color4s = new GL.Delegates.Color4s(Imports.Color4s); - GL.Color4sv = new GL.Delegates.Color4sv(Imports.Color4sv); - GL.Color4ub = new GL.Delegates.Color4ub(Imports.Color4ub); - GL.Color4ubv = new GL.Delegates.Color4ubv(Imports.Color4ubv); - GL.Color4ui = new GL.Delegates.Color4ui(Imports.Color4ui); - GL.Color4uiv = new GL.Delegates.Color4uiv(Imports.Color4uiv); - GL.Color4us = new GL.Delegates.Color4us(Imports.Color4us); - GL.Color4usv = new GL.Delegates.Color4usv(Imports.Color4usv); - GL.EdgeFlag = new GL.Delegates.EdgeFlag(Imports.EdgeFlag); - GL.EdgeFlagv = new GL.Delegates.EdgeFlagv(Imports.EdgeFlagv); - GL.End = new GL.Delegates.End(Imports.End); - GL.Indexd = new GL.Delegates.Indexd(Imports.Indexd); - GL.Indexdv = new GL.Delegates.Indexdv(Imports.Indexdv); - GL.Indexf = new GL.Delegates.Indexf(Imports.Indexf); - GL.Indexfv = new GL.Delegates.Indexfv(Imports.Indexfv); - GL.Indexi = new GL.Delegates.Indexi(Imports.Indexi); - GL.Indexiv = new GL.Delegates.Indexiv(Imports.Indexiv); - GL.Indexs = new GL.Delegates.Indexs(Imports.Indexs); - GL.Indexsv = new GL.Delegates.Indexsv(Imports.Indexsv); - GL.Normal3b = new GL.Delegates.Normal3b(Imports.Normal3b); - GL.Normal3bv = new GL.Delegates.Normal3bv(Imports.Normal3bv); - GL.Normal3d = new GL.Delegates.Normal3d(Imports.Normal3d); - GL.Normal3dv = new GL.Delegates.Normal3dv(Imports.Normal3dv); - GL.Normal3f = new GL.Delegates.Normal3f(Imports.Normal3f); - GL.Normal3fv = new GL.Delegates.Normal3fv(Imports.Normal3fv); - GL.Normal3i = new GL.Delegates.Normal3i(Imports.Normal3i); - GL.Normal3iv = new GL.Delegates.Normal3iv(Imports.Normal3iv); - GL.Normal3s = new GL.Delegates.Normal3s(Imports.Normal3s); - GL.Normal3sv = new GL.Delegates.Normal3sv(Imports.Normal3sv); - GL.RasterPos2d = new GL.Delegates.RasterPos2d(Imports.RasterPos2d); - GL.RasterPos2dv = new GL.Delegates.RasterPos2dv(Imports.RasterPos2dv); - GL.RasterPos2f = new GL.Delegates.RasterPos2f(Imports.RasterPos2f); - GL.RasterPos2fv = new GL.Delegates.RasterPos2fv(Imports.RasterPos2fv); - GL.RasterPos2i = new GL.Delegates.RasterPos2i(Imports.RasterPos2i); - GL.RasterPos2iv = new GL.Delegates.RasterPos2iv(Imports.RasterPos2iv); - GL.RasterPos2s = new GL.Delegates.RasterPos2s(Imports.RasterPos2s); - GL.RasterPos2sv = new GL.Delegates.RasterPos2sv(Imports.RasterPos2sv); - GL.RasterPos3d = new GL.Delegates.RasterPos3d(Imports.RasterPos3d); - GL.RasterPos3dv = new GL.Delegates.RasterPos3dv(Imports.RasterPos3dv); - GL.RasterPos3f = new GL.Delegates.RasterPos3f(Imports.RasterPos3f); - GL.RasterPos3fv = new GL.Delegates.RasterPos3fv(Imports.RasterPos3fv); - GL.RasterPos3i = new GL.Delegates.RasterPos3i(Imports.RasterPos3i); - GL.RasterPos3iv = new GL.Delegates.RasterPos3iv(Imports.RasterPos3iv); - GL.RasterPos3s = new GL.Delegates.RasterPos3s(Imports.RasterPos3s); - GL.RasterPos3sv = new GL.Delegates.RasterPos3sv(Imports.RasterPos3sv); - GL.RasterPos4d = new GL.Delegates.RasterPos4d(Imports.RasterPos4d); - GL.RasterPos4dv = new GL.Delegates.RasterPos4dv(Imports.RasterPos4dv); - GL.RasterPos4f = new GL.Delegates.RasterPos4f(Imports.RasterPos4f); - GL.RasterPos4fv = new GL.Delegates.RasterPos4fv(Imports.RasterPos4fv); - GL.RasterPos4i = new GL.Delegates.RasterPos4i(Imports.RasterPos4i); - GL.RasterPos4iv = new GL.Delegates.RasterPos4iv(Imports.RasterPos4iv); - GL.RasterPos4s = new GL.Delegates.RasterPos4s(Imports.RasterPos4s); - GL.RasterPos4sv = new GL.Delegates.RasterPos4sv(Imports.RasterPos4sv); - GL.Rectd = new GL.Delegates.Rectd(Imports.Rectd); - GL.Rectdv = new GL.Delegates.Rectdv(Imports.Rectdv); - GL.Rectf = new GL.Delegates.Rectf(Imports.Rectf); - GL.Rectfv = new GL.Delegates.Rectfv(Imports.Rectfv); - GL.Recti = new GL.Delegates.Recti(Imports.Recti); - GL.Rectiv = new GL.Delegates.Rectiv(Imports.Rectiv); - GL.Rects = new GL.Delegates.Rects(Imports.Rects); - GL.Rectsv = new GL.Delegates.Rectsv(Imports.Rectsv); - GL.TexCoord1d = new GL.Delegates.TexCoord1d(Imports.TexCoord1d); - GL.TexCoord1dv = new GL.Delegates.TexCoord1dv(Imports.TexCoord1dv); - GL.TexCoord1f = new GL.Delegates.TexCoord1f(Imports.TexCoord1f); - GL.TexCoord1fv = new GL.Delegates.TexCoord1fv(Imports.TexCoord1fv); - GL.TexCoord1i = new GL.Delegates.TexCoord1i(Imports.TexCoord1i); - GL.TexCoord1iv = new GL.Delegates.TexCoord1iv(Imports.TexCoord1iv); - GL.TexCoord1s = new GL.Delegates.TexCoord1s(Imports.TexCoord1s); - GL.TexCoord1sv = new GL.Delegates.TexCoord1sv(Imports.TexCoord1sv); - GL.TexCoord2d = new GL.Delegates.TexCoord2d(Imports.TexCoord2d); - GL.TexCoord2dv = new GL.Delegates.TexCoord2dv(Imports.TexCoord2dv); - GL.TexCoord2f = new GL.Delegates.TexCoord2f(Imports.TexCoord2f); - GL.TexCoord2fv = new GL.Delegates.TexCoord2fv(Imports.TexCoord2fv); - GL.TexCoord2i = new GL.Delegates.TexCoord2i(Imports.TexCoord2i); - GL.TexCoord2iv = new GL.Delegates.TexCoord2iv(Imports.TexCoord2iv); - GL.TexCoord2s = new GL.Delegates.TexCoord2s(Imports.TexCoord2s); - GL.TexCoord2sv = new GL.Delegates.TexCoord2sv(Imports.TexCoord2sv); - GL.TexCoord3d = new GL.Delegates.TexCoord3d(Imports.TexCoord3d); - GL.TexCoord3dv = new GL.Delegates.TexCoord3dv(Imports.TexCoord3dv); - GL.TexCoord3f = new GL.Delegates.TexCoord3f(Imports.TexCoord3f); - GL.TexCoord3fv = new GL.Delegates.TexCoord3fv(Imports.TexCoord3fv); - GL.TexCoord3i = new GL.Delegates.TexCoord3i(Imports.TexCoord3i); - GL.TexCoord3iv = new GL.Delegates.TexCoord3iv(Imports.TexCoord3iv); - GL.TexCoord3s = new GL.Delegates.TexCoord3s(Imports.TexCoord3s); - GL.TexCoord3sv = new GL.Delegates.TexCoord3sv(Imports.TexCoord3sv); - GL.TexCoord4d = new GL.Delegates.TexCoord4d(Imports.TexCoord4d); - GL.TexCoord4dv = new GL.Delegates.TexCoord4dv(Imports.TexCoord4dv); - GL.TexCoord4f = new GL.Delegates.TexCoord4f(Imports.TexCoord4f); - GL.TexCoord4fv = new GL.Delegates.TexCoord4fv(Imports.TexCoord4fv); - GL.TexCoord4i = new GL.Delegates.TexCoord4i(Imports.TexCoord4i); - GL.TexCoord4iv = new GL.Delegates.TexCoord4iv(Imports.TexCoord4iv); - GL.TexCoord4s = new GL.Delegates.TexCoord4s(Imports.TexCoord4s); - GL.TexCoord4sv = new GL.Delegates.TexCoord4sv(Imports.TexCoord4sv); - GL.Vertex2d = new GL.Delegates.Vertex2d(Imports.Vertex2d); - GL.Vertex2dv = new GL.Delegates.Vertex2dv(Imports.Vertex2dv); - GL.Vertex2f = new GL.Delegates.Vertex2f(Imports.Vertex2f); - GL.Vertex2fv = new GL.Delegates.Vertex2fv(Imports.Vertex2fv); - GL.Vertex2i = new GL.Delegates.Vertex2i(Imports.Vertex2i); - GL.Vertex2iv = new GL.Delegates.Vertex2iv(Imports.Vertex2iv); - GL.Vertex2s = new GL.Delegates.Vertex2s(Imports.Vertex2s); - GL.Vertex2sv = new GL.Delegates.Vertex2sv(Imports.Vertex2sv); - GL.Vertex3d = new GL.Delegates.Vertex3d(Imports.Vertex3d); - GL.Vertex3dv = new GL.Delegates.Vertex3dv(Imports.Vertex3dv); - GL.Vertex3f = new GL.Delegates.Vertex3f(Imports.Vertex3f); - GL.Vertex3fv = new GL.Delegates.Vertex3fv(Imports.Vertex3fv); - GL.Vertex3i = new GL.Delegates.Vertex3i(Imports.Vertex3i); - GL.Vertex3iv = new GL.Delegates.Vertex3iv(Imports.Vertex3iv); - GL.Vertex3s = new GL.Delegates.Vertex3s(Imports.Vertex3s); - GL.Vertex3sv = new GL.Delegates.Vertex3sv(Imports.Vertex3sv); - GL.Vertex4d = new GL.Delegates.Vertex4d(Imports.Vertex4d); - GL.Vertex4dv = new GL.Delegates.Vertex4dv(Imports.Vertex4dv); - GL.Vertex4f = new GL.Delegates.Vertex4f(Imports.Vertex4f); - GL.Vertex4fv = new GL.Delegates.Vertex4fv(Imports.Vertex4fv); - GL.Vertex4i = new GL.Delegates.Vertex4i(Imports.Vertex4i); - GL.Vertex4iv = new GL.Delegates.Vertex4iv(Imports.Vertex4iv); - GL.Vertex4s = new GL.Delegates.Vertex4s(Imports.Vertex4s); - GL.Vertex4sv = new GL.Delegates.Vertex4sv(Imports.Vertex4sv); - GL.ClipPlane = new GL.Delegates.ClipPlane(Imports.ClipPlane); - GL.ColorMaterial = new GL.Delegates.ColorMaterial(Imports.ColorMaterial); - GL.CullFace = new GL.Delegates.CullFace(Imports.CullFace); - GL.Fogf = new GL.Delegates.Fogf(Imports.Fogf); - GL.Fogfv = new GL.Delegates.Fogfv(Imports.Fogfv); - GL.Fogi = new GL.Delegates.Fogi(Imports.Fogi); - GL.Fogiv = new GL.Delegates.Fogiv(Imports.Fogiv); - GL.FrontFace = new GL.Delegates.FrontFace(Imports.FrontFace); - GL.Hint = new GL.Delegates.Hint(Imports.Hint); - GL.Lightf = new GL.Delegates.Lightf(Imports.Lightf); - GL.Lightfv = new GL.Delegates.Lightfv(Imports.Lightfv); - GL.Lighti = new GL.Delegates.Lighti(Imports.Lighti); - GL.Lightiv = new GL.Delegates.Lightiv(Imports.Lightiv); - GL.LightModelf = new GL.Delegates.LightModelf(Imports.LightModelf); - GL.LightModelfv = new GL.Delegates.LightModelfv(Imports.LightModelfv); - GL.LightModeli = new GL.Delegates.LightModeli(Imports.LightModeli); - GL.LightModeliv = new GL.Delegates.LightModeliv(Imports.LightModeliv); - GL.LineStipple = new GL.Delegates.LineStipple(Imports.LineStipple); - GL.LineWidth = new GL.Delegates.LineWidth(Imports.LineWidth); - GL.Materialf = new GL.Delegates.Materialf(Imports.Materialf); - GL.Materialfv = new GL.Delegates.Materialfv(Imports.Materialfv); - GL.Materiali = new GL.Delegates.Materiali(Imports.Materiali); - GL.Materialiv = new GL.Delegates.Materialiv(Imports.Materialiv); - GL.PointSize = new GL.Delegates.PointSize(Imports.PointSize); - GL.PolygonMode = new GL.Delegates.PolygonMode(Imports.PolygonMode); - GL.PolygonStipple = new GL.Delegates.PolygonStipple(Imports.PolygonStipple); - GL.Scissor = new GL.Delegates.Scissor(Imports.Scissor); - GL.ShadeModel = new GL.Delegates.ShadeModel(Imports.ShadeModel); - GL.TexParameterf = new GL.Delegates.TexParameterf(Imports.TexParameterf); - GL.TexParameterfv = new GL.Delegates.TexParameterfv(Imports.TexParameterfv); - GL.TexParameteri = new GL.Delegates.TexParameteri(Imports.TexParameteri); - GL.TexParameteriv = new GL.Delegates.TexParameteriv(Imports.TexParameteriv); - GL.TexImage1D = new GL.Delegates.TexImage1D(Imports.TexImage1D); - GL.TexImage2D = new GL.Delegates.TexImage2D(Imports.TexImage2D); - GL.TexEnvf = new GL.Delegates.TexEnvf(Imports.TexEnvf); - GL.TexEnvfv = new GL.Delegates.TexEnvfv(Imports.TexEnvfv); - GL.TexEnvi = new GL.Delegates.TexEnvi(Imports.TexEnvi); - GL.TexEnviv = new GL.Delegates.TexEnviv(Imports.TexEnviv); - GL.TexGend = new GL.Delegates.TexGend(Imports.TexGend); - GL.TexGendv = new GL.Delegates.TexGendv(Imports.TexGendv); - GL.TexGenf = new GL.Delegates.TexGenf(Imports.TexGenf); - GL.TexGenfv = new GL.Delegates.TexGenfv(Imports.TexGenfv); - GL.TexGeni = new GL.Delegates.TexGeni(Imports.TexGeni); - GL.TexGeniv = new GL.Delegates.TexGeniv(Imports.TexGeniv); - GL.FeedbackBuffer = new GL.Delegates.FeedbackBuffer(Imports.FeedbackBuffer); - GL.SelectBuffer = new GL.Delegates.SelectBuffer(Imports.SelectBuffer); - GL.RenderMode = new GL.Delegates.RenderMode(Imports.RenderMode); - GL.InitNames = new GL.Delegates.InitNames(Imports.InitNames); - GL.LoadName = new GL.Delegates.LoadName(Imports.LoadName); - GL.PassThrough = new GL.Delegates.PassThrough(Imports.PassThrough); - GL.PopName = new GL.Delegates.PopName(Imports.PopName); - GL.PushName = new GL.Delegates.PushName(Imports.PushName); - GL.DrawBuffer = new GL.Delegates.DrawBuffer(Imports.DrawBuffer); - GL.Clear = new GL.Delegates.Clear(Imports.Clear); - GL.ClearAccum = new GL.Delegates.ClearAccum(Imports.ClearAccum); - GL.ClearIndex = new GL.Delegates.ClearIndex(Imports.ClearIndex); - GL.ClearColor = new GL.Delegates.ClearColor(Imports.ClearColor); - GL.ClearStencil = new GL.Delegates.ClearStencil(Imports.ClearStencil); - GL.ClearDepth = new GL.Delegates.ClearDepth(Imports.ClearDepth); - GL.StencilMask = new GL.Delegates.StencilMask(Imports.StencilMask); - GL.ColorMask = new GL.Delegates.ColorMask(Imports.ColorMask); - GL.DepthMask = new GL.Delegates.DepthMask(Imports.DepthMask); - GL.IndexMask = new GL.Delegates.IndexMask(Imports.IndexMask); - GL.Accum = new GL.Delegates.Accum(Imports.Accum); - GL.Disable = new GL.Delegates.Disable(Imports.Disable); - GL.Enable = new GL.Delegates.Enable(Imports.Enable); - GL.Finish = new GL.Delegates.Finish(Imports.Finish); - GL.Flush = new GL.Delegates.Flush(Imports.Flush); - GL.PopAttrib = new GL.Delegates.PopAttrib(Imports.PopAttrib); - GL.PushAttrib = new GL.Delegates.PushAttrib(Imports.PushAttrib); - GL.Map1d = new GL.Delegates.Map1d(Imports.Map1d); - GL.Map1f = new GL.Delegates.Map1f(Imports.Map1f); - GL.Map2d = new GL.Delegates.Map2d(Imports.Map2d); - GL.Map2f = new GL.Delegates.Map2f(Imports.Map2f); - GL.MapGrid1d = new GL.Delegates.MapGrid1d(Imports.MapGrid1d); - GL.MapGrid1f = new GL.Delegates.MapGrid1f(Imports.MapGrid1f); - GL.MapGrid2d = new GL.Delegates.MapGrid2d(Imports.MapGrid2d); - GL.MapGrid2f = new GL.Delegates.MapGrid2f(Imports.MapGrid2f); - GL.EvalCoord1d = new GL.Delegates.EvalCoord1d(Imports.EvalCoord1d); - GL.EvalCoord1dv = new GL.Delegates.EvalCoord1dv(Imports.EvalCoord1dv); - GL.EvalCoord1f = new GL.Delegates.EvalCoord1f(Imports.EvalCoord1f); - GL.EvalCoord1fv = new GL.Delegates.EvalCoord1fv(Imports.EvalCoord1fv); - GL.EvalCoord2d = new GL.Delegates.EvalCoord2d(Imports.EvalCoord2d); - GL.EvalCoord2dv = new GL.Delegates.EvalCoord2dv(Imports.EvalCoord2dv); - GL.EvalCoord2f = new GL.Delegates.EvalCoord2f(Imports.EvalCoord2f); - GL.EvalCoord2fv = new GL.Delegates.EvalCoord2fv(Imports.EvalCoord2fv); - GL.EvalMesh1 = new GL.Delegates.EvalMesh1(Imports.EvalMesh1); - GL.EvalPoint1 = new GL.Delegates.EvalPoint1(Imports.EvalPoint1); - GL.EvalMesh2 = new GL.Delegates.EvalMesh2(Imports.EvalMesh2); - GL.EvalPoint2 = new GL.Delegates.EvalPoint2(Imports.EvalPoint2); - GL.AlphaFunc = new GL.Delegates.AlphaFunc(Imports.AlphaFunc); - GL.BlendFunc = new GL.Delegates.BlendFunc(Imports.BlendFunc); - GL.LogicOp = new GL.Delegates.LogicOp(Imports.LogicOp); - GL.StencilFunc = new GL.Delegates.StencilFunc(Imports.StencilFunc); - GL.StencilOp = new GL.Delegates.StencilOp(Imports.StencilOp); - GL.DepthFunc = new GL.Delegates.DepthFunc(Imports.DepthFunc); - GL.PixelZoom = new GL.Delegates.PixelZoom(Imports.PixelZoom); - GL.PixelTransferf = new GL.Delegates.PixelTransferf(Imports.PixelTransferf); - GL.PixelTransferi = new GL.Delegates.PixelTransferi(Imports.PixelTransferi); - GL.PixelStoref = new GL.Delegates.PixelStoref(Imports.PixelStoref); - GL.PixelStorei = new GL.Delegates.PixelStorei(Imports.PixelStorei); - GL.PixelMapfv = new GL.Delegates.PixelMapfv(Imports.PixelMapfv); - GL.PixelMapuiv = new GL.Delegates.PixelMapuiv(Imports.PixelMapuiv); - GL.PixelMapusv = new GL.Delegates.PixelMapusv(Imports.PixelMapusv); - GL.ReadBuffer = new GL.Delegates.ReadBuffer(Imports.ReadBuffer); - GL.CopyPixels = new GL.Delegates.CopyPixels(Imports.CopyPixels); - GL.ReadPixels = new GL.Delegates.ReadPixels(Imports.ReadPixels); - GL.DrawPixels = new GL.Delegates.DrawPixels(Imports.DrawPixels); - GL.GetBooleanv = new GL.Delegates.GetBooleanv(Imports.GetBooleanv); - GL.GetClipPlane = new GL.Delegates.GetClipPlane(Imports.GetClipPlane); - GL.GetDoublev = new GL.Delegates.GetDoublev(Imports.GetDoublev); - GL.GetError = new GL.Delegates.GetError(Imports.GetError); - GL.GetFloatv = new GL.Delegates.GetFloatv(Imports.GetFloatv); - GL.GetIntegerv = new GL.Delegates.GetIntegerv(Imports.GetIntegerv); - GL.GetLightfv = new GL.Delegates.GetLightfv(Imports.GetLightfv); - GL.GetLightiv = new GL.Delegates.GetLightiv(Imports.GetLightiv); - GL.GetMapdv = new GL.Delegates.GetMapdv(Imports.GetMapdv); - GL.GetMapfv = new GL.Delegates.GetMapfv(Imports.GetMapfv); - GL.GetMapiv = new GL.Delegates.GetMapiv(Imports.GetMapiv); - GL.GetMaterialfv = new GL.Delegates.GetMaterialfv(Imports.GetMaterialfv); - GL.GetMaterialiv = new GL.Delegates.GetMaterialiv(Imports.GetMaterialiv); - GL.GetPixelMapfv = new GL.Delegates.GetPixelMapfv(Imports.GetPixelMapfv); - GL.GetPixelMapuiv = new GL.Delegates.GetPixelMapuiv(Imports.GetPixelMapuiv); - GL.GetPixelMapusv = new GL.Delegates.GetPixelMapusv(Imports.GetPixelMapusv); - GL.GetPolygonStipple = new GL.Delegates.GetPolygonStipple(Imports.GetPolygonStipple); - GL.GetString = new GL.Delegates.GetString(Imports.GetString); - GL.GetTexEnvfv = new GL.Delegates.GetTexEnvfv(Imports.GetTexEnvfv); - GL.GetTexEnviv = new GL.Delegates.GetTexEnviv(Imports.GetTexEnviv); - GL.GetTexGendv = new GL.Delegates.GetTexGendv(Imports.GetTexGendv); - GL.GetTexGenfv = new GL.Delegates.GetTexGenfv(Imports.GetTexGenfv); - GL.GetTexGeniv = new GL.Delegates.GetTexGeniv(Imports.GetTexGeniv); - GL.GetTexImage = new GL.Delegates.GetTexImage(Imports.GetTexImage); - GL.GetTexParameterfv = new GL.Delegates.GetTexParameterfv(Imports.GetTexParameterfv); - GL.GetTexParameteriv = new GL.Delegates.GetTexParameteriv(Imports.GetTexParameteriv); - GL.GetTexLevelParameterfv = new GL.Delegates.GetTexLevelParameterfv(Imports.GetTexLevelParameterfv); - GL.GetTexLevelParameteriv = new GL.Delegates.GetTexLevelParameteriv(Imports.GetTexLevelParameteriv); - GL.IsEnabled = new GL.Delegates.IsEnabled(Imports.IsEnabled); - GL.IsList = new GL.Delegates.IsList(Imports.IsList); - GL.DepthRange = new GL.Delegates.DepthRange(Imports.DepthRange); - GL.Frustum = new GL.Delegates.Frustum(Imports.Frustum); - GL.LoadIdentity = new GL.Delegates.LoadIdentity(Imports.LoadIdentity); - GL.LoadMatrixf = new GL.Delegates.LoadMatrixf(Imports.LoadMatrixf); - GL.LoadMatrixd = new GL.Delegates.LoadMatrixd(Imports.LoadMatrixd); - GL.MatrixMode = new GL.Delegates.MatrixMode(Imports.MatrixMode); - GL.MultMatrixf = new GL.Delegates.MultMatrixf(Imports.MultMatrixf); - GL.MultMatrixd = new GL.Delegates.MultMatrixd(Imports.MultMatrixd); - GL.Ortho = new GL.Delegates.Ortho(Imports.Ortho); - GL.PopMatrix = new GL.Delegates.PopMatrix(Imports.PopMatrix); - GL.PushMatrix = new GL.Delegates.PushMatrix(Imports.PushMatrix); - GL.Rotated = new GL.Delegates.Rotated(Imports.Rotated); - GL.Rotatef = new GL.Delegates.Rotatef(Imports.Rotatef); - GL.Scaled = new GL.Delegates.Scaled(Imports.Scaled); - GL.Scalef = new GL.Delegates.Scalef(Imports.Scalef); - GL.Translated = new GL.Delegates.Translated(Imports.Translated); - GL.Translatef = new GL.Delegates.Translatef(Imports.Translatef); - GL.Viewport = new GL.Delegates.Viewport(Imports.Viewport); - GL.ArrayElement = new GL.Delegates.ArrayElement(Imports.ArrayElement); - GL.ColorPointer = new GL.Delegates.ColorPointer(Imports.ColorPointer); - GL.DisableClientState = new GL.Delegates.DisableClientState(Imports.DisableClientState); - GL.DrawArrays = new GL.Delegates.DrawArrays(Imports.DrawArrays); - GL.DrawElements = new GL.Delegates.DrawElements(Imports.DrawElements); - GL.EdgeFlagPointer = new GL.Delegates.EdgeFlagPointer(Imports.EdgeFlagPointer); - GL.EnableClientState = new GL.Delegates.EnableClientState(Imports.EnableClientState); - GL.GetPointerv = new GL.Delegates.GetPointerv(Imports.GetPointerv); - GL.IndexPointer = new GL.Delegates.IndexPointer(Imports.IndexPointer); - GL.InterleavedArrays = new GL.Delegates.InterleavedArrays(Imports.InterleavedArrays); - GL.NormalPointer = new GL.Delegates.NormalPointer(Imports.NormalPointer); - GL.TexCoordPointer = new GL.Delegates.TexCoordPointer(Imports.TexCoordPointer); - GL.VertexPointer = new GL.Delegates.VertexPointer(Imports.VertexPointer); - GL.PolygonOffset = new GL.Delegates.PolygonOffset(Imports.PolygonOffset); - GL.CopyTexImage1D = new GL.Delegates.CopyTexImage1D(Imports.CopyTexImage1D); - GL.CopyTexImage2D = new GL.Delegates.CopyTexImage2D(Imports.CopyTexImage2D); - GL.CopyTexSubImage1D = new GL.Delegates.CopyTexSubImage1D(Imports.CopyTexSubImage1D); - GL.CopyTexSubImage2D = new GL.Delegates.CopyTexSubImage2D(Imports.CopyTexSubImage2D); - GL.TexSubImage1D = new GL.Delegates.TexSubImage1D(Imports.TexSubImage1D); - GL.TexSubImage2D = new GL.Delegates.TexSubImage2D(Imports.TexSubImage2D); - GL.AreTexturesResident = new GL.Delegates.AreTexturesResident(Imports.AreTexturesResident); - GL.BindTexture = new GL.Delegates.BindTexture(Imports.BindTexture); - GL.DeleteTextures = new GL.Delegates.DeleteTextures(Imports.DeleteTextures); - GL.GenTextures = new GL.Delegates.GenTextures(Imports.GenTextures); - GL.IsTexture = new GL.Delegates.IsTexture(Imports.IsTexture); - GL.PrioritizeTextures = new GL.Delegates.PrioritizeTextures(Imports.PrioritizeTextures); - GL.Indexub = new GL.Delegates.Indexub(Imports.Indexub); - GL.Indexubv = new GL.Delegates.Indexubv(Imports.Indexubv); - GL.PopClientAttrib = new GL.Delegates.PopClientAttrib(Imports.PopClientAttrib); - GL.PushClientAttrib = new GL.Delegates.PushClientAttrib(Imports.PushClientAttrib); - GL.BlendColor = (GL.Delegates.BlendColor) GetAddress("glBlendColor", typeof(GL.Delegates.BlendColor)); - GL.BlendEquation = (GL.Delegates.BlendEquation) GetAddress("glBlendEquation", typeof(GL.Delegates.BlendEquation)); - GL.DrawRangeElements = (GL.Delegates.DrawRangeElements) GetAddress("glDrawRangeElements", typeof(GL.Delegates.DrawRangeElements)); - GL.ColorTable = (GL.Delegates.ColorTable) GetAddress("glColorTable", typeof(GL.Delegates.ColorTable)); - GL.ColorTableParameterfv = (GL.Delegates.ColorTableParameterfv) GetAddress("glColorTableParameterfv", typeof(GL.Delegates.ColorTableParameterfv)); - GL.ColorTableParameteriv = (GL.Delegates.ColorTableParameteriv) GetAddress("glColorTableParameteriv", typeof(GL.Delegates.ColorTableParameteriv)); - GL.CopyColorTable = (GL.Delegates.CopyColorTable) GetAddress("glCopyColorTable", typeof(GL.Delegates.CopyColorTable)); - GL.GetColorTable = (GL.Delegates.GetColorTable) GetAddress("glGetColorTable", typeof(GL.Delegates.GetColorTable)); - GL.GetColorTableParameterfv = (GL.Delegates.GetColorTableParameterfv) GetAddress("glGetColorTableParameterfv", typeof(GL.Delegates.GetColorTableParameterfv)); - GL.GetColorTableParameteriv = (GL.Delegates.GetColorTableParameteriv) GetAddress("glGetColorTableParameteriv", typeof(GL.Delegates.GetColorTableParameteriv)); - GL.ColorSubTable = (GL.Delegates.ColorSubTable) GetAddress("glColorSubTable", typeof(GL.Delegates.ColorSubTable)); - GL.CopyColorSubTable = (GL.Delegates.CopyColorSubTable) GetAddress("glCopyColorSubTable", typeof(GL.Delegates.CopyColorSubTable)); - GL.ConvolutionFilter1D = (GL.Delegates.ConvolutionFilter1D) GetAddress("glConvolutionFilter1D", typeof(GL.Delegates.ConvolutionFilter1D)); - GL.ConvolutionFilter2D = (GL.Delegates.ConvolutionFilter2D) GetAddress("glConvolutionFilter2D", typeof(GL.Delegates.ConvolutionFilter2D)); - GL.ConvolutionParameterf = (GL.Delegates.ConvolutionParameterf) GetAddress("glConvolutionParameterf", typeof(GL.Delegates.ConvolutionParameterf)); - GL.ConvolutionParameterfv = (GL.Delegates.ConvolutionParameterfv) GetAddress("glConvolutionParameterfv", typeof(GL.Delegates.ConvolutionParameterfv)); - GL.ConvolutionParameteri = (GL.Delegates.ConvolutionParameteri) GetAddress("glConvolutionParameteri", typeof(GL.Delegates.ConvolutionParameteri)); - GL.ConvolutionParameteriv = (GL.Delegates.ConvolutionParameteriv) GetAddress("glConvolutionParameteriv", typeof(GL.Delegates.ConvolutionParameteriv)); - GL.CopyConvolutionFilter1D = (GL.Delegates.CopyConvolutionFilter1D) GetAddress("glCopyConvolutionFilter1D", typeof(GL.Delegates.CopyConvolutionFilter1D)); - GL.CopyConvolutionFilter2D = (GL.Delegates.CopyConvolutionFilter2D) GetAddress("glCopyConvolutionFilter2D", typeof(GL.Delegates.CopyConvolutionFilter2D)); - GL.GetConvolutionFilter = (GL.Delegates.GetConvolutionFilter) GetAddress("glGetConvolutionFilter", typeof(GL.Delegates.GetConvolutionFilter)); - GL.GetConvolutionParameterfv = (GL.Delegates.GetConvolutionParameterfv) GetAddress("glGetConvolutionParameterfv", typeof(GL.Delegates.GetConvolutionParameterfv)); - GL.GetConvolutionParameteriv = (GL.Delegates.GetConvolutionParameteriv) GetAddress("glGetConvolutionParameteriv", typeof(GL.Delegates.GetConvolutionParameteriv)); - GL.GetSeparableFilter = (GL.Delegates.GetSeparableFilter) GetAddress("glGetSeparableFilter", typeof(GL.Delegates.GetSeparableFilter)); - GL.SeparableFilter2D = (GL.Delegates.SeparableFilter2D) GetAddress("glSeparableFilter2D", typeof(GL.Delegates.SeparableFilter2D)); - GL.GetHistogram = (GL.Delegates.GetHistogram) GetAddress("glGetHistogram", typeof(GL.Delegates.GetHistogram)); - GL.GetHistogramParameterfv = (GL.Delegates.GetHistogramParameterfv) GetAddress("glGetHistogramParameterfv", typeof(GL.Delegates.GetHistogramParameterfv)); - GL.GetHistogramParameteriv = (GL.Delegates.GetHistogramParameteriv) GetAddress("glGetHistogramParameteriv", typeof(GL.Delegates.GetHistogramParameteriv)); - GL.GetMinmax = (GL.Delegates.GetMinmax) GetAddress("glGetMinmax", typeof(GL.Delegates.GetMinmax)); - GL.GetMinmaxParameterfv = (GL.Delegates.GetMinmaxParameterfv) GetAddress("glGetMinmaxParameterfv", typeof(GL.Delegates.GetMinmaxParameterfv)); - GL.GetMinmaxParameteriv = (GL.Delegates.GetMinmaxParameteriv) GetAddress("glGetMinmaxParameteriv", typeof(GL.Delegates.GetMinmaxParameteriv)); - GL.Histogram = (GL.Delegates.Histogram) GetAddress("glHistogram", typeof(GL.Delegates.Histogram)); - GL.Minmax = (GL.Delegates.Minmax) GetAddress("glMinmax", typeof(GL.Delegates.Minmax)); - GL.ResetHistogram = (GL.Delegates.ResetHistogram) GetAddress("glResetHistogram", typeof(GL.Delegates.ResetHistogram)); - GL.ResetMinmax = (GL.Delegates.ResetMinmax) GetAddress("glResetMinmax", typeof(GL.Delegates.ResetMinmax)); - GL.TexImage3D = (GL.Delegates.TexImage3D) GetAddress("glTexImage3D", typeof(GL.Delegates.TexImage3D)); - GL.TexSubImage3D = (GL.Delegates.TexSubImage3D) GetAddress("glTexSubImage3D", typeof(GL.Delegates.TexSubImage3D)); - GL.CopyTexSubImage3D = (GL.Delegates.CopyTexSubImage3D) GetAddress("glCopyTexSubImage3D", typeof(GL.Delegates.CopyTexSubImage3D)); - GL.ActiveTexture = (GL.Delegates.ActiveTexture) GetAddress("glActiveTexture", typeof(GL.Delegates.ActiveTexture)); - GL.ClientActiveTexture = (GL.Delegates.ClientActiveTexture) GetAddress("glClientActiveTexture", typeof(GL.Delegates.ClientActiveTexture)); - GL.MultiTexCoord1d = (GL.Delegates.MultiTexCoord1d) GetAddress("glMultiTexCoord1d", typeof(GL.Delegates.MultiTexCoord1d)); - GL.MultiTexCoord1dv = (GL.Delegates.MultiTexCoord1dv) GetAddress("glMultiTexCoord1dv", typeof(GL.Delegates.MultiTexCoord1dv)); - GL.MultiTexCoord1f = (GL.Delegates.MultiTexCoord1f) GetAddress("glMultiTexCoord1f", typeof(GL.Delegates.MultiTexCoord1f)); - GL.MultiTexCoord1fv = (GL.Delegates.MultiTexCoord1fv) GetAddress("glMultiTexCoord1fv", typeof(GL.Delegates.MultiTexCoord1fv)); - GL.MultiTexCoord1i = (GL.Delegates.MultiTexCoord1i) GetAddress("glMultiTexCoord1i", typeof(GL.Delegates.MultiTexCoord1i)); - GL.MultiTexCoord1iv = (GL.Delegates.MultiTexCoord1iv) GetAddress("glMultiTexCoord1iv", typeof(GL.Delegates.MultiTexCoord1iv)); - GL.MultiTexCoord1s = (GL.Delegates.MultiTexCoord1s) GetAddress("glMultiTexCoord1s", typeof(GL.Delegates.MultiTexCoord1s)); - GL.MultiTexCoord1sv = (GL.Delegates.MultiTexCoord1sv) GetAddress("glMultiTexCoord1sv", typeof(GL.Delegates.MultiTexCoord1sv)); - GL.MultiTexCoord2d = (GL.Delegates.MultiTexCoord2d) GetAddress("glMultiTexCoord2d", typeof(GL.Delegates.MultiTexCoord2d)); - GL.MultiTexCoord2dv = (GL.Delegates.MultiTexCoord2dv) GetAddress("glMultiTexCoord2dv", typeof(GL.Delegates.MultiTexCoord2dv)); - GL.MultiTexCoord2f = (GL.Delegates.MultiTexCoord2f) GetAddress("glMultiTexCoord2f", typeof(GL.Delegates.MultiTexCoord2f)); - GL.MultiTexCoord2fv = (GL.Delegates.MultiTexCoord2fv) GetAddress("glMultiTexCoord2fv", typeof(GL.Delegates.MultiTexCoord2fv)); - GL.MultiTexCoord2i = (GL.Delegates.MultiTexCoord2i) GetAddress("glMultiTexCoord2i", typeof(GL.Delegates.MultiTexCoord2i)); - GL.MultiTexCoord2iv = (GL.Delegates.MultiTexCoord2iv) GetAddress("glMultiTexCoord2iv", typeof(GL.Delegates.MultiTexCoord2iv)); - GL.MultiTexCoord2s = (GL.Delegates.MultiTexCoord2s) GetAddress("glMultiTexCoord2s", typeof(GL.Delegates.MultiTexCoord2s)); - GL.MultiTexCoord2sv = (GL.Delegates.MultiTexCoord2sv) GetAddress("glMultiTexCoord2sv", typeof(GL.Delegates.MultiTexCoord2sv)); - GL.MultiTexCoord3d = (GL.Delegates.MultiTexCoord3d) GetAddress("glMultiTexCoord3d", typeof(GL.Delegates.MultiTexCoord3d)); - GL.MultiTexCoord3dv = (GL.Delegates.MultiTexCoord3dv) GetAddress("glMultiTexCoord3dv", typeof(GL.Delegates.MultiTexCoord3dv)); - GL.MultiTexCoord3f = (GL.Delegates.MultiTexCoord3f) GetAddress("glMultiTexCoord3f", typeof(GL.Delegates.MultiTexCoord3f)); - GL.MultiTexCoord3fv = (GL.Delegates.MultiTexCoord3fv) GetAddress("glMultiTexCoord3fv", typeof(GL.Delegates.MultiTexCoord3fv)); - GL.MultiTexCoord3i = (GL.Delegates.MultiTexCoord3i) GetAddress("glMultiTexCoord3i", typeof(GL.Delegates.MultiTexCoord3i)); - GL.MultiTexCoord3iv = (GL.Delegates.MultiTexCoord3iv) GetAddress("glMultiTexCoord3iv", typeof(GL.Delegates.MultiTexCoord3iv)); - GL.MultiTexCoord3s = (GL.Delegates.MultiTexCoord3s) GetAddress("glMultiTexCoord3s", typeof(GL.Delegates.MultiTexCoord3s)); - GL.MultiTexCoord3sv = (GL.Delegates.MultiTexCoord3sv) GetAddress("glMultiTexCoord3sv", typeof(GL.Delegates.MultiTexCoord3sv)); - GL.MultiTexCoord4d = (GL.Delegates.MultiTexCoord4d) GetAddress("glMultiTexCoord4d", typeof(GL.Delegates.MultiTexCoord4d)); - GL.MultiTexCoord4dv = (GL.Delegates.MultiTexCoord4dv) GetAddress("glMultiTexCoord4dv", typeof(GL.Delegates.MultiTexCoord4dv)); - GL.MultiTexCoord4f = (GL.Delegates.MultiTexCoord4f) GetAddress("glMultiTexCoord4f", typeof(GL.Delegates.MultiTexCoord4f)); - GL.MultiTexCoord4fv = (GL.Delegates.MultiTexCoord4fv) GetAddress("glMultiTexCoord4fv", typeof(GL.Delegates.MultiTexCoord4fv)); - GL.MultiTexCoord4i = (GL.Delegates.MultiTexCoord4i) GetAddress("glMultiTexCoord4i", typeof(GL.Delegates.MultiTexCoord4i)); - GL.MultiTexCoord4iv = (GL.Delegates.MultiTexCoord4iv) GetAddress("glMultiTexCoord4iv", typeof(GL.Delegates.MultiTexCoord4iv)); - GL.MultiTexCoord4s = (GL.Delegates.MultiTexCoord4s) GetAddress("glMultiTexCoord4s", typeof(GL.Delegates.MultiTexCoord4s)); - GL.MultiTexCoord4sv = (GL.Delegates.MultiTexCoord4sv) GetAddress("glMultiTexCoord4sv", typeof(GL.Delegates.MultiTexCoord4sv)); - GL.LoadTransposeMatrixf = (GL.Delegates.LoadTransposeMatrixf) GetAddress("glLoadTransposeMatrixf", typeof(GL.Delegates.LoadTransposeMatrixf)); - GL.LoadTransposeMatrixd = (GL.Delegates.LoadTransposeMatrixd) GetAddress("glLoadTransposeMatrixd", typeof(GL.Delegates.LoadTransposeMatrixd)); - GL.MultTransposeMatrixf = (GL.Delegates.MultTransposeMatrixf) GetAddress("glMultTransposeMatrixf", typeof(GL.Delegates.MultTransposeMatrixf)); - GL.MultTransposeMatrixd = (GL.Delegates.MultTransposeMatrixd) GetAddress("glMultTransposeMatrixd", typeof(GL.Delegates.MultTransposeMatrixd)); - GL.SampleCoverage = (GL.Delegates.SampleCoverage) GetAddress("glSampleCoverage", typeof(GL.Delegates.SampleCoverage)); - GL.CompressedTexImage3D = (GL.Delegates.CompressedTexImage3D) GetAddress("glCompressedTexImage3D", typeof(GL.Delegates.CompressedTexImage3D)); - GL.CompressedTexImage2D = (GL.Delegates.CompressedTexImage2D) GetAddress("glCompressedTexImage2D", typeof(GL.Delegates.CompressedTexImage2D)); - GL.CompressedTexImage1D = (GL.Delegates.CompressedTexImage1D) GetAddress("glCompressedTexImage1D", typeof(GL.Delegates.CompressedTexImage1D)); - GL.CompressedTexSubImage3D = (GL.Delegates.CompressedTexSubImage3D) GetAddress("glCompressedTexSubImage3D", typeof(GL.Delegates.CompressedTexSubImage3D)); - GL.CompressedTexSubImage2D = (GL.Delegates.CompressedTexSubImage2D) GetAddress("glCompressedTexSubImage2D", typeof(GL.Delegates.CompressedTexSubImage2D)); - GL.CompressedTexSubImage1D = (GL.Delegates.CompressedTexSubImage1D) GetAddress("glCompressedTexSubImage1D", typeof(GL.Delegates.CompressedTexSubImage1D)); - GL.GetCompressedTexImage = (GL.Delegates.GetCompressedTexImage) GetAddress("glGetCompressedTexImage", typeof(GL.Delegates.GetCompressedTexImage)); - GL.BlendFuncSeparate = (GL.Delegates.BlendFuncSeparate) GetAddress("glBlendFuncSeparate", typeof(GL.Delegates.BlendFuncSeparate)); - GL.FogCoordf = (GL.Delegates.FogCoordf) GetAddress("glFogCoordf", typeof(GL.Delegates.FogCoordf)); - GL.FogCoordfv = (GL.Delegates.FogCoordfv) GetAddress("glFogCoordfv", typeof(GL.Delegates.FogCoordfv)); - GL.FogCoordd = (GL.Delegates.FogCoordd) GetAddress("glFogCoordd", typeof(GL.Delegates.FogCoordd)); - GL.FogCoorddv = (GL.Delegates.FogCoorddv) GetAddress("glFogCoorddv", typeof(GL.Delegates.FogCoorddv)); - GL.FogCoordPointer = (GL.Delegates.FogCoordPointer) GetAddress("glFogCoordPointer", typeof(GL.Delegates.FogCoordPointer)); - GL.MultiDrawArrays = (GL.Delegates.MultiDrawArrays) GetAddress("glMultiDrawArrays", typeof(GL.Delegates.MultiDrawArrays)); - GL.MultiDrawElements = (GL.Delegates.MultiDrawElements) GetAddress("glMultiDrawElements", typeof(GL.Delegates.MultiDrawElements)); - GL.PointParameterf = (GL.Delegates.PointParameterf) GetAddress("glPointParameterf", typeof(GL.Delegates.PointParameterf)); - GL.PointParameterfv = (GL.Delegates.PointParameterfv) GetAddress("glPointParameterfv", typeof(GL.Delegates.PointParameterfv)); - GL.PointParameteri = (GL.Delegates.PointParameteri) GetAddress("glPointParameteri", typeof(GL.Delegates.PointParameteri)); - GL.PointParameteriv = (GL.Delegates.PointParameteriv) GetAddress("glPointParameteriv", typeof(GL.Delegates.PointParameteriv)); - GL.SecondaryColor3b = (GL.Delegates.SecondaryColor3b) GetAddress("glSecondaryColor3b", typeof(GL.Delegates.SecondaryColor3b)); - GL.SecondaryColor3bv = (GL.Delegates.SecondaryColor3bv) GetAddress("glSecondaryColor3bv", typeof(GL.Delegates.SecondaryColor3bv)); - GL.SecondaryColor3d = (GL.Delegates.SecondaryColor3d) GetAddress("glSecondaryColor3d", typeof(GL.Delegates.SecondaryColor3d)); - GL.SecondaryColor3dv = (GL.Delegates.SecondaryColor3dv) GetAddress("glSecondaryColor3dv", typeof(GL.Delegates.SecondaryColor3dv)); - GL.SecondaryColor3f = (GL.Delegates.SecondaryColor3f) GetAddress("glSecondaryColor3f", typeof(GL.Delegates.SecondaryColor3f)); - GL.SecondaryColor3fv = (GL.Delegates.SecondaryColor3fv) GetAddress("glSecondaryColor3fv", typeof(GL.Delegates.SecondaryColor3fv)); - GL.SecondaryColor3i = (GL.Delegates.SecondaryColor3i) GetAddress("glSecondaryColor3i", typeof(GL.Delegates.SecondaryColor3i)); - GL.SecondaryColor3iv = (GL.Delegates.SecondaryColor3iv) GetAddress("glSecondaryColor3iv", typeof(GL.Delegates.SecondaryColor3iv)); - GL.SecondaryColor3s = (GL.Delegates.SecondaryColor3s) GetAddress("glSecondaryColor3s", typeof(GL.Delegates.SecondaryColor3s)); - GL.SecondaryColor3sv = (GL.Delegates.SecondaryColor3sv) GetAddress("glSecondaryColor3sv", typeof(GL.Delegates.SecondaryColor3sv)); - GL.SecondaryColor3ub = (GL.Delegates.SecondaryColor3ub) GetAddress("glSecondaryColor3ub", typeof(GL.Delegates.SecondaryColor3ub)); - GL.SecondaryColor3ubv = (GL.Delegates.SecondaryColor3ubv) GetAddress("glSecondaryColor3ubv", typeof(GL.Delegates.SecondaryColor3ubv)); - GL.SecondaryColor3ui = (GL.Delegates.SecondaryColor3ui) GetAddress("glSecondaryColor3ui", typeof(GL.Delegates.SecondaryColor3ui)); - GL.SecondaryColor3uiv = (GL.Delegates.SecondaryColor3uiv) GetAddress("glSecondaryColor3uiv", typeof(GL.Delegates.SecondaryColor3uiv)); - GL.SecondaryColor3us = (GL.Delegates.SecondaryColor3us) GetAddress("glSecondaryColor3us", typeof(GL.Delegates.SecondaryColor3us)); - GL.SecondaryColor3usv = (GL.Delegates.SecondaryColor3usv) GetAddress("glSecondaryColor3usv", typeof(GL.Delegates.SecondaryColor3usv)); - GL.SecondaryColorPointer = (GL.Delegates.SecondaryColorPointer) GetAddress("glSecondaryColorPointer", typeof(GL.Delegates.SecondaryColorPointer)); - GL.WindowPos2d = (GL.Delegates.WindowPos2d) GetAddress("glWindowPos2d", typeof(GL.Delegates.WindowPos2d)); - GL.WindowPos2dv = (GL.Delegates.WindowPos2dv) GetAddress("glWindowPos2dv", typeof(GL.Delegates.WindowPos2dv)); - GL.WindowPos2f = (GL.Delegates.WindowPos2f) GetAddress("glWindowPos2f", typeof(GL.Delegates.WindowPos2f)); - GL.WindowPos2fv = (GL.Delegates.WindowPos2fv) GetAddress("glWindowPos2fv", typeof(GL.Delegates.WindowPos2fv)); - GL.WindowPos2i = (GL.Delegates.WindowPos2i) GetAddress("glWindowPos2i", typeof(GL.Delegates.WindowPos2i)); - GL.WindowPos2iv = (GL.Delegates.WindowPos2iv) GetAddress("glWindowPos2iv", typeof(GL.Delegates.WindowPos2iv)); - GL.WindowPos2s = (GL.Delegates.WindowPos2s) GetAddress("glWindowPos2s", typeof(GL.Delegates.WindowPos2s)); - GL.WindowPos2sv = (GL.Delegates.WindowPos2sv) GetAddress("glWindowPos2sv", typeof(GL.Delegates.WindowPos2sv)); - GL.WindowPos3d = (GL.Delegates.WindowPos3d) GetAddress("glWindowPos3d", typeof(GL.Delegates.WindowPos3d)); - GL.WindowPos3dv = (GL.Delegates.WindowPos3dv) GetAddress("glWindowPos3dv", typeof(GL.Delegates.WindowPos3dv)); - GL.WindowPos3f = (GL.Delegates.WindowPos3f) GetAddress("glWindowPos3f", typeof(GL.Delegates.WindowPos3f)); - GL.WindowPos3fv = (GL.Delegates.WindowPos3fv) GetAddress("glWindowPos3fv", typeof(GL.Delegates.WindowPos3fv)); - GL.WindowPos3i = (GL.Delegates.WindowPos3i) GetAddress("glWindowPos3i", typeof(GL.Delegates.WindowPos3i)); - GL.WindowPos3iv = (GL.Delegates.WindowPos3iv) GetAddress("glWindowPos3iv", typeof(GL.Delegates.WindowPos3iv)); - GL.WindowPos3s = (GL.Delegates.WindowPos3s) GetAddress("glWindowPos3s", typeof(GL.Delegates.WindowPos3s)); - GL.WindowPos3sv = (GL.Delegates.WindowPos3sv) GetAddress("glWindowPos3sv", typeof(GL.Delegates.WindowPos3sv)); - GL.GenQueries = (GL.Delegates.GenQueries) GetAddress("glGenQueries", typeof(GL.Delegates.GenQueries)); - GL.DeleteQueries = (GL.Delegates.DeleteQueries) GetAddress("glDeleteQueries", typeof(GL.Delegates.DeleteQueries)); - GL.IsQuery = (GL.Delegates.IsQuery) GetAddress("glIsQuery", typeof(GL.Delegates.IsQuery)); - GL.BeginQuery = (GL.Delegates.BeginQuery) GetAddress("glBeginQuery", typeof(GL.Delegates.BeginQuery)); - GL.EndQuery = (GL.Delegates.EndQuery) GetAddress("glEndQuery", typeof(GL.Delegates.EndQuery)); - GL.GetQueryiv = (GL.Delegates.GetQueryiv) GetAddress("glGetQueryiv", typeof(GL.Delegates.GetQueryiv)); - GL.GetQueryObjectiv = (GL.Delegates.GetQueryObjectiv) GetAddress("glGetQueryObjectiv", typeof(GL.Delegates.GetQueryObjectiv)); - GL.GetQueryObjectuiv = (GL.Delegates.GetQueryObjectuiv) GetAddress("glGetQueryObjectuiv", typeof(GL.Delegates.GetQueryObjectuiv)); - GL.BindBuffer = (GL.Delegates.BindBuffer) GetAddress("glBindBuffer", typeof(GL.Delegates.BindBuffer)); - GL.DeleteBuffers = (GL.Delegates.DeleteBuffers) GetAddress("glDeleteBuffers", typeof(GL.Delegates.DeleteBuffers)); - GL.GenBuffers = (GL.Delegates.GenBuffers) GetAddress("glGenBuffers", typeof(GL.Delegates.GenBuffers)); - GL.IsBuffer = (GL.Delegates.IsBuffer) GetAddress("glIsBuffer", typeof(GL.Delegates.IsBuffer)); - GL.BufferData = (GL.Delegates.BufferData) GetAddress("glBufferData", typeof(GL.Delegates.BufferData)); - GL.BufferSubData = (GL.Delegates.BufferSubData) GetAddress("glBufferSubData", typeof(GL.Delegates.BufferSubData)); - GL.GetBufferSubData = (GL.Delegates.GetBufferSubData) GetAddress("glGetBufferSubData", typeof(GL.Delegates.GetBufferSubData)); - GL.MapBuffer_ = (GL.Delegates.MapBuffer_) GetAddress("glMapBuffer_", typeof(GL.Delegates.MapBuffer_)); - GL.UnmapBuffer = (GL.Delegates.UnmapBuffer) GetAddress("glUnmapBuffer", typeof(GL.Delegates.UnmapBuffer)); - GL.GetBufferParameteriv = (GL.Delegates.GetBufferParameteriv) GetAddress("glGetBufferParameteriv", typeof(GL.Delegates.GetBufferParameteriv)); - GL.GetBufferPointerv = (GL.Delegates.GetBufferPointerv) GetAddress("glGetBufferPointerv", typeof(GL.Delegates.GetBufferPointerv)); - GL.BlendEquationSeparate = (GL.Delegates.BlendEquationSeparate) GetAddress("glBlendEquationSeparate", typeof(GL.Delegates.BlendEquationSeparate)); - GL.DrawBuffers = (GL.Delegates.DrawBuffers) GetAddress("glDrawBuffers", typeof(GL.Delegates.DrawBuffers)); - GL.StencilOpSeparate = (GL.Delegates.StencilOpSeparate) GetAddress("glStencilOpSeparate", typeof(GL.Delegates.StencilOpSeparate)); - GL.StencilFuncSeparate = (GL.Delegates.StencilFuncSeparate) GetAddress("glStencilFuncSeparate", typeof(GL.Delegates.StencilFuncSeparate)); - GL.StencilMaskSeparate = (GL.Delegates.StencilMaskSeparate) GetAddress("glStencilMaskSeparate", typeof(GL.Delegates.StencilMaskSeparate)); - GL.AttachShader = (GL.Delegates.AttachShader) GetAddress("glAttachShader", typeof(GL.Delegates.AttachShader)); - GL.BindAttribLocation = (GL.Delegates.BindAttribLocation) GetAddress("glBindAttribLocation", typeof(GL.Delegates.BindAttribLocation)); - GL.CompileShader = (GL.Delegates.CompileShader) GetAddress("glCompileShader", typeof(GL.Delegates.CompileShader)); - GL.CreateProgram = (GL.Delegates.CreateProgram) GetAddress("glCreateProgram", typeof(GL.Delegates.CreateProgram)); - GL.CreateShader = (GL.Delegates.CreateShader) GetAddress("glCreateShader", typeof(GL.Delegates.CreateShader)); - GL.DeleteProgram = (GL.Delegates.DeleteProgram) GetAddress("glDeleteProgram", typeof(GL.Delegates.DeleteProgram)); - GL.DeleteShader = (GL.Delegates.DeleteShader) GetAddress("glDeleteShader", typeof(GL.Delegates.DeleteShader)); - GL.DetachShader = (GL.Delegates.DetachShader) GetAddress("glDetachShader", typeof(GL.Delegates.DetachShader)); - GL.DisableVertexAttribArray = (GL.Delegates.DisableVertexAttribArray) GetAddress("glDisableVertexAttribArray", typeof(GL.Delegates.DisableVertexAttribArray)); - GL.EnableVertexAttribArray = (GL.Delegates.EnableVertexAttribArray) GetAddress("glEnableVertexAttribArray", typeof(GL.Delegates.EnableVertexAttribArray)); - GL.GetActiveAttrib = (GL.Delegates.GetActiveAttrib) GetAddress("glGetActiveAttrib", typeof(GL.Delegates.GetActiveAttrib)); - GL.GetActiveUniform = (GL.Delegates.GetActiveUniform) GetAddress("glGetActiveUniform", typeof(GL.Delegates.GetActiveUniform)); - GL.GetAttachedShaders = (GL.Delegates.GetAttachedShaders) GetAddress("glGetAttachedShaders", typeof(GL.Delegates.GetAttachedShaders)); - GL.GetAttribLocation = (GL.Delegates.GetAttribLocation) GetAddress("glGetAttribLocation", typeof(GL.Delegates.GetAttribLocation)); - GL.GetProgramiv = (GL.Delegates.GetProgramiv) GetAddress("glGetProgramiv", typeof(GL.Delegates.GetProgramiv)); - GL.GetProgramInfoLog = (GL.Delegates.GetProgramInfoLog) GetAddress("glGetProgramInfoLog", typeof(GL.Delegates.GetProgramInfoLog)); - GL.GetShaderiv = (GL.Delegates.GetShaderiv) GetAddress("glGetShaderiv", typeof(GL.Delegates.GetShaderiv)); - GL.GetShaderInfoLog = (GL.Delegates.GetShaderInfoLog) GetAddress("glGetShaderInfoLog", typeof(GL.Delegates.GetShaderInfoLog)); - GL.GetShaderSource = (GL.Delegates.GetShaderSource) GetAddress("glGetShaderSource", typeof(GL.Delegates.GetShaderSource)); - GL.GetUniformLocation = (GL.Delegates.GetUniformLocation) GetAddress("glGetUniformLocation", typeof(GL.Delegates.GetUniformLocation)); - GL.GetUniformfv = (GL.Delegates.GetUniformfv) GetAddress("glGetUniformfv", typeof(GL.Delegates.GetUniformfv)); - GL.GetUniformiv = (GL.Delegates.GetUniformiv) GetAddress("glGetUniformiv", typeof(GL.Delegates.GetUniformiv)); - GL.GetVertexAttribdv = (GL.Delegates.GetVertexAttribdv) GetAddress("glGetVertexAttribdv", typeof(GL.Delegates.GetVertexAttribdv)); - GL.GetVertexAttribfv = (GL.Delegates.GetVertexAttribfv) GetAddress("glGetVertexAttribfv", typeof(GL.Delegates.GetVertexAttribfv)); - GL.GetVertexAttribiv = (GL.Delegates.GetVertexAttribiv) GetAddress("glGetVertexAttribiv", typeof(GL.Delegates.GetVertexAttribiv)); - GL.GetVertexAttribPointerv = (GL.Delegates.GetVertexAttribPointerv) GetAddress("glGetVertexAttribPointerv", typeof(GL.Delegates.GetVertexAttribPointerv)); - GL.IsProgram = (GL.Delegates.IsProgram) GetAddress("glIsProgram", typeof(GL.Delegates.IsProgram)); - GL.IsShader = (GL.Delegates.IsShader) GetAddress("glIsShader", typeof(GL.Delegates.IsShader)); - GL.LinkProgram = (GL.Delegates.LinkProgram) GetAddress("glLinkProgram", typeof(GL.Delegates.LinkProgram)); - GL.ShaderSource = (GL.Delegates.ShaderSource) GetAddress("glShaderSource", typeof(GL.Delegates.ShaderSource)); - GL.UseProgram = (GL.Delegates.UseProgram) GetAddress("glUseProgram", typeof(GL.Delegates.UseProgram)); - GL.Uniform1f = (GL.Delegates.Uniform1f) GetAddress("glUniform1f", typeof(GL.Delegates.Uniform1f)); - GL.Uniform2f = (GL.Delegates.Uniform2f) GetAddress("glUniform2f", typeof(GL.Delegates.Uniform2f)); - GL.Uniform3f = (GL.Delegates.Uniform3f) GetAddress("glUniform3f", typeof(GL.Delegates.Uniform3f)); - GL.Uniform4f = (GL.Delegates.Uniform4f) GetAddress("glUniform4f", typeof(GL.Delegates.Uniform4f)); - GL.Uniform1i = (GL.Delegates.Uniform1i) GetAddress("glUniform1i", typeof(GL.Delegates.Uniform1i)); - GL.Uniform2i = (GL.Delegates.Uniform2i) GetAddress("glUniform2i", typeof(GL.Delegates.Uniform2i)); - GL.Uniform3i = (GL.Delegates.Uniform3i) GetAddress("glUniform3i", typeof(GL.Delegates.Uniform3i)); - GL.Uniform4i = (GL.Delegates.Uniform4i) GetAddress("glUniform4i", typeof(GL.Delegates.Uniform4i)); - GL.Uniform1fv = (GL.Delegates.Uniform1fv) GetAddress("glUniform1fv", typeof(GL.Delegates.Uniform1fv)); - GL.Uniform2fv = (GL.Delegates.Uniform2fv) GetAddress("glUniform2fv", typeof(GL.Delegates.Uniform2fv)); - GL.Uniform3fv = (GL.Delegates.Uniform3fv) GetAddress("glUniform3fv", typeof(GL.Delegates.Uniform3fv)); - GL.Uniform4fv = (GL.Delegates.Uniform4fv) GetAddress("glUniform4fv", typeof(GL.Delegates.Uniform4fv)); - GL.Uniform1iv = (GL.Delegates.Uniform1iv) GetAddress("glUniform1iv", typeof(GL.Delegates.Uniform1iv)); - GL.Uniform2iv = (GL.Delegates.Uniform2iv) GetAddress("glUniform2iv", typeof(GL.Delegates.Uniform2iv)); - GL.Uniform3iv = (GL.Delegates.Uniform3iv) GetAddress("glUniform3iv", typeof(GL.Delegates.Uniform3iv)); - GL.Uniform4iv = (GL.Delegates.Uniform4iv) GetAddress("glUniform4iv", typeof(GL.Delegates.Uniform4iv)); - GL.UniformMatrix2fv = (GL.Delegates.UniformMatrix2fv) GetAddress("glUniformMatrix2fv", typeof(GL.Delegates.UniformMatrix2fv)); - GL.UniformMatrix3fv = (GL.Delegates.UniformMatrix3fv) GetAddress("glUniformMatrix3fv", typeof(GL.Delegates.UniformMatrix3fv)); - GL.UniformMatrix4fv = (GL.Delegates.UniformMatrix4fv) GetAddress("glUniformMatrix4fv", typeof(GL.Delegates.UniformMatrix4fv)); - GL.ValidateProgram = (GL.Delegates.ValidateProgram) GetAddress("glValidateProgram", typeof(GL.Delegates.ValidateProgram)); - GL.VertexAttrib1d = (GL.Delegates.VertexAttrib1d) GetAddress("glVertexAttrib1d", typeof(GL.Delegates.VertexAttrib1d)); - GL.VertexAttrib1dv = (GL.Delegates.VertexAttrib1dv) GetAddress("glVertexAttrib1dv", typeof(GL.Delegates.VertexAttrib1dv)); - GL.VertexAttrib1f = (GL.Delegates.VertexAttrib1f) GetAddress("glVertexAttrib1f", typeof(GL.Delegates.VertexAttrib1f)); - GL.VertexAttrib1fv = (GL.Delegates.VertexAttrib1fv) GetAddress("glVertexAttrib1fv", typeof(GL.Delegates.VertexAttrib1fv)); - GL.VertexAttrib1s = (GL.Delegates.VertexAttrib1s) GetAddress("glVertexAttrib1s", typeof(GL.Delegates.VertexAttrib1s)); - GL.VertexAttrib1sv = (GL.Delegates.VertexAttrib1sv) GetAddress("glVertexAttrib1sv", typeof(GL.Delegates.VertexAttrib1sv)); - GL.VertexAttrib2d = (GL.Delegates.VertexAttrib2d) GetAddress("glVertexAttrib2d", typeof(GL.Delegates.VertexAttrib2d)); - GL.VertexAttrib2dv = (GL.Delegates.VertexAttrib2dv) GetAddress("glVertexAttrib2dv", typeof(GL.Delegates.VertexAttrib2dv)); - GL.VertexAttrib2f = (GL.Delegates.VertexAttrib2f) GetAddress("glVertexAttrib2f", typeof(GL.Delegates.VertexAttrib2f)); - GL.VertexAttrib2fv = (GL.Delegates.VertexAttrib2fv) GetAddress("glVertexAttrib2fv", typeof(GL.Delegates.VertexAttrib2fv)); - GL.VertexAttrib2s = (GL.Delegates.VertexAttrib2s) GetAddress("glVertexAttrib2s", typeof(GL.Delegates.VertexAttrib2s)); - GL.VertexAttrib2sv = (GL.Delegates.VertexAttrib2sv) GetAddress("glVertexAttrib2sv", typeof(GL.Delegates.VertexAttrib2sv)); - GL.VertexAttrib3d = (GL.Delegates.VertexAttrib3d) GetAddress("glVertexAttrib3d", typeof(GL.Delegates.VertexAttrib3d)); - GL.VertexAttrib3dv = (GL.Delegates.VertexAttrib3dv) GetAddress("glVertexAttrib3dv", typeof(GL.Delegates.VertexAttrib3dv)); - GL.VertexAttrib3f = (GL.Delegates.VertexAttrib3f) GetAddress("glVertexAttrib3f", typeof(GL.Delegates.VertexAttrib3f)); - GL.VertexAttrib3fv = (GL.Delegates.VertexAttrib3fv) GetAddress("glVertexAttrib3fv", typeof(GL.Delegates.VertexAttrib3fv)); - GL.VertexAttrib3s = (GL.Delegates.VertexAttrib3s) GetAddress("glVertexAttrib3s", typeof(GL.Delegates.VertexAttrib3s)); - GL.VertexAttrib3sv = (GL.Delegates.VertexAttrib3sv) GetAddress("glVertexAttrib3sv", typeof(GL.Delegates.VertexAttrib3sv)); - GL.VertexAttrib4Nbv = (GL.Delegates.VertexAttrib4Nbv) GetAddress("glVertexAttrib4Nbv", typeof(GL.Delegates.VertexAttrib4Nbv)); - GL.VertexAttrib4Niv = (GL.Delegates.VertexAttrib4Niv) GetAddress("glVertexAttrib4Niv", typeof(GL.Delegates.VertexAttrib4Niv)); - GL.VertexAttrib4Nsv = (GL.Delegates.VertexAttrib4Nsv) GetAddress("glVertexAttrib4Nsv", typeof(GL.Delegates.VertexAttrib4Nsv)); - GL.VertexAttrib4Nub = (GL.Delegates.VertexAttrib4Nub) GetAddress("glVertexAttrib4Nub", typeof(GL.Delegates.VertexAttrib4Nub)); - GL.VertexAttrib4Nubv = (GL.Delegates.VertexAttrib4Nubv) GetAddress("glVertexAttrib4Nubv", typeof(GL.Delegates.VertexAttrib4Nubv)); - GL.VertexAttrib4Nuiv = (GL.Delegates.VertexAttrib4Nuiv) GetAddress("glVertexAttrib4Nuiv", typeof(GL.Delegates.VertexAttrib4Nuiv)); - GL.VertexAttrib4Nusv = (GL.Delegates.VertexAttrib4Nusv) GetAddress("glVertexAttrib4Nusv", typeof(GL.Delegates.VertexAttrib4Nusv)); - GL.VertexAttrib4bv = (GL.Delegates.VertexAttrib4bv) GetAddress("glVertexAttrib4bv", typeof(GL.Delegates.VertexAttrib4bv)); - GL.VertexAttrib4d = (GL.Delegates.VertexAttrib4d) GetAddress("glVertexAttrib4d", typeof(GL.Delegates.VertexAttrib4d)); - GL.VertexAttrib4dv = (GL.Delegates.VertexAttrib4dv) GetAddress("glVertexAttrib4dv", typeof(GL.Delegates.VertexAttrib4dv)); - GL.VertexAttrib4f = (GL.Delegates.VertexAttrib4f) GetAddress("glVertexAttrib4f", typeof(GL.Delegates.VertexAttrib4f)); - GL.VertexAttrib4fv = (GL.Delegates.VertexAttrib4fv) GetAddress("glVertexAttrib4fv", typeof(GL.Delegates.VertexAttrib4fv)); - GL.VertexAttrib4iv = (GL.Delegates.VertexAttrib4iv) GetAddress("glVertexAttrib4iv", typeof(GL.Delegates.VertexAttrib4iv)); - GL.VertexAttrib4s = (GL.Delegates.VertexAttrib4s) GetAddress("glVertexAttrib4s", typeof(GL.Delegates.VertexAttrib4s)); - GL.VertexAttrib4sv = (GL.Delegates.VertexAttrib4sv) GetAddress("glVertexAttrib4sv", typeof(GL.Delegates.VertexAttrib4sv)); - GL.VertexAttrib4ubv = (GL.Delegates.VertexAttrib4ubv) GetAddress("glVertexAttrib4ubv", typeof(GL.Delegates.VertexAttrib4ubv)); - GL.VertexAttrib4uiv = (GL.Delegates.VertexAttrib4uiv) GetAddress("glVertexAttrib4uiv", typeof(GL.Delegates.VertexAttrib4uiv)); - GL.VertexAttrib4usv = (GL.Delegates.VertexAttrib4usv) GetAddress("glVertexAttrib4usv", typeof(GL.Delegates.VertexAttrib4usv)); - GL.VertexAttribPointer = (GL.Delegates.VertexAttribPointer) GetAddress("glVertexAttribPointer", typeof(GL.Delegates.VertexAttribPointer)); - CoreLoaded = true; + base.Load(); + GL.NewList = new GL.Delegates.NewList(GL.Imports.NewList); + GL.EndList = new GL.Delegates.EndList(GL.Imports.EndList); + GL.CallList = new GL.Delegates.CallList(GL.Imports.CallList); + GL.CallLists_ = new GL.Delegates.CallLists_(GL.Imports.CallLists_); + GL.DeleteLists = new GL.Delegates.DeleteLists(GL.Imports.DeleteLists); + GL.GenLists = new GL.Delegates.GenLists(GL.Imports.GenLists); + GL.ListBase = new GL.Delegates.ListBase(GL.Imports.ListBase); + GL.Begin = new GL.Delegates.Begin(GL.Imports.Begin); + GL.Bitmap = new GL.Delegates.Bitmap(GL.Imports.Bitmap); + GL.Color3b = new GL.Delegates.Color3b(GL.Imports.Color3b); + GL.Color3bv = new GL.Delegates.Color3bv(GL.Imports.Color3bv); + GL.Color3d = new GL.Delegates.Color3d(GL.Imports.Color3d); + GL.Color3dv = new GL.Delegates.Color3dv(GL.Imports.Color3dv); + GL.Color3f = new GL.Delegates.Color3f(GL.Imports.Color3f); + GL.Color3fv = new GL.Delegates.Color3fv(GL.Imports.Color3fv); + GL.Color3i = new GL.Delegates.Color3i(GL.Imports.Color3i); + GL.Color3iv = new GL.Delegates.Color3iv(GL.Imports.Color3iv); + GL.Color3s = new GL.Delegates.Color3s(GL.Imports.Color3s); + GL.Color3sv = new GL.Delegates.Color3sv(GL.Imports.Color3sv); + GL.Color3ub = new GL.Delegates.Color3ub(GL.Imports.Color3ub); + GL.Color3ubv = new GL.Delegates.Color3ubv(GL.Imports.Color3ubv); + GL.Color3ui = new GL.Delegates.Color3ui(GL.Imports.Color3ui); + GL.Color3uiv = new GL.Delegates.Color3uiv(GL.Imports.Color3uiv); + GL.Color3us = new GL.Delegates.Color3us(GL.Imports.Color3us); + GL.Color3usv = new GL.Delegates.Color3usv(GL.Imports.Color3usv); + GL.Color4b = new GL.Delegates.Color4b(GL.Imports.Color4b); + GL.Color4bv = new GL.Delegates.Color4bv(GL.Imports.Color4bv); + GL.Color4d = new GL.Delegates.Color4d(GL.Imports.Color4d); + GL.Color4dv = new GL.Delegates.Color4dv(GL.Imports.Color4dv); + GL.Color4f = new GL.Delegates.Color4f(GL.Imports.Color4f); + GL.Color4fv = new GL.Delegates.Color4fv(GL.Imports.Color4fv); + GL.Color4i = new GL.Delegates.Color4i(GL.Imports.Color4i); + GL.Color4iv = new GL.Delegates.Color4iv(GL.Imports.Color4iv); + GL.Color4s = new GL.Delegates.Color4s(GL.Imports.Color4s); + GL.Color4sv = new GL.Delegates.Color4sv(GL.Imports.Color4sv); + GL.Color4ub = new GL.Delegates.Color4ub(GL.Imports.Color4ub); + GL.Color4ubv = new GL.Delegates.Color4ubv(GL.Imports.Color4ubv); + GL.Color4ui = new GL.Delegates.Color4ui(GL.Imports.Color4ui); + GL.Color4uiv = new GL.Delegates.Color4uiv(GL.Imports.Color4uiv); + GL.Color4us = new GL.Delegates.Color4us(GL.Imports.Color4us); + GL.Color4usv = new GL.Delegates.Color4usv(GL.Imports.Color4usv); + GL.EdgeFlag = new GL.Delegates.EdgeFlag(GL.Imports.EdgeFlag); + GL.EdgeFlagv = new GL.Delegates.EdgeFlagv(GL.Imports.EdgeFlagv); + GL.End = new GL.Delegates.End(GL.Imports.End); + GL.Indexd = new GL.Delegates.Indexd(GL.Imports.Indexd); + GL.Indexdv = new GL.Delegates.Indexdv(GL.Imports.Indexdv); + GL.Indexf = new GL.Delegates.Indexf(GL.Imports.Indexf); + GL.Indexfv = new GL.Delegates.Indexfv(GL.Imports.Indexfv); + GL.Indexi = new GL.Delegates.Indexi(GL.Imports.Indexi); + GL.Indexiv = new GL.Delegates.Indexiv(GL.Imports.Indexiv); + GL.Indexs = new GL.Delegates.Indexs(GL.Imports.Indexs); + GL.Indexsv = new GL.Delegates.Indexsv(GL.Imports.Indexsv); + GL.Normal3b = new GL.Delegates.Normal3b(GL.Imports.Normal3b); + GL.Normal3bv = new GL.Delegates.Normal3bv(GL.Imports.Normal3bv); + GL.Normal3d = new GL.Delegates.Normal3d(GL.Imports.Normal3d); + GL.Normal3dv = new GL.Delegates.Normal3dv(GL.Imports.Normal3dv); + GL.Normal3f = new GL.Delegates.Normal3f(GL.Imports.Normal3f); + GL.Normal3fv = new GL.Delegates.Normal3fv(GL.Imports.Normal3fv); + GL.Normal3i = new GL.Delegates.Normal3i(GL.Imports.Normal3i); + GL.Normal3iv = new GL.Delegates.Normal3iv(GL.Imports.Normal3iv); + GL.Normal3s = new GL.Delegates.Normal3s(GL.Imports.Normal3s); + GL.Normal3sv = new GL.Delegates.Normal3sv(GL.Imports.Normal3sv); + GL.RasterPos2d = new GL.Delegates.RasterPos2d(GL.Imports.RasterPos2d); + GL.RasterPos2dv = new GL.Delegates.RasterPos2dv(GL.Imports.RasterPos2dv); + GL.RasterPos2f = new GL.Delegates.RasterPos2f(GL.Imports.RasterPos2f); + GL.RasterPos2fv = new GL.Delegates.RasterPos2fv(GL.Imports.RasterPos2fv); + GL.RasterPos2i = new GL.Delegates.RasterPos2i(GL.Imports.RasterPos2i); + GL.RasterPos2iv = new GL.Delegates.RasterPos2iv(GL.Imports.RasterPos2iv); + GL.RasterPos2s = new GL.Delegates.RasterPos2s(GL.Imports.RasterPos2s); + GL.RasterPos2sv = new GL.Delegates.RasterPos2sv(GL.Imports.RasterPos2sv); + GL.RasterPos3d = new GL.Delegates.RasterPos3d(GL.Imports.RasterPos3d); + GL.RasterPos3dv = new GL.Delegates.RasterPos3dv(GL.Imports.RasterPos3dv); + GL.RasterPos3f = new GL.Delegates.RasterPos3f(GL.Imports.RasterPos3f); + GL.RasterPos3fv = new GL.Delegates.RasterPos3fv(GL.Imports.RasterPos3fv); + GL.RasterPos3i = new GL.Delegates.RasterPos3i(GL.Imports.RasterPos3i); + GL.RasterPos3iv = new GL.Delegates.RasterPos3iv(GL.Imports.RasterPos3iv); + GL.RasterPos3s = new GL.Delegates.RasterPos3s(GL.Imports.RasterPos3s); + GL.RasterPos3sv = new GL.Delegates.RasterPos3sv(GL.Imports.RasterPos3sv); + GL.RasterPos4d = new GL.Delegates.RasterPos4d(GL.Imports.RasterPos4d); + GL.RasterPos4dv = new GL.Delegates.RasterPos4dv(GL.Imports.RasterPos4dv); + GL.RasterPos4f = new GL.Delegates.RasterPos4f(GL.Imports.RasterPos4f); + GL.RasterPos4fv = new GL.Delegates.RasterPos4fv(GL.Imports.RasterPos4fv); + GL.RasterPos4i = new GL.Delegates.RasterPos4i(GL.Imports.RasterPos4i); + GL.RasterPos4iv = new GL.Delegates.RasterPos4iv(GL.Imports.RasterPos4iv); + GL.RasterPos4s = new GL.Delegates.RasterPos4s(GL.Imports.RasterPos4s); + GL.RasterPos4sv = new GL.Delegates.RasterPos4sv(GL.Imports.RasterPos4sv); + GL.Rectd = new GL.Delegates.Rectd(GL.Imports.Rectd); + GL.Rectdv = new GL.Delegates.Rectdv(GL.Imports.Rectdv); + GL.Rectf = new GL.Delegates.Rectf(GL.Imports.Rectf); + GL.Rectfv = new GL.Delegates.Rectfv(GL.Imports.Rectfv); + GL.Recti = new GL.Delegates.Recti(GL.Imports.Recti); + GL.Rectiv = new GL.Delegates.Rectiv(GL.Imports.Rectiv); + GL.Rects = new GL.Delegates.Rects(GL.Imports.Rects); + GL.Rectsv = new GL.Delegates.Rectsv(GL.Imports.Rectsv); + GL.TexCoord1d = new GL.Delegates.TexCoord1d(GL.Imports.TexCoord1d); + GL.TexCoord1dv = new GL.Delegates.TexCoord1dv(GL.Imports.TexCoord1dv); + GL.TexCoord1f = new GL.Delegates.TexCoord1f(GL.Imports.TexCoord1f); + GL.TexCoord1fv = new GL.Delegates.TexCoord1fv(GL.Imports.TexCoord1fv); + GL.TexCoord1i = new GL.Delegates.TexCoord1i(GL.Imports.TexCoord1i); + GL.TexCoord1iv = new GL.Delegates.TexCoord1iv(GL.Imports.TexCoord1iv); + GL.TexCoord1s = new GL.Delegates.TexCoord1s(GL.Imports.TexCoord1s); + GL.TexCoord1sv = new GL.Delegates.TexCoord1sv(GL.Imports.TexCoord1sv); + GL.TexCoord2d = new GL.Delegates.TexCoord2d(GL.Imports.TexCoord2d); + GL.TexCoord2dv = new GL.Delegates.TexCoord2dv(GL.Imports.TexCoord2dv); + GL.TexCoord2f = new GL.Delegates.TexCoord2f(GL.Imports.TexCoord2f); + GL.TexCoord2fv = new GL.Delegates.TexCoord2fv(GL.Imports.TexCoord2fv); + GL.TexCoord2i = new GL.Delegates.TexCoord2i(GL.Imports.TexCoord2i); + GL.TexCoord2iv = new GL.Delegates.TexCoord2iv(GL.Imports.TexCoord2iv); + GL.TexCoord2s = new GL.Delegates.TexCoord2s(GL.Imports.TexCoord2s); + GL.TexCoord2sv = new GL.Delegates.TexCoord2sv(GL.Imports.TexCoord2sv); + GL.TexCoord3d = new GL.Delegates.TexCoord3d(GL.Imports.TexCoord3d); + GL.TexCoord3dv = new GL.Delegates.TexCoord3dv(GL.Imports.TexCoord3dv); + GL.TexCoord3f = new GL.Delegates.TexCoord3f(GL.Imports.TexCoord3f); + GL.TexCoord3fv = new GL.Delegates.TexCoord3fv(GL.Imports.TexCoord3fv); + GL.TexCoord3i = new GL.Delegates.TexCoord3i(GL.Imports.TexCoord3i); + GL.TexCoord3iv = new GL.Delegates.TexCoord3iv(GL.Imports.TexCoord3iv); + GL.TexCoord3s = new GL.Delegates.TexCoord3s(GL.Imports.TexCoord3s); + GL.TexCoord3sv = new GL.Delegates.TexCoord3sv(GL.Imports.TexCoord3sv); + GL.TexCoord4d = new GL.Delegates.TexCoord4d(GL.Imports.TexCoord4d); + GL.TexCoord4dv = new GL.Delegates.TexCoord4dv(GL.Imports.TexCoord4dv); + GL.TexCoord4f = new GL.Delegates.TexCoord4f(GL.Imports.TexCoord4f); + GL.TexCoord4fv = new GL.Delegates.TexCoord4fv(GL.Imports.TexCoord4fv); + GL.TexCoord4i = new GL.Delegates.TexCoord4i(GL.Imports.TexCoord4i); + GL.TexCoord4iv = new GL.Delegates.TexCoord4iv(GL.Imports.TexCoord4iv); + GL.TexCoord4s = new GL.Delegates.TexCoord4s(GL.Imports.TexCoord4s); + GL.TexCoord4sv = new GL.Delegates.TexCoord4sv(GL.Imports.TexCoord4sv); + GL.Vertex2d = new GL.Delegates.Vertex2d(GL.Imports.Vertex2d); + GL.Vertex2dv = new GL.Delegates.Vertex2dv(GL.Imports.Vertex2dv); + GL.Vertex2f = new GL.Delegates.Vertex2f(GL.Imports.Vertex2f); + GL.Vertex2fv = new GL.Delegates.Vertex2fv(GL.Imports.Vertex2fv); + GL.Vertex2i = new GL.Delegates.Vertex2i(GL.Imports.Vertex2i); + GL.Vertex2iv = new GL.Delegates.Vertex2iv(GL.Imports.Vertex2iv); + GL.Vertex2s = new GL.Delegates.Vertex2s(GL.Imports.Vertex2s); + GL.Vertex2sv = new GL.Delegates.Vertex2sv(GL.Imports.Vertex2sv); + GL.Vertex3d = new GL.Delegates.Vertex3d(GL.Imports.Vertex3d); + GL.Vertex3dv = new GL.Delegates.Vertex3dv(GL.Imports.Vertex3dv); + GL.Vertex3f = new GL.Delegates.Vertex3f(GL.Imports.Vertex3f); + GL.Vertex3fv = new GL.Delegates.Vertex3fv(GL.Imports.Vertex3fv); + GL.Vertex3i = new GL.Delegates.Vertex3i(GL.Imports.Vertex3i); + GL.Vertex3iv = new GL.Delegates.Vertex3iv(GL.Imports.Vertex3iv); + GL.Vertex3s = new GL.Delegates.Vertex3s(GL.Imports.Vertex3s); + GL.Vertex3sv = new GL.Delegates.Vertex3sv(GL.Imports.Vertex3sv); + GL.Vertex4d = new GL.Delegates.Vertex4d(GL.Imports.Vertex4d); + GL.Vertex4dv = new GL.Delegates.Vertex4dv(GL.Imports.Vertex4dv); + GL.Vertex4f = new GL.Delegates.Vertex4f(GL.Imports.Vertex4f); + GL.Vertex4fv = new GL.Delegates.Vertex4fv(GL.Imports.Vertex4fv); + GL.Vertex4i = new GL.Delegates.Vertex4i(GL.Imports.Vertex4i); + GL.Vertex4iv = new GL.Delegates.Vertex4iv(GL.Imports.Vertex4iv); + GL.Vertex4s = new GL.Delegates.Vertex4s(GL.Imports.Vertex4s); + GL.Vertex4sv = new GL.Delegates.Vertex4sv(GL.Imports.Vertex4sv); + GL.ClipPlane = new GL.Delegates.ClipPlane(GL.Imports.ClipPlane); + GL.ColorMaterial = new GL.Delegates.ColorMaterial(GL.Imports.ColorMaterial); + GL.CullFace = new GL.Delegates.CullFace(GL.Imports.CullFace); + GL.Fogf = new GL.Delegates.Fogf(GL.Imports.Fogf); + GL.Fogfv = new GL.Delegates.Fogfv(GL.Imports.Fogfv); + GL.Fogi = new GL.Delegates.Fogi(GL.Imports.Fogi); + GL.Fogiv = new GL.Delegates.Fogiv(GL.Imports.Fogiv); + GL.FrontFace = new GL.Delegates.FrontFace(GL.Imports.FrontFace); + GL.Hint = new GL.Delegates.Hint(GL.Imports.Hint); + GL.Lightf = new GL.Delegates.Lightf(GL.Imports.Lightf); + GL.Lightfv = new GL.Delegates.Lightfv(GL.Imports.Lightfv); + GL.Lighti = new GL.Delegates.Lighti(GL.Imports.Lighti); + GL.Lightiv = new GL.Delegates.Lightiv(GL.Imports.Lightiv); + GL.LightModelf = new GL.Delegates.LightModelf(GL.Imports.LightModelf); + GL.LightModelfv = new GL.Delegates.LightModelfv(GL.Imports.LightModelfv); + GL.LightModeli = new GL.Delegates.LightModeli(GL.Imports.LightModeli); + GL.LightModeliv = new GL.Delegates.LightModeliv(GL.Imports.LightModeliv); + GL.LineStipple = new GL.Delegates.LineStipple(GL.Imports.LineStipple); + GL.LineWidth = new GL.Delegates.LineWidth(GL.Imports.LineWidth); + GL.Materialf = new GL.Delegates.Materialf(GL.Imports.Materialf); + GL.Materialfv = new GL.Delegates.Materialfv(GL.Imports.Materialfv); + GL.Materiali = new GL.Delegates.Materiali(GL.Imports.Materiali); + GL.Materialiv = new GL.Delegates.Materialiv(GL.Imports.Materialiv); + GL.PointSize = new GL.Delegates.PointSize(GL.Imports.PointSize); + GL.PolygonMode = new GL.Delegates.PolygonMode(GL.Imports.PolygonMode); + GL.PolygonStipple = new GL.Delegates.PolygonStipple(GL.Imports.PolygonStipple); + GL.Scissor = new GL.Delegates.Scissor(GL.Imports.Scissor); + GL.ShadeModel = new GL.Delegates.ShadeModel(GL.Imports.ShadeModel); + GL.TexParameterf = new GL.Delegates.TexParameterf(GL.Imports.TexParameterf); + GL.TexParameterfv = new GL.Delegates.TexParameterfv(GL.Imports.TexParameterfv); + GL.TexParameteri = new GL.Delegates.TexParameteri(GL.Imports.TexParameteri); + GL.TexParameteriv = new GL.Delegates.TexParameteriv(GL.Imports.TexParameteriv); + GL.TexImage1D = new GL.Delegates.TexImage1D(GL.Imports.TexImage1D); + GL.TexImage2D = new GL.Delegates.TexImage2D(GL.Imports.TexImage2D); + GL.TexEnvf = new GL.Delegates.TexEnvf(GL.Imports.TexEnvf); + GL.TexEnvfv = new GL.Delegates.TexEnvfv(GL.Imports.TexEnvfv); + GL.TexEnvi = new GL.Delegates.TexEnvi(GL.Imports.TexEnvi); + GL.TexEnviv = new GL.Delegates.TexEnviv(GL.Imports.TexEnviv); + GL.TexGend = new GL.Delegates.TexGend(GL.Imports.TexGend); + GL.TexGendv = new GL.Delegates.TexGendv(GL.Imports.TexGendv); + GL.TexGenf = new GL.Delegates.TexGenf(GL.Imports.TexGenf); + GL.TexGenfv = new GL.Delegates.TexGenfv(GL.Imports.TexGenfv); + GL.TexGeni = new GL.Delegates.TexGeni(GL.Imports.TexGeni); + GL.TexGeniv = new GL.Delegates.TexGeniv(GL.Imports.TexGeniv); + GL.FeedbackBuffer = new GL.Delegates.FeedbackBuffer(GL.Imports.FeedbackBuffer); + GL.SelectBuffer = new GL.Delegates.SelectBuffer(GL.Imports.SelectBuffer); + GL.RenderMode = new GL.Delegates.RenderMode(GL.Imports.RenderMode); + GL.InitNames = new GL.Delegates.InitNames(GL.Imports.InitNames); + GL.LoadName = new GL.Delegates.LoadName(GL.Imports.LoadName); + GL.PassThrough = new GL.Delegates.PassThrough(GL.Imports.PassThrough); + GL.PopName = new GL.Delegates.PopName(GL.Imports.PopName); + GL.PushName = new GL.Delegates.PushName(GL.Imports.PushName); + GL.DrawBuffer = new GL.Delegates.DrawBuffer(GL.Imports.DrawBuffer); + GL.Clear = new GL.Delegates.Clear(GL.Imports.Clear); + GL.ClearAccum = new GL.Delegates.ClearAccum(GL.Imports.ClearAccum); + GL.ClearIndex = new GL.Delegates.ClearIndex(GL.Imports.ClearIndex); + GL.ClearColor = new GL.Delegates.ClearColor(GL.Imports.ClearColor); + GL.ClearStencil = new GL.Delegates.ClearStencil(GL.Imports.ClearStencil); + GL.ClearDepth = new GL.Delegates.ClearDepth(GL.Imports.ClearDepth); + GL.StencilMask = new GL.Delegates.StencilMask(GL.Imports.StencilMask); + GL.ColorMask = new GL.Delegates.ColorMask(GL.Imports.ColorMask); + GL.DepthMask = new GL.Delegates.DepthMask(GL.Imports.DepthMask); + GL.IndexMask = new GL.Delegates.IndexMask(GL.Imports.IndexMask); + GL.Accum = new GL.Delegates.Accum(GL.Imports.Accum); + GL.Disable = new GL.Delegates.Disable(GL.Imports.Disable); + GL.Enable = new GL.Delegates.Enable(GL.Imports.Enable); + GL.Finish = new GL.Delegates.Finish(GL.Imports.Finish); + GL.Flush = new GL.Delegates.Flush(GL.Imports.Flush); + GL.PopAttrib = new GL.Delegates.PopAttrib(GL.Imports.PopAttrib); + GL.PushAttrib = new GL.Delegates.PushAttrib(GL.Imports.PushAttrib); + GL.Map1d = new GL.Delegates.Map1d(GL.Imports.Map1d); + GL.Map1f = new GL.Delegates.Map1f(GL.Imports.Map1f); + GL.Map2d = new GL.Delegates.Map2d(GL.Imports.Map2d); + GL.Map2f = new GL.Delegates.Map2f(GL.Imports.Map2f); + GL.MapGrid1d = new GL.Delegates.MapGrid1d(GL.Imports.MapGrid1d); + GL.MapGrid1f = new GL.Delegates.MapGrid1f(GL.Imports.MapGrid1f); + GL.MapGrid2d = new GL.Delegates.MapGrid2d(GL.Imports.MapGrid2d); + GL.MapGrid2f = new GL.Delegates.MapGrid2f(GL.Imports.MapGrid2f); + GL.EvalCoord1d = new GL.Delegates.EvalCoord1d(GL.Imports.EvalCoord1d); + GL.EvalCoord1dv = new GL.Delegates.EvalCoord1dv(GL.Imports.EvalCoord1dv); + GL.EvalCoord1f = new GL.Delegates.EvalCoord1f(GL.Imports.EvalCoord1f); + GL.EvalCoord1fv = new GL.Delegates.EvalCoord1fv(GL.Imports.EvalCoord1fv); + GL.EvalCoord2d = new GL.Delegates.EvalCoord2d(GL.Imports.EvalCoord2d); + GL.EvalCoord2dv = new GL.Delegates.EvalCoord2dv(GL.Imports.EvalCoord2dv); + GL.EvalCoord2f = new GL.Delegates.EvalCoord2f(GL.Imports.EvalCoord2f); + GL.EvalCoord2fv = new GL.Delegates.EvalCoord2fv(GL.Imports.EvalCoord2fv); + GL.EvalMesh1 = new GL.Delegates.EvalMesh1(GL.Imports.EvalMesh1); + GL.EvalPoint1 = new GL.Delegates.EvalPoint1(GL.Imports.EvalPoint1); + GL.EvalMesh2 = new GL.Delegates.EvalMesh2(GL.Imports.EvalMesh2); + GL.EvalPoint2 = new GL.Delegates.EvalPoint2(GL.Imports.EvalPoint2); + GL.AlphaFunc = new GL.Delegates.AlphaFunc(GL.Imports.AlphaFunc); + GL.BlendFunc = new GL.Delegates.BlendFunc(GL.Imports.BlendFunc); + GL.LogicOp = new GL.Delegates.LogicOp(GL.Imports.LogicOp); + GL.StencilFunc = new GL.Delegates.StencilFunc(GL.Imports.StencilFunc); + GL.StencilOp = new GL.Delegates.StencilOp(GL.Imports.StencilOp); + GL.DepthFunc = new GL.Delegates.DepthFunc(GL.Imports.DepthFunc); + GL.PixelZoom = new GL.Delegates.PixelZoom(GL.Imports.PixelZoom); + GL.PixelTransferf = new GL.Delegates.PixelTransferf(GL.Imports.PixelTransferf); + GL.PixelTransferi = new GL.Delegates.PixelTransferi(GL.Imports.PixelTransferi); + GL.PixelStoref = new GL.Delegates.PixelStoref(GL.Imports.PixelStoref); + GL.PixelStorei = new GL.Delegates.PixelStorei(GL.Imports.PixelStorei); + GL.PixelMapfv = new GL.Delegates.PixelMapfv(GL.Imports.PixelMapfv); + GL.PixelMapuiv = new GL.Delegates.PixelMapuiv(GL.Imports.PixelMapuiv); + GL.PixelMapusv = new GL.Delegates.PixelMapusv(GL.Imports.PixelMapusv); + GL.ReadBuffer = new GL.Delegates.ReadBuffer(GL.Imports.ReadBuffer); + GL.CopyPixels = new GL.Delegates.CopyPixels(GL.Imports.CopyPixels); + GL.ReadPixels_ = new GL.Delegates.ReadPixels_(GL.Imports.ReadPixels_); + GL.DrawPixels_ = new GL.Delegates.DrawPixels_(GL.Imports.DrawPixels_); + GL.GetBooleanv = new GL.Delegates.GetBooleanv(GL.Imports.GetBooleanv); + GL.GetClipPlane = new GL.Delegates.GetClipPlane(GL.Imports.GetClipPlane); + GL.GetDoublev = new GL.Delegates.GetDoublev(GL.Imports.GetDoublev); + GL.GetError = new GL.Delegates.GetError(GL.Imports.GetError); + GL.GetFloatv = new GL.Delegates.GetFloatv(GL.Imports.GetFloatv); + GL.GetIntegerv = new GL.Delegates.GetIntegerv(GL.Imports.GetIntegerv); + GL.GetLightfv = new GL.Delegates.GetLightfv(GL.Imports.GetLightfv); + GL.GetLightiv = new GL.Delegates.GetLightiv(GL.Imports.GetLightiv); + GL.GetMapdv = new GL.Delegates.GetMapdv(GL.Imports.GetMapdv); + GL.GetMapfv = new GL.Delegates.GetMapfv(GL.Imports.GetMapfv); + GL.GetMapiv = new GL.Delegates.GetMapiv(GL.Imports.GetMapiv); + GL.GetMaterialfv = new GL.Delegates.GetMaterialfv(GL.Imports.GetMaterialfv); + GL.GetMaterialiv = new GL.Delegates.GetMaterialiv(GL.Imports.GetMaterialiv); + GL.GetPixelMapfv = new GL.Delegates.GetPixelMapfv(GL.Imports.GetPixelMapfv); + GL.GetPixelMapuiv = new GL.Delegates.GetPixelMapuiv(GL.Imports.GetPixelMapuiv); + GL.GetPixelMapusv = new GL.Delegates.GetPixelMapusv(GL.Imports.GetPixelMapusv); + GL.GetPolygonStipple = new GL.Delegates.GetPolygonStipple(GL.Imports.GetPolygonStipple); + GL.GetString = new GL.Delegates.GetString(GL.Imports.GetString); + GL.GetTexEnvfv = new GL.Delegates.GetTexEnvfv(GL.Imports.GetTexEnvfv); + GL.GetTexEnviv = new GL.Delegates.GetTexEnviv(GL.Imports.GetTexEnviv); + GL.GetTexGendv = new GL.Delegates.GetTexGendv(GL.Imports.GetTexGendv); + GL.GetTexGenfv = new GL.Delegates.GetTexGenfv(GL.Imports.GetTexGenfv); + GL.GetTexGeniv = new GL.Delegates.GetTexGeniv(GL.Imports.GetTexGeniv); + GL.GetTexImage = new GL.Delegates.GetTexImage(GL.Imports.GetTexImage); + GL.GetTexParameterfv = new GL.Delegates.GetTexParameterfv(GL.Imports.GetTexParameterfv); + GL.GetTexParameteriv = new GL.Delegates.GetTexParameteriv(GL.Imports.GetTexParameteriv); + GL.GetTexLevelParameterfv = new GL.Delegates.GetTexLevelParameterfv(GL.Imports.GetTexLevelParameterfv); + GL.GetTexLevelParameteriv = new GL.Delegates.GetTexLevelParameteriv(GL.Imports.GetTexLevelParameteriv); + GL.IsEnabled = new GL.Delegates.IsEnabled(GL.Imports.IsEnabled); + GL.IsList = new GL.Delegates.IsList(GL.Imports.IsList); + GL.DepthRange = new GL.Delegates.DepthRange(GL.Imports.DepthRange); + GL.Frustum = new GL.Delegates.Frustum(GL.Imports.Frustum); + GL.LoadIdentity = new GL.Delegates.LoadIdentity(GL.Imports.LoadIdentity); + GL.LoadMatrixf = new GL.Delegates.LoadMatrixf(GL.Imports.LoadMatrixf); + GL.LoadMatrixd = new GL.Delegates.LoadMatrixd(GL.Imports.LoadMatrixd); + GL.MatrixMode = new GL.Delegates.MatrixMode(GL.Imports.MatrixMode); + GL.MultMatrixf = new GL.Delegates.MultMatrixf(GL.Imports.MultMatrixf); + GL.MultMatrixd = new GL.Delegates.MultMatrixd(GL.Imports.MultMatrixd); + GL.Ortho = new GL.Delegates.Ortho(GL.Imports.Ortho); + GL.PopMatrix = new GL.Delegates.PopMatrix(GL.Imports.PopMatrix); + GL.PushMatrix = new GL.Delegates.PushMatrix(GL.Imports.PushMatrix); + GL.Rotated = new GL.Delegates.Rotated(GL.Imports.Rotated); + GL.Rotatef = new GL.Delegates.Rotatef(GL.Imports.Rotatef); + GL.Scaled = new GL.Delegates.Scaled(GL.Imports.Scaled); + GL.Scalef = new GL.Delegates.Scalef(GL.Imports.Scalef); + GL.Translated = new GL.Delegates.Translated(GL.Imports.Translated); + GL.Translatef = new GL.Delegates.Translatef(GL.Imports.Translatef); + GL.Viewport = new GL.Delegates.Viewport(GL.Imports.Viewport); + GL.ArrayElement = new GL.Delegates.ArrayElement(GL.Imports.ArrayElement); + GL.ColorPointer_ = new GL.Delegates.ColorPointer_(GL.Imports.ColorPointer_); + GL.DisableClientState = new GL.Delegates.DisableClientState(GL.Imports.DisableClientState); + GL.DrawArrays = new GL.Delegates.DrawArrays(GL.Imports.DrawArrays); + GL.DrawElements_ = new GL.Delegates.DrawElements_(GL.Imports.DrawElements_); + GL.EdgeFlagPointer_ = new GL.Delegates.EdgeFlagPointer_(GL.Imports.EdgeFlagPointer_); + GL.EnableClientState = new GL.Delegates.EnableClientState(GL.Imports.EnableClientState); + GL.GetPointerv = new GL.Delegates.GetPointerv(GL.Imports.GetPointerv); + GL.IndexPointer_ = new GL.Delegates.IndexPointer_(GL.Imports.IndexPointer_); + GL.InterleavedArrays_ = new GL.Delegates.InterleavedArrays_(GL.Imports.InterleavedArrays_); + GL.NormalPointer_ = new GL.Delegates.NormalPointer_(GL.Imports.NormalPointer_); + GL.TexCoordPointer_ = new GL.Delegates.TexCoordPointer_(GL.Imports.TexCoordPointer_); + GL.VertexPointer_ = new GL.Delegates.VertexPointer_(GL.Imports.VertexPointer_); + GL.PolygonOffset = new GL.Delegates.PolygonOffset(GL.Imports.PolygonOffset); + GL.CopyTexImage1D = new GL.Delegates.CopyTexImage1D(GL.Imports.CopyTexImage1D); + GL.CopyTexImage2D = new GL.Delegates.CopyTexImage2D(GL.Imports.CopyTexImage2D); + GL.CopyTexSubImage1D = new GL.Delegates.CopyTexSubImage1D(GL.Imports.CopyTexSubImage1D); + GL.CopyTexSubImage2D = new GL.Delegates.CopyTexSubImage2D(GL.Imports.CopyTexSubImage2D); + GL.TexSubImage1D = new GL.Delegates.TexSubImage1D(GL.Imports.TexSubImage1D); + GL.TexSubImage2D = new GL.Delegates.TexSubImage2D(GL.Imports.TexSubImage2D); + GL.AreTexturesResident = new GL.Delegates.AreTexturesResident(GL.Imports.AreTexturesResident); + GL.BindTexture = new GL.Delegates.BindTexture(GL.Imports.BindTexture); + GL.DeleteTextures = new GL.Delegates.DeleteTextures(GL.Imports.DeleteTextures); + GL.GenTextures = new GL.Delegates.GenTextures(GL.Imports.GenTextures); + GL.IsTexture = new GL.Delegates.IsTexture(GL.Imports.IsTexture); + GL.PrioritizeTextures = new GL.Delegates.PrioritizeTextures(GL.Imports.PrioritizeTextures); + GL.Indexub = new GL.Delegates.Indexub(GL.Imports.Indexub); + GL.Indexubv = new GL.Delegates.Indexubv(GL.Imports.Indexubv); + GL.PopClientAttrib = new GL.Delegates.PopClientAttrib(GL.Imports.PopClientAttrib); + GL.PushClientAttrib = new GL.Delegates.PushClientAttrib(GL.Imports.PushClientAttrib); } - - #endregion - - #region Load extensions - - /// - /// Loads the opengl extensions (e.g. ARB, EXT, vendor and platform specific functions). - /// - public override void LoadExtensions() - { - GL.ActiveTextureARB = (GL.Delegates.ActiveTextureARB) GetAddress("glActiveTextureARB", typeof(GL.Delegates.ActiveTextureARB)); - GL.ClientActiveTextureARB = (GL.Delegates.ClientActiveTextureARB) GetAddress("glClientActiveTextureARB", typeof(GL.Delegates.ClientActiveTextureARB)); - GL.MultiTexCoord1dARB = (GL.Delegates.MultiTexCoord1dARB) GetAddress("glMultiTexCoord1dARB", typeof(GL.Delegates.MultiTexCoord1dARB)); - GL.MultiTexCoord1dvARB = (GL.Delegates.MultiTexCoord1dvARB) GetAddress("glMultiTexCoord1dvARB", typeof(GL.Delegates.MultiTexCoord1dvARB)); - GL.MultiTexCoord1fARB = (GL.Delegates.MultiTexCoord1fARB) GetAddress("glMultiTexCoord1fARB", typeof(GL.Delegates.MultiTexCoord1fARB)); - GL.MultiTexCoord1fvARB = (GL.Delegates.MultiTexCoord1fvARB) GetAddress("glMultiTexCoord1fvARB", typeof(GL.Delegates.MultiTexCoord1fvARB)); - GL.MultiTexCoord1iARB = (GL.Delegates.MultiTexCoord1iARB) GetAddress("glMultiTexCoord1iARB", typeof(GL.Delegates.MultiTexCoord1iARB)); - GL.MultiTexCoord1ivARB = (GL.Delegates.MultiTexCoord1ivARB) GetAddress("glMultiTexCoord1ivARB", typeof(GL.Delegates.MultiTexCoord1ivARB)); - GL.MultiTexCoord1sARB = (GL.Delegates.MultiTexCoord1sARB) GetAddress("glMultiTexCoord1sARB", typeof(GL.Delegates.MultiTexCoord1sARB)); - GL.MultiTexCoord1svARB = (GL.Delegates.MultiTexCoord1svARB) GetAddress("glMultiTexCoord1svARB", typeof(GL.Delegates.MultiTexCoord1svARB)); - GL.MultiTexCoord2dARB = (GL.Delegates.MultiTexCoord2dARB) GetAddress("glMultiTexCoord2dARB", typeof(GL.Delegates.MultiTexCoord2dARB)); - GL.MultiTexCoord2dvARB = (GL.Delegates.MultiTexCoord2dvARB) GetAddress("glMultiTexCoord2dvARB", typeof(GL.Delegates.MultiTexCoord2dvARB)); - GL.MultiTexCoord2fARB = (GL.Delegates.MultiTexCoord2fARB) GetAddress("glMultiTexCoord2fARB", typeof(GL.Delegates.MultiTexCoord2fARB)); - GL.MultiTexCoord2fvARB = (GL.Delegates.MultiTexCoord2fvARB) GetAddress("glMultiTexCoord2fvARB", typeof(GL.Delegates.MultiTexCoord2fvARB)); - GL.MultiTexCoord2iARB = (GL.Delegates.MultiTexCoord2iARB) GetAddress("glMultiTexCoord2iARB", typeof(GL.Delegates.MultiTexCoord2iARB)); - GL.MultiTexCoord2ivARB = (GL.Delegates.MultiTexCoord2ivARB) GetAddress("glMultiTexCoord2ivARB", typeof(GL.Delegates.MultiTexCoord2ivARB)); - GL.MultiTexCoord2sARB = (GL.Delegates.MultiTexCoord2sARB) GetAddress("glMultiTexCoord2sARB", typeof(GL.Delegates.MultiTexCoord2sARB)); - GL.MultiTexCoord2svARB = (GL.Delegates.MultiTexCoord2svARB) GetAddress("glMultiTexCoord2svARB", typeof(GL.Delegates.MultiTexCoord2svARB)); - GL.MultiTexCoord3dARB = (GL.Delegates.MultiTexCoord3dARB) GetAddress("glMultiTexCoord3dARB", typeof(GL.Delegates.MultiTexCoord3dARB)); - GL.MultiTexCoord3dvARB = (GL.Delegates.MultiTexCoord3dvARB) GetAddress("glMultiTexCoord3dvARB", typeof(GL.Delegates.MultiTexCoord3dvARB)); - GL.MultiTexCoord3fARB = (GL.Delegates.MultiTexCoord3fARB) GetAddress("glMultiTexCoord3fARB", typeof(GL.Delegates.MultiTexCoord3fARB)); - GL.MultiTexCoord3fvARB = (GL.Delegates.MultiTexCoord3fvARB) GetAddress("glMultiTexCoord3fvARB", typeof(GL.Delegates.MultiTexCoord3fvARB)); - GL.MultiTexCoord3iARB = (GL.Delegates.MultiTexCoord3iARB) GetAddress("glMultiTexCoord3iARB", typeof(GL.Delegates.MultiTexCoord3iARB)); - GL.MultiTexCoord3ivARB = (GL.Delegates.MultiTexCoord3ivARB) GetAddress("glMultiTexCoord3ivARB", typeof(GL.Delegates.MultiTexCoord3ivARB)); - GL.MultiTexCoord3sARB = (GL.Delegates.MultiTexCoord3sARB) GetAddress("glMultiTexCoord3sARB", typeof(GL.Delegates.MultiTexCoord3sARB)); - GL.MultiTexCoord3svARB = (GL.Delegates.MultiTexCoord3svARB) GetAddress("glMultiTexCoord3svARB", typeof(GL.Delegates.MultiTexCoord3svARB)); - GL.MultiTexCoord4dARB = (GL.Delegates.MultiTexCoord4dARB) GetAddress("glMultiTexCoord4dARB", typeof(GL.Delegates.MultiTexCoord4dARB)); - GL.MultiTexCoord4dvARB = (GL.Delegates.MultiTexCoord4dvARB) GetAddress("glMultiTexCoord4dvARB", typeof(GL.Delegates.MultiTexCoord4dvARB)); - GL.MultiTexCoord4fARB = (GL.Delegates.MultiTexCoord4fARB) GetAddress("glMultiTexCoord4fARB", typeof(GL.Delegates.MultiTexCoord4fARB)); - GL.MultiTexCoord4fvARB = (GL.Delegates.MultiTexCoord4fvARB) GetAddress("glMultiTexCoord4fvARB", typeof(GL.Delegates.MultiTexCoord4fvARB)); - GL.MultiTexCoord4iARB = (GL.Delegates.MultiTexCoord4iARB) GetAddress("glMultiTexCoord4iARB", typeof(GL.Delegates.MultiTexCoord4iARB)); - GL.MultiTexCoord4ivARB = (GL.Delegates.MultiTexCoord4ivARB) GetAddress("glMultiTexCoord4ivARB", typeof(GL.Delegates.MultiTexCoord4ivARB)); - GL.MultiTexCoord4sARB = (GL.Delegates.MultiTexCoord4sARB) GetAddress("glMultiTexCoord4sARB", typeof(GL.Delegates.MultiTexCoord4sARB)); - GL.MultiTexCoord4svARB = (GL.Delegates.MultiTexCoord4svARB) GetAddress("glMultiTexCoord4svARB", typeof(GL.Delegates.MultiTexCoord4svARB)); - GL.LoadTransposeMatrixfARB = (GL.Delegates.LoadTransposeMatrixfARB) GetAddress("glLoadTransposeMatrixfARB", typeof(GL.Delegates.LoadTransposeMatrixfARB)); - GL.LoadTransposeMatrixdARB = (GL.Delegates.LoadTransposeMatrixdARB) GetAddress("glLoadTransposeMatrixdARB", typeof(GL.Delegates.LoadTransposeMatrixdARB)); - GL.MultTransposeMatrixfARB = (GL.Delegates.MultTransposeMatrixfARB) GetAddress("glMultTransposeMatrixfARB", typeof(GL.Delegates.MultTransposeMatrixfARB)); - GL.MultTransposeMatrixdARB = (GL.Delegates.MultTransposeMatrixdARB) GetAddress("glMultTransposeMatrixdARB", typeof(GL.Delegates.MultTransposeMatrixdARB)); - GL.SampleCoverageARB = (GL.Delegates.SampleCoverageARB) GetAddress("glSampleCoverageARB", typeof(GL.Delegates.SampleCoverageARB)); - GL.CompressedTexImage3DARB = (GL.Delegates.CompressedTexImage3DARB) GetAddress("glCompressedTexImage3DARB", typeof(GL.Delegates.CompressedTexImage3DARB)); - GL.CompressedTexImage2DARB = (GL.Delegates.CompressedTexImage2DARB) GetAddress("glCompressedTexImage2DARB", typeof(GL.Delegates.CompressedTexImage2DARB)); - GL.CompressedTexImage1DARB = (GL.Delegates.CompressedTexImage1DARB) GetAddress("glCompressedTexImage1DARB", typeof(GL.Delegates.CompressedTexImage1DARB)); - GL.CompressedTexSubImage3DARB = (GL.Delegates.CompressedTexSubImage3DARB) GetAddress("glCompressedTexSubImage3DARB", typeof(GL.Delegates.CompressedTexSubImage3DARB)); - GL.CompressedTexSubImage2DARB = (GL.Delegates.CompressedTexSubImage2DARB) GetAddress("glCompressedTexSubImage2DARB", typeof(GL.Delegates.CompressedTexSubImage2DARB)); - GL.CompressedTexSubImage1DARB = (GL.Delegates.CompressedTexSubImage1DARB) GetAddress("glCompressedTexSubImage1DARB", typeof(GL.Delegates.CompressedTexSubImage1DARB)); - GL.GetCompressedTexImageARB = (GL.Delegates.GetCompressedTexImageARB) GetAddress("glGetCompressedTexImageARB", typeof(GL.Delegates.GetCompressedTexImageARB)); - GL.PointParameterfARB = (GL.Delegates.PointParameterfARB) GetAddress("glPointParameterfARB", typeof(GL.Delegates.PointParameterfARB)); - GL.PointParameterfvARB = (GL.Delegates.PointParameterfvARB) GetAddress("glPointParameterfvARB", typeof(GL.Delegates.PointParameterfvARB)); - GL.WeightbvARB = (GL.Delegates.WeightbvARB) GetAddress("glWeightbvARB", typeof(GL.Delegates.WeightbvARB)); - GL.WeightsvARB = (GL.Delegates.WeightsvARB) GetAddress("glWeightsvARB", typeof(GL.Delegates.WeightsvARB)); - GL.WeightivARB = (GL.Delegates.WeightivARB) GetAddress("glWeightivARB", typeof(GL.Delegates.WeightivARB)); - GL.WeightfvARB = (GL.Delegates.WeightfvARB) GetAddress("glWeightfvARB", typeof(GL.Delegates.WeightfvARB)); - GL.WeightdvARB = (GL.Delegates.WeightdvARB) GetAddress("glWeightdvARB", typeof(GL.Delegates.WeightdvARB)); - GL.WeightubvARB = (GL.Delegates.WeightubvARB) GetAddress("glWeightubvARB", typeof(GL.Delegates.WeightubvARB)); - GL.WeightusvARB = (GL.Delegates.WeightusvARB) GetAddress("glWeightusvARB", typeof(GL.Delegates.WeightusvARB)); - GL.WeightuivARB = (GL.Delegates.WeightuivARB) GetAddress("glWeightuivARB", typeof(GL.Delegates.WeightuivARB)); - GL.WeightPointerARB = (GL.Delegates.WeightPointerARB) GetAddress("glWeightPointerARB", typeof(GL.Delegates.WeightPointerARB)); - GL.VertexBlendARB = (GL.Delegates.VertexBlendARB) GetAddress("glVertexBlendARB", typeof(GL.Delegates.VertexBlendARB)); - GL.CurrentPaletteMatrixARB = (GL.Delegates.CurrentPaletteMatrixARB) GetAddress("glCurrentPaletteMatrixARB", typeof(GL.Delegates.CurrentPaletteMatrixARB)); - GL.MatrixIndexubvARB = (GL.Delegates.MatrixIndexubvARB) GetAddress("glMatrixIndexubvARB", typeof(GL.Delegates.MatrixIndexubvARB)); - GL.MatrixIndexusvARB = (GL.Delegates.MatrixIndexusvARB) GetAddress("glMatrixIndexusvARB", typeof(GL.Delegates.MatrixIndexusvARB)); - GL.MatrixIndexuivARB = (GL.Delegates.MatrixIndexuivARB) GetAddress("glMatrixIndexuivARB", typeof(GL.Delegates.MatrixIndexuivARB)); - GL.MatrixIndexPointerARB = (GL.Delegates.MatrixIndexPointerARB) GetAddress("glMatrixIndexPointerARB", typeof(GL.Delegates.MatrixIndexPointerARB)); - GL.WindowPos2dARB = (GL.Delegates.WindowPos2dARB) GetAddress("glWindowPos2dARB", typeof(GL.Delegates.WindowPos2dARB)); - GL.WindowPos2dvARB = (GL.Delegates.WindowPos2dvARB) GetAddress("glWindowPos2dvARB", typeof(GL.Delegates.WindowPos2dvARB)); - GL.WindowPos2fARB = (GL.Delegates.WindowPos2fARB) GetAddress("glWindowPos2fARB", typeof(GL.Delegates.WindowPos2fARB)); - GL.WindowPos2fvARB = (GL.Delegates.WindowPos2fvARB) GetAddress("glWindowPos2fvARB", typeof(GL.Delegates.WindowPos2fvARB)); - GL.WindowPos2iARB = (GL.Delegates.WindowPos2iARB) GetAddress("glWindowPos2iARB", typeof(GL.Delegates.WindowPos2iARB)); - GL.WindowPos2ivARB = (GL.Delegates.WindowPos2ivARB) GetAddress("glWindowPos2ivARB", typeof(GL.Delegates.WindowPos2ivARB)); - GL.WindowPos2sARB = (GL.Delegates.WindowPos2sARB) GetAddress("glWindowPos2sARB", typeof(GL.Delegates.WindowPos2sARB)); - GL.WindowPos2svARB = (GL.Delegates.WindowPos2svARB) GetAddress("glWindowPos2svARB", typeof(GL.Delegates.WindowPos2svARB)); - GL.WindowPos3dARB = (GL.Delegates.WindowPos3dARB) GetAddress("glWindowPos3dARB", typeof(GL.Delegates.WindowPos3dARB)); - GL.WindowPos3dvARB = (GL.Delegates.WindowPos3dvARB) GetAddress("glWindowPos3dvARB", typeof(GL.Delegates.WindowPos3dvARB)); - GL.WindowPos3fARB = (GL.Delegates.WindowPos3fARB) GetAddress("glWindowPos3fARB", typeof(GL.Delegates.WindowPos3fARB)); - GL.WindowPos3fvARB = (GL.Delegates.WindowPos3fvARB) GetAddress("glWindowPos3fvARB", typeof(GL.Delegates.WindowPos3fvARB)); - GL.WindowPos3iARB = (GL.Delegates.WindowPos3iARB) GetAddress("glWindowPos3iARB", typeof(GL.Delegates.WindowPos3iARB)); - GL.WindowPos3ivARB = (GL.Delegates.WindowPos3ivARB) GetAddress("glWindowPos3ivARB", typeof(GL.Delegates.WindowPos3ivARB)); - GL.WindowPos3sARB = (GL.Delegates.WindowPos3sARB) GetAddress("glWindowPos3sARB", typeof(GL.Delegates.WindowPos3sARB)); - GL.WindowPos3svARB = (GL.Delegates.WindowPos3svARB) GetAddress("glWindowPos3svARB", typeof(GL.Delegates.WindowPos3svARB)); - GL.VertexAttrib1dARB = (GL.Delegates.VertexAttrib1dARB) GetAddress("glVertexAttrib1dARB", typeof(GL.Delegates.VertexAttrib1dARB)); - GL.VertexAttrib1dvARB = (GL.Delegates.VertexAttrib1dvARB) GetAddress("glVertexAttrib1dvARB", typeof(GL.Delegates.VertexAttrib1dvARB)); - GL.VertexAttrib1fARB = (GL.Delegates.VertexAttrib1fARB) GetAddress("glVertexAttrib1fARB", typeof(GL.Delegates.VertexAttrib1fARB)); - GL.VertexAttrib1fvARB = (GL.Delegates.VertexAttrib1fvARB) GetAddress("glVertexAttrib1fvARB", typeof(GL.Delegates.VertexAttrib1fvARB)); - GL.VertexAttrib1sARB = (GL.Delegates.VertexAttrib1sARB) GetAddress("glVertexAttrib1sARB", typeof(GL.Delegates.VertexAttrib1sARB)); - GL.VertexAttrib1svARB = (GL.Delegates.VertexAttrib1svARB) GetAddress("glVertexAttrib1svARB", typeof(GL.Delegates.VertexAttrib1svARB)); - GL.VertexAttrib2dARB = (GL.Delegates.VertexAttrib2dARB) GetAddress("glVertexAttrib2dARB", typeof(GL.Delegates.VertexAttrib2dARB)); - GL.VertexAttrib2dvARB = (GL.Delegates.VertexAttrib2dvARB) GetAddress("glVertexAttrib2dvARB", typeof(GL.Delegates.VertexAttrib2dvARB)); - GL.VertexAttrib2fARB = (GL.Delegates.VertexAttrib2fARB) GetAddress("glVertexAttrib2fARB", typeof(GL.Delegates.VertexAttrib2fARB)); - GL.VertexAttrib2fvARB = (GL.Delegates.VertexAttrib2fvARB) GetAddress("glVertexAttrib2fvARB", typeof(GL.Delegates.VertexAttrib2fvARB)); - GL.VertexAttrib2sARB = (GL.Delegates.VertexAttrib2sARB) GetAddress("glVertexAttrib2sARB", typeof(GL.Delegates.VertexAttrib2sARB)); - GL.VertexAttrib2svARB = (GL.Delegates.VertexAttrib2svARB) GetAddress("glVertexAttrib2svARB", typeof(GL.Delegates.VertexAttrib2svARB)); - GL.VertexAttrib3dARB = (GL.Delegates.VertexAttrib3dARB) GetAddress("glVertexAttrib3dARB", typeof(GL.Delegates.VertexAttrib3dARB)); - GL.VertexAttrib3dvARB = (GL.Delegates.VertexAttrib3dvARB) GetAddress("glVertexAttrib3dvARB", typeof(GL.Delegates.VertexAttrib3dvARB)); - GL.VertexAttrib3fARB = (GL.Delegates.VertexAttrib3fARB) GetAddress("glVertexAttrib3fARB", typeof(GL.Delegates.VertexAttrib3fARB)); - GL.VertexAttrib3fvARB = (GL.Delegates.VertexAttrib3fvARB) GetAddress("glVertexAttrib3fvARB", typeof(GL.Delegates.VertexAttrib3fvARB)); - GL.VertexAttrib3sARB = (GL.Delegates.VertexAttrib3sARB) GetAddress("glVertexAttrib3sARB", typeof(GL.Delegates.VertexAttrib3sARB)); - GL.VertexAttrib3svARB = (GL.Delegates.VertexAttrib3svARB) GetAddress("glVertexAttrib3svARB", typeof(GL.Delegates.VertexAttrib3svARB)); - GL.VertexAttrib4NbvARB = (GL.Delegates.VertexAttrib4NbvARB) GetAddress("glVertexAttrib4NbvARB", typeof(GL.Delegates.VertexAttrib4NbvARB)); - GL.VertexAttrib4NivARB = (GL.Delegates.VertexAttrib4NivARB) GetAddress("glVertexAttrib4NivARB", typeof(GL.Delegates.VertexAttrib4NivARB)); - GL.VertexAttrib4NsvARB = (GL.Delegates.VertexAttrib4NsvARB) GetAddress("glVertexAttrib4NsvARB", typeof(GL.Delegates.VertexAttrib4NsvARB)); - GL.VertexAttrib4NubARB = (GL.Delegates.VertexAttrib4NubARB) GetAddress("glVertexAttrib4NubARB", typeof(GL.Delegates.VertexAttrib4NubARB)); - GL.VertexAttrib4NubvARB = (GL.Delegates.VertexAttrib4NubvARB) GetAddress("glVertexAttrib4NubvARB", typeof(GL.Delegates.VertexAttrib4NubvARB)); - GL.VertexAttrib4NuivARB = (GL.Delegates.VertexAttrib4NuivARB) GetAddress("glVertexAttrib4NuivARB", typeof(GL.Delegates.VertexAttrib4NuivARB)); - GL.VertexAttrib4NusvARB = (GL.Delegates.VertexAttrib4NusvARB) GetAddress("glVertexAttrib4NusvARB", typeof(GL.Delegates.VertexAttrib4NusvARB)); - GL.VertexAttrib4bvARB = (GL.Delegates.VertexAttrib4bvARB) GetAddress("glVertexAttrib4bvARB", typeof(GL.Delegates.VertexAttrib4bvARB)); - GL.VertexAttrib4dARB = (GL.Delegates.VertexAttrib4dARB) GetAddress("glVertexAttrib4dARB", typeof(GL.Delegates.VertexAttrib4dARB)); - GL.VertexAttrib4dvARB = (GL.Delegates.VertexAttrib4dvARB) GetAddress("glVertexAttrib4dvARB", typeof(GL.Delegates.VertexAttrib4dvARB)); - GL.VertexAttrib4fARB = (GL.Delegates.VertexAttrib4fARB) GetAddress("glVertexAttrib4fARB", typeof(GL.Delegates.VertexAttrib4fARB)); - GL.VertexAttrib4fvARB = (GL.Delegates.VertexAttrib4fvARB) GetAddress("glVertexAttrib4fvARB", typeof(GL.Delegates.VertexAttrib4fvARB)); - GL.VertexAttrib4ivARB = (GL.Delegates.VertexAttrib4ivARB) GetAddress("glVertexAttrib4ivARB", typeof(GL.Delegates.VertexAttrib4ivARB)); - GL.VertexAttrib4sARB = (GL.Delegates.VertexAttrib4sARB) GetAddress("glVertexAttrib4sARB", typeof(GL.Delegates.VertexAttrib4sARB)); - GL.VertexAttrib4svARB = (GL.Delegates.VertexAttrib4svARB) GetAddress("glVertexAttrib4svARB", typeof(GL.Delegates.VertexAttrib4svARB)); - GL.VertexAttrib4ubvARB = (GL.Delegates.VertexAttrib4ubvARB) GetAddress("glVertexAttrib4ubvARB", typeof(GL.Delegates.VertexAttrib4ubvARB)); - GL.VertexAttrib4uivARB = (GL.Delegates.VertexAttrib4uivARB) GetAddress("glVertexAttrib4uivARB", typeof(GL.Delegates.VertexAttrib4uivARB)); - GL.VertexAttrib4usvARB = (GL.Delegates.VertexAttrib4usvARB) GetAddress("glVertexAttrib4usvARB", typeof(GL.Delegates.VertexAttrib4usvARB)); - GL.VertexAttribPointerARB = (GL.Delegates.VertexAttribPointerARB) GetAddress("glVertexAttribPointerARB", typeof(GL.Delegates.VertexAttribPointerARB)); - GL.EnableVertexAttribArrayARB = (GL.Delegates.EnableVertexAttribArrayARB) GetAddress("glEnableVertexAttribArrayARB", typeof(GL.Delegates.EnableVertexAttribArrayARB)); - GL.DisableVertexAttribArrayARB = (GL.Delegates.DisableVertexAttribArrayARB) GetAddress("glDisableVertexAttribArrayARB", typeof(GL.Delegates.DisableVertexAttribArrayARB)); - GL.ProgramStringARB = (GL.Delegates.ProgramStringARB) GetAddress("glProgramStringARB", typeof(GL.Delegates.ProgramStringARB)); - GL.BindProgramARB = (GL.Delegates.BindProgramARB) GetAddress("glBindProgramARB", typeof(GL.Delegates.BindProgramARB)); - GL.DeleteProgramsARB = (GL.Delegates.DeleteProgramsARB) GetAddress("glDeleteProgramsARB", typeof(GL.Delegates.DeleteProgramsARB)); - GL.GenProgramsARB = (GL.Delegates.GenProgramsARB) GetAddress("glGenProgramsARB", typeof(GL.Delegates.GenProgramsARB)); - GL.ProgramEnvParameter4dARB = (GL.Delegates.ProgramEnvParameter4dARB) GetAddress("glProgramEnvParameter4dARB", typeof(GL.Delegates.ProgramEnvParameter4dARB)); - GL.ProgramEnvParameter4dvARB = (GL.Delegates.ProgramEnvParameter4dvARB) GetAddress("glProgramEnvParameter4dvARB", typeof(GL.Delegates.ProgramEnvParameter4dvARB)); - GL.ProgramEnvParameter4fARB = (GL.Delegates.ProgramEnvParameter4fARB) GetAddress("glProgramEnvParameter4fARB", typeof(GL.Delegates.ProgramEnvParameter4fARB)); - GL.ProgramEnvParameter4fvARB = (GL.Delegates.ProgramEnvParameter4fvARB) GetAddress("glProgramEnvParameter4fvARB", typeof(GL.Delegates.ProgramEnvParameter4fvARB)); - GL.ProgramLocalParameter4dARB = (GL.Delegates.ProgramLocalParameter4dARB) GetAddress("glProgramLocalParameter4dARB", typeof(GL.Delegates.ProgramLocalParameter4dARB)); - GL.ProgramLocalParameter4dvARB = (GL.Delegates.ProgramLocalParameter4dvARB) GetAddress("glProgramLocalParameter4dvARB", typeof(GL.Delegates.ProgramLocalParameter4dvARB)); - GL.ProgramLocalParameter4fARB = (GL.Delegates.ProgramLocalParameter4fARB) GetAddress("glProgramLocalParameter4fARB", typeof(GL.Delegates.ProgramLocalParameter4fARB)); - GL.ProgramLocalParameter4fvARB = (GL.Delegates.ProgramLocalParameter4fvARB) GetAddress("glProgramLocalParameter4fvARB", typeof(GL.Delegates.ProgramLocalParameter4fvARB)); - GL.GetProgramEnvParameterdvARB = (GL.Delegates.GetProgramEnvParameterdvARB) GetAddress("glGetProgramEnvParameterdvARB", typeof(GL.Delegates.GetProgramEnvParameterdvARB)); - GL.GetProgramEnvParameterfvARB = (GL.Delegates.GetProgramEnvParameterfvARB) GetAddress("glGetProgramEnvParameterfvARB", typeof(GL.Delegates.GetProgramEnvParameterfvARB)); - GL.GetProgramLocalParameterdvARB = (GL.Delegates.GetProgramLocalParameterdvARB) GetAddress("glGetProgramLocalParameterdvARB", typeof(GL.Delegates.GetProgramLocalParameterdvARB)); - GL.GetProgramLocalParameterfvARB = (GL.Delegates.GetProgramLocalParameterfvARB) GetAddress("glGetProgramLocalParameterfvARB", typeof(GL.Delegates.GetProgramLocalParameterfvARB)); - GL.GetProgramivARB = (GL.Delegates.GetProgramivARB) GetAddress("glGetProgramivARB", typeof(GL.Delegates.GetProgramivARB)); - GL.GetProgramStringARB = (GL.Delegates.GetProgramStringARB) GetAddress("glGetProgramStringARB", typeof(GL.Delegates.GetProgramStringARB)); - GL.GetVertexAttribdvARB = (GL.Delegates.GetVertexAttribdvARB) GetAddress("glGetVertexAttribdvARB", typeof(GL.Delegates.GetVertexAttribdvARB)); - GL.GetVertexAttribfvARB = (GL.Delegates.GetVertexAttribfvARB) GetAddress("glGetVertexAttribfvARB", typeof(GL.Delegates.GetVertexAttribfvARB)); - GL.GetVertexAttribivARB = (GL.Delegates.GetVertexAttribivARB) GetAddress("glGetVertexAttribivARB", typeof(GL.Delegates.GetVertexAttribivARB)); - GL.GetVertexAttribPointervARB = (GL.Delegates.GetVertexAttribPointervARB) GetAddress("glGetVertexAttribPointervARB", typeof(GL.Delegates.GetVertexAttribPointervARB)); - GL.IsProgramARB = (GL.Delegates.IsProgramARB) GetAddress("glIsProgramARB", typeof(GL.Delegates.IsProgramARB)); - GL.BindBufferARB = (GL.Delegates.BindBufferARB) GetAddress("glBindBufferARB", typeof(GL.Delegates.BindBufferARB)); - GL.DeleteBuffersARB = (GL.Delegates.DeleteBuffersARB) GetAddress("glDeleteBuffersARB", typeof(GL.Delegates.DeleteBuffersARB)); - GL.GenBuffersARB = (GL.Delegates.GenBuffersARB) GetAddress("glGenBuffersARB", typeof(GL.Delegates.GenBuffersARB)); - GL.IsBufferARB = (GL.Delegates.IsBufferARB) GetAddress("glIsBufferARB", typeof(GL.Delegates.IsBufferARB)); - GL.BufferDataARB = (GL.Delegates.BufferDataARB) GetAddress("glBufferDataARB", typeof(GL.Delegates.BufferDataARB)); - GL.BufferSubDataARB = (GL.Delegates.BufferSubDataARB) GetAddress("glBufferSubDataARB", typeof(GL.Delegates.BufferSubDataARB)); - GL.GetBufferSubDataARB = (GL.Delegates.GetBufferSubDataARB) GetAddress("glGetBufferSubDataARB", typeof(GL.Delegates.GetBufferSubDataARB)); - GL.MapBufferARB_ = (GL.Delegates.MapBufferARB_) GetAddress("glMapBufferARB_", typeof(GL.Delegates.MapBufferARB_)); - GL.UnmapBufferARB = (GL.Delegates.UnmapBufferARB) GetAddress("glUnmapBufferARB", typeof(GL.Delegates.UnmapBufferARB)); - GL.GetBufferParameterivARB = (GL.Delegates.GetBufferParameterivARB) GetAddress("glGetBufferParameterivARB", typeof(GL.Delegates.GetBufferParameterivARB)); - GL.GetBufferPointervARB = (GL.Delegates.GetBufferPointervARB) GetAddress("glGetBufferPointervARB", typeof(GL.Delegates.GetBufferPointervARB)); - GL.GenQueriesARB = (GL.Delegates.GenQueriesARB) GetAddress("glGenQueriesARB", typeof(GL.Delegates.GenQueriesARB)); - GL.DeleteQueriesARB = (GL.Delegates.DeleteQueriesARB) GetAddress("glDeleteQueriesARB", typeof(GL.Delegates.DeleteQueriesARB)); - GL.IsQueryARB = (GL.Delegates.IsQueryARB) GetAddress("glIsQueryARB", typeof(GL.Delegates.IsQueryARB)); - GL.BeginQueryARB = (GL.Delegates.BeginQueryARB) GetAddress("glBeginQueryARB", typeof(GL.Delegates.BeginQueryARB)); - GL.EndQueryARB = (GL.Delegates.EndQueryARB) GetAddress("glEndQueryARB", typeof(GL.Delegates.EndQueryARB)); - GL.GetQueryivARB = (GL.Delegates.GetQueryivARB) GetAddress("glGetQueryivARB", typeof(GL.Delegates.GetQueryivARB)); - GL.GetQueryObjectivARB = (GL.Delegates.GetQueryObjectivARB) GetAddress("glGetQueryObjectivARB", typeof(GL.Delegates.GetQueryObjectivARB)); - GL.GetQueryObjectuivARB = (GL.Delegates.GetQueryObjectuivARB) GetAddress("glGetQueryObjectuivARB", typeof(GL.Delegates.GetQueryObjectuivARB)); - GL.DeleteObjectARB = (GL.Delegates.DeleteObjectARB) GetAddress("glDeleteObjectARB", typeof(GL.Delegates.DeleteObjectARB)); - GL.GetHandleARB = (GL.Delegates.GetHandleARB) GetAddress("glGetHandleARB", typeof(GL.Delegates.GetHandleARB)); - GL.DetachObjectARB = (GL.Delegates.DetachObjectARB) GetAddress("glDetachObjectARB", typeof(GL.Delegates.DetachObjectARB)); - GL.CreateShaderObjectARB = (GL.Delegates.CreateShaderObjectARB) GetAddress("glCreateShaderObjectARB", typeof(GL.Delegates.CreateShaderObjectARB)); - GL.ShaderSourceARB = (GL.Delegates.ShaderSourceARB) GetAddress("glShaderSourceARB", typeof(GL.Delegates.ShaderSourceARB)); - GL.CompileShaderARB = (GL.Delegates.CompileShaderARB) GetAddress("glCompileShaderARB", typeof(GL.Delegates.CompileShaderARB)); - GL.CreateProgramObjectARB = (GL.Delegates.CreateProgramObjectARB) GetAddress("glCreateProgramObjectARB", typeof(GL.Delegates.CreateProgramObjectARB)); - GL.AttachObjectARB = (GL.Delegates.AttachObjectARB) GetAddress("glAttachObjectARB", typeof(GL.Delegates.AttachObjectARB)); - GL.LinkProgramARB = (GL.Delegates.LinkProgramARB) GetAddress("glLinkProgramARB", typeof(GL.Delegates.LinkProgramARB)); - GL.UseProgramObjectARB = (GL.Delegates.UseProgramObjectARB) GetAddress("glUseProgramObjectARB", typeof(GL.Delegates.UseProgramObjectARB)); - GL.ValidateProgramARB = (GL.Delegates.ValidateProgramARB) GetAddress("glValidateProgramARB", typeof(GL.Delegates.ValidateProgramARB)); - GL.Uniform1fARB = (GL.Delegates.Uniform1fARB) GetAddress("glUniform1fARB", typeof(GL.Delegates.Uniform1fARB)); - GL.Uniform2fARB = (GL.Delegates.Uniform2fARB) GetAddress("glUniform2fARB", typeof(GL.Delegates.Uniform2fARB)); - GL.Uniform3fARB = (GL.Delegates.Uniform3fARB) GetAddress("glUniform3fARB", typeof(GL.Delegates.Uniform3fARB)); - GL.Uniform4fARB = (GL.Delegates.Uniform4fARB) GetAddress("glUniform4fARB", typeof(GL.Delegates.Uniform4fARB)); - GL.Uniform1iARB = (GL.Delegates.Uniform1iARB) GetAddress("glUniform1iARB", typeof(GL.Delegates.Uniform1iARB)); - GL.Uniform2iARB = (GL.Delegates.Uniform2iARB) GetAddress("glUniform2iARB", typeof(GL.Delegates.Uniform2iARB)); - GL.Uniform3iARB = (GL.Delegates.Uniform3iARB) GetAddress("glUniform3iARB", typeof(GL.Delegates.Uniform3iARB)); - GL.Uniform4iARB = (GL.Delegates.Uniform4iARB) GetAddress("glUniform4iARB", typeof(GL.Delegates.Uniform4iARB)); - GL.Uniform1fvARB = (GL.Delegates.Uniform1fvARB) GetAddress("glUniform1fvARB", typeof(GL.Delegates.Uniform1fvARB)); - GL.Uniform2fvARB = (GL.Delegates.Uniform2fvARB) GetAddress("glUniform2fvARB", typeof(GL.Delegates.Uniform2fvARB)); - GL.Uniform3fvARB = (GL.Delegates.Uniform3fvARB) GetAddress("glUniform3fvARB", typeof(GL.Delegates.Uniform3fvARB)); - GL.Uniform4fvARB = (GL.Delegates.Uniform4fvARB) GetAddress("glUniform4fvARB", typeof(GL.Delegates.Uniform4fvARB)); - GL.Uniform1ivARB = (GL.Delegates.Uniform1ivARB) GetAddress("glUniform1ivARB", typeof(GL.Delegates.Uniform1ivARB)); - GL.Uniform2ivARB = (GL.Delegates.Uniform2ivARB) GetAddress("glUniform2ivARB", typeof(GL.Delegates.Uniform2ivARB)); - GL.Uniform3ivARB = (GL.Delegates.Uniform3ivARB) GetAddress("glUniform3ivARB", typeof(GL.Delegates.Uniform3ivARB)); - GL.Uniform4ivARB = (GL.Delegates.Uniform4ivARB) GetAddress("glUniform4ivARB", typeof(GL.Delegates.Uniform4ivARB)); - GL.UniformMatrix2fvARB = (GL.Delegates.UniformMatrix2fvARB) GetAddress("glUniformMatrix2fvARB", typeof(GL.Delegates.UniformMatrix2fvARB)); - GL.UniformMatrix3fvARB = (GL.Delegates.UniformMatrix3fvARB) GetAddress("glUniformMatrix3fvARB", typeof(GL.Delegates.UniformMatrix3fvARB)); - GL.UniformMatrix4fvARB = (GL.Delegates.UniformMatrix4fvARB) GetAddress("glUniformMatrix4fvARB", typeof(GL.Delegates.UniformMatrix4fvARB)); - GL.GetObjectParameterfvARB = (GL.Delegates.GetObjectParameterfvARB) GetAddress("glGetObjectParameterfvARB", typeof(GL.Delegates.GetObjectParameterfvARB)); - GL.GetObjectParameterivARB = (GL.Delegates.GetObjectParameterivARB) GetAddress("glGetObjectParameterivARB", typeof(GL.Delegates.GetObjectParameterivARB)); - GL.GetInfoLogARB = (GL.Delegates.GetInfoLogARB) GetAddress("glGetInfoLogARB", typeof(GL.Delegates.GetInfoLogARB)); - GL.GetAttachedObjectsARB = (GL.Delegates.GetAttachedObjectsARB) GetAddress("glGetAttachedObjectsARB", typeof(GL.Delegates.GetAttachedObjectsARB)); - GL.GetUniformLocationARB = (GL.Delegates.GetUniformLocationARB) GetAddress("glGetUniformLocationARB", typeof(GL.Delegates.GetUniformLocationARB)); - GL.GetActiveUniformARB = (GL.Delegates.GetActiveUniformARB) GetAddress("glGetActiveUniformARB", typeof(GL.Delegates.GetActiveUniformARB)); - GL.GetUniformfvARB = (GL.Delegates.GetUniformfvARB) GetAddress("glGetUniformfvARB", typeof(GL.Delegates.GetUniformfvARB)); - GL.GetUniformivARB = (GL.Delegates.GetUniformivARB) GetAddress("glGetUniformivARB", typeof(GL.Delegates.GetUniformivARB)); - GL.GetShaderSourceARB = (GL.Delegates.GetShaderSourceARB) GetAddress("glGetShaderSourceARB", typeof(GL.Delegates.GetShaderSourceARB)); - GL.BindAttribLocationARB = (GL.Delegates.BindAttribLocationARB) GetAddress("glBindAttribLocationARB", typeof(GL.Delegates.BindAttribLocationARB)); - GL.GetActiveAttribARB = (GL.Delegates.GetActiveAttribARB) GetAddress("glGetActiveAttribARB", typeof(GL.Delegates.GetActiveAttribARB)); - GL.GetAttribLocationARB = (GL.Delegates.GetAttribLocationARB) GetAddress("glGetAttribLocationARB", typeof(GL.Delegates.GetAttribLocationARB)); - GL.DrawBuffersARB = (GL.Delegates.DrawBuffersARB) GetAddress("glDrawBuffersARB", typeof(GL.Delegates.DrawBuffersARB)); - GL.ClampColorARB = (GL.Delegates.ClampColorARB) GetAddress("glClampColorARB", typeof(GL.Delegates.ClampColorARB)); - GL.BlendColorEXT = (GL.Delegates.BlendColorEXT) GetAddress("glBlendColorEXT", typeof(GL.Delegates.BlendColorEXT)); - GL.PolygonOffsetEXT = (GL.Delegates.PolygonOffsetEXT) GetAddress("glPolygonOffsetEXT", typeof(GL.Delegates.PolygonOffsetEXT)); - GL.TexImage3DEXT = (GL.Delegates.TexImage3DEXT) GetAddress("glTexImage3DEXT", typeof(GL.Delegates.TexImage3DEXT)); - GL.TexSubImage3DEXT = (GL.Delegates.TexSubImage3DEXT) GetAddress("glTexSubImage3DEXT", typeof(GL.Delegates.TexSubImage3DEXT)); - GL.GetTexFilterFuncSGIS = (GL.Delegates.GetTexFilterFuncSGIS) GetAddress("glGetTexFilterFuncSGIS", typeof(GL.Delegates.GetTexFilterFuncSGIS)); - GL.TexFilterFuncSGIS = (GL.Delegates.TexFilterFuncSGIS) GetAddress("glTexFilterFuncSGIS", typeof(GL.Delegates.TexFilterFuncSGIS)); - GL.TexSubImage1DEXT = (GL.Delegates.TexSubImage1DEXT) GetAddress("glTexSubImage1DEXT", typeof(GL.Delegates.TexSubImage1DEXT)); - GL.TexSubImage2DEXT = (GL.Delegates.TexSubImage2DEXT) GetAddress("glTexSubImage2DEXT", typeof(GL.Delegates.TexSubImage2DEXT)); - GL.CopyTexImage1DEXT = (GL.Delegates.CopyTexImage1DEXT) GetAddress("glCopyTexImage1DEXT", typeof(GL.Delegates.CopyTexImage1DEXT)); - GL.CopyTexImage2DEXT = (GL.Delegates.CopyTexImage2DEXT) GetAddress("glCopyTexImage2DEXT", typeof(GL.Delegates.CopyTexImage2DEXT)); - GL.CopyTexSubImage1DEXT = (GL.Delegates.CopyTexSubImage1DEXT) GetAddress("glCopyTexSubImage1DEXT", typeof(GL.Delegates.CopyTexSubImage1DEXT)); - GL.CopyTexSubImage2DEXT = (GL.Delegates.CopyTexSubImage2DEXT) GetAddress("glCopyTexSubImage2DEXT", typeof(GL.Delegates.CopyTexSubImage2DEXT)); - GL.CopyTexSubImage3DEXT = (GL.Delegates.CopyTexSubImage3DEXT) GetAddress("glCopyTexSubImage3DEXT", typeof(GL.Delegates.CopyTexSubImage3DEXT)); - GL.GetHistogramEXT = (GL.Delegates.GetHistogramEXT) GetAddress("glGetHistogramEXT", typeof(GL.Delegates.GetHistogramEXT)); - GL.GetHistogramParameterfvEXT = (GL.Delegates.GetHistogramParameterfvEXT) GetAddress("glGetHistogramParameterfvEXT", typeof(GL.Delegates.GetHistogramParameterfvEXT)); - GL.GetHistogramParameterivEXT = (GL.Delegates.GetHistogramParameterivEXT) GetAddress("glGetHistogramParameterivEXT", typeof(GL.Delegates.GetHistogramParameterivEXT)); - GL.GetMinmaxEXT = (GL.Delegates.GetMinmaxEXT) GetAddress("glGetMinmaxEXT", typeof(GL.Delegates.GetMinmaxEXT)); - GL.GetMinmaxParameterfvEXT = (GL.Delegates.GetMinmaxParameterfvEXT) GetAddress("glGetMinmaxParameterfvEXT", typeof(GL.Delegates.GetMinmaxParameterfvEXT)); - GL.GetMinmaxParameterivEXT = (GL.Delegates.GetMinmaxParameterivEXT) GetAddress("glGetMinmaxParameterivEXT", typeof(GL.Delegates.GetMinmaxParameterivEXT)); - GL.HistogramEXT = (GL.Delegates.HistogramEXT) GetAddress("glHistogramEXT", typeof(GL.Delegates.HistogramEXT)); - GL.MinmaxEXT = (GL.Delegates.MinmaxEXT) GetAddress("glMinmaxEXT", typeof(GL.Delegates.MinmaxEXT)); - GL.ResetHistogramEXT = (GL.Delegates.ResetHistogramEXT) GetAddress("glResetHistogramEXT", typeof(GL.Delegates.ResetHistogramEXT)); - GL.ResetMinmaxEXT = (GL.Delegates.ResetMinmaxEXT) GetAddress("glResetMinmaxEXT", typeof(GL.Delegates.ResetMinmaxEXT)); - GL.ConvolutionFilter1DEXT = (GL.Delegates.ConvolutionFilter1DEXT) GetAddress("glConvolutionFilter1DEXT", typeof(GL.Delegates.ConvolutionFilter1DEXT)); - GL.ConvolutionFilter2DEXT = (GL.Delegates.ConvolutionFilter2DEXT) GetAddress("glConvolutionFilter2DEXT", typeof(GL.Delegates.ConvolutionFilter2DEXT)); - GL.ConvolutionParameterfEXT = (GL.Delegates.ConvolutionParameterfEXT) GetAddress("glConvolutionParameterfEXT", typeof(GL.Delegates.ConvolutionParameterfEXT)); - GL.ConvolutionParameterfvEXT = (GL.Delegates.ConvolutionParameterfvEXT) GetAddress("glConvolutionParameterfvEXT", typeof(GL.Delegates.ConvolutionParameterfvEXT)); - GL.ConvolutionParameteriEXT = (GL.Delegates.ConvolutionParameteriEXT) GetAddress("glConvolutionParameteriEXT", typeof(GL.Delegates.ConvolutionParameteriEXT)); - GL.ConvolutionParameterivEXT = (GL.Delegates.ConvolutionParameterivEXT) GetAddress("glConvolutionParameterivEXT", typeof(GL.Delegates.ConvolutionParameterivEXT)); - GL.CopyConvolutionFilter1DEXT = (GL.Delegates.CopyConvolutionFilter1DEXT) GetAddress("glCopyConvolutionFilter1DEXT", typeof(GL.Delegates.CopyConvolutionFilter1DEXT)); - GL.CopyConvolutionFilter2DEXT = (GL.Delegates.CopyConvolutionFilter2DEXT) GetAddress("glCopyConvolutionFilter2DEXT", typeof(GL.Delegates.CopyConvolutionFilter2DEXT)); - GL.GetConvolutionFilterEXT = (GL.Delegates.GetConvolutionFilterEXT) GetAddress("glGetConvolutionFilterEXT", typeof(GL.Delegates.GetConvolutionFilterEXT)); - GL.GetConvolutionParameterfvEXT = (GL.Delegates.GetConvolutionParameterfvEXT) GetAddress("glGetConvolutionParameterfvEXT", typeof(GL.Delegates.GetConvolutionParameterfvEXT)); - GL.GetConvolutionParameterivEXT = (GL.Delegates.GetConvolutionParameterivEXT) GetAddress("glGetConvolutionParameterivEXT", typeof(GL.Delegates.GetConvolutionParameterivEXT)); - GL.GetSeparableFilterEXT = (GL.Delegates.GetSeparableFilterEXT) GetAddress("glGetSeparableFilterEXT", typeof(GL.Delegates.GetSeparableFilterEXT)); - GL.SeparableFilter2DEXT = (GL.Delegates.SeparableFilter2DEXT) GetAddress("glSeparableFilter2DEXT", typeof(GL.Delegates.SeparableFilter2DEXT)); - GL.ColorTableSGI = (GL.Delegates.ColorTableSGI) GetAddress("glColorTableSGI", typeof(GL.Delegates.ColorTableSGI)); - GL.ColorTableParameterfvSGI = (GL.Delegates.ColorTableParameterfvSGI) GetAddress("glColorTableParameterfvSGI", typeof(GL.Delegates.ColorTableParameterfvSGI)); - GL.ColorTableParameterivSGI = (GL.Delegates.ColorTableParameterivSGI) GetAddress("glColorTableParameterivSGI", typeof(GL.Delegates.ColorTableParameterivSGI)); - GL.CopyColorTableSGI = (GL.Delegates.CopyColorTableSGI) GetAddress("glCopyColorTableSGI", typeof(GL.Delegates.CopyColorTableSGI)); - GL.GetColorTableSGI = (GL.Delegates.GetColorTableSGI) GetAddress("glGetColorTableSGI", typeof(GL.Delegates.GetColorTableSGI)); - GL.GetColorTableParameterfvSGI = (GL.Delegates.GetColorTableParameterfvSGI) GetAddress("glGetColorTableParameterfvSGI", typeof(GL.Delegates.GetColorTableParameterfvSGI)); - GL.GetColorTableParameterivSGI = (GL.Delegates.GetColorTableParameterivSGI) GetAddress("glGetColorTableParameterivSGI", typeof(GL.Delegates.GetColorTableParameterivSGI)); - GL.PixelTexGenSGIX = (GL.Delegates.PixelTexGenSGIX) GetAddress("glPixelTexGenSGIX", typeof(GL.Delegates.PixelTexGenSGIX)); - GL.PixelTexGenParameteriSGIS = (GL.Delegates.PixelTexGenParameteriSGIS) GetAddress("glPixelTexGenParameteriSGIS", typeof(GL.Delegates.PixelTexGenParameteriSGIS)); - GL.PixelTexGenParameterivSGIS = (GL.Delegates.PixelTexGenParameterivSGIS) GetAddress("glPixelTexGenParameterivSGIS", typeof(GL.Delegates.PixelTexGenParameterivSGIS)); - GL.PixelTexGenParameterfSGIS = (GL.Delegates.PixelTexGenParameterfSGIS) GetAddress("glPixelTexGenParameterfSGIS", typeof(GL.Delegates.PixelTexGenParameterfSGIS)); - GL.PixelTexGenParameterfvSGIS = (GL.Delegates.PixelTexGenParameterfvSGIS) GetAddress("glPixelTexGenParameterfvSGIS", typeof(GL.Delegates.PixelTexGenParameterfvSGIS)); - GL.GetPixelTexGenParameterivSGIS = (GL.Delegates.GetPixelTexGenParameterivSGIS) GetAddress("glGetPixelTexGenParameterivSGIS", typeof(GL.Delegates.GetPixelTexGenParameterivSGIS)); - GL.GetPixelTexGenParameterfvSGIS = (GL.Delegates.GetPixelTexGenParameterfvSGIS) GetAddress("glGetPixelTexGenParameterfvSGIS", typeof(GL.Delegates.GetPixelTexGenParameterfvSGIS)); - GL.TexImage4DSGIS = (GL.Delegates.TexImage4DSGIS) GetAddress("glTexImage4DSGIS", typeof(GL.Delegates.TexImage4DSGIS)); - GL.TexSubImage4DSGIS = (GL.Delegates.TexSubImage4DSGIS) GetAddress("glTexSubImage4DSGIS", typeof(GL.Delegates.TexSubImage4DSGIS)); - GL.AreTexturesResidentEXT = (GL.Delegates.AreTexturesResidentEXT) GetAddress("glAreTexturesResidentEXT", typeof(GL.Delegates.AreTexturesResidentEXT)); - GL.BindTextureEXT = (GL.Delegates.BindTextureEXT) GetAddress("glBindTextureEXT", typeof(GL.Delegates.BindTextureEXT)); - GL.DeleteTexturesEXT = (GL.Delegates.DeleteTexturesEXT) GetAddress("glDeleteTexturesEXT", typeof(GL.Delegates.DeleteTexturesEXT)); - GL.GenTexturesEXT = (GL.Delegates.GenTexturesEXT) GetAddress("glGenTexturesEXT", typeof(GL.Delegates.GenTexturesEXT)); - GL.IsTextureEXT = (GL.Delegates.IsTextureEXT) GetAddress("glIsTextureEXT", typeof(GL.Delegates.IsTextureEXT)); - GL.PrioritizeTexturesEXT = (GL.Delegates.PrioritizeTexturesEXT) GetAddress("glPrioritizeTexturesEXT", typeof(GL.Delegates.PrioritizeTexturesEXT)); - GL.DetailTexFuncSGIS = (GL.Delegates.DetailTexFuncSGIS) GetAddress("glDetailTexFuncSGIS", typeof(GL.Delegates.DetailTexFuncSGIS)); - GL.GetDetailTexFuncSGIS = (GL.Delegates.GetDetailTexFuncSGIS) GetAddress("glGetDetailTexFuncSGIS", typeof(GL.Delegates.GetDetailTexFuncSGIS)); - GL.SharpenTexFuncSGIS = (GL.Delegates.SharpenTexFuncSGIS) GetAddress("glSharpenTexFuncSGIS", typeof(GL.Delegates.SharpenTexFuncSGIS)); - GL.GetSharpenTexFuncSGIS = (GL.Delegates.GetSharpenTexFuncSGIS) GetAddress("glGetSharpenTexFuncSGIS", typeof(GL.Delegates.GetSharpenTexFuncSGIS)); - GL.SampleMaskSGIS = (GL.Delegates.SampleMaskSGIS) GetAddress("glSampleMaskSGIS", typeof(GL.Delegates.SampleMaskSGIS)); - GL.SamplePatternSGIS = (GL.Delegates.SamplePatternSGIS) GetAddress("glSamplePatternSGIS", typeof(GL.Delegates.SamplePatternSGIS)); - GL.ArrayElementEXT = (GL.Delegates.ArrayElementEXT) GetAddress("glArrayElementEXT", typeof(GL.Delegates.ArrayElementEXT)); - GL.ColorPointerEXT = (GL.Delegates.ColorPointerEXT) GetAddress("glColorPointerEXT", typeof(GL.Delegates.ColorPointerEXT)); - GL.DrawArraysEXT = (GL.Delegates.DrawArraysEXT) GetAddress("glDrawArraysEXT", typeof(GL.Delegates.DrawArraysEXT)); - GL.EdgeFlagPointerEXT = (GL.Delegates.EdgeFlagPointerEXT) GetAddress("glEdgeFlagPointerEXT", typeof(GL.Delegates.EdgeFlagPointerEXT)); - GL.GetPointervEXT = (GL.Delegates.GetPointervEXT) GetAddress("glGetPointervEXT", typeof(GL.Delegates.GetPointervEXT)); - GL.IndexPointerEXT = (GL.Delegates.IndexPointerEXT) GetAddress("glIndexPointerEXT", typeof(GL.Delegates.IndexPointerEXT)); - GL.NormalPointerEXT = (GL.Delegates.NormalPointerEXT) GetAddress("glNormalPointerEXT", typeof(GL.Delegates.NormalPointerEXT)); - GL.TexCoordPointerEXT = (GL.Delegates.TexCoordPointerEXT) GetAddress("glTexCoordPointerEXT", typeof(GL.Delegates.TexCoordPointerEXT)); - GL.VertexPointerEXT = (GL.Delegates.VertexPointerEXT) GetAddress("glVertexPointerEXT", typeof(GL.Delegates.VertexPointerEXT)); - GL.BlendEquationEXT = (GL.Delegates.BlendEquationEXT) GetAddress("glBlendEquationEXT", typeof(GL.Delegates.BlendEquationEXT)); - GL.SpriteParameterfSGIX = (GL.Delegates.SpriteParameterfSGIX) GetAddress("glSpriteParameterfSGIX", typeof(GL.Delegates.SpriteParameterfSGIX)); - GL.SpriteParameterfvSGIX = (GL.Delegates.SpriteParameterfvSGIX) GetAddress("glSpriteParameterfvSGIX", typeof(GL.Delegates.SpriteParameterfvSGIX)); - GL.SpriteParameteriSGIX = (GL.Delegates.SpriteParameteriSGIX) GetAddress("glSpriteParameteriSGIX", typeof(GL.Delegates.SpriteParameteriSGIX)); - GL.SpriteParameterivSGIX = (GL.Delegates.SpriteParameterivSGIX) GetAddress("glSpriteParameterivSGIX", typeof(GL.Delegates.SpriteParameterivSGIX)); - GL.PointParameterfEXT = (GL.Delegates.PointParameterfEXT) GetAddress("glPointParameterfEXT", typeof(GL.Delegates.PointParameterfEXT)); - GL.PointParameterfvEXT = (GL.Delegates.PointParameterfvEXT) GetAddress("glPointParameterfvEXT", typeof(GL.Delegates.PointParameterfvEXT)); - GL.PointParameterfSGIS = (GL.Delegates.PointParameterfSGIS) GetAddress("glPointParameterfSGIS", typeof(GL.Delegates.PointParameterfSGIS)); - GL.PointParameterfvSGIS = (GL.Delegates.PointParameterfvSGIS) GetAddress("glPointParameterfvSGIS", typeof(GL.Delegates.PointParameterfvSGIS)); - GL.GetInstrumentsSGIX = (GL.Delegates.GetInstrumentsSGIX) GetAddress("glGetInstrumentsSGIX", typeof(GL.Delegates.GetInstrumentsSGIX)); - GL.InstrumentsBufferSGIX = (GL.Delegates.InstrumentsBufferSGIX) GetAddress("glInstrumentsBufferSGIX", typeof(GL.Delegates.InstrumentsBufferSGIX)); - GL.PollInstrumentsSGIX = (GL.Delegates.PollInstrumentsSGIX) GetAddress("glPollInstrumentsSGIX", typeof(GL.Delegates.PollInstrumentsSGIX)); - GL.ReadInstrumentsSGIX = (GL.Delegates.ReadInstrumentsSGIX) GetAddress("glReadInstrumentsSGIX", typeof(GL.Delegates.ReadInstrumentsSGIX)); - GL.StartInstrumentsSGIX = (GL.Delegates.StartInstrumentsSGIX) GetAddress("glStartInstrumentsSGIX", typeof(GL.Delegates.StartInstrumentsSGIX)); - GL.StopInstrumentsSGIX = (GL.Delegates.StopInstrumentsSGIX) GetAddress("glStopInstrumentsSGIX", typeof(GL.Delegates.StopInstrumentsSGIX)); - GL.FrameZoomSGIX = (GL.Delegates.FrameZoomSGIX) GetAddress("glFrameZoomSGIX", typeof(GL.Delegates.FrameZoomSGIX)); - GL.TagSampleBufferSGIX = (GL.Delegates.TagSampleBufferSGIX) GetAddress("glTagSampleBufferSGIX", typeof(GL.Delegates.TagSampleBufferSGIX)); - GL.DeformationMap3dSGIX = (GL.Delegates.DeformationMap3dSGIX) GetAddress("glDeformationMap3dSGIX", typeof(GL.Delegates.DeformationMap3dSGIX)); - GL.DeformationMap3fSGIX = (GL.Delegates.DeformationMap3fSGIX) GetAddress("glDeformationMap3fSGIX", typeof(GL.Delegates.DeformationMap3fSGIX)); - GL.DeformSGIX = (GL.Delegates.DeformSGIX) GetAddress("glDeformSGIX", typeof(GL.Delegates.DeformSGIX)); - GL.LoadIdentityDeformationMapSGIX = (GL.Delegates.LoadIdentityDeformationMapSGIX) GetAddress("glLoadIdentityDeformationMapSGIX", typeof(GL.Delegates.LoadIdentityDeformationMapSGIX)); - GL.ReferencePlaneSGIX = (GL.Delegates.ReferencePlaneSGIX) GetAddress("glReferencePlaneSGIX", typeof(GL.Delegates.ReferencePlaneSGIX)); - GL.FlushRasterSGIX = (GL.Delegates.FlushRasterSGIX) GetAddress("glFlushRasterSGIX", typeof(GL.Delegates.FlushRasterSGIX)); - GL.FogFuncSGIS = (GL.Delegates.FogFuncSGIS) GetAddress("glFogFuncSGIS", typeof(GL.Delegates.FogFuncSGIS)); - GL.GetFogFuncSGIS = (GL.Delegates.GetFogFuncSGIS) GetAddress("glGetFogFuncSGIS", typeof(GL.Delegates.GetFogFuncSGIS)); - GL.ImageTransformParameteriHP = (GL.Delegates.ImageTransformParameteriHP) GetAddress("glImageTransformParameteriHP", typeof(GL.Delegates.ImageTransformParameteriHP)); - GL.ImageTransformParameterfHP = (GL.Delegates.ImageTransformParameterfHP) GetAddress("glImageTransformParameterfHP", typeof(GL.Delegates.ImageTransformParameterfHP)); - GL.ImageTransformParameterivHP = (GL.Delegates.ImageTransformParameterivHP) GetAddress("glImageTransformParameterivHP", typeof(GL.Delegates.ImageTransformParameterivHP)); - GL.ImageTransformParameterfvHP = (GL.Delegates.ImageTransformParameterfvHP) GetAddress("glImageTransformParameterfvHP", typeof(GL.Delegates.ImageTransformParameterfvHP)); - GL.GetImageTransformParameterivHP = (GL.Delegates.GetImageTransformParameterivHP) GetAddress("glGetImageTransformParameterivHP", typeof(GL.Delegates.GetImageTransformParameterivHP)); - GL.GetImageTransformParameterfvHP = (GL.Delegates.GetImageTransformParameterfvHP) GetAddress("glGetImageTransformParameterfvHP", typeof(GL.Delegates.GetImageTransformParameterfvHP)); - GL.ColorSubTableEXT = (GL.Delegates.ColorSubTableEXT) GetAddress("glColorSubTableEXT", typeof(GL.Delegates.ColorSubTableEXT)); - GL.CopyColorSubTableEXT = (GL.Delegates.CopyColorSubTableEXT) GetAddress("glCopyColorSubTableEXT", typeof(GL.Delegates.CopyColorSubTableEXT)); - GL.HintPGI = (GL.Delegates.HintPGI) GetAddress("glHintPGI", typeof(GL.Delegates.HintPGI)); - GL.ColorTableEXT = (GL.Delegates.ColorTableEXT) GetAddress("glColorTableEXT", typeof(GL.Delegates.ColorTableEXT)); - GL.GetColorTableEXT = (GL.Delegates.GetColorTableEXT) GetAddress("glGetColorTableEXT", typeof(GL.Delegates.GetColorTableEXT)); - GL.GetColorTableParameterivEXT = (GL.Delegates.GetColorTableParameterivEXT) GetAddress("glGetColorTableParameterivEXT", typeof(GL.Delegates.GetColorTableParameterivEXT)); - GL.GetColorTableParameterfvEXT = (GL.Delegates.GetColorTableParameterfvEXT) GetAddress("glGetColorTableParameterfvEXT", typeof(GL.Delegates.GetColorTableParameterfvEXT)); - GL.GetListParameterfvSGIX = (GL.Delegates.GetListParameterfvSGIX) GetAddress("glGetListParameterfvSGIX", typeof(GL.Delegates.GetListParameterfvSGIX)); - GL.GetListParameterivSGIX = (GL.Delegates.GetListParameterivSGIX) GetAddress("glGetListParameterivSGIX", typeof(GL.Delegates.GetListParameterivSGIX)); - GL.ListParameterfSGIX = (GL.Delegates.ListParameterfSGIX) GetAddress("glListParameterfSGIX", typeof(GL.Delegates.ListParameterfSGIX)); - GL.ListParameterfvSGIX = (GL.Delegates.ListParameterfvSGIX) GetAddress("glListParameterfvSGIX", typeof(GL.Delegates.ListParameterfvSGIX)); - GL.ListParameteriSGIX = (GL.Delegates.ListParameteriSGIX) GetAddress("glListParameteriSGIX", typeof(GL.Delegates.ListParameteriSGIX)); - GL.ListParameterivSGIX = (GL.Delegates.ListParameterivSGIX) GetAddress("glListParameterivSGIX", typeof(GL.Delegates.ListParameterivSGIX)); - GL.IndexMaterialEXT = (GL.Delegates.IndexMaterialEXT) GetAddress("glIndexMaterialEXT", typeof(GL.Delegates.IndexMaterialEXT)); - GL.IndexFuncEXT = (GL.Delegates.IndexFuncEXT) GetAddress("glIndexFuncEXT", typeof(GL.Delegates.IndexFuncEXT)); - GL.LockArraysEXT = (GL.Delegates.LockArraysEXT) GetAddress("glLockArraysEXT", typeof(GL.Delegates.LockArraysEXT)); - GL.UnlockArraysEXT = (GL.Delegates.UnlockArraysEXT) GetAddress("glUnlockArraysEXT", typeof(GL.Delegates.UnlockArraysEXT)); - GL.CullParameterdvEXT = (GL.Delegates.CullParameterdvEXT) GetAddress("glCullParameterdvEXT", typeof(GL.Delegates.CullParameterdvEXT)); - GL.CullParameterfvEXT = (GL.Delegates.CullParameterfvEXT) GetAddress("glCullParameterfvEXT", typeof(GL.Delegates.CullParameterfvEXT)); - GL.FragmentColorMaterialSGIX = (GL.Delegates.FragmentColorMaterialSGIX) GetAddress("glFragmentColorMaterialSGIX", typeof(GL.Delegates.FragmentColorMaterialSGIX)); - GL.FragmentLightfSGIX = (GL.Delegates.FragmentLightfSGIX) GetAddress("glFragmentLightfSGIX", typeof(GL.Delegates.FragmentLightfSGIX)); - GL.FragmentLightfvSGIX = (GL.Delegates.FragmentLightfvSGIX) GetAddress("glFragmentLightfvSGIX", typeof(GL.Delegates.FragmentLightfvSGIX)); - GL.FragmentLightiSGIX = (GL.Delegates.FragmentLightiSGIX) GetAddress("glFragmentLightiSGIX", typeof(GL.Delegates.FragmentLightiSGIX)); - GL.FragmentLightivSGIX = (GL.Delegates.FragmentLightivSGIX) GetAddress("glFragmentLightivSGIX", typeof(GL.Delegates.FragmentLightivSGIX)); - GL.FragmentLightModelfSGIX = (GL.Delegates.FragmentLightModelfSGIX) GetAddress("glFragmentLightModelfSGIX", typeof(GL.Delegates.FragmentLightModelfSGIX)); - GL.FragmentLightModelfvSGIX = (GL.Delegates.FragmentLightModelfvSGIX) GetAddress("glFragmentLightModelfvSGIX", typeof(GL.Delegates.FragmentLightModelfvSGIX)); - GL.FragmentLightModeliSGIX = (GL.Delegates.FragmentLightModeliSGIX) GetAddress("glFragmentLightModeliSGIX", typeof(GL.Delegates.FragmentLightModeliSGIX)); - GL.FragmentLightModelivSGIX = (GL.Delegates.FragmentLightModelivSGIX) GetAddress("glFragmentLightModelivSGIX", typeof(GL.Delegates.FragmentLightModelivSGIX)); - GL.FragmentMaterialfSGIX = (GL.Delegates.FragmentMaterialfSGIX) GetAddress("glFragmentMaterialfSGIX", typeof(GL.Delegates.FragmentMaterialfSGIX)); - GL.FragmentMaterialfvSGIX = (GL.Delegates.FragmentMaterialfvSGIX) GetAddress("glFragmentMaterialfvSGIX", typeof(GL.Delegates.FragmentMaterialfvSGIX)); - GL.FragmentMaterialiSGIX = (GL.Delegates.FragmentMaterialiSGIX) GetAddress("glFragmentMaterialiSGIX", typeof(GL.Delegates.FragmentMaterialiSGIX)); - GL.FragmentMaterialivSGIX = (GL.Delegates.FragmentMaterialivSGIX) GetAddress("glFragmentMaterialivSGIX", typeof(GL.Delegates.FragmentMaterialivSGIX)); - GL.GetFragmentLightfvSGIX = (GL.Delegates.GetFragmentLightfvSGIX) GetAddress("glGetFragmentLightfvSGIX", typeof(GL.Delegates.GetFragmentLightfvSGIX)); - GL.GetFragmentLightivSGIX = (GL.Delegates.GetFragmentLightivSGIX) GetAddress("glGetFragmentLightivSGIX", typeof(GL.Delegates.GetFragmentLightivSGIX)); - GL.GetFragmentMaterialfvSGIX = (GL.Delegates.GetFragmentMaterialfvSGIX) GetAddress("glGetFragmentMaterialfvSGIX", typeof(GL.Delegates.GetFragmentMaterialfvSGIX)); - GL.GetFragmentMaterialivSGIX = (GL.Delegates.GetFragmentMaterialivSGIX) GetAddress("glGetFragmentMaterialivSGIX", typeof(GL.Delegates.GetFragmentMaterialivSGIX)); - GL.LightEnviSGIX = (GL.Delegates.LightEnviSGIX) GetAddress("glLightEnviSGIX", typeof(GL.Delegates.LightEnviSGIX)); - GL.DrawRangeElementsEXT = (GL.Delegates.DrawRangeElementsEXT) GetAddress("glDrawRangeElementsEXT", typeof(GL.Delegates.DrawRangeElementsEXT)); - GL.ApplyTextureEXT = (GL.Delegates.ApplyTextureEXT) GetAddress("glApplyTextureEXT", typeof(GL.Delegates.ApplyTextureEXT)); - GL.TextureLightEXT = (GL.Delegates.TextureLightEXT) GetAddress("glTextureLightEXT", typeof(GL.Delegates.TextureLightEXT)); - GL.TextureMaterialEXT = (GL.Delegates.TextureMaterialEXT) GetAddress("glTextureMaterialEXT", typeof(GL.Delegates.TextureMaterialEXT)); - GL.AsyncMarkerSGIX = (GL.Delegates.AsyncMarkerSGIX) GetAddress("glAsyncMarkerSGIX", typeof(GL.Delegates.AsyncMarkerSGIX)); - GL.FinishAsyncSGIX = (GL.Delegates.FinishAsyncSGIX) GetAddress("glFinishAsyncSGIX", typeof(GL.Delegates.FinishAsyncSGIX)); - GL.PollAsyncSGIX = (GL.Delegates.PollAsyncSGIX) GetAddress("glPollAsyncSGIX", typeof(GL.Delegates.PollAsyncSGIX)); - GL.GenAsyncMarkersSGIX = (GL.Delegates.GenAsyncMarkersSGIX) GetAddress("glGenAsyncMarkersSGIX", typeof(GL.Delegates.GenAsyncMarkersSGIX)); - GL.DeleteAsyncMarkersSGIX = (GL.Delegates.DeleteAsyncMarkersSGIX) GetAddress("glDeleteAsyncMarkersSGIX", typeof(GL.Delegates.DeleteAsyncMarkersSGIX)); - GL.IsAsyncMarkerSGIX = (GL.Delegates.IsAsyncMarkerSGIX) GetAddress("glIsAsyncMarkerSGIX", typeof(GL.Delegates.IsAsyncMarkerSGIX)); - GL.VertexPointervINTEL = (GL.Delegates.VertexPointervINTEL) GetAddress("glVertexPointervINTEL", typeof(GL.Delegates.VertexPointervINTEL)); - GL.NormalPointervINTEL = (GL.Delegates.NormalPointervINTEL) GetAddress("glNormalPointervINTEL", typeof(GL.Delegates.NormalPointervINTEL)); - GL.ColorPointervINTEL = (GL.Delegates.ColorPointervINTEL) GetAddress("glColorPointervINTEL", typeof(GL.Delegates.ColorPointervINTEL)); - GL.TexCoordPointervINTEL = (GL.Delegates.TexCoordPointervINTEL) GetAddress("glTexCoordPointervINTEL", typeof(GL.Delegates.TexCoordPointervINTEL)); - GL.PixelTransformParameteriEXT = (GL.Delegates.PixelTransformParameteriEXT) GetAddress("glPixelTransformParameteriEXT", typeof(GL.Delegates.PixelTransformParameteriEXT)); - GL.PixelTransformParameterfEXT = (GL.Delegates.PixelTransformParameterfEXT) GetAddress("glPixelTransformParameterfEXT", typeof(GL.Delegates.PixelTransformParameterfEXT)); - GL.PixelTransformParameterivEXT = (GL.Delegates.PixelTransformParameterivEXT) GetAddress("glPixelTransformParameterivEXT", typeof(GL.Delegates.PixelTransformParameterivEXT)); - GL.PixelTransformParameterfvEXT = (GL.Delegates.PixelTransformParameterfvEXT) GetAddress("glPixelTransformParameterfvEXT", typeof(GL.Delegates.PixelTransformParameterfvEXT)); - GL.SecondaryColor3bEXT = (GL.Delegates.SecondaryColor3bEXT) GetAddress("glSecondaryColor3bEXT", typeof(GL.Delegates.SecondaryColor3bEXT)); - GL.SecondaryColor3bvEXT = (GL.Delegates.SecondaryColor3bvEXT) GetAddress("glSecondaryColor3bvEXT", typeof(GL.Delegates.SecondaryColor3bvEXT)); - GL.SecondaryColor3dEXT = (GL.Delegates.SecondaryColor3dEXT) GetAddress("glSecondaryColor3dEXT", typeof(GL.Delegates.SecondaryColor3dEXT)); - GL.SecondaryColor3dvEXT = (GL.Delegates.SecondaryColor3dvEXT) GetAddress("glSecondaryColor3dvEXT", typeof(GL.Delegates.SecondaryColor3dvEXT)); - GL.SecondaryColor3fEXT = (GL.Delegates.SecondaryColor3fEXT) GetAddress("glSecondaryColor3fEXT", typeof(GL.Delegates.SecondaryColor3fEXT)); - GL.SecondaryColor3fvEXT = (GL.Delegates.SecondaryColor3fvEXT) GetAddress("glSecondaryColor3fvEXT", typeof(GL.Delegates.SecondaryColor3fvEXT)); - GL.SecondaryColor3iEXT = (GL.Delegates.SecondaryColor3iEXT) GetAddress("glSecondaryColor3iEXT", typeof(GL.Delegates.SecondaryColor3iEXT)); - GL.SecondaryColor3ivEXT = (GL.Delegates.SecondaryColor3ivEXT) GetAddress("glSecondaryColor3ivEXT", typeof(GL.Delegates.SecondaryColor3ivEXT)); - GL.SecondaryColor3sEXT = (GL.Delegates.SecondaryColor3sEXT) GetAddress("glSecondaryColor3sEXT", typeof(GL.Delegates.SecondaryColor3sEXT)); - GL.SecondaryColor3svEXT = (GL.Delegates.SecondaryColor3svEXT) GetAddress("glSecondaryColor3svEXT", typeof(GL.Delegates.SecondaryColor3svEXT)); - GL.SecondaryColor3ubEXT = (GL.Delegates.SecondaryColor3ubEXT) GetAddress("glSecondaryColor3ubEXT", typeof(GL.Delegates.SecondaryColor3ubEXT)); - GL.SecondaryColor3ubvEXT = (GL.Delegates.SecondaryColor3ubvEXT) GetAddress("glSecondaryColor3ubvEXT", typeof(GL.Delegates.SecondaryColor3ubvEXT)); - GL.SecondaryColor3uiEXT = (GL.Delegates.SecondaryColor3uiEXT) GetAddress("glSecondaryColor3uiEXT", typeof(GL.Delegates.SecondaryColor3uiEXT)); - GL.SecondaryColor3uivEXT = (GL.Delegates.SecondaryColor3uivEXT) GetAddress("glSecondaryColor3uivEXT", typeof(GL.Delegates.SecondaryColor3uivEXT)); - GL.SecondaryColor3usEXT = (GL.Delegates.SecondaryColor3usEXT) GetAddress("glSecondaryColor3usEXT", typeof(GL.Delegates.SecondaryColor3usEXT)); - GL.SecondaryColor3usvEXT = (GL.Delegates.SecondaryColor3usvEXT) GetAddress("glSecondaryColor3usvEXT", typeof(GL.Delegates.SecondaryColor3usvEXT)); - GL.SecondaryColorPointerEXT = (GL.Delegates.SecondaryColorPointerEXT) GetAddress("glSecondaryColorPointerEXT", typeof(GL.Delegates.SecondaryColorPointerEXT)); - GL.TextureNormalEXT = (GL.Delegates.TextureNormalEXT) GetAddress("glTextureNormalEXT", typeof(GL.Delegates.TextureNormalEXT)); - GL.MultiDrawArraysEXT = (GL.Delegates.MultiDrawArraysEXT) GetAddress("glMultiDrawArraysEXT", typeof(GL.Delegates.MultiDrawArraysEXT)); - GL.MultiDrawElementsEXT = (GL.Delegates.MultiDrawElementsEXT) GetAddress("glMultiDrawElementsEXT", typeof(GL.Delegates.MultiDrawElementsEXT)); - GL.FogCoordfEXT = (GL.Delegates.FogCoordfEXT) GetAddress("glFogCoordfEXT", typeof(GL.Delegates.FogCoordfEXT)); - GL.FogCoordfvEXT = (GL.Delegates.FogCoordfvEXT) GetAddress("glFogCoordfvEXT", typeof(GL.Delegates.FogCoordfvEXT)); - GL.FogCoorddEXT = (GL.Delegates.FogCoorddEXT) GetAddress("glFogCoorddEXT", typeof(GL.Delegates.FogCoorddEXT)); - GL.FogCoorddvEXT = (GL.Delegates.FogCoorddvEXT) GetAddress("glFogCoorddvEXT", typeof(GL.Delegates.FogCoorddvEXT)); - GL.FogCoordPointerEXT = (GL.Delegates.FogCoordPointerEXT) GetAddress("glFogCoordPointerEXT", typeof(GL.Delegates.FogCoordPointerEXT)); - GL.Tangent3bEXT = (GL.Delegates.Tangent3bEXT) GetAddress("glTangent3bEXT", typeof(GL.Delegates.Tangent3bEXT)); - GL.Tangent3bvEXT = (GL.Delegates.Tangent3bvEXT) GetAddress("glTangent3bvEXT", typeof(GL.Delegates.Tangent3bvEXT)); - GL.Tangent3dEXT = (GL.Delegates.Tangent3dEXT) GetAddress("glTangent3dEXT", typeof(GL.Delegates.Tangent3dEXT)); - GL.Tangent3dvEXT = (GL.Delegates.Tangent3dvEXT) GetAddress("glTangent3dvEXT", typeof(GL.Delegates.Tangent3dvEXT)); - GL.Tangent3fEXT = (GL.Delegates.Tangent3fEXT) GetAddress("glTangent3fEXT", typeof(GL.Delegates.Tangent3fEXT)); - GL.Tangent3fvEXT = (GL.Delegates.Tangent3fvEXT) GetAddress("glTangent3fvEXT", typeof(GL.Delegates.Tangent3fvEXT)); - GL.Tangent3iEXT = (GL.Delegates.Tangent3iEXT) GetAddress("glTangent3iEXT", typeof(GL.Delegates.Tangent3iEXT)); - GL.Tangent3ivEXT = (GL.Delegates.Tangent3ivEXT) GetAddress("glTangent3ivEXT", typeof(GL.Delegates.Tangent3ivEXT)); - GL.Tangent3sEXT = (GL.Delegates.Tangent3sEXT) GetAddress("glTangent3sEXT", typeof(GL.Delegates.Tangent3sEXT)); - GL.Tangent3svEXT = (GL.Delegates.Tangent3svEXT) GetAddress("glTangent3svEXT", typeof(GL.Delegates.Tangent3svEXT)); - GL.Binormal3bEXT = (GL.Delegates.Binormal3bEXT) GetAddress("glBinormal3bEXT", typeof(GL.Delegates.Binormal3bEXT)); - GL.Binormal3bvEXT = (GL.Delegates.Binormal3bvEXT) GetAddress("glBinormal3bvEXT", typeof(GL.Delegates.Binormal3bvEXT)); - GL.Binormal3dEXT = (GL.Delegates.Binormal3dEXT) GetAddress("glBinormal3dEXT", typeof(GL.Delegates.Binormal3dEXT)); - GL.Binormal3dvEXT = (GL.Delegates.Binormal3dvEXT) GetAddress("glBinormal3dvEXT", typeof(GL.Delegates.Binormal3dvEXT)); - GL.Binormal3fEXT = (GL.Delegates.Binormal3fEXT) GetAddress("glBinormal3fEXT", typeof(GL.Delegates.Binormal3fEXT)); - GL.Binormal3fvEXT = (GL.Delegates.Binormal3fvEXT) GetAddress("glBinormal3fvEXT", typeof(GL.Delegates.Binormal3fvEXT)); - GL.Binormal3iEXT = (GL.Delegates.Binormal3iEXT) GetAddress("glBinormal3iEXT", typeof(GL.Delegates.Binormal3iEXT)); - GL.Binormal3ivEXT = (GL.Delegates.Binormal3ivEXT) GetAddress("glBinormal3ivEXT", typeof(GL.Delegates.Binormal3ivEXT)); - GL.Binormal3sEXT = (GL.Delegates.Binormal3sEXT) GetAddress("glBinormal3sEXT", typeof(GL.Delegates.Binormal3sEXT)); - GL.Binormal3svEXT = (GL.Delegates.Binormal3svEXT) GetAddress("glBinormal3svEXT", typeof(GL.Delegates.Binormal3svEXT)); - GL.TangentPointerEXT = (GL.Delegates.TangentPointerEXT) GetAddress("glTangentPointerEXT", typeof(GL.Delegates.TangentPointerEXT)); - GL.BinormalPointerEXT = (GL.Delegates.BinormalPointerEXT) GetAddress("glBinormalPointerEXT", typeof(GL.Delegates.BinormalPointerEXT)); - GL.FinishTextureSUNX = (GL.Delegates.FinishTextureSUNX) GetAddress("glFinishTextureSUNX", typeof(GL.Delegates.FinishTextureSUNX)); - GL.GlobalAlphaFactorbSUN = (GL.Delegates.GlobalAlphaFactorbSUN) GetAddress("glGlobalAlphaFactorbSUN", typeof(GL.Delegates.GlobalAlphaFactorbSUN)); - GL.GlobalAlphaFactorsSUN = (GL.Delegates.GlobalAlphaFactorsSUN) GetAddress("glGlobalAlphaFactorsSUN", typeof(GL.Delegates.GlobalAlphaFactorsSUN)); - GL.GlobalAlphaFactoriSUN = (GL.Delegates.GlobalAlphaFactoriSUN) GetAddress("glGlobalAlphaFactoriSUN", typeof(GL.Delegates.GlobalAlphaFactoriSUN)); - GL.GlobalAlphaFactorfSUN = (GL.Delegates.GlobalAlphaFactorfSUN) GetAddress("glGlobalAlphaFactorfSUN", typeof(GL.Delegates.GlobalAlphaFactorfSUN)); - GL.GlobalAlphaFactordSUN = (GL.Delegates.GlobalAlphaFactordSUN) GetAddress("glGlobalAlphaFactordSUN", typeof(GL.Delegates.GlobalAlphaFactordSUN)); - GL.GlobalAlphaFactorubSUN = (GL.Delegates.GlobalAlphaFactorubSUN) GetAddress("glGlobalAlphaFactorubSUN", typeof(GL.Delegates.GlobalAlphaFactorubSUN)); - GL.GlobalAlphaFactorusSUN = (GL.Delegates.GlobalAlphaFactorusSUN) GetAddress("glGlobalAlphaFactorusSUN", typeof(GL.Delegates.GlobalAlphaFactorusSUN)); - GL.GlobalAlphaFactoruiSUN = (GL.Delegates.GlobalAlphaFactoruiSUN) GetAddress("glGlobalAlphaFactoruiSUN", typeof(GL.Delegates.GlobalAlphaFactoruiSUN)); - GL.ReplacementCodeuiSUN = (GL.Delegates.ReplacementCodeuiSUN) GetAddress("glReplacementCodeuiSUN", typeof(GL.Delegates.ReplacementCodeuiSUN)); - GL.ReplacementCodeusSUN = (GL.Delegates.ReplacementCodeusSUN) GetAddress("glReplacementCodeusSUN", typeof(GL.Delegates.ReplacementCodeusSUN)); - GL.ReplacementCodeubSUN = (GL.Delegates.ReplacementCodeubSUN) GetAddress("glReplacementCodeubSUN", typeof(GL.Delegates.ReplacementCodeubSUN)); - GL.ReplacementCodeuivSUN = (GL.Delegates.ReplacementCodeuivSUN) GetAddress("glReplacementCodeuivSUN", typeof(GL.Delegates.ReplacementCodeuivSUN)); - GL.ReplacementCodeusvSUN = (GL.Delegates.ReplacementCodeusvSUN) GetAddress("glReplacementCodeusvSUN", typeof(GL.Delegates.ReplacementCodeusvSUN)); - GL.ReplacementCodeubvSUN = (GL.Delegates.ReplacementCodeubvSUN) GetAddress("glReplacementCodeubvSUN", typeof(GL.Delegates.ReplacementCodeubvSUN)); - GL.ReplacementCodePointerSUN = (GL.Delegates.ReplacementCodePointerSUN) GetAddress("glReplacementCodePointerSUN", typeof(GL.Delegates.ReplacementCodePointerSUN)); - GL.Color4ubVertex2fSUN = (GL.Delegates.Color4ubVertex2fSUN) GetAddress("glColor4ubVertex2fSUN", typeof(GL.Delegates.Color4ubVertex2fSUN)); - GL.Color4ubVertex2fvSUN = (GL.Delegates.Color4ubVertex2fvSUN) GetAddress("glColor4ubVertex2fvSUN", typeof(GL.Delegates.Color4ubVertex2fvSUN)); - GL.Color4ubVertex3fSUN = (GL.Delegates.Color4ubVertex3fSUN) GetAddress("glColor4ubVertex3fSUN", typeof(GL.Delegates.Color4ubVertex3fSUN)); - GL.Color4ubVertex3fvSUN = (GL.Delegates.Color4ubVertex3fvSUN) GetAddress("glColor4ubVertex3fvSUN", typeof(GL.Delegates.Color4ubVertex3fvSUN)); - GL.Color3fVertex3fSUN = (GL.Delegates.Color3fVertex3fSUN) GetAddress("glColor3fVertex3fSUN", typeof(GL.Delegates.Color3fVertex3fSUN)); - GL.Color3fVertex3fvSUN = (GL.Delegates.Color3fVertex3fvSUN) GetAddress("glColor3fVertex3fvSUN", typeof(GL.Delegates.Color3fVertex3fvSUN)); - GL.Normal3fVertex3fSUN = (GL.Delegates.Normal3fVertex3fSUN) GetAddress("glNormal3fVertex3fSUN", typeof(GL.Delegates.Normal3fVertex3fSUN)); - GL.Normal3fVertex3fvSUN = (GL.Delegates.Normal3fVertex3fvSUN) GetAddress("glNormal3fVertex3fvSUN", typeof(GL.Delegates.Normal3fVertex3fvSUN)); - GL.Color4fNormal3fVertex3fSUN = (GL.Delegates.Color4fNormal3fVertex3fSUN) GetAddress("glColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fSUN)); - GL.Color4fNormal3fVertex3fvSUN = (GL.Delegates.Color4fNormal3fVertex3fvSUN) GetAddress("glColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fvSUN)); - GL.TexCoord2fVertex3fSUN = (GL.Delegates.TexCoord2fVertex3fSUN) GetAddress("glTexCoord2fVertex3fSUN", typeof(GL.Delegates.TexCoord2fVertex3fSUN)); - GL.TexCoord2fVertex3fvSUN = (GL.Delegates.TexCoord2fVertex3fvSUN) GetAddress("glTexCoord2fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fVertex3fvSUN)); - GL.TexCoord4fVertex4fSUN = (GL.Delegates.TexCoord4fVertex4fSUN) GetAddress("glTexCoord4fVertex4fSUN", typeof(GL.Delegates.TexCoord4fVertex4fSUN)); - GL.TexCoord4fVertex4fvSUN = (GL.Delegates.TexCoord4fVertex4fvSUN) GetAddress("glTexCoord4fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fVertex4fvSUN)); - GL.TexCoord2fColor4ubVertex3fSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fSUN) GetAddress("glTexCoord2fColor4ubVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fSUN)); - GL.TexCoord2fColor4ubVertex3fvSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fvSUN) GetAddress("glTexCoord2fColor4ubVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fvSUN)); - GL.TexCoord2fColor3fVertex3fSUN = (GL.Delegates.TexCoord2fColor3fVertex3fSUN) GetAddress("glTexCoord2fColor3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fSUN)); - GL.TexCoord2fColor3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor3fVertex3fvSUN) GetAddress("glTexCoord2fColor3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fvSUN)); - GL.TexCoord2fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fSUN) GetAddress("glTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fSUN)); - GL.TexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fvSUN) GetAddress("glTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fvSUN)); - GL.TexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN) GetAddress("glTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN)); - GL.TexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN) GetAddress("glTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN)); - GL.TexCoord4fColor4fNormal3fVertex4fSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN) GetAddress("glTexCoord4fColor4fNormal3fVertex4fSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN)); - GL.TexCoord4fColor4fNormal3fVertex4fvSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN) GetAddress("glTexCoord4fColor4fNormal3fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN)); - GL.ReplacementCodeuiVertex3fSUN = (GL.Delegates.ReplacementCodeuiVertex3fSUN) GetAddress("glReplacementCodeuiVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fSUN)); - GL.ReplacementCodeuiVertex3fvSUN = (GL.Delegates.ReplacementCodeuiVertex3fvSUN) GetAddress("glReplacementCodeuiVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fvSUN)); - GL.ReplacementCodeuiColor4ubVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN) GetAddress("glReplacementCodeuiColor4ubVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN)); - GL.ReplacementCodeuiColor4ubVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN) GetAddress("glReplacementCodeuiColor4ubVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN)); - GL.ReplacementCodeuiColor3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN) GetAddress("glReplacementCodeuiColor3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN)); - GL.ReplacementCodeuiColor3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN) GetAddress("glReplacementCodeuiColor3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN)); - GL.ReplacementCodeuiNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN)); - GL.ReplacementCodeuiNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)); - GL.BlendFuncSeparateEXT = (GL.Delegates.BlendFuncSeparateEXT) GetAddress("glBlendFuncSeparateEXT", typeof(GL.Delegates.BlendFuncSeparateEXT)); - GL.BlendFuncSeparateINGR = (GL.Delegates.BlendFuncSeparateINGR) GetAddress("glBlendFuncSeparateINGR", typeof(GL.Delegates.BlendFuncSeparateINGR)); - GL.VertexWeightfEXT = (GL.Delegates.VertexWeightfEXT) GetAddress("glVertexWeightfEXT", typeof(GL.Delegates.VertexWeightfEXT)); - GL.VertexWeightfvEXT = (GL.Delegates.VertexWeightfvEXT) GetAddress("glVertexWeightfvEXT", typeof(GL.Delegates.VertexWeightfvEXT)); - GL.VertexWeightPointerEXT = (GL.Delegates.VertexWeightPointerEXT) GetAddress("glVertexWeightPointerEXT", typeof(GL.Delegates.VertexWeightPointerEXT)); - GL.FlushVertexArrayRangeNV = (GL.Delegates.FlushVertexArrayRangeNV) GetAddress("glFlushVertexArrayRangeNV", typeof(GL.Delegates.FlushVertexArrayRangeNV)); - GL.VertexArrayRangeNV = (GL.Delegates.VertexArrayRangeNV) GetAddress("glVertexArrayRangeNV", typeof(GL.Delegates.VertexArrayRangeNV)); - GL.CombinerParameterfvNV = (GL.Delegates.CombinerParameterfvNV) GetAddress("glCombinerParameterfvNV", typeof(GL.Delegates.CombinerParameterfvNV)); - GL.CombinerParameterfNV = (GL.Delegates.CombinerParameterfNV) GetAddress("glCombinerParameterfNV", typeof(GL.Delegates.CombinerParameterfNV)); - GL.CombinerParameterivNV = (GL.Delegates.CombinerParameterivNV) GetAddress("glCombinerParameterivNV", typeof(GL.Delegates.CombinerParameterivNV)); - GL.CombinerParameteriNV = (GL.Delegates.CombinerParameteriNV) GetAddress("glCombinerParameteriNV", typeof(GL.Delegates.CombinerParameteriNV)); - GL.CombinerInputNV = (GL.Delegates.CombinerInputNV) GetAddress("glCombinerInputNV", typeof(GL.Delegates.CombinerInputNV)); - GL.CombinerOutputNV = (GL.Delegates.CombinerOutputNV) GetAddress("glCombinerOutputNV", typeof(GL.Delegates.CombinerOutputNV)); - GL.FinalCombinerInputNV = (GL.Delegates.FinalCombinerInputNV) GetAddress("glFinalCombinerInputNV", typeof(GL.Delegates.FinalCombinerInputNV)); - GL.GetCombinerInputParameterfvNV = (GL.Delegates.GetCombinerInputParameterfvNV) GetAddress("glGetCombinerInputParameterfvNV", typeof(GL.Delegates.GetCombinerInputParameterfvNV)); - GL.GetCombinerInputParameterivNV = (GL.Delegates.GetCombinerInputParameterivNV) GetAddress("glGetCombinerInputParameterivNV", typeof(GL.Delegates.GetCombinerInputParameterivNV)); - GL.GetCombinerOutputParameterfvNV = (GL.Delegates.GetCombinerOutputParameterfvNV) GetAddress("glGetCombinerOutputParameterfvNV", typeof(GL.Delegates.GetCombinerOutputParameterfvNV)); - GL.GetCombinerOutputParameterivNV = (GL.Delegates.GetCombinerOutputParameterivNV) GetAddress("glGetCombinerOutputParameterivNV", typeof(GL.Delegates.GetCombinerOutputParameterivNV)); - GL.GetFinalCombinerInputParameterfvNV = (GL.Delegates.GetFinalCombinerInputParameterfvNV) GetAddress("glGetFinalCombinerInputParameterfvNV", typeof(GL.Delegates.GetFinalCombinerInputParameterfvNV)); - GL.GetFinalCombinerInputParameterivNV = (GL.Delegates.GetFinalCombinerInputParameterivNV) GetAddress("glGetFinalCombinerInputParameterivNV", typeof(GL.Delegates.GetFinalCombinerInputParameterivNV)); - GL.ResizeBuffersMESA = (GL.Delegates.ResizeBuffersMESA) GetAddress("glResizeBuffersMESA", typeof(GL.Delegates.ResizeBuffersMESA)); - GL.WindowPos2dMESA = (GL.Delegates.WindowPos2dMESA) GetAddress("glWindowPos2dMESA", typeof(GL.Delegates.WindowPos2dMESA)); - GL.WindowPos2dvMESA = (GL.Delegates.WindowPos2dvMESA) GetAddress("glWindowPos2dvMESA", typeof(GL.Delegates.WindowPos2dvMESA)); - GL.WindowPos2fMESA = (GL.Delegates.WindowPos2fMESA) GetAddress("glWindowPos2fMESA", typeof(GL.Delegates.WindowPos2fMESA)); - GL.WindowPos2fvMESA = (GL.Delegates.WindowPos2fvMESA) GetAddress("glWindowPos2fvMESA", typeof(GL.Delegates.WindowPos2fvMESA)); - GL.WindowPos2iMESA = (GL.Delegates.WindowPos2iMESA) GetAddress("glWindowPos2iMESA", typeof(GL.Delegates.WindowPos2iMESA)); - GL.WindowPos2ivMESA = (GL.Delegates.WindowPos2ivMESA) GetAddress("glWindowPos2ivMESA", typeof(GL.Delegates.WindowPos2ivMESA)); - GL.WindowPos2sMESA = (GL.Delegates.WindowPos2sMESA) GetAddress("glWindowPos2sMESA", typeof(GL.Delegates.WindowPos2sMESA)); - GL.WindowPos2svMESA = (GL.Delegates.WindowPos2svMESA) GetAddress("glWindowPos2svMESA", typeof(GL.Delegates.WindowPos2svMESA)); - GL.WindowPos3dMESA = (GL.Delegates.WindowPos3dMESA) GetAddress("glWindowPos3dMESA", typeof(GL.Delegates.WindowPos3dMESA)); - GL.WindowPos3dvMESA = (GL.Delegates.WindowPos3dvMESA) GetAddress("glWindowPos3dvMESA", typeof(GL.Delegates.WindowPos3dvMESA)); - GL.WindowPos3fMESA = (GL.Delegates.WindowPos3fMESA) GetAddress("glWindowPos3fMESA", typeof(GL.Delegates.WindowPos3fMESA)); - GL.WindowPos3fvMESA = (GL.Delegates.WindowPos3fvMESA) GetAddress("glWindowPos3fvMESA", typeof(GL.Delegates.WindowPos3fvMESA)); - GL.WindowPos3iMESA = (GL.Delegates.WindowPos3iMESA) GetAddress("glWindowPos3iMESA", typeof(GL.Delegates.WindowPos3iMESA)); - GL.WindowPos3ivMESA = (GL.Delegates.WindowPos3ivMESA) GetAddress("glWindowPos3ivMESA", typeof(GL.Delegates.WindowPos3ivMESA)); - GL.WindowPos3sMESA = (GL.Delegates.WindowPos3sMESA) GetAddress("glWindowPos3sMESA", typeof(GL.Delegates.WindowPos3sMESA)); - GL.WindowPos3svMESA = (GL.Delegates.WindowPos3svMESA) GetAddress("glWindowPos3svMESA", typeof(GL.Delegates.WindowPos3svMESA)); - GL.WindowPos4dMESA = (GL.Delegates.WindowPos4dMESA) GetAddress("glWindowPos4dMESA", typeof(GL.Delegates.WindowPos4dMESA)); - GL.WindowPos4dvMESA = (GL.Delegates.WindowPos4dvMESA) GetAddress("glWindowPos4dvMESA", typeof(GL.Delegates.WindowPos4dvMESA)); - GL.WindowPos4fMESA = (GL.Delegates.WindowPos4fMESA) GetAddress("glWindowPos4fMESA", typeof(GL.Delegates.WindowPos4fMESA)); - GL.WindowPos4fvMESA = (GL.Delegates.WindowPos4fvMESA) GetAddress("glWindowPos4fvMESA", typeof(GL.Delegates.WindowPos4fvMESA)); - GL.WindowPos4iMESA = (GL.Delegates.WindowPos4iMESA) GetAddress("glWindowPos4iMESA", typeof(GL.Delegates.WindowPos4iMESA)); - GL.WindowPos4ivMESA = (GL.Delegates.WindowPos4ivMESA) GetAddress("glWindowPos4ivMESA", typeof(GL.Delegates.WindowPos4ivMESA)); - GL.WindowPos4sMESA = (GL.Delegates.WindowPos4sMESA) GetAddress("glWindowPos4sMESA", typeof(GL.Delegates.WindowPos4sMESA)); - GL.WindowPos4svMESA = (GL.Delegates.WindowPos4svMESA) GetAddress("glWindowPos4svMESA", typeof(GL.Delegates.WindowPos4svMESA)); - GL.MultiModeDrawArraysIBM = (GL.Delegates.MultiModeDrawArraysIBM) GetAddress("glMultiModeDrawArraysIBM", typeof(GL.Delegates.MultiModeDrawArraysIBM)); - GL.MultiModeDrawElementsIBM = (GL.Delegates.MultiModeDrawElementsIBM) GetAddress("glMultiModeDrawElementsIBM", typeof(GL.Delegates.MultiModeDrawElementsIBM)); - GL.ColorPointerListIBM = (GL.Delegates.ColorPointerListIBM) GetAddress("glColorPointerListIBM", typeof(GL.Delegates.ColorPointerListIBM)); - GL.SecondaryColorPointerListIBM = (GL.Delegates.SecondaryColorPointerListIBM) GetAddress("glSecondaryColorPointerListIBM", typeof(GL.Delegates.SecondaryColorPointerListIBM)); - GL.EdgeFlagPointerListIBM = (GL.Delegates.EdgeFlagPointerListIBM) GetAddress("glEdgeFlagPointerListIBM", typeof(GL.Delegates.EdgeFlagPointerListIBM)); - GL.FogCoordPointerListIBM = (GL.Delegates.FogCoordPointerListIBM) GetAddress("glFogCoordPointerListIBM", typeof(GL.Delegates.FogCoordPointerListIBM)); - GL.IndexPointerListIBM = (GL.Delegates.IndexPointerListIBM) GetAddress("glIndexPointerListIBM", typeof(GL.Delegates.IndexPointerListIBM)); - GL.NormalPointerListIBM = (GL.Delegates.NormalPointerListIBM) GetAddress("glNormalPointerListIBM", typeof(GL.Delegates.NormalPointerListIBM)); - GL.TexCoordPointerListIBM = (GL.Delegates.TexCoordPointerListIBM) GetAddress("glTexCoordPointerListIBM", typeof(GL.Delegates.TexCoordPointerListIBM)); - GL.VertexPointerListIBM = (GL.Delegates.VertexPointerListIBM) GetAddress("glVertexPointerListIBM", typeof(GL.Delegates.VertexPointerListIBM)); - GL.TbufferMask3DFX = (GL.Delegates.TbufferMask3DFX) GetAddress("glTbufferMask3DFX", typeof(GL.Delegates.TbufferMask3DFX)); - GL.SampleMaskEXT = (GL.Delegates.SampleMaskEXT) GetAddress("glSampleMaskEXT", typeof(GL.Delegates.SampleMaskEXT)); - GL.SamplePatternEXT = (GL.Delegates.SamplePatternEXT) GetAddress("glSamplePatternEXT", typeof(GL.Delegates.SamplePatternEXT)); - GL.TextureColorMaskSGIS = (GL.Delegates.TextureColorMaskSGIS) GetAddress("glTextureColorMaskSGIS", typeof(GL.Delegates.TextureColorMaskSGIS)); - GL.IglooInterfaceSGIX = (GL.Delegates.IglooInterfaceSGIX) GetAddress("glIglooInterfaceSGIX", typeof(GL.Delegates.IglooInterfaceSGIX)); - GL.DeleteFencesNV = (GL.Delegates.DeleteFencesNV) GetAddress("glDeleteFencesNV", typeof(GL.Delegates.DeleteFencesNV)); - GL.GenFencesNV = (GL.Delegates.GenFencesNV) GetAddress("glGenFencesNV", typeof(GL.Delegates.GenFencesNV)); - GL.IsFenceNV = (GL.Delegates.IsFenceNV) GetAddress("glIsFenceNV", typeof(GL.Delegates.IsFenceNV)); - GL.TestFenceNV = (GL.Delegates.TestFenceNV) GetAddress("glTestFenceNV", typeof(GL.Delegates.TestFenceNV)); - GL.GetFenceivNV = (GL.Delegates.GetFenceivNV) GetAddress("glGetFenceivNV", typeof(GL.Delegates.GetFenceivNV)); - GL.FinishFenceNV = (GL.Delegates.FinishFenceNV) GetAddress("glFinishFenceNV", typeof(GL.Delegates.FinishFenceNV)); - GL.SetFenceNV = (GL.Delegates.SetFenceNV) GetAddress("glSetFenceNV", typeof(GL.Delegates.SetFenceNV)); - GL.MapControlPointsNV = (GL.Delegates.MapControlPointsNV) GetAddress("glMapControlPointsNV", typeof(GL.Delegates.MapControlPointsNV)); - GL.MapParameterivNV = (GL.Delegates.MapParameterivNV) GetAddress("glMapParameterivNV", typeof(GL.Delegates.MapParameterivNV)); - GL.MapParameterfvNV = (GL.Delegates.MapParameterfvNV) GetAddress("glMapParameterfvNV", typeof(GL.Delegates.MapParameterfvNV)); - GL.GetMapControlPointsNV = (GL.Delegates.GetMapControlPointsNV) GetAddress("glGetMapControlPointsNV", typeof(GL.Delegates.GetMapControlPointsNV)); - GL.GetMapParameterivNV = (GL.Delegates.GetMapParameterivNV) GetAddress("glGetMapParameterivNV", typeof(GL.Delegates.GetMapParameterivNV)); - GL.GetMapParameterfvNV = (GL.Delegates.GetMapParameterfvNV) GetAddress("glGetMapParameterfvNV", typeof(GL.Delegates.GetMapParameterfvNV)); - GL.GetMapAttribParameterivNV = (GL.Delegates.GetMapAttribParameterivNV) GetAddress("glGetMapAttribParameterivNV", typeof(GL.Delegates.GetMapAttribParameterivNV)); - GL.GetMapAttribParameterfvNV = (GL.Delegates.GetMapAttribParameterfvNV) GetAddress("glGetMapAttribParameterfvNV", typeof(GL.Delegates.GetMapAttribParameterfvNV)); - GL.EvalMapsNV = (GL.Delegates.EvalMapsNV) GetAddress("glEvalMapsNV", typeof(GL.Delegates.EvalMapsNV)); - GL.CombinerStageParameterfvNV = (GL.Delegates.CombinerStageParameterfvNV) GetAddress("glCombinerStageParameterfvNV", typeof(GL.Delegates.CombinerStageParameterfvNV)); - GL.GetCombinerStageParameterfvNV = (GL.Delegates.GetCombinerStageParameterfvNV) GetAddress("glGetCombinerStageParameterfvNV", typeof(GL.Delegates.GetCombinerStageParameterfvNV)); - GL.AreProgramsResidentNV = (GL.Delegates.AreProgramsResidentNV) GetAddress("glAreProgramsResidentNV", typeof(GL.Delegates.AreProgramsResidentNV)); - GL.BindProgramNV = (GL.Delegates.BindProgramNV) GetAddress("glBindProgramNV", typeof(GL.Delegates.BindProgramNV)); - GL.DeleteProgramsNV = (GL.Delegates.DeleteProgramsNV) GetAddress("glDeleteProgramsNV", typeof(GL.Delegates.DeleteProgramsNV)); - GL.ExecuteProgramNV = (GL.Delegates.ExecuteProgramNV) GetAddress("glExecuteProgramNV", typeof(GL.Delegates.ExecuteProgramNV)); - GL.GenProgramsNV = (GL.Delegates.GenProgramsNV) GetAddress("glGenProgramsNV", typeof(GL.Delegates.GenProgramsNV)); - GL.GetProgramParameterdvNV = (GL.Delegates.GetProgramParameterdvNV) GetAddress("glGetProgramParameterdvNV", typeof(GL.Delegates.GetProgramParameterdvNV)); - GL.GetProgramParameterfvNV = (GL.Delegates.GetProgramParameterfvNV) GetAddress("glGetProgramParameterfvNV", typeof(GL.Delegates.GetProgramParameterfvNV)); - GL.GetProgramivNV = (GL.Delegates.GetProgramivNV) GetAddress("glGetProgramivNV", typeof(GL.Delegates.GetProgramivNV)); - GL.GetProgramStringNV = (GL.Delegates.GetProgramStringNV) GetAddress("glGetProgramStringNV", typeof(GL.Delegates.GetProgramStringNV)); - GL.GetTrackMatrixivNV = (GL.Delegates.GetTrackMatrixivNV) GetAddress("glGetTrackMatrixivNV", typeof(GL.Delegates.GetTrackMatrixivNV)); - GL.GetVertexAttribdvNV = (GL.Delegates.GetVertexAttribdvNV) GetAddress("glGetVertexAttribdvNV", typeof(GL.Delegates.GetVertexAttribdvNV)); - GL.GetVertexAttribfvNV = (GL.Delegates.GetVertexAttribfvNV) GetAddress("glGetVertexAttribfvNV", typeof(GL.Delegates.GetVertexAttribfvNV)); - GL.GetVertexAttribivNV = (GL.Delegates.GetVertexAttribivNV) GetAddress("glGetVertexAttribivNV", typeof(GL.Delegates.GetVertexAttribivNV)); - GL.GetVertexAttribPointervNV = (GL.Delegates.GetVertexAttribPointervNV) GetAddress("glGetVertexAttribPointervNV", typeof(GL.Delegates.GetVertexAttribPointervNV)); - GL.IsProgramNV = (GL.Delegates.IsProgramNV) GetAddress("glIsProgramNV", typeof(GL.Delegates.IsProgramNV)); - GL.LoadProgramNV = (GL.Delegates.LoadProgramNV) GetAddress("glLoadProgramNV", typeof(GL.Delegates.LoadProgramNV)); - GL.ProgramParameter4dNV = (GL.Delegates.ProgramParameter4dNV) GetAddress("glProgramParameter4dNV", typeof(GL.Delegates.ProgramParameter4dNV)); - GL.ProgramParameter4dvNV = (GL.Delegates.ProgramParameter4dvNV) GetAddress("glProgramParameter4dvNV", typeof(GL.Delegates.ProgramParameter4dvNV)); - GL.ProgramParameter4fNV = (GL.Delegates.ProgramParameter4fNV) GetAddress("glProgramParameter4fNV", typeof(GL.Delegates.ProgramParameter4fNV)); - GL.ProgramParameter4fvNV = (GL.Delegates.ProgramParameter4fvNV) GetAddress("glProgramParameter4fvNV", typeof(GL.Delegates.ProgramParameter4fvNV)); - GL.ProgramParameters4dvNV = (GL.Delegates.ProgramParameters4dvNV) GetAddress("glProgramParameters4dvNV", typeof(GL.Delegates.ProgramParameters4dvNV)); - GL.ProgramParameters4fvNV = (GL.Delegates.ProgramParameters4fvNV) GetAddress("glProgramParameters4fvNV", typeof(GL.Delegates.ProgramParameters4fvNV)); - GL.RequestResidentProgramsNV = (GL.Delegates.RequestResidentProgramsNV) GetAddress("glRequestResidentProgramsNV", typeof(GL.Delegates.RequestResidentProgramsNV)); - GL.TrackMatrixNV = (GL.Delegates.TrackMatrixNV) GetAddress("glTrackMatrixNV", typeof(GL.Delegates.TrackMatrixNV)); - GL.VertexAttribPointerNV = (GL.Delegates.VertexAttribPointerNV) GetAddress("glVertexAttribPointerNV", typeof(GL.Delegates.VertexAttribPointerNV)); - GL.VertexAttrib1dNV = (GL.Delegates.VertexAttrib1dNV) GetAddress("glVertexAttrib1dNV", typeof(GL.Delegates.VertexAttrib1dNV)); - GL.VertexAttrib1dvNV = (GL.Delegates.VertexAttrib1dvNV) GetAddress("glVertexAttrib1dvNV", typeof(GL.Delegates.VertexAttrib1dvNV)); - GL.VertexAttrib1fNV = (GL.Delegates.VertexAttrib1fNV) GetAddress("glVertexAttrib1fNV", typeof(GL.Delegates.VertexAttrib1fNV)); - GL.VertexAttrib1fvNV = (GL.Delegates.VertexAttrib1fvNV) GetAddress("glVertexAttrib1fvNV", typeof(GL.Delegates.VertexAttrib1fvNV)); - GL.VertexAttrib1sNV = (GL.Delegates.VertexAttrib1sNV) GetAddress("glVertexAttrib1sNV", typeof(GL.Delegates.VertexAttrib1sNV)); - GL.VertexAttrib1svNV = (GL.Delegates.VertexAttrib1svNV) GetAddress("glVertexAttrib1svNV", typeof(GL.Delegates.VertexAttrib1svNV)); - GL.VertexAttrib2dNV = (GL.Delegates.VertexAttrib2dNV) GetAddress("glVertexAttrib2dNV", typeof(GL.Delegates.VertexAttrib2dNV)); - GL.VertexAttrib2dvNV = (GL.Delegates.VertexAttrib2dvNV) GetAddress("glVertexAttrib2dvNV", typeof(GL.Delegates.VertexAttrib2dvNV)); - GL.VertexAttrib2fNV = (GL.Delegates.VertexAttrib2fNV) GetAddress("glVertexAttrib2fNV", typeof(GL.Delegates.VertexAttrib2fNV)); - GL.VertexAttrib2fvNV = (GL.Delegates.VertexAttrib2fvNV) GetAddress("glVertexAttrib2fvNV", typeof(GL.Delegates.VertexAttrib2fvNV)); - GL.VertexAttrib2sNV = (GL.Delegates.VertexAttrib2sNV) GetAddress("glVertexAttrib2sNV", typeof(GL.Delegates.VertexAttrib2sNV)); - GL.VertexAttrib2svNV = (GL.Delegates.VertexAttrib2svNV) GetAddress("glVertexAttrib2svNV", typeof(GL.Delegates.VertexAttrib2svNV)); - GL.VertexAttrib3dNV = (GL.Delegates.VertexAttrib3dNV) GetAddress("glVertexAttrib3dNV", typeof(GL.Delegates.VertexAttrib3dNV)); - GL.VertexAttrib3dvNV = (GL.Delegates.VertexAttrib3dvNV) GetAddress("glVertexAttrib3dvNV", typeof(GL.Delegates.VertexAttrib3dvNV)); - GL.VertexAttrib3fNV = (GL.Delegates.VertexAttrib3fNV) GetAddress("glVertexAttrib3fNV", typeof(GL.Delegates.VertexAttrib3fNV)); - GL.VertexAttrib3fvNV = (GL.Delegates.VertexAttrib3fvNV) GetAddress("glVertexAttrib3fvNV", typeof(GL.Delegates.VertexAttrib3fvNV)); - GL.VertexAttrib3sNV = (GL.Delegates.VertexAttrib3sNV) GetAddress("glVertexAttrib3sNV", typeof(GL.Delegates.VertexAttrib3sNV)); - GL.VertexAttrib3svNV = (GL.Delegates.VertexAttrib3svNV) GetAddress("glVertexAttrib3svNV", typeof(GL.Delegates.VertexAttrib3svNV)); - GL.VertexAttrib4dNV = (GL.Delegates.VertexAttrib4dNV) GetAddress("glVertexAttrib4dNV", typeof(GL.Delegates.VertexAttrib4dNV)); - GL.VertexAttrib4dvNV = (GL.Delegates.VertexAttrib4dvNV) GetAddress("glVertexAttrib4dvNV", typeof(GL.Delegates.VertexAttrib4dvNV)); - GL.VertexAttrib4fNV = (GL.Delegates.VertexAttrib4fNV) GetAddress("glVertexAttrib4fNV", typeof(GL.Delegates.VertexAttrib4fNV)); - GL.VertexAttrib4fvNV = (GL.Delegates.VertexAttrib4fvNV) GetAddress("glVertexAttrib4fvNV", typeof(GL.Delegates.VertexAttrib4fvNV)); - GL.VertexAttrib4sNV = (GL.Delegates.VertexAttrib4sNV) GetAddress("glVertexAttrib4sNV", typeof(GL.Delegates.VertexAttrib4sNV)); - GL.VertexAttrib4svNV = (GL.Delegates.VertexAttrib4svNV) GetAddress("glVertexAttrib4svNV", typeof(GL.Delegates.VertexAttrib4svNV)); - GL.VertexAttrib4ubNV = (GL.Delegates.VertexAttrib4ubNV) GetAddress("glVertexAttrib4ubNV", typeof(GL.Delegates.VertexAttrib4ubNV)); - GL.VertexAttrib4ubvNV = (GL.Delegates.VertexAttrib4ubvNV) GetAddress("glVertexAttrib4ubvNV", typeof(GL.Delegates.VertexAttrib4ubvNV)); - GL.VertexAttribs1dvNV = (GL.Delegates.VertexAttribs1dvNV) GetAddress("glVertexAttribs1dvNV", typeof(GL.Delegates.VertexAttribs1dvNV)); - GL.VertexAttribs1fvNV = (GL.Delegates.VertexAttribs1fvNV) GetAddress("glVertexAttribs1fvNV", typeof(GL.Delegates.VertexAttribs1fvNV)); - GL.VertexAttribs1svNV = (GL.Delegates.VertexAttribs1svNV) GetAddress("glVertexAttribs1svNV", typeof(GL.Delegates.VertexAttribs1svNV)); - GL.VertexAttribs2dvNV = (GL.Delegates.VertexAttribs2dvNV) GetAddress("glVertexAttribs2dvNV", typeof(GL.Delegates.VertexAttribs2dvNV)); - GL.VertexAttribs2fvNV = (GL.Delegates.VertexAttribs2fvNV) GetAddress("glVertexAttribs2fvNV", typeof(GL.Delegates.VertexAttribs2fvNV)); - GL.VertexAttribs2svNV = (GL.Delegates.VertexAttribs2svNV) GetAddress("glVertexAttribs2svNV", typeof(GL.Delegates.VertexAttribs2svNV)); - GL.VertexAttribs3dvNV = (GL.Delegates.VertexAttribs3dvNV) GetAddress("glVertexAttribs3dvNV", typeof(GL.Delegates.VertexAttribs3dvNV)); - GL.VertexAttribs3fvNV = (GL.Delegates.VertexAttribs3fvNV) GetAddress("glVertexAttribs3fvNV", typeof(GL.Delegates.VertexAttribs3fvNV)); - GL.VertexAttribs3svNV = (GL.Delegates.VertexAttribs3svNV) GetAddress("glVertexAttribs3svNV", typeof(GL.Delegates.VertexAttribs3svNV)); - GL.VertexAttribs4dvNV = (GL.Delegates.VertexAttribs4dvNV) GetAddress("glVertexAttribs4dvNV", typeof(GL.Delegates.VertexAttribs4dvNV)); - GL.VertexAttribs4fvNV = (GL.Delegates.VertexAttribs4fvNV) GetAddress("glVertexAttribs4fvNV", typeof(GL.Delegates.VertexAttribs4fvNV)); - GL.VertexAttribs4svNV = (GL.Delegates.VertexAttribs4svNV) GetAddress("glVertexAttribs4svNV", typeof(GL.Delegates.VertexAttribs4svNV)); - GL.VertexAttribs4ubvNV = (GL.Delegates.VertexAttribs4ubvNV) GetAddress("glVertexAttribs4ubvNV", typeof(GL.Delegates.VertexAttribs4ubvNV)); - GL.TexBumpParameterivATI = (GL.Delegates.TexBumpParameterivATI) GetAddress("glTexBumpParameterivATI", typeof(GL.Delegates.TexBumpParameterivATI)); - GL.TexBumpParameterfvATI = (GL.Delegates.TexBumpParameterfvATI) GetAddress("glTexBumpParameterfvATI", typeof(GL.Delegates.TexBumpParameterfvATI)); - GL.GetTexBumpParameterivATI = (GL.Delegates.GetTexBumpParameterivATI) GetAddress("glGetTexBumpParameterivATI", typeof(GL.Delegates.GetTexBumpParameterivATI)); - GL.GetTexBumpParameterfvATI = (GL.Delegates.GetTexBumpParameterfvATI) GetAddress("glGetTexBumpParameterfvATI", typeof(GL.Delegates.GetTexBumpParameterfvATI)); - GL.GenFragmentShadersATI = (GL.Delegates.GenFragmentShadersATI) GetAddress("glGenFragmentShadersATI", typeof(GL.Delegates.GenFragmentShadersATI)); - GL.BindFragmentShaderATI = (GL.Delegates.BindFragmentShaderATI) GetAddress("glBindFragmentShaderATI", typeof(GL.Delegates.BindFragmentShaderATI)); - GL.DeleteFragmentShaderATI = (GL.Delegates.DeleteFragmentShaderATI) GetAddress("glDeleteFragmentShaderATI", typeof(GL.Delegates.DeleteFragmentShaderATI)); - GL.BeginFragmentShaderATI = (GL.Delegates.BeginFragmentShaderATI) GetAddress("glBeginFragmentShaderATI", typeof(GL.Delegates.BeginFragmentShaderATI)); - GL.EndFragmentShaderATI = (GL.Delegates.EndFragmentShaderATI) GetAddress("glEndFragmentShaderATI", typeof(GL.Delegates.EndFragmentShaderATI)); - GL.PassTexCoordATI = (GL.Delegates.PassTexCoordATI) GetAddress("glPassTexCoordATI", typeof(GL.Delegates.PassTexCoordATI)); - GL.SampleMapATI = (GL.Delegates.SampleMapATI) GetAddress("glSampleMapATI", typeof(GL.Delegates.SampleMapATI)); - GL.ColorFragmentOp1ATI = (GL.Delegates.ColorFragmentOp1ATI) GetAddress("glColorFragmentOp1ATI", typeof(GL.Delegates.ColorFragmentOp1ATI)); - GL.ColorFragmentOp2ATI = (GL.Delegates.ColorFragmentOp2ATI) GetAddress("glColorFragmentOp2ATI", typeof(GL.Delegates.ColorFragmentOp2ATI)); - GL.ColorFragmentOp3ATI = (GL.Delegates.ColorFragmentOp3ATI) GetAddress("glColorFragmentOp3ATI", typeof(GL.Delegates.ColorFragmentOp3ATI)); - GL.AlphaFragmentOp1ATI = (GL.Delegates.AlphaFragmentOp1ATI) GetAddress("glAlphaFragmentOp1ATI", typeof(GL.Delegates.AlphaFragmentOp1ATI)); - GL.AlphaFragmentOp2ATI = (GL.Delegates.AlphaFragmentOp2ATI) GetAddress("glAlphaFragmentOp2ATI", typeof(GL.Delegates.AlphaFragmentOp2ATI)); - GL.AlphaFragmentOp3ATI = (GL.Delegates.AlphaFragmentOp3ATI) GetAddress("glAlphaFragmentOp3ATI", typeof(GL.Delegates.AlphaFragmentOp3ATI)); - GL.SetFragmentShaderConstantATI = (GL.Delegates.SetFragmentShaderConstantATI) GetAddress("glSetFragmentShaderConstantATI", typeof(GL.Delegates.SetFragmentShaderConstantATI)); - GL.PNTrianglesiATI = (GL.Delegates.PNTrianglesiATI) GetAddress("glPNTrianglesiATI", typeof(GL.Delegates.PNTrianglesiATI)); - GL.PNTrianglesfATI = (GL.Delegates.PNTrianglesfATI) GetAddress("glPNTrianglesfATI", typeof(GL.Delegates.PNTrianglesfATI)); - GL.NewObjectBufferATI = (GL.Delegates.NewObjectBufferATI) GetAddress("glNewObjectBufferATI", typeof(GL.Delegates.NewObjectBufferATI)); - GL.IsObjectBufferATI = (GL.Delegates.IsObjectBufferATI) GetAddress("glIsObjectBufferATI", typeof(GL.Delegates.IsObjectBufferATI)); - GL.UpdateObjectBufferATI = (GL.Delegates.UpdateObjectBufferATI) GetAddress("glUpdateObjectBufferATI", typeof(GL.Delegates.UpdateObjectBufferATI)); - GL.GetObjectBufferfvATI = (GL.Delegates.GetObjectBufferfvATI) GetAddress("glGetObjectBufferfvATI", typeof(GL.Delegates.GetObjectBufferfvATI)); - GL.GetObjectBufferivATI = (GL.Delegates.GetObjectBufferivATI) GetAddress("glGetObjectBufferivATI", typeof(GL.Delegates.GetObjectBufferivATI)); - GL.FreeObjectBufferATI = (GL.Delegates.FreeObjectBufferATI) GetAddress("glFreeObjectBufferATI", typeof(GL.Delegates.FreeObjectBufferATI)); - GL.ArrayObjectATI = (GL.Delegates.ArrayObjectATI) GetAddress("glArrayObjectATI", typeof(GL.Delegates.ArrayObjectATI)); - GL.GetArrayObjectfvATI = (GL.Delegates.GetArrayObjectfvATI) GetAddress("glGetArrayObjectfvATI", typeof(GL.Delegates.GetArrayObjectfvATI)); - GL.GetArrayObjectivATI = (GL.Delegates.GetArrayObjectivATI) GetAddress("glGetArrayObjectivATI", typeof(GL.Delegates.GetArrayObjectivATI)); - GL.VariantArrayObjectATI = (GL.Delegates.VariantArrayObjectATI) GetAddress("glVariantArrayObjectATI", typeof(GL.Delegates.VariantArrayObjectATI)); - GL.GetVariantArrayObjectfvATI = (GL.Delegates.GetVariantArrayObjectfvATI) GetAddress("glGetVariantArrayObjectfvATI", typeof(GL.Delegates.GetVariantArrayObjectfvATI)); - GL.GetVariantArrayObjectivATI = (GL.Delegates.GetVariantArrayObjectivATI) GetAddress("glGetVariantArrayObjectivATI", typeof(GL.Delegates.GetVariantArrayObjectivATI)); - GL.BeginVertexShaderEXT = (GL.Delegates.BeginVertexShaderEXT) GetAddress("glBeginVertexShaderEXT", typeof(GL.Delegates.BeginVertexShaderEXT)); - GL.EndVertexShaderEXT = (GL.Delegates.EndVertexShaderEXT) GetAddress("glEndVertexShaderEXT", typeof(GL.Delegates.EndVertexShaderEXT)); - GL.BindVertexShaderEXT = (GL.Delegates.BindVertexShaderEXT) GetAddress("glBindVertexShaderEXT", typeof(GL.Delegates.BindVertexShaderEXT)); - GL.GenVertexShadersEXT = (GL.Delegates.GenVertexShadersEXT) GetAddress("glGenVertexShadersEXT", typeof(GL.Delegates.GenVertexShadersEXT)); - GL.DeleteVertexShaderEXT = (GL.Delegates.DeleteVertexShaderEXT) GetAddress("glDeleteVertexShaderEXT", typeof(GL.Delegates.DeleteVertexShaderEXT)); - GL.ShaderOp1EXT = (GL.Delegates.ShaderOp1EXT) GetAddress("glShaderOp1EXT", typeof(GL.Delegates.ShaderOp1EXT)); - GL.ShaderOp2EXT = (GL.Delegates.ShaderOp2EXT) GetAddress("glShaderOp2EXT", typeof(GL.Delegates.ShaderOp2EXT)); - GL.ShaderOp3EXT = (GL.Delegates.ShaderOp3EXT) GetAddress("glShaderOp3EXT", typeof(GL.Delegates.ShaderOp3EXT)); - GL.SwizzleEXT = (GL.Delegates.SwizzleEXT) GetAddress("glSwizzleEXT", typeof(GL.Delegates.SwizzleEXT)); - GL.WriteMaskEXT = (GL.Delegates.WriteMaskEXT) GetAddress("glWriteMaskEXT", typeof(GL.Delegates.WriteMaskEXT)); - GL.InsertComponentEXT = (GL.Delegates.InsertComponentEXT) GetAddress("glInsertComponentEXT", typeof(GL.Delegates.InsertComponentEXT)); - GL.ExtractComponentEXT = (GL.Delegates.ExtractComponentEXT) GetAddress("glExtractComponentEXT", typeof(GL.Delegates.ExtractComponentEXT)); - GL.GenSymbolsEXT = (GL.Delegates.GenSymbolsEXT) GetAddress("glGenSymbolsEXT", typeof(GL.Delegates.GenSymbolsEXT)); - GL.SetInvariantEXT = (GL.Delegates.SetInvariantEXT) GetAddress("glSetInvariantEXT", typeof(GL.Delegates.SetInvariantEXT)); - GL.SetLocalConstantEXT = (GL.Delegates.SetLocalConstantEXT) GetAddress("glSetLocalConstantEXT", typeof(GL.Delegates.SetLocalConstantEXT)); - GL.VariantbvEXT = (GL.Delegates.VariantbvEXT) GetAddress("glVariantbvEXT", typeof(GL.Delegates.VariantbvEXT)); - GL.VariantsvEXT = (GL.Delegates.VariantsvEXT) GetAddress("glVariantsvEXT", typeof(GL.Delegates.VariantsvEXT)); - GL.VariantivEXT = (GL.Delegates.VariantivEXT) GetAddress("glVariantivEXT", typeof(GL.Delegates.VariantivEXT)); - GL.VariantfvEXT = (GL.Delegates.VariantfvEXT) GetAddress("glVariantfvEXT", typeof(GL.Delegates.VariantfvEXT)); - GL.VariantdvEXT = (GL.Delegates.VariantdvEXT) GetAddress("glVariantdvEXT", typeof(GL.Delegates.VariantdvEXT)); - GL.VariantubvEXT = (GL.Delegates.VariantubvEXT) GetAddress("glVariantubvEXT", typeof(GL.Delegates.VariantubvEXT)); - GL.VariantusvEXT = (GL.Delegates.VariantusvEXT) GetAddress("glVariantusvEXT", typeof(GL.Delegates.VariantusvEXT)); - GL.VariantuivEXT = (GL.Delegates.VariantuivEXT) GetAddress("glVariantuivEXT", typeof(GL.Delegates.VariantuivEXT)); - GL.VariantPointerEXT = (GL.Delegates.VariantPointerEXT) GetAddress("glVariantPointerEXT", typeof(GL.Delegates.VariantPointerEXT)); - GL.EnableVariantClientStateEXT = (GL.Delegates.EnableVariantClientStateEXT) GetAddress("glEnableVariantClientStateEXT", typeof(GL.Delegates.EnableVariantClientStateEXT)); - GL.DisableVariantClientStateEXT = (GL.Delegates.DisableVariantClientStateEXT) GetAddress("glDisableVariantClientStateEXT", typeof(GL.Delegates.DisableVariantClientStateEXT)); - GL.BindLightParameterEXT = (GL.Delegates.BindLightParameterEXT) GetAddress("glBindLightParameterEXT", typeof(GL.Delegates.BindLightParameterEXT)); - GL.BindMaterialParameterEXT = (GL.Delegates.BindMaterialParameterEXT) GetAddress("glBindMaterialParameterEXT", typeof(GL.Delegates.BindMaterialParameterEXT)); - GL.BindTexGenParameterEXT = (GL.Delegates.BindTexGenParameterEXT) GetAddress("glBindTexGenParameterEXT", typeof(GL.Delegates.BindTexGenParameterEXT)); - GL.BindTextureUnitParameterEXT = (GL.Delegates.BindTextureUnitParameterEXT) GetAddress("glBindTextureUnitParameterEXT", typeof(GL.Delegates.BindTextureUnitParameterEXT)); - GL.BindParameterEXT = (GL.Delegates.BindParameterEXT) GetAddress("glBindParameterEXT", typeof(GL.Delegates.BindParameterEXT)); - GL.IsVariantEnabledEXT = (GL.Delegates.IsVariantEnabledEXT) GetAddress("glIsVariantEnabledEXT", typeof(GL.Delegates.IsVariantEnabledEXT)); - GL.GetVariantBooleanvEXT = (GL.Delegates.GetVariantBooleanvEXT) GetAddress("glGetVariantBooleanvEXT", typeof(GL.Delegates.GetVariantBooleanvEXT)); - GL.GetVariantIntegervEXT = (GL.Delegates.GetVariantIntegervEXT) GetAddress("glGetVariantIntegervEXT", typeof(GL.Delegates.GetVariantIntegervEXT)); - GL.GetVariantFloatvEXT = (GL.Delegates.GetVariantFloatvEXT) GetAddress("glGetVariantFloatvEXT", typeof(GL.Delegates.GetVariantFloatvEXT)); - GL.GetVariantPointervEXT = (GL.Delegates.GetVariantPointervEXT) GetAddress("glGetVariantPointervEXT", typeof(GL.Delegates.GetVariantPointervEXT)); - GL.GetInvariantBooleanvEXT = (GL.Delegates.GetInvariantBooleanvEXT) GetAddress("glGetInvariantBooleanvEXT", typeof(GL.Delegates.GetInvariantBooleanvEXT)); - GL.GetInvariantIntegervEXT = (GL.Delegates.GetInvariantIntegervEXT) GetAddress("glGetInvariantIntegervEXT", typeof(GL.Delegates.GetInvariantIntegervEXT)); - GL.GetInvariantFloatvEXT = (GL.Delegates.GetInvariantFloatvEXT) GetAddress("glGetInvariantFloatvEXT", typeof(GL.Delegates.GetInvariantFloatvEXT)); - GL.GetLocalConstantBooleanvEXT = (GL.Delegates.GetLocalConstantBooleanvEXT) GetAddress("glGetLocalConstantBooleanvEXT", typeof(GL.Delegates.GetLocalConstantBooleanvEXT)); - GL.GetLocalConstantIntegervEXT = (GL.Delegates.GetLocalConstantIntegervEXT) GetAddress("glGetLocalConstantIntegervEXT", typeof(GL.Delegates.GetLocalConstantIntegervEXT)); - GL.GetLocalConstantFloatvEXT = (GL.Delegates.GetLocalConstantFloatvEXT) GetAddress("glGetLocalConstantFloatvEXT", typeof(GL.Delegates.GetLocalConstantFloatvEXT)); - GL.VertexStream1sATI = (GL.Delegates.VertexStream1sATI) GetAddress("glVertexStream1sATI", typeof(GL.Delegates.VertexStream1sATI)); - GL.VertexStream1svATI = (GL.Delegates.VertexStream1svATI) GetAddress("glVertexStream1svATI", typeof(GL.Delegates.VertexStream1svATI)); - GL.VertexStream1iATI = (GL.Delegates.VertexStream1iATI) GetAddress("glVertexStream1iATI", typeof(GL.Delegates.VertexStream1iATI)); - GL.VertexStream1ivATI = (GL.Delegates.VertexStream1ivATI) GetAddress("glVertexStream1ivATI", typeof(GL.Delegates.VertexStream1ivATI)); - GL.VertexStream1fATI = (GL.Delegates.VertexStream1fATI) GetAddress("glVertexStream1fATI", typeof(GL.Delegates.VertexStream1fATI)); - GL.VertexStream1fvATI = (GL.Delegates.VertexStream1fvATI) GetAddress("glVertexStream1fvATI", typeof(GL.Delegates.VertexStream1fvATI)); - GL.VertexStream1dATI = (GL.Delegates.VertexStream1dATI) GetAddress("glVertexStream1dATI", typeof(GL.Delegates.VertexStream1dATI)); - GL.VertexStream1dvATI = (GL.Delegates.VertexStream1dvATI) GetAddress("glVertexStream1dvATI", typeof(GL.Delegates.VertexStream1dvATI)); - GL.VertexStream2sATI = (GL.Delegates.VertexStream2sATI) GetAddress("glVertexStream2sATI", typeof(GL.Delegates.VertexStream2sATI)); - GL.VertexStream2svATI = (GL.Delegates.VertexStream2svATI) GetAddress("glVertexStream2svATI", typeof(GL.Delegates.VertexStream2svATI)); - GL.VertexStream2iATI = (GL.Delegates.VertexStream2iATI) GetAddress("glVertexStream2iATI", typeof(GL.Delegates.VertexStream2iATI)); - GL.VertexStream2ivATI = (GL.Delegates.VertexStream2ivATI) GetAddress("glVertexStream2ivATI", typeof(GL.Delegates.VertexStream2ivATI)); - GL.VertexStream2fATI = (GL.Delegates.VertexStream2fATI) GetAddress("glVertexStream2fATI", typeof(GL.Delegates.VertexStream2fATI)); - GL.VertexStream2fvATI = (GL.Delegates.VertexStream2fvATI) GetAddress("glVertexStream2fvATI", typeof(GL.Delegates.VertexStream2fvATI)); - GL.VertexStream2dATI = (GL.Delegates.VertexStream2dATI) GetAddress("glVertexStream2dATI", typeof(GL.Delegates.VertexStream2dATI)); - GL.VertexStream2dvATI = (GL.Delegates.VertexStream2dvATI) GetAddress("glVertexStream2dvATI", typeof(GL.Delegates.VertexStream2dvATI)); - GL.VertexStream3sATI = (GL.Delegates.VertexStream3sATI) GetAddress("glVertexStream3sATI", typeof(GL.Delegates.VertexStream3sATI)); - GL.VertexStream3svATI = (GL.Delegates.VertexStream3svATI) GetAddress("glVertexStream3svATI", typeof(GL.Delegates.VertexStream3svATI)); - GL.VertexStream3iATI = (GL.Delegates.VertexStream3iATI) GetAddress("glVertexStream3iATI", typeof(GL.Delegates.VertexStream3iATI)); - GL.VertexStream3ivATI = (GL.Delegates.VertexStream3ivATI) GetAddress("glVertexStream3ivATI", typeof(GL.Delegates.VertexStream3ivATI)); - GL.VertexStream3fATI = (GL.Delegates.VertexStream3fATI) GetAddress("glVertexStream3fATI", typeof(GL.Delegates.VertexStream3fATI)); - GL.VertexStream3fvATI = (GL.Delegates.VertexStream3fvATI) GetAddress("glVertexStream3fvATI", typeof(GL.Delegates.VertexStream3fvATI)); - GL.VertexStream3dATI = (GL.Delegates.VertexStream3dATI) GetAddress("glVertexStream3dATI", typeof(GL.Delegates.VertexStream3dATI)); - GL.VertexStream3dvATI = (GL.Delegates.VertexStream3dvATI) GetAddress("glVertexStream3dvATI", typeof(GL.Delegates.VertexStream3dvATI)); - GL.VertexStream4sATI = (GL.Delegates.VertexStream4sATI) GetAddress("glVertexStream4sATI", typeof(GL.Delegates.VertexStream4sATI)); - GL.VertexStream4svATI = (GL.Delegates.VertexStream4svATI) GetAddress("glVertexStream4svATI", typeof(GL.Delegates.VertexStream4svATI)); - GL.VertexStream4iATI = (GL.Delegates.VertexStream4iATI) GetAddress("glVertexStream4iATI", typeof(GL.Delegates.VertexStream4iATI)); - GL.VertexStream4ivATI = (GL.Delegates.VertexStream4ivATI) GetAddress("glVertexStream4ivATI", typeof(GL.Delegates.VertexStream4ivATI)); - GL.VertexStream4fATI = (GL.Delegates.VertexStream4fATI) GetAddress("glVertexStream4fATI", typeof(GL.Delegates.VertexStream4fATI)); - GL.VertexStream4fvATI = (GL.Delegates.VertexStream4fvATI) GetAddress("glVertexStream4fvATI", typeof(GL.Delegates.VertexStream4fvATI)); - GL.VertexStream4dATI = (GL.Delegates.VertexStream4dATI) GetAddress("glVertexStream4dATI", typeof(GL.Delegates.VertexStream4dATI)); - GL.VertexStream4dvATI = (GL.Delegates.VertexStream4dvATI) GetAddress("glVertexStream4dvATI", typeof(GL.Delegates.VertexStream4dvATI)); - GL.NormalStream3bATI = (GL.Delegates.NormalStream3bATI) GetAddress("glNormalStream3bATI", typeof(GL.Delegates.NormalStream3bATI)); - GL.NormalStream3bvATI = (GL.Delegates.NormalStream3bvATI) GetAddress("glNormalStream3bvATI", typeof(GL.Delegates.NormalStream3bvATI)); - GL.NormalStream3sATI = (GL.Delegates.NormalStream3sATI) GetAddress("glNormalStream3sATI", typeof(GL.Delegates.NormalStream3sATI)); - GL.NormalStream3svATI = (GL.Delegates.NormalStream3svATI) GetAddress("glNormalStream3svATI", typeof(GL.Delegates.NormalStream3svATI)); - GL.NormalStream3iATI = (GL.Delegates.NormalStream3iATI) GetAddress("glNormalStream3iATI", typeof(GL.Delegates.NormalStream3iATI)); - GL.NormalStream3ivATI = (GL.Delegates.NormalStream3ivATI) GetAddress("glNormalStream3ivATI", typeof(GL.Delegates.NormalStream3ivATI)); - GL.NormalStream3fATI = (GL.Delegates.NormalStream3fATI) GetAddress("glNormalStream3fATI", typeof(GL.Delegates.NormalStream3fATI)); - GL.NormalStream3fvATI = (GL.Delegates.NormalStream3fvATI) GetAddress("glNormalStream3fvATI", typeof(GL.Delegates.NormalStream3fvATI)); - GL.NormalStream3dATI = (GL.Delegates.NormalStream3dATI) GetAddress("glNormalStream3dATI", typeof(GL.Delegates.NormalStream3dATI)); - GL.NormalStream3dvATI = (GL.Delegates.NormalStream3dvATI) GetAddress("glNormalStream3dvATI", typeof(GL.Delegates.NormalStream3dvATI)); - GL.ClientActiveVertexStreamATI = (GL.Delegates.ClientActiveVertexStreamATI) GetAddress("glClientActiveVertexStreamATI", typeof(GL.Delegates.ClientActiveVertexStreamATI)); - GL.VertexBlendEnviATI = (GL.Delegates.VertexBlendEnviATI) GetAddress("glVertexBlendEnviATI", typeof(GL.Delegates.VertexBlendEnviATI)); - GL.VertexBlendEnvfATI = (GL.Delegates.VertexBlendEnvfATI) GetAddress("glVertexBlendEnvfATI", typeof(GL.Delegates.VertexBlendEnvfATI)); - GL.ElementPointerATI = (GL.Delegates.ElementPointerATI) GetAddress("glElementPointerATI", typeof(GL.Delegates.ElementPointerATI)); - GL.DrawElementArrayATI = (GL.Delegates.DrawElementArrayATI) GetAddress("glDrawElementArrayATI", typeof(GL.Delegates.DrawElementArrayATI)); - GL.DrawRangeElementArrayATI = (GL.Delegates.DrawRangeElementArrayATI) GetAddress("glDrawRangeElementArrayATI", typeof(GL.Delegates.DrawRangeElementArrayATI)); - GL.DrawMeshArraysSUN = (GL.Delegates.DrawMeshArraysSUN) GetAddress("glDrawMeshArraysSUN", typeof(GL.Delegates.DrawMeshArraysSUN)); - GL.GenOcclusionQueriesNV = (GL.Delegates.GenOcclusionQueriesNV) GetAddress("glGenOcclusionQueriesNV", typeof(GL.Delegates.GenOcclusionQueriesNV)); - GL.DeleteOcclusionQueriesNV = (GL.Delegates.DeleteOcclusionQueriesNV) GetAddress("glDeleteOcclusionQueriesNV", typeof(GL.Delegates.DeleteOcclusionQueriesNV)); - GL.IsOcclusionQueryNV = (GL.Delegates.IsOcclusionQueryNV) GetAddress("glIsOcclusionQueryNV", typeof(GL.Delegates.IsOcclusionQueryNV)); - GL.BeginOcclusionQueryNV = (GL.Delegates.BeginOcclusionQueryNV) GetAddress("glBeginOcclusionQueryNV", typeof(GL.Delegates.BeginOcclusionQueryNV)); - GL.EndOcclusionQueryNV = (GL.Delegates.EndOcclusionQueryNV) GetAddress("glEndOcclusionQueryNV", typeof(GL.Delegates.EndOcclusionQueryNV)); - GL.GetOcclusionQueryivNV = (GL.Delegates.GetOcclusionQueryivNV) GetAddress("glGetOcclusionQueryivNV", typeof(GL.Delegates.GetOcclusionQueryivNV)); - GL.GetOcclusionQueryuivNV = (GL.Delegates.GetOcclusionQueryuivNV) GetAddress("glGetOcclusionQueryuivNV", typeof(GL.Delegates.GetOcclusionQueryuivNV)); - GL.PointParameteriNV = (GL.Delegates.PointParameteriNV) GetAddress("glPointParameteriNV", typeof(GL.Delegates.PointParameteriNV)); - GL.PointParameterivNV = (GL.Delegates.PointParameterivNV) GetAddress("glPointParameterivNV", typeof(GL.Delegates.PointParameterivNV)); - GL.ActiveStencilFaceEXT = (GL.Delegates.ActiveStencilFaceEXT) GetAddress("glActiveStencilFaceEXT", typeof(GL.Delegates.ActiveStencilFaceEXT)); - GL.ElementPointerAPPLE = (GL.Delegates.ElementPointerAPPLE) GetAddress("glElementPointerAPPLE", typeof(GL.Delegates.ElementPointerAPPLE)); - GL.DrawElementArrayAPPLE = (GL.Delegates.DrawElementArrayAPPLE) GetAddress("glDrawElementArrayAPPLE", typeof(GL.Delegates.DrawElementArrayAPPLE)); - GL.DrawRangeElementArrayAPPLE = (GL.Delegates.DrawRangeElementArrayAPPLE) GetAddress("glDrawRangeElementArrayAPPLE", typeof(GL.Delegates.DrawRangeElementArrayAPPLE)); - GL.MultiDrawElementArrayAPPLE = (GL.Delegates.MultiDrawElementArrayAPPLE) GetAddress("glMultiDrawElementArrayAPPLE", typeof(GL.Delegates.MultiDrawElementArrayAPPLE)); - GL.MultiDrawRangeElementArrayAPPLE = (GL.Delegates.MultiDrawRangeElementArrayAPPLE) GetAddress("glMultiDrawRangeElementArrayAPPLE", typeof(GL.Delegates.MultiDrawRangeElementArrayAPPLE)); - GL.GenFencesAPPLE = (GL.Delegates.GenFencesAPPLE) GetAddress("glGenFencesAPPLE", typeof(GL.Delegates.GenFencesAPPLE)); - GL.DeleteFencesAPPLE = (GL.Delegates.DeleteFencesAPPLE) GetAddress("glDeleteFencesAPPLE", typeof(GL.Delegates.DeleteFencesAPPLE)); - GL.SetFenceAPPLE = (GL.Delegates.SetFenceAPPLE) GetAddress("glSetFenceAPPLE", typeof(GL.Delegates.SetFenceAPPLE)); - GL.IsFenceAPPLE = (GL.Delegates.IsFenceAPPLE) GetAddress("glIsFenceAPPLE", typeof(GL.Delegates.IsFenceAPPLE)); - GL.TestFenceAPPLE = (GL.Delegates.TestFenceAPPLE) GetAddress("glTestFenceAPPLE", typeof(GL.Delegates.TestFenceAPPLE)); - GL.FinishFenceAPPLE = (GL.Delegates.FinishFenceAPPLE) GetAddress("glFinishFenceAPPLE", typeof(GL.Delegates.FinishFenceAPPLE)); - GL.TestObjectAPPLE = (GL.Delegates.TestObjectAPPLE) GetAddress("glTestObjectAPPLE", typeof(GL.Delegates.TestObjectAPPLE)); - GL.FinishObjectAPPLE = (GL.Delegates.FinishObjectAPPLE) GetAddress("glFinishObjectAPPLE", typeof(GL.Delegates.FinishObjectAPPLE)); - GL.BindVertexArrayAPPLE = (GL.Delegates.BindVertexArrayAPPLE) GetAddress("glBindVertexArrayAPPLE", typeof(GL.Delegates.BindVertexArrayAPPLE)); - GL.DeleteVertexArraysAPPLE = (GL.Delegates.DeleteVertexArraysAPPLE) GetAddress("glDeleteVertexArraysAPPLE", typeof(GL.Delegates.DeleteVertexArraysAPPLE)); - GL.GenVertexArraysAPPLE = (GL.Delegates.GenVertexArraysAPPLE) GetAddress("glGenVertexArraysAPPLE", typeof(GL.Delegates.GenVertexArraysAPPLE)); - GL.IsVertexArrayAPPLE = (GL.Delegates.IsVertexArrayAPPLE) GetAddress("glIsVertexArrayAPPLE", typeof(GL.Delegates.IsVertexArrayAPPLE)); - GL.VertexArrayRangeAPPLE = (GL.Delegates.VertexArrayRangeAPPLE) GetAddress("glVertexArrayRangeAPPLE", typeof(GL.Delegates.VertexArrayRangeAPPLE)); - GL.FlushVertexArrayRangeAPPLE = (GL.Delegates.FlushVertexArrayRangeAPPLE) GetAddress("glFlushVertexArrayRangeAPPLE", typeof(GL.Delegates.FlushVertexArrayRangeAPPLE)); - GL.VertexArrayParameteriAPPLE = (GL.Delegates.VertexArrayParameteriAPPLE) GetAddress("glVertexArrayParameteriAPPLE", typeof(GL.Delegates.VertexArrayParameteriAPPLE)); - GL.DrawBuffersATI = (GL.Delegates.DrawBuffersATI) GetAddress("glDrawBuffersATI", typeof(GL.Delegates.DrawBuffersATI)); - GL.ProgramNamedParameter4fNV = (GL.Delegates.ProgramNamedParameter4fNV) GetAddress("glProgramNamedParameter4fNV", typeof(GL.Delegates.ProgramNamedParameter4fNV)); - GL.ProgramNamedParameter4dNV = (GL.Delegates.ProgramNamedParameter4dNV) GetAddress("glProgramNamedParameter4dNV", typeof(GL.Delegates.ProgramNamedParameter4dNV)); - GL.ProgramNamedParameter4fvNV = (GL.Delegates.ProgramNamedParameter4fvNV) GetAddress("glProgramNamedParameter4fvNV", typeof(GL.Delegates.ProgramNamedParameter4fvNV)); - GL.ProgramNamedParameter4dvNV = (GL.Delegates.ProgramNamedParameter4dvNV) GetAddress("glProgramNamedParameter4dvNV", typeof(GL.Delegates.ProgramNamedParameter4dvNV)); - GL.GetProgramNamedParameterfvNV = (GL.Delegates.GetProgramNamedParameterfvNV) GetAddress("glGetProgramNamedParameterfvNV", typeof(GL.Delegates.GetProgramNamedParameterfvNV)); - GL.GetProgramNamedParameterdvNV = (GL.Delegates.GetProgramNamedParameterdvNV) GetAddress("glGetProgramNamedParameterdvNV", typeof(GL.Delegates.GetProgramNamedParameterdvNV)); - GL.Vertex2hNV = (GL.Delegates.Vertex2hNV) GetAddress("glVertex2hNV", typeof(GL.Delegates.Vertex2hNV)); - GL.Vertex2hvNV = (GL.Delegates.Vertex2hvNV) GetAddress("glVertex2hvNV", typeof(GL.Delegates.Vertex2hvNV)); - GL.Vertex3hNV = (GL.Delegates.Vertex3hNV) GetAddress("glVertex3hNV", typeof(GL.Delegates.Vertex3hNV)); - GL.Vertex3hvNV = (GL.Delegates.Vertex3hvNV) GetAddress("glVertex3hvNV", typeof(GL.Delegates.Vertex3hvNV)); - GL.Vertex4hNV = (GL.Delegates.Vertex4hNV) GetAddress("glVertex4hNV", typeof(GL.Delegates.Vertex4hNV)); - GL.Vertex4hvNV = (GL.Delegates.Vertex4hvNV) GetAddress("glVertex4hvNV", typeof(GL.Delegates.Vertex4hvNV)); - GL.Normal3hNV = (GL.Delegates.Normal3hNV) GetAddress("glNormal3hNV", typeof(GL.Delegates.Normal3hNV)); - GL.Normal3hvNV = (GL.Delegates.Normal3hvNV) GetAddress("glNormal3hvNV", typeof(GL.Delegates.Normal3hvNV)); - GL.Color3hNV = (GL.Delegates.Color3hNV) GetAddress("glColor3hNV", typeof(GL.Delegates.Color3hNV)); - GL.Color3hvNV = (GL.Delegates.Color3hvNV) GetAddress("glColor3hvNV", typeof(GL.Delegates.Color3hvNV)); - GL.Color4hNV = (GL.Delegates.Color4hNV) GetAddress("glColor4hNV", typeof(GL.Delegates.Color4hNV)); - GL.Color4hvNV = (GL.Delegates.Color4hvNV) GetAddress("glColor4hvNV", typeof(GL.Delegates.Color4hvNV)); - GL.TexCoord1hNV = (GL.Delegates.TexCoord1hNV) GetAddress("glTexCoord1hNV", typeof(GL.Delegates.TexCoord1hNV)); - GL.TexCoord1hvNV = (GL.Delegates.TexCoord1hvNV) GetAddress("glTexCoord1hvNV", typeof(GL.Delegates.TexCoord1hvNV)); - GL.TexCoord2hNV = (GL.Delegates.TexCoord2hNV) GetAddress("glTexCoord2hNV", typeof(GL.Delegates.TexCoord2hNV)); - GL.TexCoord2hvNV = (GL.Delegates.TexCoord2hvNV) GetAddress("glTexCoord2hvNV", typeof(GL.Delegates.TexCoord2hvNV)); - GL.TexCoord3hNV = (GL.Delegates.TexCoord3hNV) GetAddress("glTexCoord3hNV", typeof(GL.Delegates.TexCoord3hNV)); - GL.TexCoord3hvNV = (GL.Delegates.TexCoord3hvNV) GetAddress("glTexCoord3hvNV", typeof(GL.Delegates.TexCoord3hvNV)); - GL.TexCoord4hNV = (GL.Delegates.TexCoord4hNV) GetAddress("glTexCoord4hNV", typeof(GL.Delegates.TexCoord4hNV)); - GL.TexCoord4hvNV = (GL.Delegates.TexCoord4hvNV) GetAddress("glTexCoord4hvNV", typeof(GL.Delegates.TexCoord4hvNV)); - GL.MultiTexCoord1hNV = (GL.Delegates.MultiTexCoord1hNV) GetAddress("glMultiTexCoord1hNV", typeof(GL.Delegates.MultiTexCoord1hNV)); - GL.MultiTexCoord1hvNV = (GL.Delegates.MultiTexCoord1hvNV) GetAddress("glMultiTexCoord1hvNV", typeof(GL.Delegates.MultiTexCoord1hvNV)); - GL.MultiTexCoord2hNV = (GL.Delegates.MultiTexCoord2hNV) GetAddress("glMultiTexCoord2hNV", typeof(GL.Delegates.MultiTexCoord2hNV)); - GL.MultiTexCoord2hvNV = (GL.Delegates.MultiTexCoord2hvNV) GetAddress("glMultiTexCoord2hvNV", typeof(GL.Delegates.MultiTexCoord2hvNV)); - GL.MultiTexCoord3hNV = (GL.Delegates.MultiTexCoord3hNV) GetAddress("glMultiTexCoord3hNV", typeof(GL.Delegates.MultiTexCoord3hNV)); - GL.MultiTexCoord3hvNV = (GL.Delegates.MultiTexCoord3hvNV) GetAddress("glMultiTexCoord3hvNV", typeof(GL.Delegates.MultiTexCoord3hvNV)); - GL.MultiTexCoord4hNV = (GL.Delegates.MultiTexCoord4hNV) GetAddress("glMultiTexCoord4hNV", typeof(GL.Delegates.MultiTexCoord4hNV)); - GL.MultiTexCoord4hvNV = (GL.Delegates.MultiTexCoord4hvNV) GetAddress("glMultiTexCoord4hvNV", typeof(GL.Delegates.MultiTexCoord4hvNV)); - GL.FogCoordhNV = (GL.Delegates.FogCoordhNV) GetAddress("glFogCoordhNV", typeof(GL.Delegates.FogCoordhNV)); - GL.FogCoordhvNV = (GL.Delegates.FogCoordhvNV) GetAddress("glFogCoordhvNV", typeof(GL.Delegates.FogCoordhvNV)); - GL.SecondaryColor3hNV = (GL.Delegates.SecondaryColor3hNV) GetAddress("glSecondaryColor3hNV", typeof(GL.Delegates.SecondaryColor3hNV)); - GL.SecondaryColor3hvNV = (GL.Delegates.SecondaryColor3hvNV) GetAddress("glSecondaryColor3hvNV", typeof(GL.Delegates.SecondaryColor3hvNV)); - GL.VertexWeighthNV = (GL.Delegates.VertexWeighthNV) GetAddress("glVertexWeighthNV", typeof(GL.Delegates.VertexWeighthNV)); - GL.VertexWeighthvNV = (GL.Delegates.VertexWeighthvNV) GetAddress("glVertexWeighthvNV", typeof(GL.Delegates.VertexWeighthvNV)); - GL.VertexAttrib1hNV = (GL.Delegates.VertexAttrib1hNV) GetAddress("glVertexAttrib1hNV", typeof(GL.Delegates.VertexAttrib1hNV)); - GL.VertexAttrib1hvNV = (GL.Delegates.VertexAttrib1hvNV) GetAddress("glVertexAttrib1hvNV", typeof(GL.Delegates.VertexAttrib1hvNV)); - GL.VertexAttrib2hNV = (GL.Delegates.VertexAttrib2hNV) GetAddress("glVertexAttrib2hNV", typeof(GL.Delegates.VertexAttrib2hNV)); - GL.VertexAttrib2hvNV = (GL.Delegates.VertexAttrib2hvNV) GetAddress("glVertexAttrib2hvNV", typeof(GL.Delegates.VertexAttrib2hvNV)); - GL.VertexAttrib3hNV = (GL.Delegates.VertexAttrib3hNV) GetAddress("glVertexAttrib3hNV", typeof(GL.Delegates.VertexAttrib3hNV)); - GL.VertexAttrib3hvNV = (GL.Delegates.VertexAttrib3hvNV) GetAddress("glVertexAttrib3hvNV", typeof(GL.Delegates.VertexAttrib3hvNV)); - GL.VertexAttrib4hNV = (GL.Delegates.VertexAttrib4hNV) GetAddress("glVertexAttrib4hNV", typeof(GL.Delegates.VertexAttrib4hNV)); - GL.VertexAttrib4hvNV = (GL.Delegates.VertexAttrib4hvNV) GetAddress("glVertexAttrib4hvNV", typeof(GL.Delegates.VertexAttrib4hvNV)); - GL.VertexAttribs1hvNV = (GL.Delegates.VertexAttribs1hvNV) GetAddress("glVertexAttribs1hvNV", typeof(GL.Delegates.VertexAttribs1hvNV)); - GL.VertexAttribs2hvNV = (GL.Delegates.VertexAttribs2hvNV) GetAddress("glVertexAttribs2hvNV", typeof(GL.Delegates.VertexAttribs2hvNV)); - GL.VertexAttribs3hvNV = (GL.Delegates.VertexAttribs3hvNV) GetAddress("glVertexAttribs3hvNV", typeof(GL.Delegates.VertexAttribs3hvNV)); - GL.VertexAttribs4hvNV = (GL.Delegates.VertexAttribs4hvNV) GetAddress("glVertexAttribs4hvNV", typeof(GL.Delegates.VertexAttribs4hvNV)); - GL.PixelDataRangeNV = (GL.Delegates.PixelDataRangeNV) GetAddress("glPixelDataRangeNV", typeof(GL.Delegates.PixelDataRangeNV)); - GL.FlushPixelDataRangeNV = (GL.Delegates.FlushPixelDataRangeNV) GetAddress("glFlushPixelDataRangeNV", typeof(GL.Delegates.FlushPixelDataRangeNV)); - GL.PrimitiveRestartNV = (GL.Delegates.PrimitiveRestartNV) GetAddress("glPrimitiveRestartNV", typeof(GL.Delegates.PrimitiveRestartNV)); - GL.PrimitiveRestartIndexNV = (GL.Delegates.PrimitiveRestartIndexNV) GetAddress("glPrimitiveRestartIndexNV", typeof(GL.Delegates.PrimitiveRestartIndexNV)); - GL.MapObjectBufferATI_ = (GL.Delegates.MapObjectBufferATI_) GetAddress("glMapObjectBufferATI_", typeof(GL.Delegates.MapObjectBufferATI_)); - GL.UnmapObjectBufferATI = (GL.Delegates.UnmapObjectBufferATI) GetAddress("glUnmapObjectBufferATI", typeof(GL.Delegates.UnmapObjectBufferATI)); - GL.StencilOpSeparateATI = (GL.Delegates.StencilOpSeparateATI) GetAddress("glStencilOpSeparateATI", typeof(GL.Delegates.StencilOpSeparateATI)); - GL.StencilFuncSeparateATI = (GL.Delegates.StencilFuncSeparateATI) GetAddress("glStencilFuncSeparateATI", typeof(GL.Delegates.StencilFuncSeparateATI)); - GL.VertexAttribArrayObjectATI = (GL.Delegates.VertexAttribArrayObjectATI) GetAddress("glVertexAttribArrayObjectATI", typeof(GL.Delegates.VertexAttribArrayObjectATI)); - GL.GetVertexAttribArrayObjectfvATI = (GL.Delegates.GetVertexAttribArrayObjectfvATI) GetAddress("glGetVertexAttribArrayObjectfvATI", typeof(GL.Delegates.GetVertexAttribArrayObjectfvATI)); - GL.GetVertexAttribArrayObjectivATI = (GL.Delegates.GetVertexAttribArrayObjectivATI) GetAddress("glGetVertexAttribArrayObjectivATI", typeof(GL.Delegates.GetVertexAttribArrayObjectivATI)); - GL.DepthBoundsEXT = (GL.Delegates.DepthBoundsEXT) GetAddress("glDepthBoundsEXT", typeof(GL.Delegates.DepthBoundsEXT)); - GL.BlendEquationSeparateEXT = (GL.Delegates.BlendEquationSeparateEXT) GetAddress("glBlendEquationSeparateEXT", typeof(GL.Delegates.BlendEquationSeparateEXT)); - GL.IsRenderbufferEXT = (GL.Delegates.IsRenderbufferEXT) GetAddress("glIsRenderbufferEXT", typeof(GL.Delegates.IsRenderbufferEXT)); - GL.BindRenderbufferEXT = (GL.Delegates.BindRenderbufferEXT) GetAddress("glBindRenderbufferEXT", typeof(GL.Delegates.BindRenderbufferEXT)); - GL.DeleteRenderbuffersEXT = (GL.Delegates.DeleteRenderbuffersEXT) GetAddress("glDeleteRenderbuffersEXT", typeof(GL.Delegates.DeleteRenderbuffersEXT)); - GL.GenRenderbuffersEXT = (GL.Delegates.GenRenderbuffersEXT) GetAddress("glGenRenderbuffersEXT", typeof(GL.Delegates.GenRenderbuffersEXT)); - GL.RenderbufferStorageEXT = (GL.Delegates.RenderbufferStorageEXT) GetAddress("glRenderbufferStorageEXT", typeof(GL.Delegates.RenderbufferStorageEXT)); - GL.GetRenderbufferParameterivEXT = (GL.Delegates.GetRenderbufferParameterivEXT) GetAddress("glGetRenderbufferParameterivEXT", typeof(GL.Delegates.GetRenderbufferParameterivEXT)); - GL.IsFramebufferEXT = (GL.Delegates.IsFramebufferEXT) GetAddress("glIsFramebufferEXT", typeof(GL.Delegates.IsFramebufferEXT)); - GL.BindFramebufferEXT = (GL.Delegates.BindFramebufferEXT) GetAddress("glBindFramebufferEXT", typeof(GL.Delegates.BindFramebufferEXT)); - GL.DeleteFramebuffersEXT = (GL.Delegates.DeleteFramebuffersEXT) GetAddress("glDeleteFramebuffersEXT", typeof(GL.Delegates.DeleteFramebuffersEXT)); - GL.GenFramebuffersEXT = (GL.Delegates.GenFramebuffersEXT) GetAddress("glGenFramebuffersEXT", typeof(GL.Delegates.GenFramebuffersEXT)); - GL.CheckFramebufferStatusEXT = (GL.Delegates.CheckFramebufferStatusEXT) GetAddress("glCheckFramebufferStatusEXT", typeof(GL.Delegates.CheckFramebufferStatusEXT)); - GL.FramebufferTexture1DEXT = (GL.Delegates.FramebufferTexture1DEXT) GetAddress("glFramebufferTexture1DEXT", typeof(GL.Delegates.FramebufferTexture1DEXT)); - GL.FramebufferTexture2DEXT = (GL.Delegates.FramebufferTexture2DEXT) GetAddress("glFramebufferTexture2DEXT", typeof(GL.Delegates.FramebufferTexture2DEXT)); - GL.FramebufferTexture3DEXT = (GL.Delegates.FramebufferTexture3DEXT) GetAddress("glFramebufferTexture3DEXT", typeof(GL.Delegates.FramebufferTexture3DEXT)); - GL.FramebufferRenderbufferEXT = (GL.Delegates.FramebufferRenderbufferEXT) GetAddress("glFramebufferRenderbufferEXT", typeof(GL.Delegates.FramebufferRenderbufferEXT)); - GL.GetFramebufferAttachmentParameterivEXT = (GL.Delegates.GetFramebufferAttachmentParameterivEXT) GetAddress("glGetFramebufferAttachmentParameterivEXT", typeof(GL.Delegates.GetFramebufferAttachmentParameterivEXT)); - GL.GenerateMipmapEXT = (GL.Delegates.GenerateMipmapEXT) GetAddress("glGenerateMipmapEXT", typeof(GL.Delegates.GenerateMipmapEXT)); - GL.StringMarkerGREMEDY = (GL.Delegates.StringMarkerGREMEDY) GetAddress("glStringMarkerGREMEDY", typeof(GL.Delegates.StringMarkerGREMEDY)); - CoreLoaded = true; - } - #endregion } } + diff --git a/Source/OpenGL/OpenGL/Bindings/WindowsVistaContextLoad.cs b/Source/OpenGL/OpenGL/Bindings/WindowsVistaContextLoad.cs index 5cd3cf67..6ce08c46 100644 --- a/Source/OpenGL/OpenGL/Bindings/WindowsVistaContextLoad.cs +++ b/Source/OpenGL/OpenGL/Bindings/WindowsVistaContextLoad.cs @@ -1,2859 +1,482 @@ using System; using System.Runtime.InteropServices; -using OpenTK.OpenGL; namespace OpenTK.OpenGL.Platform { public partial class WindowsVistaContext { - #region DllImports + #region OpenGL core and extension function loading - internal class Imports - { - [DllImport(_dll_name, EntryPoint = "glNewList")] - public static extern void NewList(uint list, Enums.ListMode mode); - - [DllImport(_dll_name, EntryPoint = "glEndList")] - public static extern void EndList(); - - [DllImport(_dll_name, EntryPoint = "glCallList")] - public static extern void CallList(uint list); - - [DllImport(_dll_name, EntryPoint = "glCallLists")] - public static extern void CallLists(int n, Enums.ListNameType type, [MarshalAs(UnmanagedType.AsAny)] object lists); - - [DllImport(_dll_name, EntryPoint = "glDeleteLists")] - public static extern void DeleteLists(uint list, int range); - - [DllImport(_dll_name, EntryPoint = "glGenLists")] - public static extern uint GenLists(int range); - - [DllImport(_dll_name, EntryPoint = "glListBase")] - public static extern void ListBase(uint @base); - - [DllImport(_dll_name, EntryPoint = "glBegin")] - public static extern void Begin(Enums.BeginMode mode); - - [DllImport(_dll_name, EntryPoint = "glBitmap")] - public static extern void Bitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, byte[] bitmap); - - [DllImport(_dll_name, EntryPoint = "glColor3b")] - public static extern void Color3b(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glColor3bv")] - public static extern void Color3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3d")] - public static extern void Color3d(double red, double green, double blue); - - [DllImport(_dll_name, EntryPoint = "glColor3dv")] - public static extern void Color3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3f")] - public static extern void Color3f(float red, float green, float blue); - - [DllImport(_dll_name, EntryPoint = "glColor3fv")] - public static extern void Color3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3i")] - public static extern void Color3i(int red, int green, int blue); - - [DllImport(_dll_name, EntryPoint = "glColor3iv")] - public static extern void Color3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3s")] - public static extern void Color3s(short red, short green, short blue); - - [DllImport(_dll_name, EntryPoint = "glColor3sv")] - public static extern void Color3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3ub")] - public static extern void Color3ub(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glColor3ubv")] - public static extern void Color3ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3ui")] - public static extern void Color3ui(uint red, uint green, uint blue); - - [DllImport(_dll_name, EntryPoint = "glColor3uiv")] - public static extern void Color3uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3us")] - public static extern void Color3us(ushort red, ushort green, ushort blue); - - [DllImport(_dll_name, EntryPoint = "glColor3usv")] - public static extern void Color3usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4b")] - public static extern void Color4b(byte red, byte green, byte blue, byte alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4bv")] - public static extern void Color4bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4d")] - public static extern void Color4d(double red, double green, double blue, double alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4dv")] - public static extern void Color4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4f")] - public static extern void Color4f(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4fv")] - public static extern void Color4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4i")] - public static extern void Color4i(int red, int green, int blue, int alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4iv")] - public static extern void Color4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4s")] - public static extern void Color4s(short red, short green, short blue, short alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4sv")] - public static extern void Color4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4ub")] - public static extern void Color4ub(byte red, byte green, byte blue, byte alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4ubv")] - public static extern void Color4ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4ui")] - public static extern void Color4ui(uint red, uint green, uint blue, uint alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4uiv")] - public static extern void Color4uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4us")] - public static extern void Color4us(ushort red, ushort green, ushort blue, ushort alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4usv")] - public static extern void Color4usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlag")] - public static extern void EdgeFlag(bool flag); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlagv")] - public static extern void EdgeFlagv(bool[] flag); - - [DllImport(_dll_name, EntryPoint = "glEnd")] - public static extern void End(); - - [DllImport(_dll_name, EntryPoint = "glIndexd")] - public static extern void Indexd(double c); - - [DllImport(_dll_name, EntryPoint = "glIndexdv")] - public static extern void Indexdv(double[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexf")] - public static extern void Indexf(float c); - - [DllImport(_dll_name, EntryPoint = "glIndexfv")] - public static extern void Indexfv(float[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexi")] - public static extern void Indexi(int c); - - [DllImport(_dll_name, EntryPoint = "glIndexiv")] - public static extern void Indexiv(int[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexs")] - public static extern void Indexs(short c); - - [DllImport(_dll_name, EntryPoint = "glIndexsv")] - public static extern void Indexsv(short[] c); - - [DllImport(_dll_name, EntryPoint = "glNormal3b")] - public static extern void Normal3b(byte nx, byte ny, byte nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3bv")] - public static extern void Normal3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3d")] - public static extern void Normal3d(double nx, double ny, double nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3dv")] - public static extern void Normal3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3f")] - public static extern void Normal3f(float nx, float ny, float nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3fv")] - public static extern void Normal3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3i")] - public static extern void Normal3i(int nx, int ny, int nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3iv")] - public static extern void Normal3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3s")] - public static extern void Normal3s(short nx, short ny, short nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3sv")] - public static extern void Normal3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2d")] - public static extern void RasterPos2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2dv")] - public static extern void RasterPos2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2f")] - public static extern void RasterPos2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2fv")] - public static extern void RasterPos2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2i")] - public static extern void RasterPos2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2iv")] - public static extern void RasterPos2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2s")] - public static extern void RasterPos2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2sv")] - public static extern void RasterPos2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3d")] - public static extern void RasterPos3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3dv")] - public static extern void RasterPos3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3f")] - public static extern void RasterPos3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3fv")] - public static extern void RasterPos3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3i")] - public static extern void RasterPos3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3iv")] - public static extern void RasterPos3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3s")] - public static extern void RasterPos3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3sv")] - public static extern void RasterPos3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4d")] - public static extern void RasterPos4d(double x, double y, double z, double w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4dv")] - public static extern void RasterPos4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4f")] - public static extern void RasterPos4f(float x, float y, float z, float w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4fv")] - public static extern void RasterPos4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4i")] - public static extern void RasterPos4i(int x, int y, int z, int w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4iv")] - public static extern void RasterPos4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4s")] - public static extern void RasterPos4s(short x, short y, short z, short w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4sv")] - public static extern void RasterPos4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRectd")] - public static extern void Rectd(double x1, double y1, double x2, double y2); - - [DllImport(_dll_name, EntryPoint = "glRectdv")] - public static extern void Rectdv(double[] v1, double[] v2); - - [DllImport(_dll_name, EntryPoint = "glRectf")] - public static extern void Rectf(float x1, float y1, float x2, float y2); - - [DllImport(_dll_name, EntryPoint = "glRectfv")] - public static extern void Rectfv(float[] v1, float[] v2); - - [DllImport(_dll_name, EntryPoint = "glRecti")] - public static extern void Recti(int x1, int y1, int x2, int y2); - - [DllImport(_dll_name, EntryPoint = "glRectiv")] - public static extern void Rectiv(int[] v1, int[] v2); - - [DllImport(_dll_name, EntryPoint = "glRects")] - public static extern void Rects(short x1, short y1, short x2, short y2); - - [DllImport(_dll_name, EntryPoint = "glRectsv")] - public static extern void Rectsv(short[] v1, short[] v2); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1d")] - public static extern void TexCoord1d(double s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1dv")] - public static extern void TexCoord1dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1f")] - public static extern void TexCoord1f(float s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1fv")] - public static extern void TexCoord1fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1i")] - public static extern void TexCoord1i(int s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1iv")] - public static extern void TexCoord1iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1s")] - public static extern void TexCoord1s(short s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1sv")] - public static extern void TexCoord1sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2d")] - public static extern void TexCoord2d(double s, double t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2dv")] - public static extern void TexCoord2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2f")] - public static extern void TexCoord2f(float s, float t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2fv")] - public static extern void TexCoord2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2i")] - public static extern void TexCoord2i(int s, int t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2iv")] - public static extern void TexCoord2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2s")] - public static extern void TexCoord2s(short s, short t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2sv")] - public static extern void TexCoord2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3d")] - public static extern void TexCoord3d(double s, double t, double r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3dv")] - public static extern void TexCoord3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3f")] - public static extern void TexCoord3f(float s, float t, float r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3fv")] - public static extern void TexCoord3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3i")] - public static extern void TexCoord3i(int s, int t, int r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3iv")] - public static extern void TexCoord3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3s")] - public static extern void TexCoord3s(short s, short t, short r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3sv")] - public static extern void TexCoord3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4d")] - public static extern void TexCoord4d(double s, double t, double r, double q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4dv")] - public static extern void TexCoord4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4f")] - public static extern void TexCoord4f(float s, float t, float r, float q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4fv")] - public static extern void TexCoord4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4i")] - public static extern void TexCoord4i(int s, int t, int r, int q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4iv")] - public static extern void TexCoord4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4s")] - public static extern void TexCoord4s(short s, short t, short r, short q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4sv")] - public static extern void TexCoord4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2d")] - public static extern void Vertex2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glVertex2dv")] - public static extern void Vertex2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2f")] - public static extern void Vertex2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glVertex2fv")] - public static extern void Vertex2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2i")] - public static extern void Vertex2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glVertex2iv")] - public static extern void Vertex2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2s")] - public static extern void Vertex2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glVertex2sv")] - public static extern void Vertex2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3d")] - public static extern void Vertex3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glVertex3dv")] - public static extern void Vertex3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3f")] - public static extern void Vertex3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glVertex3fv")] - public static extern void Vertex3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3i")] - public static extern void Vertex3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glVertex3iv")] - public static extern void Vertex3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3s")] - public static extern void Vertex3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glVertex3sv")] - public static extern void Vertex3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4d")] - public static extern void Vertex4d(double x, double y, double z, double w); - - [DllImport(_dll_name, EntryPoint = "glVertex4dv")] - public static extern void Vertex4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4f")] - public static extern void Vertex4f(float x, float y, float z, float w); - - [DllImport(_dll_name, EntryPoint = "glVertex4fv")] - public static extern void Vertex4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4i")] - public static extern void Vertex4i(int x, int y, int z, int w); - - [DllImport(_dll_name, EntryPoint = "glVertex4iv")] - public static extern void Vertex4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4s")] - public static extern void Vertex4s(short x, short y, short z, short w); - - [DllImport(_dll_name, EntryPoint = "glVertex4sv")] - public static extern void Vertex4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glClipPlane")] - public static extern void ClipPlane(Enums.ClipPlaneName plane, double[] equation); - - [DllImport(_dll_name, EntryPoint = "glColorMaterial")] - public static extern void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode); - - [DllImport(_dll_name, EntryPoint = "glCullFace")] - public static extern void CullFace(Enums.CullFaceMode mode); - - [DllImport(_dll_name, EntryPoint = "glFogf")] - public static extern void Fogf(Enums.FogParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glFogfv")] - public static extern void Fogfv(Enums.FogParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFogi")] - public static extern void Fogi(Enums.FogParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glFogiv")] - public static extern void Fogiv(Enums.FogParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFrontFace")] - public static extern void FrontFace(Enums.FrontFaceDirection mode); - - [DllImport(_dll_name, EntryPoint = "glHint")] - public static extern void Hint(Enums.HintTarget target, Enums.HintMode mode); - - [DllImport(_dll_name, EntryPoint = "glLightf")] - public static extern void Lightf(Enums.LightName light, Enums.LightParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glLightfv")] - public static extern void Lightfv(Enums.LightName light, Enums.LightParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLighti")] - public static extern void Lighti(Enums.LightName light, Enums.LightParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glLightiv")] - public static extern void Lightiv(Enums.LightName light, Enums.LightParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLightModelf")] - public static extern void LightModelf(Enums.LightModelParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glLightModelfv")] - public static extern void LightModelfv(Enums.LightModelParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLightModeli")] - public static extern void LightModeli(Enums.LightModelParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glLightModeliv")] - public static extern void LightModeliv(Enums.LightModelParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLineStipple")] - public static extern void LineStipple(int factor, ushort pattern); - - [DllImport(_dll_name, EntryPoint = "glLineWidth")] - public static extern void LineWidth(float width); - - [DllImport(_dll_name, EntryPoint = "glMaterialf")] - public static extern void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glMaterialfv")] - public static extern void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glMateriali")] - public static extern void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glMaterialiv")] - public static extern void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glPointSize")] - public static extern void PointSize(float size); - - [DllImport(_dll_name, EntryPoint = "glPolygonMode")] - public static extern void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode); - - [DllImport(_dll_name, EntryPoint = "glPolygonStipple")] - public static extern void PolygonStipple(byte[] mask); - - [DllImport(_dll_name, EntryPoint = "glScissor")] - public static extern void Scissor(int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glShadeModel")] - public static extern void ShadeModel(Enums.ShadingModel mode); - - [DllImport(_dll_name, EntryPoint = "glTexParameterf")] - public static extern void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexParameterfv")] - public static extern void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexParameteri")] - public static extern void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexParameteriv")] - public static extern void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexImage1D")] - public static extern void TexImage1D(Enums.TextureTarget target, int level, int internalformat, int width, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexImage2D")] - public static extern void TexImage2D(Enums.TextureTarget target, int level, int internalformat, int width, int height, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexEnvf")] - public static extern void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexEnvfv")] - public static extern void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexEnvi")] - public static extern void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexEnviv")] - public static extern void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGend")] - public static extern void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, double param); - - [DllImport(_dll_name, EntryPoint = "glTexGendv")] - public static extern void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGenf")] - public static extern void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexGenfv")] - public static extern void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGeni")] - public static extern void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexGeniv")] - public static extern void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFeedbackBuffer")] - public static extern void FeedbackBuffer(int size, Enums.FeedbackType type, out float[] buffer); - - [DllImport(_dll_name, EntryPoint = "glSelectBuffer")] - public static extern void SelectBuffer(int size, out uint[] buffer); - - [DllImport(_dll_name, EntryPoint = "glRenderMode")] - public static extern int RenderMode(Enums.RenderingMode mode); - - [DllImport(_dll_name, EntryPoint = "glInitNames")] - public static extern void InitNames(); - - [DllImport(_dll_name, EntryPoint = "glLoadName")] - public static extern void LoadName(uint name); - - [DllImport(_dll_name, EntryPoint = "glPassThrough")] - public static extern void PassThrough(float token); - - [DllImport(_dll_name, EntryPoint = "glPopName")] - public static extern void PopName(); - - [DllImport(_dll_name, EntryPoint = "glPushName")] - public static extern void PushName(uint name); - - [DllImport(_dll_name, EntryPoint = "glDrawBuffer")] - public static extern void DrawBuffer(Enums.DrawBufferMode mode); - - [DllImport(_dll_name, EntryPoint = "glClear")] - public static extern void Clear(Enums.ClearBufferMask mask); - - [DllImport(_dll_name, EntryPoint = "glClearAccum")] - public static extern void ClearAccum(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glClearIndex")] - public static extern void ClearIndex(float c); - - [DllImport(_dll_name, EntryPoint = "glClearColor")] - public static extern void ClearColor(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glClearStencil")] - public static extern void ClearStencil(int s); - - [DllImport(_dll_name, EntryPoint = "glClearDepth")] - public static extern void ClearDepth(double depth); - - [DllImport(_dll_name, EntryPoint = "glStencilMask")] - public static extern void StencilMask(uint mask); - - [DllImport(_dll_name, EntryPoint = "glColorMask")] - public static extern void ColorMask(bool red, bool green, bool blue, bool alpha); - - [DllImport(_dll_name, EntryPoint = "glDepthMask")] - public static extern void DepthMask(bool flag); - - [DllImport(_dll_name, EntryPoint = "glIndexMask")] - public static extern void IndexMask(uint mask); - - [DllImport(_dll_name, EntryPoint = "glAccum")] - public static extern void Accum(Enums.AccumOp op, float value); - - [DllImport(_dll_name, EntryPoint = "glDisable")] - public static extern void Disable(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glEnable")] - public static extern void Enable(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glFinish")] - public static extern void Finish(); - - [DllImport(_dll_name, EntryPoint = "glFlush")] - public static extern void Flush(); - - [DllImport(_dll_name, EntryPoint = "glPopAttrib")] - public static extern void PopAttrib(); - - [DllImport(_dll_name, EntryPoint = "glPushAttrib")] - public static extern void PushAttrib(Enums.AttribMask mask); - - [DllImport(_dll_name, EntryPoint = "glMap1d")] - public static extern void Map1d(Enums.MapTarget target, double u1, double u2, int stride, int order, double[] points); - - [DllImport(_dll_name, EntryPoint = "glMap1f")] - public static extern void Map1f(Enums.MapTarget target, float u1, float u2, int stride, int order, float[] points); - - [DllImport(_dll_name, EntryPoint = "glMap2d")] - public static extern void Map2d(Enums.MapTarget target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points); - - [DllImport(_dll_name, EntryPoint = "glMap2f")] - public static extern void Map2f(Enums.MapTarget target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points); - - [DllImport(_dll_name, EntryPoint = "glMapGrid1d")] - public static extern void MapGrid1d(int un, double u1, double u2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid1f")] - public static extern void MapGrid1f(int un, float u1, float u2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid2d")] - public static extern void MapGrid2d(int un, double u1, double u2, int vn, double v1, double v2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid2f")] - public static extern void MapGrid2f(int un, float u1, float u2, int vn, float v1, float v2); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1d")] - public static extern void EvalCoord1d(double u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1dv")] - public static extern void EvalCoord1dv(double[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1f")] - public static extern void EvalCoord1f(float u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1fv")] - public static extern void EvalCoord1fv(float[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2d")] - public static extern void EvalCoord2d(double u, double v); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2dv")] - public static extern void EvalCoord2dv(double[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2f")] - public static extern void EvalCoord2f(float u, float v); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2fv")] - public static extern void EvalCoord2fv(float[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalMesh1")] - public static extern void EvalMesh1(Enums.MeshMode1 mode, int i1, int i2); - - [DllImport(_dll_name, EntryPoint = "glEvalPoint1")] - public static extern void EvalPoint1(int i); - - [DllImport(_dll_name, EntryPoint = "glEvalMesh2")] - public static extern void EvalMesh2(Enums.MeshMode2 mode, int i1, int i2, int j1, int j2); - - [DllImport(_dll_name, EntryPoint = "glEvalPoint2")] - public static extern void EvalPoint2(int i, int j); - - [DllImport(_dll_name, EntryPoint = "glAlphaFunc")] - public static extern void AlphaFunc(Enums.AlphaFunction func, float reference); - - [DllImport(_dll_name, EntryPoint = "glBlendFunc")] - public static extern void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor); - - [DllImport(_dll_name, EntryPoint = "glLogicOp")] - public static extern void LogicOp(Enums.LogicOp opcode); - - [DllImport(_dll_name, EntryPoint = "glStencilFunc")] - public static extern void StencilFunc(Enums.StencilFunction func, int reference, uint mask); - - [DllImport(_dll_name, EntryPoint = "glStencilOp")] - public static extern void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass); - - [DllImport(_dll_name, EntryPoint = "glDepthFunc")] - public static extern void DepthFunc(Enums.DepthFunction func); - - [DllImport(_dll_name, EntryPoint = "glPixelZoom")] - public static extern void PixelZoom(float xfactor, float yfactor); - - [DllImport(_dll_name, EntryPoint = "glPixelTransferf")] - public static extern void PixelTransferf(Enums.PixelTransferParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPixelTransferi")] - public static extern void PixelTransferi(Enums.PixelTransferParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPixelStoref")] - public static extern void PixelStoref(Enums.PixelStoreParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPixelStorei")] - public static extern void PixelStorei(Enums.PixelStoreParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPixelMapfv")] - public static extern void PixelMapfv(Enums.PixelMap map, int mapsize, float[] values); - - [DllImport(_dll_name, EntryPoint = "glPixelMapuiv")] - public static extern void PixelMapuiv(Enums.PixelMap map, int mapsize, uint[] values); - - [DllImport(_dll_name, EntryPoint = "glPixelMapusv")] - public static extern void PixelMapusv(Enums.PixelMap map, int mapsize, ushort[] values); - - [DllImport(_dll_name, EntryPoint = "glReadBuffer")] - public static extern void ReadBuffer(Enums.ReadBufferMode mode); - - [DllImport(_dll_name, EntryPoint = "glCopyPixels")] - public static extern void CopyPixels(int x, int y, int width, int height, Enums.PixelCopyType type); - - [DllImport(_dll_name, EntryPoint = "glReadPixels")] - public static extern void ReadPixels(int x, int y, int width, int height, Enums.PixelFormat format, Enums.PixelType type, out object pixels); - - [DllImport(_dll_name, EntryPoint = "glDrawPixels")] - public static extern void DrawPixels(int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glGetBooleanv")] - public static extern void GetBooleanv(Enums.GetPName pname, out bool[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetClipPlane")] - public static extern void GetClipPlane(Enums.ClipPlaneName plane, out double[] equation); - - [DllImport(_dll_name, EntryPoint = "glGetDoublev")] - public static extern void GetDoublev(Enums.GetPName pname, out double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetError")] - public static extern Enums.ErrorCode GetError(); - - [DllImport(_dll_name, EntryPoint = "glGetFloatv")] - public static extern void GetFloatv(Enums.GetPName pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetIntegerv")] - public static extern void GetIntegerv(Enums.GetPName pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetLightfv")] - public static extern void GetLightfv(Enums.LightName light, Enums.LightParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetLightiv")] - public static extern void GetLightiv(Enums.LightName light, Enums.LightParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMapdv")] - public static extern void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, out double[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMapfv")] - public static extern void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, out float[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMapiv")] - public static extern void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, out int[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMaterialfv")] - public static extern void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMaterialiv")] - public static extern void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapfv")] - public static extern void GetPixelMapfv(Enums.PixelMap map, out float[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapuiv")] - public static extern void GetPixelMapuiv(Enums.PixelMap map, out uint[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapusv")] - public static extern void GetPixelMapusv(Enums.PixelMap map, out ushort[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPolygonStipple")] - public static extern void GetPolygonStipple(out byte[] mask); - - [DllImport(_dll_name, EntryPoint = "glGetString")] - public static extern string GetString(Enums.StringName name); - - [DllImport(_dll_name, EntryPoint = "glGetTexEnvfv")] - public static extern void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexEnviv")] - public static extern void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGendv")] - public static extern void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGenfv")] - public static extern void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGeniv")] - public static extern void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexImage")] - public static extern void GetTexImage(Enums.TextureTarget target, int level, Enums.PixelFormat format, Enums.PixelType type, out object pixels); - - [DllImport(_dll_name, EntryPoint = "glGetTexParameterfv")] - public static extern void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexParameteriv")] - public static extern void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexLevelParameterfv")] - public static extern void GetTexLevelParameterfv(Enums.TextureTarget target, int level, Enums.GetTextureParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexLevelParameteriv")] - public static extern void GetTexLevelParameteriv(Enums.TextureTarget target, int level, Enums.GetTextureParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glIsEnabled")] - public static extern bool IsEnabled(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glIsList")] - public static extern bool IsList(uint list); - - [DllImport(_dll_name, EntryPoint = "glDepthRange")] - public static extern void DepthRange(double near, double far); - - [DllImport(_dll_name, EntryPoint = "glFrustum")] - public static extern void Frustum(double left, double right, double bottom, double top, double zNear, double zFar); - - [DllImport(_dll_name, EntryPoint = "glLoadIdentity")] - public static extern void LoadIdentity(); - - [DllImport(_dll_name, EntryPoint = "glLoadMatrixf")] - public static extern void LoadMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glLoadMatrixd")] - public static extern void LoadMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glMatrixMode")] - public static extern void MatrixMode(Enums.MatrixMode mode); - - [DllImport(_dll_name, EntryPoint = "glMultMatrixf")] - public static extern void MultMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glMultMatrixd")] - public static extern void MultMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glOrtho")] - public static extern void Ortho(double left, double right, double bottom, double top, double zNear, double zFar); - - [DllImport(_dll_name, EntryPoint = "glPopMatrix")] - public static extern void PopMatrix(); - - [DllImport(_dll_name, EntryPoint = "glPushMatrix")] - public static extern void PushMatrix(); - - [DllImport(_dll_name, EntryPoint = "glRotated")] - public static extern void Rotated(double angle, double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glRotatef")] - public static extern void Rotatef(float angle, float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glScaled")] - public static extern void Scaled(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glScalef")] - public static extern void Scalef(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glTranslated")] - public static extern void Translated(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glTranslatef")] - public static extern void Translatef(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glViewport")] - public static extern void Viewport(int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glArrayElement")] - public static extern void ArrayElement(int i); - - [DllImport(_dll_name, EntryPoint = "glColorPointer")] - public static extern void ColorPointer(int size, Enums.ColorPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glDisableClientState")] - public static extern void DisableClientState(Enums.EnableCap array); - - [DllImport(_dll_name, EntryPoint = "glDrawArrays")] - public static extern void DrawArrays(Enums.BeginMode mode, int first, int count); - - [DllImport(_dll_name, EntryPoint = "glDrawElements")] - public static extern void DrawElements(Enums.BeginMode mode, int count, uint type, [MarshalAs(UnmanagedType.AsAny)] object indices); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlagPointer")] - public static extern void EdgeFlagPointer(int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glEnableClientState")] - public static extern void EnableClientState(Enums.EnableCap array); - - [DllImport(_dll_name, EntryPoint = "glGetPointerv")] - public static extern void GetPointerv(Enums.GetPointervPName pname, out object parameters); - - [DllImport(_dll_name, EntryPoint = "glIndexPointer")] - public static extern void IndexPointer(Enums.IndexPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glInterleavedArrays")] - public static extern void InterleavedArrays(Enums.InterleavedArrayFormat format, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glNormalPointer")] - public static extern void NormalPointer(Enums.NormalPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glTexCoordPointer")] - public static extern void TexCoordPointer(int size, Enums.TexCoordPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glVertexPointer")] - public static extern void VertexPointer(int size, Enums.VertexPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glPolygonOffset")] - public static extern void PolygonOffset(float factor, float units); - - [DllImport(_dll_name, EntryPoint = "glCopyTexImage1D")] - public static extern void CopyTexImage1D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int x, int y, int width, int border); - - [DllImport(_dll_name, EntryPoint = "glCopyTexImage2D")] - public static extern void CopyTexImage2D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int x, int y, int width, int height, int border); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage1D")] - public static extern void CopyTexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage2D")] - public static extern void CopyTexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage1D")] - public static extern void TexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int width, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage2D")] - public static extern void TexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glAreTexturesResident")] - public static extern bool AreTexturesResident(int n, uint[] textures, out bool[] residences); - - [DllImport(_dll_name, EntryPoint = "glBindTexture")] - public static extern void BindTexture(Enums.TextureTarget target, uint texture); - - [DllImport(_dll_name, EntryPoint = "glDeleteTextures")] - public static extern void DeleteTextures(int n, uint[] textures); - - [DllImport(_dll_name, EntryPoint = "glGenTextures")] - public static extern void GenTextures(int n, out uint[] textures); - - [DllImport(_dll_name, EntryPoint = "glIsTexture")] - public static extern bool IsTexture(uint texture); - - [DllImport(_dll_name, EntryPoint = "glPrioritizeTextures")] - public static extern void PrioritizeTextures(int n, uint[] textures, float[] priorities); - - [DllImport(_dll_name, EntryPoint = "glIndexub")] - public static extern void Indexub(byte c); - - [DllImport(_dll_name, EntryPoint = "glIndexubv")] - public static extern void Indexubv(byte[] c); - - [DllImport(_dll_name, EntryPoint = "glPopClientAttrib")] - public static extern void PopClientAttrib(); - - [DllImport(_dll_name, EntryPoint = "glPushClientAttrib")] - public static extern void PushClientAttrib(Enums.ClientAttribMask mask); - - [DllImport(_dll_name, EntryPoint = "glBlendColor")] - public static extern void BlendColor(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glBlendEquation")] - public static extern void BlendEquation(Enums.BlendEquationModeEXT mode); - - [DllImport(_dll_name, EntryPoint = "glDrawRangeElements")] - public static extern void DrawRangeElements(Enums.BeginMode mode, uint start, uint end, int count, uint type, [MarshalAs(UnmanagedType.AsAny)] object indices); - - [DllImport(_dll_name, EntryPoint = "glColorTable")] - public static extern void ColorTable(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, int width, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object table); - - [DllImport(_dll_name, EntryPoint = "glColorTableParameterfv")] - public static extern void ColorTableParameterfv(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glColorTableParameteriv")] - public static extern void ColorTableParameteriv(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glCopyColorTable")] - public static extern void CopyColorTable(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glGetColorTable")] - public static extern void GetColorTable(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, out object table); - - [DllImport(_dll_name, EntryPoint = "glGetColorTableParameterfv")] - public static extern void GetColorTableParameterfv(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetColorTableParameteriv")] - public static extern void GetColorTableParameteriv(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glColorSubTable")] - public static extern void ColorSubTable(Enums.ColorTableTargetSGI target, int start, int count, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCopyColorSubTable")] - public static extern void CopyColorSubTable(Enums.ColorTableTargetSGI target, int start, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glConvolutionFilter1D")] - public static extern void ConvolutionFilter1D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int width, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object image); - - [DllImport(_dll_name, EntryPoint = "glConvolutionFilter2D")] - public static extern void ConvolutionFilter2D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object image); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameterf")] - public static extern void ConvolutionParameterf(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, float parameters); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameterfv")] - public static extern void ConvolutionParameterfv(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameteri")] - public static extern void ConvolutionParameteri(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, int parameters); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameteriv")] - public static extern void ConvolutionParameteriv(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glCopyConvolutionFilter1D")] - public static extern void CopyConvolutionFilter1D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glCopyConvolutionFilter2D")] - public static extern void CopyConvolutionFilter2D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glGetConvolutionFilter")] - public static extern void GetConvolutionFilter(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, out object image); - - [DllImport(_dll_name, EntryPoint = "glGetConvolutionParameterfv")] - public static extern void GetConvolutionParameterfv(Enums.ConvolutionTargetEXT target, Enums.GetConvolutionParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetConvolutionParameteriv")] - public static extern void GetConvolutionParameteriv(Enums.ConvolutionTargetEXT target, Enums.GetConvolutionParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetSeparableFilter")] - public static extern void GetSeparableFilter(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, out object row, out object column, out object span); - - [DllImport(_dll_name, EntryPoint = "glSeparableFilter2D")] - public static extern void SeparableFilter2D(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object row, [MarshalAs(UnmanagedType.AsAny)] object column); - - [DllImport(_dll_name, EntryPoint = "glGetHistogram")] - public static extern void GetHistogram(Enums.HistogramTargetEXT target, bool reset, Enums.PixelFormat format, Enums.PixelType type, out object values); - - [DllImport(_dll_name, EntryPoint = "glGetHistogramParameterfv")] - public static extern void GetHistogramParameterfv(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetHistogramParameteriv")] - public static extern void GetHistogramParameteriv(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMinmax")] - public static extern void GetMinmax(Enums.MinmaxTargetEXT target, bool reset, Enums.PixelFormat format, Enums.PixelType type, out object values); - - [DllImport(_dll_name, EntryPoint = "glGetMinmaxParameterfv")] - public static extern void GetMinmaxParameterfv(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMinmaxParameteriv")] - public static extern void GetMinmaxParameteriv(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glHistogram")] - public static extern void Histogram(Enums.HistogramTargetEXT target, int width, Enums.PixelInternalFormat internalformat, bool sink); - - [DllImport(_dll_name, EntryPoint = "glMinmax")] - public static extern void Minmax(Enums.MinmaxTargetEXT target, Enums.PixelInternalFormat internalformat, bool sink); - - [DllImport(_dll_name, EntryPoint = "glResetHistogram")] - public static extern void ResetHistogram(Enums.HistogramTargetEXT target); - - [DllImport(_dll_name, EntryPoint = "glResetMinmax")] - public static extern void ResetMinmax(Enums.MinmaxTargetEXT target); - - [DllImport(_dll_name, EntryPoint = "glTexImage3D")] - public static extern void TexImage3D(Enums.TextureTarget target, int level, int internalformat, int width, int height, int depth, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage3D")] - public static extern void TexSubImage3D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage3D")] - public static extern void CopyTexSubImage3D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glActiveTexture")] - public static extern void ActiveTexture(uint texture); - - [DllImport(_dll_name, EntryPoint = "glClientActiveTexture")] - public static extern void ClientActiveTexture(uint texture); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1d")] - public static extern void MultiTexCoord1d(uint target, double s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1dv")] - public static extern void MultiTexCoord1dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1f")] - public static extern void MultiTexCoord1f(uint target, float s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1fv")] - public static extern void MultiTexCoord1fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1i")] - public static extern void MultiTexCoord1i(uint target, int s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1iv")] - public static extern void MultiTexCoord1iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1s")] - public static extern void MultiTexCoord1s(uint target, short s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1sv")] - public static extern void MultiTexCoord1sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2d")] - public static extern void MultiTexCoord2d(uint target, double s, double t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2dv")] - public static extern void MultiTexCoord2dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2f")] - public static extern void MultiTexCoord2f(uint target, float s, float t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2fv")] - public static extern void MultiTexCoord2fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2i")] - public static extern void MultiTexCoord2i(uint target, int s, int t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2iv")] - public static extern void MultiTexCoord2iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2s")] - public static extern void MultiTexCoord2s(uint target, short s, short t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2sv")] - public static extern void MultiTexCoord2sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3d")] - public static extern void MultiTexCoord3d(uint target, double s, double t, double r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3dv")] - public static extern void MultiTexCoord3dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3f")] - public static extern void MultiTexCoord3f(uint target, float s, float t, float r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3fv")] - public static extern void MultiTexCoord3fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3i")] - public static extern void MultiTexCoord3i(uint target, int s, int t, int r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3iv")] - public static extern void MultiTexCoord3iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3s")] - public static extern void MultiTexCoord3s(uint target, short s, short t, short r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3sv")] - public static extern void MultiTexCoord3sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4d")] - public static extern void MultiTexCoord4d(uint target, double s, double t, double r, double q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4dv")] - public static extern void MultiTexCoord4dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4f")] - public static extern void MultiTexCoord4f(uint target, float s, float t, float r, float q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4fv")] - public static extern void MultiTexCoord4fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4i")] - public static extern void MultiTexCoord4i(uint target, int s, int t, int r, int q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4iv")] - public static extern void MultiTexCoord4iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4s")] - public static extern void MultiTexCoord4s(uint target, short s, short t, short r, short q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4sv")] - public static extern void MultiTexCoord4sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glLoadTransposeMatrixf")] - public static extern void LoadTransposeMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glLoadTransposeMatrixd")] - public static extern void LoadTransposeMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glMultTransposeMatrixf")] - public static extern void MultTransposeMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glMultTransposeMatrixd")] - public static extern void MultTransposeMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glSampleCoverage")] - public static extern void SampleCoverage(float value, bool invert); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexImage3D")] - public static extern void CompressedTexImage3D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int width, int height, int depth, int border, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexImage2D")] - public static extern void CompressedTexImage2D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int width, int height, int border, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexImage1D")] - public static extern void CompressedTexImage1D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int width, int border, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexSubImage3D")] - public static extern void CompressedTexSubImage3D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, Enums.PixelFormat format, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexSubImage2D")] - public static extern void CompressedTexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int width, int height, Enums.PixelFormat format, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexSubImage1D")] - public static extern void CompressedTexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int width, Enums.PixelFormat format, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glGetCompressedTexImage")] - public static extern void GetCompressedTexImage(Enums.TextureTarget target, int level, out object img); - - [DllImport(_dll_name, EntryPoint = "glBlendFuncSeparate")] - public static extern void BlendFuncSeparate(uint sfactorRGB, uint dfactorRGB, uint sfactorAlpha, uint dfactorAlpha); - - [DllImport(_dll_name, EntryPoint = "glFogCoordf")] - public static extern void FogCoordf(float coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoordfv")] - public static extern void FogCoordfv(float[] coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoordd")] - public static extern void FogCoordd(double coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoorddv")] - public static extern void FogCoorddv(double[] coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoordPointer")] - public static extern void FogCoordPointer(uint type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glMultiDrawArrays")] - public static extern void MultiDrawArrays(Enums.BeginMode mode, out int[] first, out int[] count, int primcount); - - [DllImport(_dll_name, EntryPoint = "glMultiDrawElements")] - public static extern void MultiDrawElements(Enums.BeginMode mode, int[] count, uint type, [MarshalAs(UnmanagedType.AsAny)] object indices, int primcount); - - [DllImport(_dll_name, EntryPoint = "glPointParameterf")] - public static extern void PointParameterf(Enums.PointParameterNameSGIS pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPointParameterfv")] - public static extern void PointParameterfv(Enums.PointParameterNameSGIS pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glPointParameteri")] - public static extern void PointParameteri(Enums.PointParameterNameSGIS pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPointParameteriv")] - public static extern void PointParameteriv(Enums.PointParameterNameSGIS pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3b")] - public static extern void SecondaryColor3b(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3bv")] - public static extern void SecondaryColor3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3d")] - public static extern void SecondaryColor3d(double red, double green, double blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3dv")] - public static extern void SecondaryColor3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3f")] - public static extern void SecondaryColor3f(float red, float green, float blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3fv")] - public static extern void SecondaryColor3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3i")] - public static extern void SecondaryColor3i(int red, int green, int blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3iv")] - public static extern void SecondaryColor3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3s")] - public static extern void SecondaryColor3s(short red, short green, short blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3sv")] - public static extern void SecondaryColor3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3ub")] - public static extern void SecondaryColor3ub(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3ubv")] - public static extern void SecondaryColor3ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3ui")] - public static extern void SecondaryColor3ui(uint red, uint green, uint blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3uiv")] - public static extern void SecondaryColor3uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3us")] - public static extern void SecondaryColor3us(ushort red, ushort green, ushort blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3usv")] - public static extern void SecondaryColor3usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColorPointer")] - public static extern void SecondaryColorPointer(int size, Enums.ColorPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2d")] - public static extern void WindowPos2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2dv")] - public static extern void WindowPos2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2f")] - public static extern void WindowPos2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2fv")] - public static extern void WindowPos2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2i")] - public static extern void WindowPos2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2iv")] - public static extern void WindowPos2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2s")] - public static extern void WindowPos2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2sv")] - public static extern void WindowPos2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3d")] - public static extern void WindowPos3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3dv")] - public static extern void WindowPos3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3f")] - public static extern void WindowPos3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3fv")] - public static extern void WindowPos3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3i")] - public static extern void WindowPos3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3iv")] - public static extern void WindowPos3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3s")] - public static extern void WindowPos3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3sv")] - public static extern void WindowPos3sv(short[] v); - - } - #endregion - - #region Load core - - /// - /// Loads the core opengl functions (versions 1.0-2.0). - /// public override void Load() { - if (GL.CoreLoaded) return; - if (GL.ExtensionsLoaded) return; - GL.NewList = new GL.Delegates.NewList(Imports.NewList); - GL.EndList = new GL.Delegates.EndList(Imports.EndList); - GL.CallList = new GL.Delegates.CallList(Imports.CallList); - GL.CallLists = new GL.Delegates.CallLists(Imports.CallLists); - GL.DeleteLists = new GL.Delegates.DeleteLists(Imports.DeleteLists); - GL.GenLists = new GL.Delegates.GenLists(Imports.GenLists); - GL.ListBase = new GL.Delegates.ListBase(Imports.ListBase); - GL.Begin = new GL.Delegates.Begin(Imports.Begin); - GL.Bitmap = new GL.Delegates.Bitmap(Imports.Bitmap); - GL.Color3b = new GL.Delegates.Color3b(Imports.Color3b); - GL.Color3bv = new GL.Delegates.Color3bv(Imports.Color3bv); - GL.Color3d = new GL.Delegates.Color3d(Imports.Color3d); - GL.Color3dv = new GL.Delegates.Color3dv(Imports.Color3dv); - GL.Color3f = new GL.Delegates.Color3f(Imports.Color3f); - GL.Color3fv = new GL.Delegates.Color3fv(Imports.Color3fv); - GL.Color3i = new GL.Delegates.Color3i(Imports.Color3i); - GL.Color3iv = new GL.Delegates.Color3iv(Imports.Color3iv); - GL.Color3s = new GL.Delegates.Color3s(Imports.Color3s); - GL.Color3sv = new GL.Delegates.Color3sv(Imports.Color3sv); - GL.Color3ub = new GL.Delegates.Color3ub(Imports.Color3ub); - GL.Color3ubv = new GL.Delegates.Color3ubv(Imports.Color3ubv); - GL.Color3ui = new GL.Delegates.Color3ui(Imports.Color3ui); - GL.Color3uiv = new GL.Delegates.Color3uiv(Imports.Color3uiv); - GL.Color3us = new GL.Delegates.Color3us(Imports.Color3us); - GL.Color3usv = new GL.Delegates.Color3usv(Imports.Color3usv); - GL.Color4b = new GL.Delegates.Color4b(Imports.Color4b); - GL.Color4bv = new GL.Delegates.Color4bv(Imports.Color4bv); - GL.Color4d = new GL.Delegates.Color4d(Imports.Color4d); - GL.Color4dv = new GL.Delegates.Color4dv(Imports.Color4dv); - GL.Color4f = new GL.Delegates.Color4f(Imports.Color4f); - GL.Color4fv = new GL.Delegates.Color4fv(Imports.Color4fv); - GL.Color4i = new GL.Delegates.Color4i(Imports.Color4i); - GL.Color4iv = new GL.Delegates.Color4iv(Imports.Color4iv); - GL.Color4s = new GL.Delegates.Color4s(Imports.Color4s); - GL.Color4sv = new GL.Delegates.Color4sv(Imports.Color4sv); - GL.Color4ub = new GL.Delegates.Color4ub(Imports.Color4ub); - GL.Color4ubv = new GL.Delegates.Color4ubv(Imports.Color4ubv); - GL.Color4ui = new GL.Delegates.Color4ui(Imports.Color4ui); - GL.Color4uiv = new GL.Delegates.Color4uiv(Imports.Color4uiv); - GL.Color4us = new GL.Delegates.Color4us(Imports.Color4us); - GL.Color4usv = new GL.Delegates.Color4usv(Imports.Color4usv); - GL.EdgeFlag = new GL.Delegates.EdgeFlag(Imports.EdgeFlag); - GL.EdgeFlagv = new GL.Delegates.EdgeFlagv(Imports.EdgeFlagv); - GL.End = new GL.Delegates.End(Imports.End); - GL.Indexd = new GL.Delegates.Indexd(Imports.Indexd); - GL.Indexdv = new GL.Delegates.Indexdv(Imports.Indexdv); - GL.Indexf = new GL.Delegates.Indexf(Imports.Indexf); - GL.Indexfv = new GL.Delegates.Indexfv(Imports.Indexfv); - GL.Indexi = new GL.Delegates.Indexi(Imports.Indexi); - GL.Indexiv = new GL.Delegates.Indexiv(Imports.Indexiv); - GL.Indexs = new GL.Delegates.Indexs(Imports.Indexs); - GL.Indexsv = new GL.Delegates.Indexsv(Imports.Indexsv); - GL.Normal3b = new GL.Delegates.Normal3b(Imports.Normal3b); - GL.Normal3bv = new GL.Delegates.Normal3bv(Imports.Normal3bv); - GL.Normal3d = new GL.Delegates.Normal3d(Imports.Normal3d); - GL.Normal3dv = new GL.Delegates.Normal3dv(Imports.Normal3dv); - GL.Normal3f = new GL.Delegates.Normal3f(Imports.Normal3f); - GL.Normal3fv = new GL.Delegates.Normal3fv(Imports.Normal3fv); - GL.Normal3i = new GL.Delegates.Normal3i(Imports.Normal3i); - GL.Normal3iv = new GL.Delegates.Normal3iv(Imports.Normal3iv); - GL.Normal3s = new GL.Delegates.Normal3s(Imports.Normal3s); - GL.Normal3sv = new GL.Delegates.Normal3sv(Imports.Normal3sv); - GL.RasterPos2d = new GL.Delegates.RasterPos2d(Imports.RasterPos2d); - GL.RasterPos2dv = new GL.Delegates.RasterPos2dv(Imports.RasterPos2dv); - GL.RasterPos2f = new GL.Delegates.RasterPos2f(Imports.RasterPos2f); - GL.RasterPos2fv = new GL.Delegates.RasterPos2fv(Imports.RasterPos2fv); - GL.RasterPos2i = new GL.Delegates.RasterPos2i(Imports.RasterPos2i); - GL.RasterPos2iv = new GL.Delegates.RasterPos2iv(Imports.RasterPos2iv); - GL.RasterPos2s = new GL.Delegates.RasterPos2s(Imports.RasterPos2s); - GL.RasterPos2sv = new GL.Delegates.RasterPos2sv(Imports.RasterPos2sv); - GL.RasterPos3d = new GL.Delegates.RasterPos3d(Imports.RasterPos3d); - GL.RasterPos3dv = new GL.Delegates.RasterPos3dv(Imports.RasterPos3dv); - GL.RasterPos3f = new GL.Delegates.RasterPos3f(Imports.RasterPos3f); - GL.RasterPos3fv = new GL.Delegates.RasterPos3fv(Imports.RasterPos3fv); - GL.RasterPos3i = new GL.Delegates.RasterPos3i(Imports.RasterPos3i); - GL.RasterPos3iv = new GL.Delegates.RasterPos3iv(Imports.RasterPos3iv); - GL.RasterPos3s = new GL.Delegates.RasterPos3s(Imports.RasterPos3s); - GL.RasterPos3sv = new GL.Delegates.RasterPos3sv(Imports.RasterPos3sv); - GL.RasterPos4d = new GL.Delegates.RasterPos4d(Imports.RasterPos4d); - GL.RasterPos4dv = new GL.Delegates.RasterPos4dv(Imports.RasterPos4dv); - GL.RasterPos4f = new GL.Delegates.RasterPos4f(Imports.RasterPos4f); - GL.RasterPos4fv = new GL.Delegates.RasterPos4fv(Imports.RasterPos4fv); - GL.RasterPos4i = new GL.Delegates.RasterPos4i(Imports.RasterPos4i); - GL.RasterPos4iv = new GL.Delegates.RasterPos4iv(Imports.RasterPos4iv); - GL.RasterPos4s = new GL.Delegates.RasterPos4s(Imports.RasterPos4s); - GL.RasterPos4sv = new GL.Delegates.RasterPos4sv(Imports.RasterPos4sv); - GL.Rectd = new GL.Delegates.Rectd(Imports.Rectd); - GL.Rectdv = new GL.Delegates.Rectdv(Imports.Rectdv); - GL.Rectf = new GL.Delegates.Rectf(Imports.Rectf); - GL.Rectfv = new GL.Delegates.Rectfv(Imports.Rectfv); - GL.Recti = new GL.Delegates.Recti(Imports.Recti); - GL.Rectiv = new GL.Delegates.Rectiv(Imports.Rectiv); - GL.Rects = new GL.Delegates.Rects(Imports.Rects); - GL.Rectsv = new GL.Delegates.Rectsv(Imports.Rectsv); - GL.TexCoord1d = new GL.Delegates.TexCoord1d(Imports.TexCoord1d); - GL.TexCoord1dv = new GL.Delegates.TexCoord1dv(Imports.TexCoord1dv); - GL.TexCoord1f = new GL.Delegates.TexCoord1f(Imports.TexCoord1f); - GL.TexCoord1fv = new GL.Delegates.TexCoord1fv(Imports.TexCoord1fv); - GL.TexCoord1i = new GL.Delegates.TexCoord1i(Imports.TexCoord1i); - GL.TexCoord1iv = new GL.Delegates.TexCoord1iv(Imports.TexCoord1iv); - GL.TexCoord1s = new GL.Delegates.TexCoord1s(Imports.TexCoord1s); - GL.TexCoord1sv = new GL.Delegates.TexCoord1sv(Imports.TexCoord1sv); - GL.TexCoord2d = new GL.Delegates.TexCoord2d(Imports.TexCoord2d); - GL.TexCoord2dv = new GL.Delegates.TexCoord2dv(Imports.TexCoord2dv); - GL.TexCoord2f = new GL.Delegates.TexCoord2f(Imports.TexCoord2f); - GL.TexCoord2fv = new GL.Delegates.TexCoord2fv(Imports.TexCoord2fv); - GL.TexCoord2i = new GL.Delegates.TexCoord2i(Imports.TexCoord2i); - GL.TexCoord2iv = new GL.Delegates.TexCoord2iv(Imports.TexCoord2iv); - GL.TexCoord2s = new GL.Delegates.TexCoord2s(Imports.TexCoord2s); - GL.TexCoord2sv = new GL.Delegates.TexCoord2sv(Imports.TexCoord2sv); - GL.TexCoord3d = new GL.Delegates.TexCoord3d(Imports.TexCoord3d); - GL.TexCoord3dv = new GL.Delegates.TexCoord3dv(Imports.TexCoord3dv); - GL.TexCoord3f = new GL.Delegates.TexCoord3f(Imports.TexCoord3f); - GL.TexCoord3fv = new GL.Delegates.TexCoord3fv(Imports.TexCoord3fv); - GL.TexCoord3i = new GL.Delegates.TexCoord3i(Imports.TexCoord3i); - GL.TexCoord3iv = new GL.Delegates.TexCoord3iv(Imports.TexCoord3iv); - GL.TexCoord3s = new GL.Delegates.TexCoord3s(Imports.TexCoord3s); - GL.TexCoord3sv = new GL.Delegates.TexCoord3sv(Imports.TexCoord3sv); - GL.TexCoord4d = new GL.Delegates.TexCoord4d(Imports.TexCoord4d); - GL.TexCoord4dv = new GL.Delegates.TexCoord4dv(Imports.TexCoord4dv); - GL.TexCoord4f = new GL.Delegates.TexCoord4f(Imports.TexCoord4f); - GL.TexCoord4fv = new GL.Delegates.TexCoord4fv(Imports.TexCoord4fv); - GL.TexCoord4i = new GL.Delegates.TexCoord4i(Imports.TexCoord4i); - GL.TexCoord4iv = new GL.Delegates.TexCoord4iv(Imports.TexCoord4iv); - GL.TexCoord4s = new GL.Delegates.TexCoord4s(Imports.TexCoord4s); - GL.TexCoord4sv = new GL.Delegates.TexCoord4sv(Imports.TexCoord4sv); - GL.Vertex2d = new GL.Delegates.Vertex2d(Imports.Vertex2d); - GL.Vertex2dv = new GL.Delegates.Vertex2dv(Imports.Vertex2dv); - GL.Vertex2f = new GL.Delegates.Vertex2f(Imports.Vertex2f); - GL.Vertex2fv = new GL.Delegates.Vertex2fv(Imports.Vertex2fv); - GL.Vertex2i = new GL.Delegates.Vertex2i(Imports.Vertex2i); - GL.Vertex2iv = new GL.Delegates.Vertex2iv(Imports.Vertex2iv); - GL.Vertex2s = new GL.Delegates.Vertex2s(Imports.Vertex2s); - GL.Vertex2sv = new GL.Delegates.Vertex2sv(Imports.Vertex2sv); - GL.Vertex3d = new GL.Delegates.Vertex3d(Imports.Vertex3d); - GL.Vertex3dv = new GL.Delegates.Vertex3dv(Imports.Vertex3dv); - GL.Vertex3f = new GL.Delegates.Vertex3f(Imports.Vertex3f); - GL.Vertex3fv = new GL.Delegates.Vertex3fv(Imports.Vertex3fv); - GL.Vertex3i = new GL.Delegates.Vertex3i(Imports.Vertex3i); - GL.Vertex3iv = new GL.Delegates.Vertex3iv(Imports.Vertex3iv); - GL.Vertex3s = new GL.Delegates.Vertex3s(Imports.Vertex3s); - GL.Vertex3sv = new GL.Delegates.Vertex3sv(Imports.Vertex3sv); - GL.Vertex4d = new GL.Delegates.Vertex4d(Imports.Vertex4d); - GL.Vertex4dv = new GL.Delegates.Vertex4dv(Imports.Vertex4dv); - GL.Vertex4f = new GL.Delegates.Vertex4f(Imports.Vertex4f); - GL.Vertex4fv = new GL.Delegates.Vertex4fv(Imports.Vertex4fv); - GL.Vertex4i = new GL.Delegates.Vertex4i(Imports.Vertex4i); - GL.Vertex4iv = new GL.Delegates.Vertex4iv(Imports.Vertex4iv); - GL.Vertex4s = new GL.Delegates.Vertex4s(Imports.Vertex4s); - GL.Vertex4sv = new GL.Delegates.Vertex4sv(Imports.Vertex4sv); - GL.ClipPlane = new GL.Delegates.ClipPlane(Imports.ClipPlane); - GL.ColorMaterial = new GL.Delegates.ColorMaterial(Imports.ColorMaterial); - GL.CullFace = new GL.Delegates.CullFace(Imports.CullFace); - GL.Fogf = new GL.Delegates.Fogf(Imports.Fogf); - GL.Fogfv = new GL.Delegates.Fogfv(Imports.Fogfv); - GL.Fogi = new GL.Delegates.Fogi(Imports.Fogi); - GL.Fogiv = new GL.Delegates.Fogiv(Imports.Fogiv); - GL.FrontFace = new GL.Delegates.FrontFace(Imports.FrontFace); - GL.Hint = new GL.Delegates.Hint(Imports.Hint); - GL.Lightf = new GL.Delegates.Lightf(Imports.Lightf); - GL.Lightfv = new GL.Delegates.Lightfv(Imports.Lightfv); - GL.Lighti = new GL.Delegates.Lighti(Imports.Lighti); - GL.Lightiv = new GL.Delegates.Lightiv(Imports.Lightiv); - GL.LightModelf = new GL.Delegates.LightModelf(Imports.LightModelf); - GL.LightModelfv = new GL.Delegates.LightModelfv(Imports.LightModelfv); - GL.LightModeli = new GL.Delegates.LightModeli(Imports.LightModeli); - GL.LightModeliv = new GL.Delegates.LightModeliv(Imports.LightModeliv); - GL.LineStipple = new GL.Delegates.LineStipple(Imports.LineStipple); - GL.LineWidth = new GL.Delegates.LineWidth(Imports.LineWidth); - GL.Materialf = new GL.Delegates.Materialf(Imports.Materialf); - GL.Materialfv = new GL.Delegates.Materialfv(Imports.Materialfv); - GL.Materiali = new GL.Delegates.Materiali(Imports.Materiali); - GL.Materialiv = new GL.Delegates.Materialiv(Imports.Materialiv); - GL.PointSize = new GL.Delegates.PointSize(Imports.PointSize); - GL.PolygonMode = new GL.Delegates.PolygonMode(Imports.PolygonMode); - GL.PolygonStipple = new GL.Delegates.PolygonStipple(Imports.PolygonStipple); - GL.Scissor = new GL.Delegates.Scissor(Imports.Scissor); - GL.ShadeModel = new GL.Delegates.ShadeModel(Imports.ShadeModel); - GL.TexParameterf = new GL.Delegates.TexParameterf(Imports.TexParameterf); - GL.TexParameterfv = new GL.Delegates.TexParameterfv(Imports.TexParameterfv); - GL.TexParameteri = new GL.Delegates.TexParameteri(Imports.TexParameteri); - GL.TexParameteriv = new GL.Delegates.TexParameteriv(Imports.TexParameteriv); - GL.TexImage1D = new GL.Delegates.TexImage1D(Imports.TexImage1D); - GL.TexImage2D = new GL.Delegates.TexImage2D(Imports.TexImage2D); - GL.TexEnvf = new GL.Delegates.TexEnvf(Imports.TexEnvf); - GL.TexEnvfv = new GL.Delegates.TexEnvfv(Imports.TexEnvfv); - GL.TexEnvi = new GL.Delegates.TexEnvi(Imports.TexEnvi); - GL.TexEnviv = new GL.Delegates.TexEnviv(Imports.TexEnviv); - GL.TexGend = new GL.Delegates.TexGend(Imports.TexGend); - GL.TexGendv = new GL.Delegates.TexGendv(Imports.TexGendv); - GL.TexGenf = new GL.Delegates.TexGenf(Imports.TexGenf); - GL.TexGenfv = new GL.Delegates.TexGenfv(Imports.TexGenfv); - GL.TexGeni = new GL.Delegates.TexGeni(Imports.TexGeni); - GL.TexGeniv = new GL.Delegates.TexGeniv(Imports.TexGeniv); - GL.FeedbackBuffer = new GL.Delegates.FeedbackBuffer(Imports.FeedbackBuffer); - GL.SelectBuffer = new GL.Delegates.SelectBuffer(Imports.SelectBuffer); - GL.RenderMode = new GL.Delegates.RenderMode(Imports.RenderMode); - GL.InitNames = new GL.Delegates.InitNames(Imports.InitNames); - GL.LoadName = new GL.Delegates.LoadName(Imports.LoadName); - GL.PassThrough = new GL.Delegates.PassThrough(Imports.PassThrough); - GL.PopName = new GL.Delegates.PopName(Imports.PopName); - GL.PushName = new GL.Delegates.PushName(Imports.PushName); - GL.DrawBuffer = new GL.Delegates.DrawBuffer(Imports.DrawBuffer); - GL.Clear = new GL.Delegates.Clear(Imports.Clear); - GL.ClearAccum = new GL.Delegates.ClearAccum(Imports.ClearAccum); - GL.ClearIndex = new GL.Delegates.ClearIndex(Imports.ClearIndex); - GL.ClearColor = new GL.Delegates.ClearColor(Imports.ClearColor); - GL.ClearStencil = new GL.Delegates.ClearStencil(Imports.ClearStencil); - GL.ClearDepth = new GL.Delegates.ClearDepth(Imports.ClearDepth); - GL.StencilMask = new GL.Delegates.StencilMask(Imports.StencilMask); - GL.ColorMask = new GL.Delegates.ColorMask(Imports.ColorMask); - GL.DepthMask = new GL.Delegates.DepthMask(Imports.DepthMask); - GL.IndexMask = new GL.Delegates.IndexMask(Imports.IndexMask); - GL.Accum = new GL.Delegates.Accum(Imports.Accum); - GL.Disable = new GL.Delegates.Disable(Imports.Disable); - GL.Enable = new GL.Delegates.Enable(Imports.Enable); - GL.Finish = new GL.Delegates.Finish(Imports.Finish); - GL.Flush = new GL.Delegates.Flush(Imports.Flush); - GL.PopAttrib = new GL.Delegates.PopAttrib(Imports.PopAttrib); - GL.PushAttrib = new GL.Delegates.PushAttrib(Imports.PushAttrib); - GL.Map1d = new GL.Delegates.Map1d(Imports.Map1d); - GL.Map1f = new GL.Delegates.Map1f(Imports.Map1f); - GL.Map2d = new GL.Delegates.Map2d(Imports.Map2d); - GL.Map2f = new GL.Delegates.Map2f(Imports.Map2f); - GL.MapGrid1d = new GL.Delegates.MapGrid1d(Imports.MapGrid1d); - GL.MapGrid1f = new GL.Delegates.MapGrid1f(Imports.MapGrid1f); - GL.MapGrid2d = new GL.Delegates.MapGrid2d(Imports.MapGrid2d); - GL.MapGrid2f = new GL.Delegates.MapGrid2f(Imports.MapGrid2f); - GL.EvalCoord1d = new GL.Delegates.EvalCoord1d(Imports.EvalCoord1d); - GL.EvalCoord1dv = new GL.Delegates.EvalCoord1dv(Imports.EvalCoord1dv); - GL.EvalCoord1f = new GL.Delegates.EvalCoord1f(Imports.EvalCoord1f); - GL.EvalCoord1fv = new GL.Delegates.EvalCoord1fv(Imports.EvalCoord1fv); - GL.EvalCoord2d = new GL.Delegates.EvalCoord2d(Imports.EvalCoord2d); - GL.EvalCoord2dv = new GL.Delegates.EvalCoord2dv(Imports.EvalCoord2dv); - GL.EvalCoord2f = new GL.Delegates.EvalCoord2f(Imports.EvalCoord2f); - GL.EvalCoord2fv = new GL.Delegates.EvalCoord2fv(Imports.EvalCoord2fv); - GL.EvalMesh1 = new GL.Delegates.EvalMesh1(Imports.EvalMesh1); - GL.EvalPoint1 = new GL.Delegates.EvalPoint1(Imports.EvalPoint1); - GL.EvalMesh2 = new GL.Delegates.EvalMesh2(Imports.EvalMesh2); - GL.EvalPoint2 = new GL.Delegates.EvalPoint2(Imports.EvalPoint2); - GL.AlphaFunc = new GL.Delegates.AlphaFunc(Imports.AlphaFunc); - GL.BlendFunc = new GL.Delegates.BlendFunc(Imports.BlendFunc); - GL.LogicOp = new GL.Delegates.LogicOp(Imports.LogicOp); - GL.StencilFunc = new GL.Delegates.StencilFunc(Imports.StencilFunc); - GL.StencilOp = new GL.Delegates.StencilOp(Imports.StencilOp); - GL.DepthFunc = new GL.Delegates.DepthFunc(Imports.DepthFunc); - GL.PixelZoom = new GL.Delegates.PixelZoom(Imports.PixelZoom); - GL.PixelTransferf = new GL.Delegates.PixelTransferf(Imports.PixelTransferf); - GL.PixelTransferi = new GL.Delegates.PixelTransferi(Imports.PixelTransferi); - GL.PixelStoref = new GL.Delegates.PixelStoref(Imports.PixelStoref); - GL.PixelStorei = new GL.Delegates.PixelStorei(Imports.PixelStorei); - GL.PixelMapfv = new GL.Delegates.PixelMapfv(Imports.PixelMapfv); - GL.PixelMapuiv = new GL.Delegates.PixelMapuiv(Imports.PixelMapuiv); - GL.PixelMapusv = new GL.Delegates.PixelMapusv(Imports.PixelMapusv); - GL.ReadBuffer = new GL.Delegates.ReadBuffer(Imports.ReadBuffer); - GL.CopyPixels = new GL.Delegates.CopyPixels(Imports.CopyPixels); - GL.ReadPixels = new GL.Delegates.ReadPixels(Imports.ReadPixels); - GL.DrawPixels = new GL.Delegates.DrawPixels(Imports.DrawPixels); - GL.GetBooleanv = new GL.Delegates.GetBooleanv(Imports.GetBooleanv); - GL.GetClipPlane = new GL.Delegates.GetClipPlane(Imports.GetClipPlane); - GL.GetDoublev = new GL.Delegates.GetDoublev(Imports.GetDoublev); - GL.GetError = new GL.Delegates.GetError(Imports.GetError); - GL.GetFloatv = new GL.Delegates.GetFloatv(Imports.GetFloatv); - GL.GetIntegerv = new GL.Delegates.GetIntegerv(Imports.GetIntegerv); - GL.GetLightfv = new GL.Delegates.GetLightfv(Imports.GetLightfv); - GL.GetLightiv = new GL.Delegates.GetLightiv(Imports.GetLightiv); - GL.GetMapdv = new GL.Delegates.GetMapdv(Imports.GetMapdv); - GL.GetMapfv = new GL.Delegates.GetMapfv(Imports.GetMapfv); - GL.GetMapiv = new GL.Delegates.GetMapiv(Imports.GetMapiv); - GL.GetMaterialfv = new GL.Delegates.GetMaterialfv(Imports.GetMaterialfv); - GL.GetMaterialiv = new GL.Delegates.GetMaterialiv(Imports.GetMaterialiv); - GL.GetPixelMapfv = new GL.Delegates.GetPixelMapfv(Imports.GetPixelMapfv); - GL.GetPixelMapuiv = new GL.Delegates.GetPixelMapuiv(Imports.GetPixelMapuiv); - GL.GetPixelMapusv = new GL.Delegates.GetPixelMapusv(Imports.GetPixelMapusv); - GL.GetPolygonStipple = new GL.Delegates.GetPolygonStipple(Imports.GetPolygonStipple); - GL.GetString = new GL.Delegates.GetString(Imports.GetString); - GL.GetTexEnvfv = new GL.Delegates.GetTexEnvfv(Imports.GetTexEnvfv); - GL.GetTexEnviv = new GL.Delegates.GetTexEnviv(Imports.GetTexEnviv); - GL.GetTexGendv = new GL.Delegates.GetTexGendv(Imports.GetTexGendv); - GL.GetTexGenfv = new GL.Delegates.GetTexGenfv(Imports.GetTexGenfv); - GL.GetTexGeniv = new GL.Delegates.GetTexGeniv(Imports.GetTexGeniv); - GL.GetTexImage = new GL.Delegates.GetTexImage(Imports.GetTexImage); - GL.GetTexParameterfv = new GL.Delegates.GetTexParameterfv(Imports.GetTexParameterfv); - GL.GetTexParameteriv = new GL.Delegates.GetTexParameteriv(Imports.GetTexParameteriv); - GL.GetTexLevelParameterfv = new GL.Delegates.GetTexLevelParameterfv(Imports.GetTexLevelParameterfv); - GL.GetTexLevelParameteriv = new GL.Delegates.GetTexLevelParameteriv(Imports.GetTexLevelParameteriv); - GL.IsEnabled = new GL.Delegates.IsEnabled(Imports.IsEnabled); - GL.IsList = new GL.Delegates.IsList(Imports.IsList); - GL.DepthRange = new GL.Delegates.DepthRange(Imports.DepthRange); - GL.Frustum = new GL.Delegates.Frustum(Imports.Frustum); - GL.LoadIdentity = new GL.Delegates.LoadIdentity(Imports.LoadIdentity); - GL.LoadMatrixf = new GL.Delegates.LoadMatrixf(Imports.LoadMatrixf); - GL.LoadMatrixd = new GL.Delegates.LoadMatrixd(Imports.LoadMatrixd); - GL.MatrixMode = new GL.Delegates.MatrixMode(Imports.MatrixMode); - GL.MultMatrixf = new GL.Delegates.MultMatrixf(Imports.MultMatrixf); - GL.MultMatrixd = new GL.Delegates.MultMatrixd(Imports.MultMatrixd); - GL.Ortho = new GL.Delegates.Ortho(Imports.Ortho); - GL.PopMatrix = new GL.Delegates.PopMatrix(Imports.PopMatrix); - GL.PushMatrix = new GL.Delegates.PushMatrix(Imports.PushMatrix); - GL.Rotated = new GL.Delegates.Rotated(Imports.Rotated); - GL.Rotatef = new GL.Delegates.Rotatef(Imports.Rotatef); - GL.Scaled = new GL.Delegates.Scaled(Imports.Scaled); - GL.Scalef = new GL.Delegates.Scalef(Imports.Scalef); - GL.Translated = new GL.Delegates.Translated(Imports.Translated); - GL.Translatef = new GL.Delegates.Translatef(Imports.Translatef); - GL.Viewport = new GL.Delegates.Viewport(Imports.Viewport); - GL.ArrayElement = new GL.Delegates.ArrayElement(Imports.ArrayElement); - GL.ColorPointer = new GL.Delegates.ColorPointer(Imports.ColorPointer); - GL.DisableClientState = new GL.Delegates.DisableClientState(Imports.DisableClientState); - GL.DrawArrays = new GL.Delegates.DrawArrays(Imports.DrawArrays); - GL.DrawElements = new GL.Delegates.DrawElements(Imports.DrawElements); - GL.EdgeFlagPointer = new GL.Delegates.EdgeFlagPointer(Imports.EdgeFlagPointer); - GL.EnableClientState = new GL.Delegates.EnableClientState(Imports.EnableClientState); - GL.GetPointerv = new GL.Delegates.GetPointerv(Imports.GetPointerv); - GL.IndexPointer = new GL.Delegates.IndexPointer(Imports.IndexPointer); - GL.InterleavedArrays = new GL.Delegates.InterleavedArrays(Imports.InterleavedArrays); - GL.NormalPointer = new GL.Delegates.NormalPointer(Imports.NormalPointer); - GL.TexCoordPointer = new GL.Delegates.TexCoordPointer(Imports.TexCoordPointer); - GL.VertexPointer = new GL.Delegates.VertexPointer(Imports.VertexPointer); - GL.PolygonOffset = new GL.Delegates.PolygonOffset(Imports.PolygonOffset); - GL.CopyTexImage1D = new GL.Delegates.CopyTexImage1D(Imports.CopyTexImage1D); - GL.CopyTexImage2D = new GL.Delegates.CopyTexImage2D(Imports.CopyTexImage2D); - GL.CopyTexSubImage1D = new GL.Delegates.CopyTexSubImage1D(Imports.CopyTexSubImage1D); - GL.CopyTexSubImage2D = new GL.Delegates.CopyTexSubImage2D(Imports.CopyTexSubImage2D); - GL.TexSubImage1D = new GL.Delegates.TexSubImage1D(Imports.TexSubImage1D); - GL.TexSubImage2D = new GL.Delegates.TexSubImage2D(Imports.TexSubImage2D); - GL.AreTexturesResident = new GL.Delegates.AreTexturesResident(Imports.AreTexturesResident); - GL.BindTexture = new GL.Delegates.BindTexture(Imports.BindTexture); - GL.DeleteTextures = new GL.Delegates.DeleteTextures(Imports.DeleteTextures); - GL.GenTextures = new GL.Delegates.GenTextures(Imports.GenTextures); - GL.IsTexture = new GL.Delegates.IsTexture(Imports.IsTexture); - GL.PrioritizeTextures = new GL.Delegates.PrioritizeTextures(Imports.PrioritizeTextures); - GL.Indexub = new GL.Delegates.Indexub(Imports.Indexub); - GL.Indexubv = new GL.Delegates.Indexubv(Imports.Indexubv); - GL.PopClientAttrib = new GL.Delegates.PopClientAttrib(Imports.PopClientAttrib); - GL.PushClientAttrib = new GL.Delegates.PushClientAttrib(Imports.PushClientAttrib); - GL.BlendColor = new GL.Delegates.BlendColor(Imports.BlendColor); - GL.BlendEquation = new GL.Delegates.BlendEquation(Imports.BlendEquation); - GL.DrawRangeElements = new GL.Delegates.DrawRangeElements(Imports.DrawRangeElements); - GL.ColorTable = new GL.Delegates.ColorTable(Imports.ColorTable); - GL.ColorTableParameterfv = new GL.Delegates.ColorTableParameterfv(Imports.ColorTableParameterfv); - GL.ColorTableParameteriv = new GL.Delegates.ColorTableParameteriv(Imports.ColorTableParameteriv); - GL.CopyColorTable = new GL.Delegates.CopyColorTable(Imports.CopyColorTable); - GL.GetColorTable = new GL.Delegates.GetColorTable(Imports.GetColorTable); - GL.GetColorTableParameterfv = new GL.Delegates.GetColorTableParameterfv(Imports.GetColorTableParameterfv); - GL.GetColorTableParameteriv = new GL.Delegates.GetColorTableParameteriv(Imports.GetColorTableParameteriv); - GL.ColorSubTable = new GL.Delegates.ColorSubTable(Imports.ColorSubTable); - GL.CopyColorSubTable = new GL.Delegates.CopyColorSubTable(Imports.CopyColorSubTable); - GL.ConvolutionFilter1D = new GL.Delegates.ConvolutionFilter1D(Imports.ConvolutionFilter1D); - GL.ConvolutionFilter2D = new GL.Delegates.ConvolutionFilter2D(Imports.ConvolutionFilter2D); - GL.ConvolutionParameterf = new GL.Delegates.ConvolutionParameterf(Imports.ConvolutionParameterf); - GL.ConvolutionParameterfv = new GL.Delegates.ConvolutionParameterfv(Imports.ConvolutionParameterfv); - GL.ConvolutionParameteri = new GL.Delegates.ConvolutionParameteri(Imports.ConvolutionParameteri); - GL.ConvolutionParameteriv = new GL.Delegates.ConvolutionParameteriv(Imports.ConvolutionParameteriv); - GL.CopyConvolutionFilter1D = new GL.Delegates.CopyConvolutionFilter1D(Imports.CopyConvolutionFilter1D); - GL.CopyConvolutionFilter2D = new GL.Delegates.CopyConvolutionFilter2D(Imports.CopyConvolutionFilter2D); - GL.GetConvolutionFilter = new GL.Delegates.GetConvolutionFilter(Imports.GetConvolutionFilter); - GL.GetConvolutionParameterfv = new GL.Delegates.GetConvolutionParameterfv(Imports.GetConvolutionParameterfv); - GL.GetConvolutionParameteriv = new GL.Delegates.GetConvolutionParameteriv(Imports.GetConvolutionParameteriv); - GL.GetSeparableFilter = new GL.Delegates.GetSeparableFilter(Imports.GetSeparableFilter); - GL.SeparableFilter2D = new GL.Delegates.SeparableFilter2D(Imports.SeparableFilter2D); - GL.GetHistogram = new GL.Delegates.GetHistogram(Imports.GetHistogram); - GL.GetHistogramParameterfv = new GL.Delegates.GetHistogramParameterfv(Imports.GetHistogramParameterfv); - GL.GetHistogramParameteriv = new GL.Delegates.GetHistogramParameteriv(Imports.GetHistogramParameteriv); - GL.GetMinmax = new GL.Delegates.GetMinmax(Imports.GetMinmax); - GL.GetMinmaxParameterfv = new GL.Delegates.GetMinmaxParameterfv(Imports.GetMinmaxParameterfv); - GL.GetMinmaxParameteriv = new GL.Delegates.GetMinmaxParameteriv(Imports.GetMinmaxParameteriv); - GL.Histogram = new GL.Delegates.Histogram(Imports.Histogram); - GL.Minmax = new GL.Delegates.Minmax(Imports.Minmax); - GL.ResetHistogram = new GL.Delegates.ResetHistogram(Imports.ResetHistogram); - GL.ResetMinmax = new GL.Delegates.ResetMinmax(Imports.ResetMinmax); - GL.TexImage3D = new GL.Delegates.TexImage3D(Imports.TexImage3D); - GL.TexSubImage3D = new GL.Delegates.TexSubImage3D(Imports.TexSubImage3D); - GL.CopyTexSubImage3D = new GL.Delegates.CopyTexSubImage3D(Imports.CopyTexSubImage3D); - GL.ActiveTexture = new GL.Delegates.ActiveTexture(Imports.ActiveTexture); - GL.ClientActiveTexture = new GL.Delegates.ClientActiveTexture(Imports.ClientActiveTexture); - GL.MultiTexCoord1d = new GL.Delegates.MultiTexCoord1d(Imports.MultiTexCoord1d); - GL.MultiTexCoord1dv = new GL.Delegates.MultiTexCoord1dv(Imports.MultiTexCoord1dv); - GL.MultiTexCoord1f = new GL.Delegates.MultiTexCoord1f(Imports.MultiTexCoord1f); - GL.MultiTexCoord1fv = new GL.Delegates.MultiTexCoord1fv(Imports.MultiTexCoord1fv); - GL.MultiTexCoord1i = new GL.Delegates.MultiTexCoord1i(Imports.MultiTexCoord1i); - GL.MultiTexCoord1iv = new GL.Delegates.MultiTexCoord1iv(Imports.MultiTexCoord1iv); - GL.MultiTexCoord1s = new GL.Delegates.MultiTexCoord1s(Imports.MultiTexCoord1s); - GL.MultiTexCoord1sv = new GL.Delegates.MultiTexCoord1sv(Imports.MultiTexCoord1sv); - GL.MultiTexCoord2d = new GL.Delegates.MultiTexCoord2d(Imports.MultiTexCoord2d); - GL.MultiTexCoord2dv = new GL.Delegates.MultiTexCoord2dv(Imports.MultiTexCoord2dv); - GL.MultiTexCoord2f = new GL.Delegates.MultiTexCoord2f(Imports.MultiTexCoord2f); - GL.MultiTexCoord2fv = new GL.Delegates.MultiTexCoord2fv(Imports.MultiTexCoord2fv); - GL.MultiTexCoord2i = new GL.Delegates.MultiTexCoord2i(Imports.MultiTexCoord2i); - GL.MultiTexCoord2iv = new GL.Delegates.MultiTexCoord2iv(Imports.MultiTexCoord2iv); - GL.MultiTexCoord2s = new GL.Delegates.MultiTexCoord2s(Imports.MultiTexCoord2s); - GL.MultiTexCoord2sv = new GL.Delegates.MultiTexCoord2sv(Imports.MultiTexCoord2sv); - GL.MultiTexCoord3d = new GL.Delegates.MultiTexCoord3d(Imports.MultiTexCoord3d); - GL.MultiTexCoord3dv = new GL.Delegates.MultiTexCoord3dv(Imports.MultiTexCoord3dv); - GL.MultiTexCoord3f = new GL.Delegates.MultiTexCoord3f(Imports.MultiTexCoord3f); - GL.MultiTexCoord3fv = new GL.Delegates.MultiTexCoord3fv(Imports.MultiTexCoord3fv); - GL.MultiTexCoord3i = new GL.Delegates.MultiTexCoord3i(Imports.MultiTexCoord3i); - GL.MultiTexCoord3iv = new GL.Delegates.MultiTexCoord3iv(Imports.MultiTexCoord3iv); - GL.MultiTexCoord3s = new GL.Delegates.MultiTexCoord3s(Imports.MultiTexCoord3s); - GL.MultiTexCoord3sv = new GL.Delegates.MultiTexCoord3sv(Imports.MultiTexCoord3sv); - GL.MultiTexCoord4d = new GL.Delegates.MultiTexCoord4d(Imports.MultiTexCoord4d); - GL.MultiTexCoord4dv = new GL.Delegates.MultiTexCoord4dv(Imports.MultiTexCoord4dv); - GL.MultiTexCoord4f = new GL.Delegates.MultiTexCoord4f(Imports.MultiTexCoord4f); - GL.MultiTexCoord4fv = new GL.Delegates.MultiTexCoord4fv(Imports.MultiTexCoord4fv); - GL.MultiTexCoord4i = new GL.Delegates.MultiTexCoord4i(Imports.MultiTexCoord4i); - GL.MultiTexCoord4iv = new GL.Delegates.MultiTexCoord4iv(Imports.MultiTexCoord4iv); - GL.MultiTexCoord4s = new GL.Delegates.MultiTexCoord4s(Imports.MultiTexCoord4s); - GL.MultiTexCoord4sv = new GL.Delegates.MultiTexCoord4sv(Imports.MultiTexCoord4sv); - GL.LoadTransposeMatrixf = new GL.Delegates.LoadTransposeMatrixf(Imports.LoadTransposeMatrixf); - GL.LoadTransposeMatrixd = new GL.Delegates.LoadTransposeMatrixd(Imports.LoadTransposeMatrixd); - GL.MultTransposeMatrixf = new GL.Delegates.MultTransposeMatrixf(Imports.MultTransposeMatrixf); - GL.MultTransposeMatrixd = new GL.Delegates.MultTransposeMatrixd(Imports.MultTransposeMatrixd); - GL.SampleCoverage = new GL.Delegates.SampleCoverage(Imports.SampleCoverage); - GL.CompressedTexImage3D = new GL.Delegates.CompressedTexImage3D(Imports.CompressedTexImage3D); - GL.CompressedTexImage2D = new GL.Delegates.CompressedTexImage2D(Imports.CompressedTexImage2D); - GL.CompressedTexImage1D = new GL.Delegates.CompressedTexImage1D(Imports.CompressedTexImage1D); - GL.CompressedTexSubImage3D = new GL.Delegates.CompressedTexSubImage3D(Imports.CompressedTexSubImage3D); - GL.CompressedTexSubImage2D = new GL.Delegates.CompressedTexSubImage2D(Imports.CompressedTexSubImage2D); - GL.CompressedTexSubImage1D = new GL.Delegates.CompressedTexSubImage1D(Imports.CompressedTexSubImage1D); - GL.GetCompressedTexImage = new GL.Delegates.GetCompressedTexImage(Imports.GetCompressedTexImage); - GL.BlendFuncSeparate = new GL.Delegates.BlendFuncSeparate(Imports.BlendFuncSeparate); - GL.FogCoordf = new GL.Delegates.FogCoordf(Imports.FogCoordf); - GL.FogCoordfv = new GL.Delegates.FogCoordfv(Imports.FogCoordfv); - GL.FogCoordd = new GL.Delegates.FogCoordd(Imports.FogCoordd); - GL.FogCoorddv = new GL.Delegates.FogCoorddv(Imports.FogCoorddv); - GL.FogCoordPointer = new GL.Delegates.FogCoordPointer(Imports.FogCoordPointer); - GL.MultiDrawArrays = new GL.Delegates.MultiDrawArrays(Imports.MultiDrawArrays); - GL.MultiDrawElements = new GL.Delegates.MultiDrawElements(Imports.MultiDrawElements); - GL.PointParameterf = new GL.Delegates.PointParameterf(Imports.PointParameterf); - GL.PointParameterfv = new GL.Delegates.PointParameterfv(Imports.PointParameterfv); - GL.PointParameteri = new GL.Delegates.PointParameteri(Imports.PointParameteri); - GL.PointParameteriv = new GL.Delegates.PointParameteriv(Imports.PointParameteriv); - GL.SecondaryColor3b = new GL.Delegates.SecondaryColor3b(Imports.SecondaryColor3b); - GL.SecondaryColor3bv = new GL.Delegates.SecondaryColor3bv(Imports.SecondaryColor3bv); - GL.SecondaryColor3d = new GL.Delegates.SecondaryColor3d(Imports.SecondaryColor3d); - GL.SecondaryColor3dv = new GL.Delegates.SecondaryColor3dv(Imports.SecondaryColor3dv); - GL.SecondaryColor3f = new GL.Delegates.SecondaryColor3f(Imports.SecondaryColor3f); - GL.SecondaryColor3fv = new GL.Delegates.SecondaryColor3fv(Imports.SecondaryColor3fv); - GL.SecondaryColor3i = new GL.Delegates.SecondaryColor3i(Imports.SecondaryColor3i); - GL.SecondaryColor3iv = new GL.Delegates.SecondaryColor3iv(Imports.SecondaryColor3iv); - GL.SecondaryColor3s = new GL.Delegates.SecondaryColor3s(Imports.SecondaryColor3s); - GL.SecondaryColor3sv = new GL.Delegates.SecondaryColor3sv(Imports.SecondaryColor3sv); - GL.SecondaryColor3ub = new GL.Delegates.SecondaryColor3ub(Imports.SecondaryColor3ub); - GL.SecondaryColor3ubv = new GL.Delegates.SecondaryColor3ubv(Imports.SecondaryColor3ubv); - GL.SecondaryColor3ui = new GL.Delegates.SecondaryColor3ui(Imports.SecondaryColor3ui); - GL.SecondaryColor3uiv = new GL.Delegates.SecondaryColor3uiv(Imports.SecondaryColor3uiv); - GL.SecondaryColor3us = new GL.Delegates.SecondaryColor3us(Imports.SecondaryColor3us); - GL.SecondaryColor3usv = new GL.Delegates.SecondaryColor3usv(Imports.SecondaryColor3usv); - GL.SecondaryColorPointer = new GL.Delegates.SecondaryColorPointer(Imports.SecondaryColorPointer); - GL.WindowPos2d = new GL.Delegates.WindowPos2d(Imports.WindowPos2d); - GL.WindowPos2dv = new GL.Delegates.WindowPos2dv(Imports.WindowPos2dv); - GL.WindowPos2f = new GL.Delegates.WindowPos2f(Imports.WindowPos2f); - GL.WindowPos2fv = new GL.Delegates.WindowPos2fv(Imports.WindowPos2fv); - GL.WindowPos2i = new GL.Delegates.WindowPos2i(Imports.WindowPos2i); - GL.WindowPos2iv = new GL.Delegates.WindowPos2iv(Imports.WindowPos2iv); - GL.WindowPos2s = new GL.Delegates.WindowPos2s(Imports.WindowPos2s); - GL.WindowPos2sv = new GL.Delegates.WindowPos2sv(Imports.WindowPos2sv); - GL.WindowPos3d = new GL.Delegates.WindowPos3d(Imports.WindowPos3d); - GL.WindowPos3dv = new GL.Delegates.WindowPos3dv(Imports.WindowPos3dv); - GL.WindowPos3f = new GL.Delegates.WindowPos3f(Imports.WindowPos3f); - GL.WindowPos3fv = new GL.Delegates.WindowPos3fv(Imports.WindowPos3fv); - GL.WindowPos3i = new GL.Delegates.WindowPos3i(Imports.WindowPos3i); - GL.WindowPos3iv = new GL.Delegates.WindowPos3iv(Imports.WindowPos3iv); - GL.WindowPos3s = new GL.Delegates.WindowPos3s(Imports.WindowPos3s); - GL.WindowPos3sv = new GL.Delegates.WindowPos3sv(Imports.WindowPos3sv); - GL.GenQueries = (GL.Delegates.GenQueries) GetAddress("glGenQueries", typeof(GL.Delegates.GenQueries)); - GL.DeleteQueries = (GL.Delegates.DeleteQueries) GetAddress("glDeleteQueries", typeof(GL.Delegates.DeleteQueries)); - GL.IsQuery = (GL.Delegates.IsQuery) GetAddress("glIsQuery", typeof(GL.Delegates.IsQuery)); - GL.BeginQuery = (GL.Delegates.BeginQuery) GetAddress("glBeginQuery", typeof(GL.Delegates.BeginQuery)); - GL.EndQuery = (GL.Delegates.EndQuery) GetAddress("glEndQuery", typeof(GL.Delegates.EndQuery)); - GL.GetQueryiv = (GL.Delegates.GetQueryiv) GetAddress("glGetQueryiv", typeof(GL.Delegates.GetQueryiv)); - GL.GetQueryObjectiv = (GL.Delegates.GetQueryObjectiv) GetAddress("glGetQueryObjectiv", typeof(GL.Delegates.GetQueryObjectiv)); - GL.GetQueryObjectuiv = (GL.Delegates.GetQueryObjectuiv) GetAddress("glGetQueryObjectuiv", typeof(GL.Delegates.GetQueryObjectuiv)); - GL.BindBuffer = (GL.Delegates.BindBuffer) GetAddress("glBindBuffer", typeof(GL.Delegates.BindBuffer)); - GL.DeleteBuffers = (GL.Delegates.DeleteBuffers) GetAddress("glDeleteBuffers", typeof(GL.Delegates.DeleteBuffers)); - GL.GenBuffers = (GL.Delegates.GenBuffers) GetAddress("glGenBuffers", typeof(GL.Delegates.GenBuffers)); - GL.IsBuffer = (GL.Delegates.IsBuffer) GetAddress("glIsBuffer", typeof(GL.Delegates.IsBuffer)); - GL.BufferData = (GL.Delegates.BufferData) GetAddress("glBufferData", typeof(GL.Delegates.BufferData)); - GL.BufferSubData = (GL.Delegates.BufferSubData) GetAddress("glBufferSubData", typeof(GL.Delegates.BufferSubData)); - GL.GetBufferSubData = (GL.Delegates.GetBufferSubData) GetAddress("glGetBufferSubData", typeof(GL.Delegates.GetBufferSubData)); - GL.MapBuffer_ = (GL.Delegates.MapBuffer_) GetAddress("glMapBuffer_", typeof(GL.Delegates.MapBuffer_)); - GL.UnmapBuffer = (GL.Delegates.UnmapBuffer) GetAddress("glUnmapBuffer", typeof(GL.Delegates.UnmapBuffer)); - GL.GetBufferParameteriv = (GL.Delegates.GetBufferParameteriv) GetAddress("glGetBufferParameteriv", typeof(GL.Delegates.GetBufferParameteriv)); - GL.GetBufferPointerv = (GL.Delegates.GetBufferPointerv) GetAddress("glGetBufferPointerv", typeof(GL.Delegates.GetBufferPointerv)); - GL.BlendEquationSeparate = (GL.Delegates.BlendEquationSeparate) GetAddress("glBlendEquationSeparate", typeof(GL.Delegates.BlendEquationSeparate)); - GL.DrawBuffers = (GL.Delegates.DrawBuffers) GetAddress("glDrawBuffers", typeof(GL.Delegates.DrawBuffers)); - GL.StencilOpSeparate = (GL.Delegates.StencilOpSeparate) GetAddress("glStencilOpSeparate", typeof(GL.Delegates.StencilOpSeparate)); - GL.StencilFuncSeparate = (GL.Delegates.StencilFuncSeparate) GetAddress("glStencilFuncSeparate", typeof(GL.Delegates.StencilFuncSeparate)); - GL.StencilMaskSeparate = (GL.Delegates.StencilMaskSeparate) GetAddress("glStencilMaskSeparate", typeof(GL.Delegates.StencilMaskSeparate)); - GL.AttachShader = (GL.Delegates.AttachShader) GetAddress("glAttachShader", typeof(GL.Delegates.AttachShader)); - GL.BindAttribLocation = (GL.Delegates.BindAttribLocation) GetAddress("glBindAttribLocation", typeof(GL.Delegates.BindAttribLocation)); - GL.CompileShader = (GL.Delegates.CompileShader) GetAddress("glCompileShader", typeof(GL.Delegates.CompileShader)); - GL.CreateProgram = (GL.Delegates.CreateProgram) GetAddress("glCreateProgram", typeof(GL.Delegates.CreateProgram)); - GL.CreateShader = (GL.Delegates.CreateShader) GetAddress("glCreateShader", typeof(GL.Delegates.CreateShader)); - GL.DeleteProgram = (GL.Delegates.DeleteProgram) GetAddress("glDeleteProgram", typeof(GL.Delegates.DeleteProgram)); - GL.DeleteShader = (GL.Delegates.DeleteShader) GetAddress("glDeleteShader", typeof(GL.Delegates.DeleteShader)); - GL.DetachShader = (GL.Delegates.DetachShader) GetAddress("glDetachShader", typeof(GL.Delegates.DetachShader)); - GL.DisableVertexAttribArray = (GL.Delegates.DisableVertexAttribArray) GetAddress("glDisableVertexAttribArray", typeof(GL.Delegates.DisableVertexAttribArray)); - GL.EnableVertexAttribArray = (GL.Delegates.EnableVertexAttribArray) GetAddress("glEnableVertexAttribArray", typeof(GL.Delegates.EnableVertexAttribArray)); - GL.GetActiveAttrib = (GL.Delegates.GetActiveAttrib) GetAddress("glGetActiveAttrib", typeof(GL.Delegates.GetActiveAttrib)); - GL.GetActiveUniform = (GL.Delegates.GetActiveUniform) GetAddress("glGetActiveUniform", typeof(GL.Delegates.GetActiveUniform)); - GL.GetAttachedShaders = (GL.Delegates.GetAttachedShaders) GetAddress("glGetAttachedShaders", typeof(GL.Delegates.GetAttachedShaders)); - GL.GetAttribLocation = (GL.Delegates.GetAttribLocation) GetAddress("glGetAttribLocation", typeof(GL.Delegates.GetAttribLocation)); - GL.GetProgramiv = (GL.Delegates.GetProgramiv) GetAddress("glGetProgramiv", typeof(GL.Delegates.GetProgramiv)); - GL.GetProgramInfoLog = (GL.Delegates.GetProgramInfoLog) GetAddress("glGetProgramInfoLog", typeof(GL.Delegates.GetProgramInfoLog)); - GL.GetShaderiv = (GL.Delegates.GetShaderiv) GetAddress("glGetShaderiv", typeof(GL.Delegates.GetShaderiv)); - GL.GetShaderInfoLog = (GL.Delegates.GetShaderInfoLog) GetAddress("glGetShaderInfoLog", typeof(GL.Delegates.GetShaderInfoLog)); - GL.GetShaderSource = (GL.Delegates.GetShaderSource) GetAddress("glGetShaderSource", typeof(GL.Delegates.GetShaderSource)); - GL.GetUniformLocation = (GL.Delegates.GetUniformLocation) GetAddress("glGetUniformLocation", typeof(GL.Delegates.GetUniformLocation)); - GL.GetUniformfv = (GL.Delegates.GetUniformfv) GetAddress("glGetUniformfv", typeof(GL.Delegates.GetUniformfv)); - GL.GetUniformiv = (GL.Delegates.GetUniformiv) GetAddress("glGetUniformiv", typeof(GL.Delegates.GetUniformiv)); - GL.GetVertexAttribdv = (GL.Delegates.GetVertexAttribdv) GetAddress("glGetVertexAttribdv", typeof(GL.Delegates.GetVertexAttribdv)); - GL.GetVertexAttribfv = (GL.Delegates.GetVertexAttribfv) GetAddress("glGetVertexAttribfv", typeof(GL.Delegates.GetVertexAttribfv)); - GL.GetVertexAttribiv = (GL.Delegates.GetVertexAttribiv) GetAddress("glGetVertexAttribiv", typeof(GL.Delegates.GetVertexAttribiv)); - GL.GetVertexAttribPointerv = (GL.Delegates.GetVertexAttribPointerv) GetAddress("glGetVertexAttribPointerv", typeof(GL.Delegates.GetVertexAttribPointerv)); - GL.IsProgram = (GL.Delegates.IsProgram) GetAddress("glIsProgram", typeof(GL.Delegates.IsProgram)); - GL.IsShader = (GL.Delegates.IsShader) GetAddress("glIsShader", typeof(GL.Delegates.IsShader)); - GL.LinkProgram = (GL.Delegates.LinkProgram) GetAddress("glLinkProgram", typeof(GL.Delegates.LinkProgram)); - GL.ShaderSource = (GL.Delegates.ShaderSource) GetAddress("glShaderSource", typeof(GL.Delegates.ShaderSource)); - GL.UseProgram = (GL.Delegates.UseProgram) GetAddress("glUseProgram", typeof(GL.Delegates.UseProgram)); - GL.Uniform1f = (GL.Delegates.Uniform1f) GetAddress("glUniform1f", typeof(GL.Delegates.Uniform1f)); - GL.Uniform2f = (GL.Delegates.Uniform2f) GetAddress("glUniform2f", typeof(GL.Delegates.Uniform2f)); - GL.Uniform3f = (GL.Delegates.Uniform3f) GetAddress("glUniform3f", typeof(GL.Delegates.Uniform3f)); - GL.Uniform4f = (GL.Delegates.Uniform4f) GetAddress("glUniform4f", typeof(GL.Delegates.Uniform4f)); - GL.Uniform1i = (GL.Delegates.Uniform1i) GetAddress("glUniform1i", typeof(GL.Delegates.Uniform1i)); - GL.Uniform2i = (GL.Delegates.Uniform2i) GetAddress("glUniform2i", typeof(GL.Delegates.Uniform2i)); - GL.Uniform3i = (GL.Delegates.Uniform3i) GetAddress("glUniform3i", typeof(GL.Delegates.Uniform3i)); - GL.Uniform4i = (GL.Delegates.Uniform4i) GetAddress("glUniform4i", typeof(GL.Delegates.Uniform4i)); - GL.Uniform1fv = (GL.Delegates.Uniform1fv) GetAddress("glUniform1fv", typeof(GL.Delegates.Uniform1fv)); - GL.Uniform2fv = (GL.Delegates.Uniform2fv) GetAddress("glUniform2fv", typeof(GL.Delegates.Uniform2fv)); - GL.Uniform3fv = (GL.Delegates.Uniform3fv) GetAddress("glUniform3fv", typeof(GL.Delegates.Uniform3fv)); - GL.Uniform4fv = (GL.Delegates.Uniform4fv) GetAddress("glUniform4fv", typeof(GL.Delegates.Uniform4fv)); - GL.Uniform1iv = (GL.Delegates.Uniform1iv) GetAddress("glUniform1iv", typeof(GL.Delegates.Uniform1iv)); - GL.Uniform2iv = (GL.Delegates.Uniform2iv) GetAddress("glUniform2iv", typeof(GL.Delegates.Uniform2iv)); - GL.Uniform3iv = (GL.Delegates.Uniform3iv) GetAddress("glUniform3iv", typeof(GL.Delegates.Uniform3iv)); - GL.Uniform4iv = (GL.Delegates.Uniform4iv) GetAddress("glUniform4iv", typeof(GL.Delegates.Uniform4iv)); - GL.UniformMatrix2fv = (GL.Delegates.UniformMatrix2fv) GetAddress("glUniformMatrix2fv", typeof(GL.Delegates.UniformMatrix2fv)); - GL.UniformMatrix3fv = (GL.Delegates.UniformMatrix3fv) GetAddress("glUniformMatrix3fv", typeof(GL.Delegates.UniformMatrix3fv)); - GL.UniformMatrix4fv = (GL.Delegates.UniformMatrix4fv) GetAddress("glUniformMatrix4fv", typeof(GL.Delegates.UniformMatrix4fv)); - GL.ValidateProgram = (GL.Delegates.ValidateProgram) GetAddress("glValidateProgram", typeof(GL.Delegates.ValidateProgram)); - GL.VertexAttrib1d = (GL.Delegates.VertexAttrib1d) GetAddress("glVertexAttrib1d", typeof(GL.Delegates.VertexAttrib1d)); - GL.VertexAttrib1dv = (GL.Delegates.VertexAttrib1dv) GetAddress("glVertexAttrib1dv", typeof(GL.Delegates.VertexAttrib1dv)); - GL.VertexAttrib1f = (GL.Delegates.VertexAttrib1f) GetAddress("glVertexAttrib1f", typeof(GL.Delegates.VertexAttrib1f)); - GL.VertexAttrib1fv = (GL.Delegates.VertexAttrib1fv) GetAddress("glVertexAttrib1fv", typeof(GL.Delegates.VertexAttrib1fv)); - GL.VertexAttrib1s = (GL.Delegates.VertexAttrib1s) GetAddress("glVertexAttrib1s", typeof(GL.Delegates.VertexAttrib1s)); - GL.VertexAttrib1sv = (GL.Delegates.VertexAttrib1sv) GetAddress("glVertexAttrib1sv", typeof(GL.Delegates.VertexAttrib1sv)); - GL.VertexAttrib2d = (GL.Delegates.VertexAttrib2d) GetAddress("glVertexAttrib2d", typeof(GL.Delegates.VertexAttrib2d)); - GL.VertexAttrib2dv = (GL.Delegates.VertexAttrib2dv) GetAddress("glVertexAttrib2dv", typeof(GL.Delegates.VertexAttrib2dv)); - GL.VertexAttrib2f = (GL.Delegates.VertexAttrib2f) GetAddress("glVertexAttrib2f", typeof(GL.Delegates.VertexAttrib2f)); - GL.VertexAttrib2fv = (GL.Delegates.VertexAttrib2fv) GetAddress("glVertexAttrib2fv", typeof(GL.Delegates.VertexAttrib2fv)); - GL.VertexAttrib2s = (GL.Delegates.VertexAttrib2s) GetAddress("glVertexAttrib2s", typeof(GL.Delegates.VertexAttrib2s)); - GL.VertexAttrib2sv = (GL.Delegates.VertexAttrib2sv) GetAddress("glVertexAttrib2sv", typeof(GL.Delegates.VertexAttrib2sv)); - GL.VertexAttrib3d = (GL.Delegates.VertexAttrib3d) GetAddress("glVertexAttrib3d", typeof(GL.Delegates.VertexAttrib3d)); - GL.VertexAttrib3dv = (GL.Delegates.VertexAttrib3dv) GetAddress("glVertexAttrib3dv", typeof(GL.Delegates.VertexAttrib3dv)); - GL.VertexAttrib3f = (GL.Delegates.VertexAttrib3f) GetAddress("glVertexAttrib3f", typeof(GL.Delegates.VertexAttrib3f)); - GL.VertexAttrib3fv = (GL.Delegates.VertexAttrib3fv) GetAddress("glVertexAttrib3fv", typeof(GL.Delegates.VertexAttrib3fv)); - GL.VertexAttrib3s = (GL.Delegates.VertexAttrib3s) GetAddress("glVertexAttrib3s", typeof(GL.Delegates.VertexAttrib3s)); - GL.VertexAttrib3sv = (GL.Delegates.VertexAttrib3sv) GetAddress("glVertexAttrib3sv", typeof(GL.Delegates.VertexAttrib3sv)); - GL.VertexAttrib4Nbv = (GL.Delegates.VertexAttrib4Nbv) GetAddress("glVertexAttrib4Nbv", typeof(GL.Delegates.VertexAttrib4Nbv)); - GL.VertexAttrib4Niv = (GL.Delegates.VertexAttrib4Niv) GetAddress("glVertexAttrib4Niv", typeof(GL.Delegates.VertexAttrib4Niv)); - GL.VertexAttrib4Nsv = (GL.Delegates.VertexAttrib4Nsv) GetAddress("glVertexAttrib4Nsv", typeof(GL.Delegates.VertexAttrib4Nsv)); - GL.VertexAttrib4Nub = (GL.Delegates.VertexAttrib4Nub) GetAddress("glVertexAttrib4Nub", typeof(GL.Delegates.VertexAttrib4Nub)); - GL.VertexAttrib4Nubv = (GL.Delegates.VertexAttrib4Nubv) GetAddress("glVertexAttrib4Nubv", typeof(GL.Delegates.VertexAttrib4Nubv)); - GL.VertexAttrib4Nuiv = (GL.Delegates.VertexAttrib4Nuiv) GetAddress("glVertexAttrib4Nuiv", typeof(GL.Delegates.VertexAttrib4Nuiv)); - GL.VertexAttrib4Nusv = (GL.Delegates.VertexAttrib4Nusv) GetAddress("glVertexAttrib4Nusv", typeof(GL.Delegates.VertexAttrib4Nusv)); - GL.VertexAttrib4bv = (GL.Delegates.VertexAttrib4bv) GetAddress("glVertexAttrib4bv", typeof(GL.Delegates.VertexAttrib4bv)); - GL.VertexAttrib4d = (GL.Delegates.VertexAttrib4d) GetAddress("glVertexAttrib4d", typeof(GL.Delegates.VertexAttrib4d)); - GL.VertexAttrib4dv = (GL.Delegates.VertexAttrib4dv) GetAddress("glVertexAttrib4dv", typeof(GL.Delegates.VertexAttrib4dv)); - GL.VertexAttrib4f = (GL.Delegates.VertexAttrib4f) GetAddress("glVertexAttrib4f", typeof(GL.Delegates.VertexAttrib4f)); - GL.VertexAttrib4fv = (GL.Delegates.VertexAttrib4fv) GetAddress("glVertexAttrib4fv", typeof(GL.Delegates.VertexAttrib4fv)); - GL.VertexAttrib4iv = (GL.Delegates.VertexAttrib4iv) GetAddress("glVertexAttrib4iv", typeof(GL.Delegates.VertexAttrib4iv)); - GL.VertexAttrib4s = (GL.Delegates.VertexAttrib4s) GetAddress("glVertexAttrib4s", typeof(GL.Delegates.VertexAttrib4s)); - GL.VertexAttrib4sv = (GL.Delegates.VertexAttrib4sv) GetAddress("glVertexAttrib4sv", typeof(GL.Delegates.VertexAttrib4sv)); - GL.VertexAttrib4ubv = (GL.Delegates.VertexAttrib4ubv) GetAddress("glVertexAttrib4ubv", typeof(GL.Delegates.VertexAttrib4ubv)); - GL.VertexAttrib4uiv = (GL.Delegates.VertexAttrib4uiv) GetAddress("glVertexAttrib4uiv", typeof(GL.Delegates.VertexAttrib4uiv)); - GL.VertexAttrib4usv = (GL.Delegates.VertexAttrib4usv) GetAddress("glVertexAttrib4usv", typeof(GL.Delegates.VertexAttrib4usv)); - GL.VertexAttribPointer = (GL.Delegates.VertexAttribPointer) GetAddress("glVertexAttribPointer", typeof(GL.Delegates.VertexAttribPointer)); - CoreLoaded = true; + base.Load(); + GL.NewList = new GL.Delegates.NewList(GL.Imports.NewList); + GL.EndList = new GL.Delegates.EndList(GL.Imports.EndList); + GL.CallList = new GL.Delegates.CallList(GL.Imports.CallList); + GL.CallLists_ = new GL.Delegates.CallLists_(GL.Imports.CallLists_); + GL.DeleteLists = new GL.Delegates.DeleteLists(GL.Imports.DeleteLists); + GL.GenLists = new GL.Delegates.GenLists(GL.Imports.GenLists); + GL.ListBase = new GL.Delegates.ListBase(GL.Imports.ListBase); + GL.Begin = new GL.Delegates.Begin(GL.Imports.Begin); + GL.Bitmap = new GL.Delegates.Bitmap(GL.Imports.Bitmap); + GL.Color3b = new GL.Delegates.Color3b(GL.Imports.Color3b); + GL.Color3bv = new GL.Delegates.Color3bv(GL.Imports.Color3bv); + GL.Color3d = new GL.Delegates.Color3d(GL.Imports.Color3d); + GL.Color3dv = new GL.Delegates.Color3dv(GL.Imports.Color3dv); + GL.Color3f = new GL.Delegates.Color3f(GL.Imports.Color3f); + GL.Color3fv = new GL.Delegates.Color3fv(GL.Imports.Color3fv); + GL.Color3i = new GL.Delegates.Color3i(GL.Imports.Color3i); + GL.Color3iv = new GL.Delegates.Color3iv(GL.Imports.Color3iv); + GL.Color3s = new GL.Delegates.Color3s(GL.Imports.Color3s); + GL.Color3sv = new GL.Delegates.Color3sv(GL.Imports.Color3sv); + GL.Color3ub = new GL.Delegates.Color3ub(GL.Imports.Color3ub); + GL.Color3ubv = new GL.Delegates.Color3ubv(GL.Imports.Color3ubv); + GL.Color3ui = new GL.Delegates.Color3ui(GL.Imports.Color3ui); + GL.Color3uiv = new GL.Delegates.Color3uiv(GL.Imports.Color3uiv); + GL.Color3us = new GL.Delegates.Color3us(GL.Imports.Color3us); + GL.Color3usv = new GL.Delegates.Color3usv(GL.Imports.Color3usv); + GL.Color4b = new GL.Delegates.Color4b(GL.Imports.Color4b); + GL.Color4bv = new GL.Delegates.Color4bv(GL.Imports.Color4bv); + GL.Color4d = new GL.Delegates.Color4d(GL.Imports.Color4d); + GL.Color4dv = new GL.Delegates.Color4dv(GL.Imports.Color4dv); + GL.Color4f = new GL.Delegates.Color4f(GL.Imports.Color4f); + GL.Color4fv = new GL.Delegates.Color4fv(GL.Imports.Color4fv); + GL.Color4i = new GL.Delegates.Color4i(GL.Imports.Color4i); + GL.Color4iv = new GL.Delegates.Color4iv(GL.Imports.Color4iv); + GL.Color4s = new GL.Delegates.Color4s(GL.Imports.Color4s); + GL.Color4sv = new GL.Delegates.Color4sv(GL.Imports.Color4sv); + GL.Color4ub = new GL.Delegates.Color4ub(GL.Imports.Color4ub); + GL.Color4ubv = new GL.Delegates.Color4ubv(GL.Imports.Color4ubv); + GL.Color4ui = new GL.Delegates.Color4ui(GL.Imports.Color4ui); + GL.Color4uiv = new GL.Delegates.Color4uiv(GL.Imports.Color4uiv); + GL.Color4us = new GL.Delegates.Color4us(GL.Imports.Color4us); + GL.Color4usv = new GL.Delegates.Color4usv(GL.Imports.Color4usv); + GL.EdgeFlag = new GL.Delegates.EdgeFlag(GL.Imports.EdgeFlag); + GL.EdgeFlagv = new GL.Delegates.EdgeFlagv(GL.Imports.EdgeFlagv); + GL.End = new GL.Delegates.End(GL.Imports.End); + GL.Indexd = new GL.Delegates.Indexd(GL.Imports.Indexd); + GL.Indexdv = new GL.Delegates.Indexdv(GL.Imports.Indexdv); + GL.Indexf = new GL.Delegates.Indexf(GL.Imports.Indexf); + GL.Indexfv = new GL.Delegates.Indexfv(GL.Imports.Indexfv); + GL.Indexi = new GL.Delegates.Indexi(GL.Imports.Indexi); + GL.Indexiv = new GL.Delegates.Indexiv(GL.Imports.Indexiv); + GL.Indexs = new GL.Delegates.Indexs(GL.Imports.Indexs); + GL.Indexsv = new GL.Delegates.Indexsv(GL.Imports.Indexsv); + GL.Normal3b = new GL.Delegates.Normal3b(GL.Imports.Normal3b); + GL.Normal3bv = new GL.Delegates.Normal3bv(GL.Imports.Normal3bv); + GL.Normal3d = new GL.Delegates.Normal3d(GL.Imports.Normal3d); + GL.Normal3dv = new GL.Delegates.Normal3dv(GL.Imports.Normal3dv); + GL.Normal3f = new GL.Delegates.Normal3f(GL.Imports.Normal3f); + GL.Normal3fv = new GL.Delegates.Normal3fv(GL.Imports.Normal3fv); + GL.Normal3i = new GL.Delegates.Normal3i(GL.Imports.Normal3i); + GL.Normal3iv = new GL.Delegates.Normal3iv(GL.Imports.Normal3iv); + GL.Normal3s = new GL.Delegates.Normal3s(GL.Imports.Normal3s); + GL.Normal3sv = new GL.Delegates.Normal3sv(GL.Imports.Normal3sv); + GL.RasterPos2d = new GL.Delegates.RasterPos2d(GL.Imports.RasterPos2d); + GL.RasterPos2dv = new GL.Delegates.RasterPos2dv(GL.Imports.RasterPos2dv); + GL.RasterPos2f = new GL.Delegates.RasterPos2f(GL.Imports.RasterPos2f); + GL.RasterPos2fv = new GL.Delegates.RasterPos2fv(GL.Imports.RasterPos2fv); + GL.RasterPos2i = new GL.Delegates.RasterPos2i(GL.Imports.RasterPos2i); + GL.RasterPos2iv = new GL.Delegates.RasterPos2iv(GL.Imports.RasterPos2iv); + GL.RasterPos2s = new GL.Delegates.RasterPos2s(GL.Imports.RasterPos2s); + GL.RasterPos2sv = new GL.Delegates.RasterPos2sv(GL.Imports.RasterPos2sv); + GL.RasterPos3d = new GL.Delegates.RasterPos3d(GL.Imports.RasterPos3d); + GL.RasterPos3dv = new GL.Delegates.RasterPos3dv(GL.Imports.RasterPos3dv); + GL.RasterPos3f = new GL.Delegates.RasterPos3f(GL.Imports.RasterPos3f); + GL.RasterPos3fv = new GL.Delegates.RasterPos3fv(GL.Imports.RasterPos3fv); + GL.RasterPos3i = new GL.Delegates.RasterPos3i(GL.Imports.RasterPos3i); + GL.RasterPos3iv = new GL.Delegates.RasterPos3iv(GL.Imports.RasterPos3iv); + GL.RasterPos3s = new GL.Delegates.RasterPos3s(GL.Imports.RasterPos3s); + GL.RasterPos3sv = new GL.Delegates.RasterPos3sv(GL.Imports.RasterPos3sv); + GL.RasterPos4d = new GL.Delegates.RasterPos4d(GL.Imports.RasterPos4d); + GL.RasterPos4dv = new GL.Delegates.RasterPos4dv(GL.Imports.RasterPos4dv); + GL.RasterPos4f = new GL.Delegates.RasterPos4f(GL.Imports.RasterPos4f); + GL.RasterPos4fv = new GL.Delegates.RasterPos4fv(GL.Imports.RasterPos4fv); + GL.RasterPos4i = new GL.Delegates.RasterPos4i(GL.Imports.RasterPos4i); + GL.RasterPos4iv = new GL.Delegates.RasterPos4iv(GL.Imports.RasterPos4iv); + GL.RasterPos4s = new GL.Delegates.RasterPos4s(GL.Imports.RasterPos4s); + GL.RasterPos4sv = new GL.Delegates.RasterPos4sv(GL.Imports.RasterPos4sv); + GL.Rectd = new GL.Delegates.Rectd(GL.Imports.Rectd); + GL.Rectdv = new GL.Delegates.Rectdv(GL.Imports.Rectdv); + GL.Rectf = new GL.Delegates.Rectf(GL.Imports.Rectf); + GL.Rectfv = new GL.Delegates.Rectfv(GL.Imports.Rectfv); + GL.Recti = new GL.Delegates.Recti(GL.Imports.Recti); + GL.Rectiv = new GL.Delegates.Rectiv(GL.Imports.Rectiv); + GL.Rects = new GL.Delegates.Rects(GL.Imports.Rects); + GL.Rectsv = new GL.Delegates.Rectsv(GL.Imports.Rectsv); + GL.TexCoord1d = new GL.Delegates.TexCoord1d(GL.Imports.TexCoord1d); + GL.TexCoord1dv = new GL.Delegates.TexCoord1dv(GL.Imports.TexCoord1dv); + GL.TexCoord1f = new GL.Delegates.TexCoord1f(GL.Imports.TexCoord1f); + GL.TexCoord1fv = new GL.Delegates.TexCoord1fv(GL.Imports.TexCoord1fv); + GL.TexCoord1i = new GL.Delegates.TexCoord1i(GL.Imports.TexCoord1i); + GL.TexCoord1iv = new GL.Delegates.TexCoord1iv(GL.Imports.TexCoord1iv); + GL.TexCoord1s = new GL.Delegates.TexCoord1s(GL.Imports.TexCoord1s); + GL.TexCoord1sv = new GL.Delegates.TexCoord1sv(GL.Imports.TexCoord1sv); + GL.TexCoord2d = new GL.Delegates.TexCoord2d(GL.Imports.TexCoord2d); + GL.TexCoord2dv = new GL.Delegates.TexCoord2dv(GL.Imports.TexCoord2dv); + GL.TexCoord2f = new GL.Delegates.TexCoord2f(GL.Imports.TexCoord2f); + GL.TexCoord2fv = new GL.Delegates.TexCoord2fv(GL.Imports.TexCoord2fv); + GL.TexCoord2i = new GL.Delegates.TexCoord2i(GL.Imports.TexCoord2i); + GL.TexCoord2iv = new GL.Delegates.TexCoord2iv(GL.Imports.TexCoord2iv); + GL.TexCoord2s = new GL.Delegates.TexCoord2s(GL.Imports.TexCoord2s); + GL.TexCoord2sv = new GL.Delegates.TexCoord2sv(GL.Imports.TexCoord2sv); + GL.TexCoord3d = new GL.Delegates.TexCoord3d(GL.Imports.TexCoord3d); + GL.TexCoord3dv = new GL.Delegates.TexCoord3dv(GL.Imports.TexCoord3dv); + GL.TexCoord3f = new GL.Delegates.TexCoord3f(GL.Imports.TexCoord3f); + GL.TexCoord3fv = new GL.Delegates.TexCoord3fv(GL.Imports.TexCoord3fv); + GL.TexCoord3i = new GL.Delegates.TexCoord3i(GL.Imports.TexCoord3i); + GL.TexCoord3iv = new GL.Delegates.TexCoord3iv(GL.Imports.TexCoord3iv); + GL.TexCoord3s = new GL.Delegates.TexCoord3s(GL.Imports.TexCoord3s); + GL.TexCoord3sv = new GL.Delegates.TexCoord3sv(GL.Imports.TexCoord3sv); + GL.TexCoord4d = new GL.Delegates.TexCoord4d(GL.Imports.TexCoord4d); + GL.TexCoord4dv = new GL.Delegates.TexCoord4dv(GL.Imports.TexCoord4dv); + GL.TexCoord4f = new GL.Delegates.TexCoord4f(GL.Imports.TexCoord4f); + GL.TexCoord4fv = new GL.Delegates.TexCoord4fv(GL.Imports.TexCoord4fv); + GL.TexCoord4i = new GL.Delegates.TexCoord4i(GL.Imports.TexCoord4i); + GL.TexCoord4iv = new GL.Delegates.TexCoord4iv(GL.Imports.TexCoord4iv); + GL.TexCoord4s = new GL.Delegates.TexCoord4s(GL.Imports.TexCoord4s); + GL.TexCoord4sv = new GL.Delegates.TexCoord4sv(GL.Imports.TexCoord4sv); + GL.Vertex2d = new GL.Delegates.Vertex2d(GL.Imports.Vertex2d); + GL.Vertex2dv = new GL.Delegates.Vertex2dv(GL.Imports.Vertex2dv); + GL.Vertex2f = new GL.Delegates.Vertex2f(GL.Imports.Vertex2f); + GL.Vertex2fv = new GL.Delegates.Vertex2fv(GL.Imports.Vertex2fv); + GL.Vertex2i = new GL.Delegates.Vertex2i(GL.Imports.Vertex2i); + GL.Vertex2iv = new GL.Delegates.Vertex2iv(GL.Imports.Vertex2iv); + GL.Vertex2s = new GL.Delegates.Vertex2s(GL.Imports.Vertex2s); + GL.Vertex2sv = new GL.Delegates.Vertex2sv(GL.Imports.Vertex2sv); + GL.Vertex3d = new GL.Delegates.Vertex3d(GL.Imports.Vertex3d); + GL.Vertex3dv = new GL.Delegates.Vertex3dv(GL.Imports.Vertex3dv); + GL.Vertex3f = new GL.Delegates.Vertex3f(GL.Imports.Vertex3f); + GL.Vertex3fv = new GL.Delegates.Vertex3fv(GL.Imports.Vertex3fv); + GL.Vertex3i = new GL.Delegates.Vertex3i(GL.Imports.Vertex3i); + GL.Vertex3iv = new GL.Delegates.Vertex3iv(GL.Imports.Vertex3iv); + GL.Vertex3s = new GL.Delegates.Vertex3s(GL.Imports.Vertex3s); + GL.Vertex3sv = new GL.Delegates.Vertex3sv(GL.Imports.Vertex3sv); + GL.Vertex4d = new GL.Delegates.Vertex4d(GL.Imports.Vertex4d); + GL.Vertex4dv = new GL.Delegates.Vertex4dv(GL.Imports.Vertex4dv); + GL.Vertex4f = new GL.Delegates.Vertex4f(GL.Imports.Vertex4f); + GL.Vertex4fv = new GL.Delegates.Vertex4fv(GL.Imports.Vertex4fv); + GL.Vertex4i = new GL.Delegates.Vertex4i(GL.Imports.Vertex4i); + GL.Vertex4iv = new GL.Delegates.Vertex4iv(GL.Imports.Vertex4iv); + GL.Vertex4s = new GL.Delegates.Vertex4s(GL.Imports.Vertex4s); + GL.Vertex4sv = new GL.Delegates.Vertex4sv(GL.Imports.Vertex4sv); + GL.ClipPlane = new GL.Delegates.ClipPlane(GL.Imports.ClipPlane); + GL.ColorMaterial = new GL.Delegates.ColorMaterial(GL.Imports.ColorMaterial); + GL.CullFace = new GL.Delegates.CullFace(GL.Imports.CullFace); + GL.Fogf = new GL.Delegates.Fogf(GL.Imports.Fogf); + GL.Fogfv = new GL.Delegates.Fogfv(GL.Imports.Fogfv); + GL.Fogi = new GL.Delegates.Fogi(GL.Imports.Fogi); + GL.Fogiv = new GL.Delegates.Fogiv(GL.Imports.Fogiv); + GL.FrontFace = new GL.Delegates.FrontFace(GL.Imports.FrontFace); + GL.Hint = new GL.Delegates.Hint(GL.Imports.Hint); + GL.Lightf = new GL.Delegates.Lightf(GL.Imports.Lightf); + GL.Lightfv = new GL.Delegates.Lightfv(GL.Imports.Lightfv); + GL.Lighti = new GL.Delegates.Lighti(GL.Imports.Lighti); + GL.Lightiv = new GL.Delegates.Lightiv(GL.Imports.Lightiv); + GL.LightModelf = new GL.Delegates.LightModelf(GL.Imports.LightModelf); + GL.LightModelfv = new GL.Delegates.LightModelfv(GL.Imports.LightModelfv); + GL.LightModeli = new GL.Delegates.LightModeli(GL.Imports.LightModeli); + GL.LightModeliv = new GL.Delegates.LightModeliv(GL.Imports.LightModeliv); + GL.LineStipple = new GL.Delegates.LineStipple(GL.Imports.LineStipple); + GL.LineWidth = new GL.Delegates.LineWidth(GL.Imports.LineWidth); + GL.Materialf = new GL.Delegates.Materialf(GL.Imports.Materialf); + GL.Materialfv = new GL.Delegates.Materialfv(GL.Imports.Materialfv); + GL.Materiali = new GL.Delegates.Materiali(GL.Imports.Materiali); + GL.Materialiv = new GL.Delegates.Materialiv(GL.Imports.Materialiv); + GL.PointSize = new GL.Delegates.PointSize(GL.Imports.PointSize); + GL.PolygonMode = new GL.Delegates.PolygonMode(GL.Imports.PolygonMode); + GL.PolygonStipple = new GL.Delegates.PolygonStipple(GL.Imports.PolygonStipple); + GL.Scissor = new GL.Delegates.Scissor(GL.Imports.Scissor); + GL.ShadeModel = new GL.Delegates.ShadeModel(GL.Imports.ShadeModel); + GL.TexParameterf = new GL.Delegates.TexParameterf(GL.Imports.TexParameterf); + GL.TexParameterfv = new GL.Delegates.TexParameterfv(GL.Imports.TexParameterfv); + GL.TexParameteri = new GL.Delegates.TexParameteri(GL.Imports.TexParameteri); + GL.TexParameteriv = new GL.Delegates.TexParameteriv(GL.Imports.TexParameteriv); + GL.TexImage1D = new GL.Delegates.TexImage1D(GL.Imports.TexImage1D); + GL.TexImage2D = new GL.Delegates.TexImage2D(GL.Imports.TexImage2D); + GL.TexEnvf = new GL.Delegates.TexEnvf(GL.Imports.TexEnvf); + GL.TexEnvfv = new GL.Delegates.TexEnvfv(GL.Imports.TexEnvfv); + GL.TexEnvi = new GL.Delegates.TexEnvi(GL.Imports.TexEnvi); + GL.TexEnviv = new GL.Delegates.TexEnviv(GL.Imports.TexEnviv); + GL.TexGend = new GL.Delegates.TexGend(GL.Imports.TexGend); + GL.TexGendv = new GL.Delegates.TexGendv(GL.Imports.TexGendv); + GL.TexGenf = new GL.Delegates.TexGenf(GL.Imports.TexGenf); + GL.TexGenfv = new GL.Delegates.TexGenfv(GL.Imports.TexGenfv); + GL.TexGeni = new GL.Delegates.TexGeni(GL.Imports.TexGeni); + GL.TexGeniv = new GL.Delegates.TexGeniv(GL.Imports.TexGeniv); + GL.FeedbackBuffer = new GL.Delegates.FeedbackBuffer(GL.Imports.FeedbackBuffer); + GL.SelectBuffer = new GL.Delegates.SelectBuffer(GL.Imports.SelectBuffer); + GL.RenderMode = new GL.Delegates.RenderMode(GL.Imports.RenderMode); + GL.InitNames = new GL.Delegates.InitNames(GL.Imports.InitNames); + GL.LoadName = new GL.Delegates.LoadName(GL.Imports.LoadName); + GL.PassThrough = new GL.Delegates.PassThrough(GL.Imports.PassThrough); + GL.PopName = new GL.Delegates.PopName(GL.Imports.PopName); + GL.PushName = new GL.Delegates.PushName(GL.Imports.PushName); + GL.DrawBuffer = new GL.Delegates.DrawBuffer(GL.Imports.DrawBuffer); + GL.Clear = new GL.Delegates.Clear(GL.Imports.Clear); + GL.ClearAccum = new GL.Delegates.ClearAccum(GL.Imports.ClearAccum); + GL.ClearIndex = new GL.Delegates.ClearIndex(GL.Imports.ClearIndex); + GL.ClearColor = new GL.Delegates.ClearColor(GL.Imports.ClearColor); + GL.ClearStencil = new GL.Delegates.ClearStencil(GL.Imports.ClearStencil); + GL.ClearDepth = new GL.Delegates.ClearDepth(GL.Imports.ClearDepth); + GL.StencilMask = new GL.Delegates.StencilMask(GL.Imports.StencilMask); + GL.ColorMask = new GL.Delegates.ColorMask(GL.Imports.ColorMask); + GL.DepthMask = new GL.Delegates.DepthMask(GL.Imports.DepthMask); + GL.IndexMask = new GL.Delegates.IndexMask(GL.Imports.IndexMask); + GL.Accum = new GL.Delegates.Accum(GL.Imports.Accum); + GL.Disable = new GL.Delegates.Disable(GL.Imports.Disable); + GL.Enable = new GL.Delegates.Enable(GL.Imports.Enable); + GL.Finish = new GL.Delegates.Finish(GL.Imports.Finish); + GL.Flush = new GL.Delegates.Flush(GL.Imports.Flush); + GL.PopAttrib = new GL.Delegates.PopAttrib(GL.Imports.PopAttrib); + GL.PushAttrib = new GL.Delegates.PushAttrib(GL.Imports.PushAttrib); + GL.Map1d = new GL.Delegates.Map1d(GL.Imports.Map1d); + GL.Map1f = new GL.Delegates.Map1f(GL.Imports.Map1f); + GL.Map2d = new GL.Delegates.Map2d(GL.Imports.Map2d); + GL.Map2f = new GL.Delegates.Map2f(GL.Imports.Map2f); + GL.MapGrid1d = new GL.Delegates.MapGrid1d(GL.Imports.MapGrid1d); + GL.MapGrid1f = new GL.Delegates.MapGrid1f(GL.Imports.MapGrid1f); + GL.MapGrid2d = new GL.Delegates.MapGrid2d(GL.Imports.MapGrid2d); + GL.MapGrid2f = new GL.Delegates.MapGrid2f(GL.Imports.MapGrid2f); + GL.EvalCoord1d = new GL.Delegates.EvalCoord1d(GL.Imports.EvalCoord1d); + GL.EvalCoord1dv = new GL.Delegates.EvalCoord1dv(GL.Imports.EvalCoord1dv); + GL.EvalCoord1f = new GL.Delegates.EvalCoord1f(GL.Imports.EvalCoord1f); + GL.EvalCoord1fv = new GL.Delegates.EvalCoord1fv(GL.Imports.EvalCoord1fv); + GL.EvalCoord2d = new GL.Delegates.EvalCoord2d(GL.Imports.EvalCoord2d); + GL.EvalCoord2dv = new GL.Delegates.EvalCoord2dv(GL.Imports.EvalCoord2dv); + GL.EvalCoord2f = new GL.Delegates.EvalCoord2f(GL.Imports.EvalCoord2f); + GL.EvalCoord2fv = new GL.Delegates.EvalCoord2fv(GL.Imports.EvalCoord2fv); + GL.EvalMesh1 = new GL.Delegates.EvalMesh1(GL.Imports.EvalMesh1); + GL.EvalPoint1 = new GL.Delegates.EvalPoint1(GL.Imports.EvalPoint1); + GL.EvalMesh2 = new GL.Delegates.EvalMesh2(GL.Imports.EvalMesh2); + GL.EvalPoint2 = new GL.Delegates.EvalPoint2(GL.Imports.EvalPoint2); + GL.AlphaFunc = new GL.Delegates.AlphaFunc(GL.Imports.AlphaFunc); + GL.BlendFunc = new GL.Delegates.BlendFunc(GL.Imports.BlendFunc); + GL.LogicOp = new GL.Delegates.LogicOp(GL.Imports.LogicOp); + GL.StencilFunc = new GL.Delegates.StencilFunc(GL.Imports.StencilFunc); + GL.StencilOp = new GL.Delegates.StencilOp(GL.Imports.StencilOp); + GL.DepthFunc = new GL.Delegates.DepthFunc(GL.Imports.DepthFunc); + GL.PixelZoom = new GL.Delegates.PixelZoom(GL.Imports.PixelZoom); + GL.PixelTransferf = new GL.Delegates.PixelTransferf(GL.Imports.PixelTransferf); + GL.PixelTransferi = new GL.Delegates.PixelTransferi(GL.Imports.PixelTransferi); + GL.PixelStoref = new GL.Delegates.PixelStoref(GL.Imports.PixelStoref); + GL.PixelStorei = new GL.Delegates.PixelStorei(GL.Imports.PixelStorei); + GL.PixelMapfv = new GL.Delegates.PixelMapfv(GL.Imports.PixelMapfv); + GL.PixelMapuiv = new GL.Delegates.PixelMapuiv(GL.Imports.PixelMapuiv); + GL.PixelMapusv = new GL.Delegates.PixelMapusv(GL.Imports.PixelMapusv); + GL.ReadBuffer = new GL.Delegates.ReadBuffer(GL.Imports.ReadBuffer); + GL.CopyPixels = new GL.Delegates.CopyPixels(GL.Imports.CopyPixels); + GL.ReadPixels_ = new GL.Delegates.ReadPixels_(GL.Imports.ReadPixels_); + GL.DrawPixels_ = new GL.Delegates.DrawPixels_(GL.Imports.DrawPixels_); + GL.GetBooleanv = new GL.Delegates.GetBooleanv(GL.Imports.GetBooleanv); + GL.GetClipPlane = new GL.Delegates.GetClipPlane(GL.Imports.GetClipPlane); + GL.GetDoublev = new GL.Delegates.GetDoublev(GL.Imports.GetDoublev); + GL.GetError = new GL.Delegates.GetError(GL.Imports.GetError); + GL.GetFloatv = new GL.Delegates.GetFloatv(GL.Imports.GetFloatv); + GL.GetIntegerv = new GL.Delegates.GetIntegerv(GL.Imports.GetIntegerv); + GL.GetLightfv = new GL.Delegates.GetLightfv(GL.Imports.GetLightfv); + GL.GetLightiv = new GL.Delegates.GetLightiv(GL.Imports.GetLightiv); + GL.GetMapdv = new GL.Delegates.GetMapdv(GL.Imports.GetMapdv); + GL.GetMapfv = new GL.Delegates.GetMapfv(GL.Imports.GetMapfv); + GL.GetMapiv = new GL.Delegates.GetMapiv(GL.Imports.GetMapiv); + GL.GetMaterialfv = new GL.Delegates.GetMaterialfv(GL.Imports.GetMaterialfv); + GL.GetMaterialiv = new GL.Delegates.GetMaterialiv(GL.Imports.GetMaterialiv); + GL.GetPixelMapfv = new GL.Delegates.GetPixelMapfv(GL.Imports.GetPixelMapfv); + GL.GetPixelMapuiv = new GL.Delegates.GetPixelMapuiv(GL.Imports.GetPixelMapuiv); + GL.GetPixelMapusv = new GL.Delegates.GetPixelMapusv(GL.Imports.GetPixelMapusv); + GL.GetPolygonStipple = new GL.Delegates.GetPolygonStipple(GL.Imports.GetPolygonStipple); + GL.GetString = new GL.Delegates.GetString(GL.Imports.GetString); + GL.GetTexEnvfv = new GL.Delegates.GetTexEnvfv(GL.Imports.GetTexEnvfv); + GL.GetTexEnviv = new GL.Delegates.GetTexEnviv(GL.Imports.GetTexEnviv); + GL.GetTexGendv = new GL.Delegates.GetTexGendv(GL.Imports.GetTexGendv); + GL.GetTexGenfv = new GL.Delegates.GetTexGenfv(GL.Imports.GetTexGenfv); + GL.GetTexGeniv = new GL.Delegates.GetTexGeniv(GL.Imports.GetTexGeniv); + GL.GetTexImage = new GL.Delegates.GetTexImage(GL.Imports.GetTexImage); + GL.GetTexParameterfv = new GL.Delegates.GetTexParameterfv(GL.Imports.GetTexParameterfv); + GL.GetTexParameteriv = new GL.Delegates.GetTexParameteriv(GL.Imports.GetTexParameteriv); + GL.GetTexLevelParameterfv = new GL.Delegates.GetTexLevelParameterfv(GL.Imports.GetTexLevelParameterfv); + GL.GetTexLevelParameteriv = new GL.Delegates.GetTexLevelParameteriv(GL.Imports.GetTexLevelParameteriv); + GL.IsEnabled = new GL.Delegates.IsEnabled(GL.Imports.IsEnabled); + GL.IsList = new GL.Delegates.IsList(GL.Imports.IsList); + GL.DepthRange = new GL.Delegates.DepthRange(GL.Imports.DepthRange); + GL.Frustum = new GL.Delegates.Frustum(GL.Imports.Frustum); + GL.LoadIdentity = new GL.Delegates.LoadIdentity(GL.Imports.LoadIdentity); + GL.LoadMatrixf = new GL.Delegates.LoadMatrixf(GL.Imports.LoadMatrixf); + GL.LoadMatrixd = new GL.Delegates.LoadMatrixd(GL.Imports.LoadMatrixd); + GL.MatrixMode = new GL.Delegates.MatrixMode(GL.Imports.MatrixMode); + GL.MultMatrixf = new GL.Delegates.MultMatrixf(GL.Imports.MultMatrixf); + GL.MultMatrixd = new GL.Delegates.MultMatrixd(GL.Imports.MultMatrixd); + GL.Ortho = new GL.Delegates.Ortho(GL.Imports.Ortho); + GL.PopMatrix = new GL.Delegates.PopMatrix(GL.Imports.PopMatrix); + GL.PushMatrix = new GL.Delegates.PushMatrix(GL.Imports.PushMatrix); + GL.Rotated = new GL.Delegates.Rotated(GL.Imports.Rotated); + GL.Rotatef = new GL.Delegates.Rotatef(GL.Imports.Rotatef); + GL.Scaled = new GL.Delegates.Scaled(GL.Imports.Scaled); + GL.Scalef = new GL.Delegates.Scalef(GL.Imports.Scalef); + GL.Translated = new GL.Delegates.Translated(GL.Imports.Translated); + GL.Translatef = new GL.Delegates.Translatef(GL.Imports.Translatef); + GL.Viewport = new GL.Delegates.Viewport(GL.Imports.Viewport); + GL.ArrayElement = new GL.Delegates.ArrayElement(GL.Imports.ArrayElement); + GL.ColorPointer_ = new GL.Delegates.ColorPointer_(GL.Imports.ColorPointer_); + GL.DisableClientState = new GL.Delegates.DisableClientState(GL.Imports.DisableClientState); + GL.DrawArrays = new GL.Delegates.DrawArrays(GL.Imports.DrawArrays); + GL.DrawElements_ = new GL.Delegates.DrawElements_(GL.Imports.DrawElements_); + GL.EdgeFlagPointer_ = new GL.Delegates.EdgeFlagPointer_(GL.Imports.EdgeFlagPointer_); + GL.EnableClientState = new GL.Delegates.EnableClientState(GL.Imports.EnableClientState); + GL.GetPointerv = new GL.Delegates.GetPointerv(GL.Imports.GetPointerv); + GL.IndexPointer_ = new GL.Delegates.IndexPointer_(GL.Imports.IndexPointer_); + GL.InterleavedArrays_ = new GL.Delegates.InterleavedArrays_(GL.Imports.InterleavedArrays_); + GL.NormalPointer_ = new GL.Delegates.NormalPointer_(GL.Imports.NormalPointer_); + GL.TexCoordPointer_ = new GL.Delegates.TexCoordPointer_(GL.Imports.TexCoordPointer_); + GL.VertexPointer_ = new GL.Delegates.VertexPointer_(GL.Imports.VertexPointer_); + GL.PolygonOffset = new GL.Delegates.PolygonOffset(GL.Imports.PolygonOffset); + GL.CopyTexImage1D = new GL.Delegates.CopyTexImage1D(GL.Imports.CopyTexImage1D); + GL.CopyTexImage2D = new GL.Delegates.CopyTexImage2D(GL.Imports.CopyTexImage2D); + GL.CopyTexSubImage1D = new GL.Delegates.CopyTexSubImage1D(GL.Imports.CopyTexSubImage1D); + GL.CopyTexSubImage2D = new GL.Delegates.CopyTexSubImage2D(GL.Imports.CopyTexSubImage2D); + GL.TexSubImage1D = new GL.Delegates.TexSubImage1D(GL.Imports.TexSubImage1D); + GL.TexSubImage2D = new GL.Delegates.TexSubImage2D(GL.Imports.TexSubImage2D); + GL.AreTexturesResident = new GL.Delegates.AreTexturesResident(GL.Imports.AreTexturesResident); + GL.BindTexture = new GL.Delegates.BindTexture(GL.Imports.BindTexture); + GL.DeleteTextures = new GL.Delegates.DeleteTextures(GL.Imports.DeleteTextures); + GL.GenTextures = new GL.Delegates.GenTextures(GL.Imports.GenTextures); + GL.IsTexture = new GL.Delegates.IsTexture(GL.Imports.IsTexture); + GL.PrioritizeTextures = new GL.Delegates.PrioritizeTextures(GL.Imports.PrioritizeTextures); + GL.Indexub = new GL.Delegates.Indexub(GL.Imports.Indexub); + GL.Indexubv = new GL.Delegates.Indexubv(GL.Imports.Indexubv); + GL.PopClientAttrib = new GL.Delegates.PopClientAttrib(GL.Imports.PopClientAttrib); + GL.PushClientAttrib = new GL.Delegates.PushClientAttrib(GL.Imports.PushClientAttrib); + GL.BlendColor = new GL.Delegates.BlendColor(GL.Imports.BlendColor); + GL.BlendEquation = new GL.Delegates.BlendEquation(GL.Imports.BlendEquation); + GL.DrawRangeElements_ = new GL.Delegates.DrawRangeElements_(GL.Imports.DrawRangeElements_); + GL.ColorTable_ = new GL.Delegates.ColorTable_(GL.Imports.ColorTable_); + GL.ColorTableParameterfv = new GL.Delegates.ColorTableParameterfv(GL.Imports.ColorTableParameterfv); + GL.ColorTableParameteriv = new GL.Delegates.ColorTableParameteriv(GL.Imports.ColorTableParameteriv); + GL.CopyColorTable = new GL.Delegates.CopyColorTable(GL.Imports.CopyColorTable); + GL.GetColorTable_ = new GL.Delegates.GetColorTable_(GL.Imports.GetColorTable_); + GL.GetColorTableParameterfv = new GL.Delegates.GetColorTableParameterfv(GL.Imports.GetColorTableParameterfv); + GL.GetColorTableParameteriv = new GL.Delegates.GetColorTableParameteriv(GL.Imports.GetColorTableParameteriv); + GL.ColorSubTable_ = new GL.Delegates.ColorSubTable_(GL.Imports.ColorSubTable_); + GL.CopyColorSubTable = new GL.Delegates.CopyColorSubTable(GL.Imports.CopyColorSubTable); + GL.ConvolutionFilter1D_ = new GL.Delegates.ConvolutionFilter1D_(GL.Imports.ConvolutionFilter1D_); + GL.ConvolutionFilter2D_ = new GL.Delegates.ConvolutionFilter2D_(GL.Imports.ConvolutionFilter2D_); + GL.ConvolutionParameterf = new GL.Delegates.ConvolutionParameterf(GL.Imports.ConvolutionParameterf); + GL.ConvolutionParameterfv = new GL.Delegates.ConvolutionParameterfv(GL.Imports.ConvolutionParameterfv); + GL.ConvolutionParameteri = new GL.Delegates.ConvolutionParameteri(GL.Imports.ConvolutionParameteri); + GL.ConvolutionParameteriv = new GL.Delegates.ConvolutionParameteriv(GL.Imports.ConvolutionParameteriv); + GL.CopyConvolutionFilter1D = new GL.Delegates.CopyConvolutionFilter1D(GL.Imports.CopyConvolutionFilter1D); + GL.CopyConvolutionFilter2D = new GL.Delegates.CopyConvolutionFilter2D(GL.Imports.CopyConvolutionFilter2D); + GL.GetConvolutionFilter_ = new GL.Delegates.GetConvolutionFilter_(GL.Imports.GetConvolutionFilter_); + GL.GetConvolutionParameterfv = new GL.Delegates.GetConvolutionParameterfv(GL.Imports.GetConvolutionParameterfv); + GL.GetConvolutionParameteriv = new GL.Delegates.GetConvolutionParameteriv(GL.Imports.GetConvolutionParameteriv); + GL.GetSeparableFilter_ = new GL.Delegates.GetSeparableFilter_(GL.Imports.GetSeparableFilter_); + GL.SeparableFilter2D_ = new GL.Delegates.SeparableFilter2D_(GL.Imports.SeparableFilter2D_); + GL.GetHistogram_ = new GL.Delegates.GetHistogram_(GL.Imports.GetHistogram_); + GL.GetHistogramParameterfv = new GL.Delegates.GetHistogramParameterfv(GL.Imports.GetHistogramParameterfv); + GL.GetHistogramParameteriv = new GL.Delegates.GetHistogramParameteriv(GL.Imports.GetHistogramParameteriv); + GL.GetMinmax_ = new GL.Delegates.GetMinmax_(GL.Imports.GetMinmax_); + GL.GetMinmaxParameterfv = new GL.Delegates.GetMinmaxParameterfv(GL.Imports.GetMinmaxParameterfv); + GL.GetMinmaxParameteriv = new GL.Delegates.GetMinmaxParameteriv(GL.Imports.GetMinmaxParameteriv); + GL.Histogram = new GL.Delegates.Histogram(GL.Imports.Histogram); + GL.Minmax = new GL.Delegates.Minmax(GL.Imports.Minmax); + GL.ResetHistogram = new GL.Delegates.ResetHistogram(GL.Imports.ResetHistogram); + GL.ResetMinmax = new GL.Delegates.ResetMinmax(GL.Imports.ResetMinmax); + GL.TexImage3D = new GL.Delegates.TexImage3D(GL.Imports.TexImage3D); + GL.TexSubImage3D = new GL.Delegates.TexSubImage3D(GL.Imports.TexSubImage3D); + GL.CopyTexSubImage3D = new GL.Delegates.CopyTexSubImage3D(GL.Imports.CopyTexSubImage3D); + GL.ActiveTexture = new GL.Delegates.ActiveTexture(GL.Imports.ActiveTexture); + GL.ClientActiveTexture = new GL.Delegates.ClientActiveTexture(GL.Imports.ClientActiveTexture); + GL.MultiTexCoord1d = new GL.Delegates.MultiTexCoord1d(GL.Imports.MultiTexCoord1d); + GL.MultiTexCoord1dv = new GL.Delegates.MultiTexCoord1dv(GL.Imports.MultiTexCoord1dv); + GL.MultiTexCoord1f = new GL.Delegates.MultiTexCoord1f(GL.Imports.MultiTexCoord1f); + GL.MultiTexCoord1fv = new GL.Delegates.MultiTexCoord1fv(GL.Imports.MultiTexCoord1fv); + GL.MultiTexCoord1i = new GL.Delegates.MultiTexCoord1i(GL.Imports.MultiTexCoord1i); + GL.MultiTexCoord1iv = new GL.Delegates.MultiTexCoord1iv(GL.Imports.MultiTexCoord1iv); + GL.MultiTexCoord1s = new GL.Delegates.MultiTexCoord1s(GL.Imports.MultiTexCoord1s); + GL.MultiTexCoord1sv = new GL.Delegates.MultiTexCoord1sv(GL.Imports.MultiTexCoord1sv); + GL.MultiTexCoord2d = new GL.Delegates.MultiTexCoord2d(GL.Imports.MultiTexCoord2d); + GL.MultiTexCoord2dv = new GL.Delegates.MultiTexCoord2dv(GL.Imports.MultiTexCoord2dv); + GL.MultiTexCoord2f = new GL.Delegates.MultiTexCoord2f(GL.Imports.MultiTexCoord2f); + GL.MultiTexCoord2fv = new GL.Delegates.MultiTexCoord2fv(GL.Imports.MultiTexCoord2fv); + GL.MultiTexCoord2i = new GL.Delegates.MultiTexCoord2i(GL.Imports.MultiTexCoord2i); + GL.MultiTexCoord2iv = new GL.Delegates.MultiTexCoord2iv(GL.Imports.MultiTexCoord2iv); + GL.MultiTexCoord2s = new GL.Delegates.MultiTexCoord2s(GL.Imports.MultiTexCoord2s); + GL.MultiTexCoord2sv = new GL.Delegates.MultiTexCoord2sv(GL.Imports.MultiTexCoord2sv); + GL.MultiTexCoord3d = new GL.Delegates.MultiTexCoord3d(GL.Imports.MultiTexCoord3d); + GL.MultiTexCoord3dv = new GL.Delegates.MultiTexCoord3dv(GL.Imports.MultiTexCoord3dv); + GL.MultiTexCoord3f = new GL.Delegates.MultiTexCoord3f(GL.Imports.MultiTexCoord3f); + GL.MultiTexCoord3fv = new GL.Delegates.MultiTexCoord3fv(GL.Imports.MultiTexCoord3fv); + GL.MultiTexCoord3i = new GL.Delegates.MultiTexCoord3i(GL.Imports.MultiTexCoord3i); + GL.MultiTexCoord3iv = new GL.Delegates.MultiTexCoord3iv(GL.Imports.MultiTexCoord3iv); + GL.MultiTexCoord3s = new GL.Delegates.MultiTexCoord3s(GL.Imports.MultiTexCoord3s); + GL.MultiTexCoord3sv = new GL.Delegates.MultiTexCoord3sv(GL.Imports.MultiTexCoord3sv); + GL.MultiTexCoord4d = new GL.Delegates.MultiTexCoord4d(GL.Imports.MultiTexCoord4d); + GL.MultiTexCoord4dv = new GL.Delegates.MultiTexCoord4dv(GL.Imports.MultiTexCoord4dv); + GL.MultiTexCoord4f = new GL.Delegates.MultiTexCoord4f(GL.Imports.MultiTexCoord4f); + GL.MultiTexCoord4fv = new GL.Delegates.MultiTexCoord4fv(GL.Imports.MultiTexCoord4fv); + GL.MultiTexCoord4i = new GL.Delegates.MultiTexCoord4i(GL.Imports.MultiTexCoord4i); + GL.MultiTexCoord4iv = new GL.Delegates.MultiTexCoord4iv(GL.Imports.MultiTexCoord4iv); + GL.MultiTexCoord4s = new GL.Delegates.MultiTexCoord4s(GL.Imports.MultiTexCoord4s); + GL.MultiTexCoord4sv = new GL.Delegates.MultiTexCoord4sv(GL.Imports.MultiTexCoord4sv); + GL.LoadTransposeMatrixf = new GL.Delegates.LoadTransposeMatrixf(GL.Imports.LoadTransposeMatrixf); + GL.LoadTransposeMatrixd = new GL.Delegates.LoadTransposeMatrixd(GL.Imports.LoadTransposeMatrixd); + GL.MultTransposeMatrixf = new GL.Delegates.MultTransposeMatrixf(GL.Imports.MultTransposeMatrixf); + GL.MultTransposeMatrixd = new GL.Delegates.MultTransposeMatrixd(GL.Imports.MultTransposeMatrixd); + GL.SampleCoverage = new GL.Delegates.SampleCoverage(GL.Imports.SampleCoverage); + GL.CompressedTexImage3D = new GL.Delegates.CompressedTexImage3D(GL.Imports.CompressedTexImage3D); + GL.CompressedTexImage2D = new GL.Delegates.CompressedTexImage2D(GL.Imports.CompressedTexImage2D); + GL.CompressedTexImage1D = new GL.Delegates.CompressedTexImage1D(GL.Imports.CompressedTexImage1D); + GL.CompressedTexSubImage3D = new GL.Delegates.CompressedTexSubImage3D(GL.Imports.CompressedTexSubImage3D); + GL.CompressedTexSubImage2D = new GL.Delegates.CompressedTexSubImage2D(GL.Imports.CompressedTexSubImage2D); + GL.CompressedTexSubImage1D = new GL.Delegates.CompressedTexSubImage1D(GL.Imports.CompressedTexSubImage1D); + GL.GetCompressedTexImage = new GL.Delegates.GetCompressedTexImage(GL.Imports.GetCompressedTexImage); + GL.BlendFuncSeparate = new GL.Delegates.BlendFuncSeparate(GL.Imports.BlendFuncSeparate); + GL.FogCoordf = new GL.Delegates.FogCoordf(GL.Imports.FogCoordf); + GL.FogCoordfv = new GL.Delegates.FogCoordfv(GL.Imports.FogCoordfv); + GL.FogCoordd = new GL.Delegates.FogCoordd(GL.Imports.FogCoordd); + GL.FogCoorddv = new GL.Delegates.FogCoorddv(GL.Imports.FogCoorddv); + GL.FogCoordPointer_ = new GL.Delegates.FogCoordPointer_(GL.Imports.FogCoordPointer_); + GL.MultiDrawArrays = new GL.Delegates.MultiDrawArrays(GL.Imports.MultiDrawArrays); + GL.MultiDrawElements = new GL.Delegates.MultiDrawElements(GL.Imports.MultiDrawElements); + GL.PointParameterf = new GL.Delegates.PointParameterf(GL.Imports.PointParameterf); + GL.PointParameterfv = new GL.Delegates.PointParameterfv(GL.Imports.PointParameterfv); + GL.PointParameteri = new GL.Delegates.PointParameteri(GL.Imports.PointParameteri); + GL.PointParameteriv = new GL.Delegates.PointParameteriv(GL.Imports.PointParameteriv); + GL.SecondaryColor3b = new GL.Delegates.SecondaryColor3b(GL.Imports.SecondaryColor3b); + GL.SecondaryColor3bv = new GL.Delegates.SecondaryColor3bv(GL.Imports.SecondaryColor3bv); + GL.SecondaryColor3d = new GL.Delegates.SecondaryColor3d(GL.Imports.SecondaryColor3d); + GL.SecondaryColor3dv = new GL.Delegates.SecondaryColor3dv(GL.Imports.SecondaryColor3dv); + GL.SecondaryColor3f = new GL.Delegates.SecondaryColor3f(GL.Imports.SecondaryColor3f); + GL.SecondaryColor3fv = new GL.Delegates.SecondaryColor3fv(GL.Imports.SecondaryColor3fv); + GL.SecondaryColor3i = new GL.Delegates.SecondaryColor3i(GL.Imports.SecondaryColor3i); + GL.SecondaryColor3iv = new GL.Delegates.SecondaryColor3iv(GL.Imports.SecondaryColor3iv); + GL.SecondaryColor3s = new GL.Delegates.SecondaryColor3s(GL.Imports.SecondaryColor3s); + GL.SecondaryColor3sv = new GL.Delegates.SecondaryColor3sv(GL.Imports.SecondaryColor3sv); + GL.SecondaryColor3ub = new GL.Delegates.SecondaryColor3ub(GL.Imports.SecondaryColor3ub); + GL.SecondaryColor3ubv = new GL.Delegates.SecondaryColor3ubv(GL.Imports.SecondaryColor3ubv); + GL.SecondaryColor3ui = new GL.Delegates.SecondaryColor3ui(GL.Imports.SecondaryColor3ui); + GL.SecondaryColor3uiv = new GL.Delegates.SecondaryColor3uiv(GL.Imports.SecondaryColor3uiv); + GL.SecondaryColor3us = new GL.Delegates.SecondaryColor3us(GL.Imports.SecondaryColor3us); + GL.SecondaryColor3usv = new GL.Delegates.SecondaryColor3usv(GL.Imports.SecondaryColor3usv); + GL.SecondaryColorPointer_ = new GL.Delegates.SecondaryColorPointer_(GL.Imports.SecondaryColorPointer_); + GL.WindowPos2d = new GL.Delegates.WindowPos2d(GL.Imports.WindowPos2d); + GL.WindowPos2dv = new GL.Delegates.WindowPos2dv(GL.Imports.WindowPos2dv); + GL.WindowPos2f = new GL.Delegates.WindowPos2f(GL.Imports.WindowPos2f); + GL.WindowPos2fv = new GL.Delegates.WindowPos2fv(GL.Imports.WindowPos2fv); + GL.WindowPos2i = new GL.Delegates.WindowPos2i(GL.Imports.WindowPos2i); + GL.WindowPos2iv = new GL.Delegates.WindowPos2iv(GL.Imports.WindowPos2iv); + GL.WindowPos2s = new GL.Delegates.WindowPos2s(GL.Imports.WindowPos2s); + GL.WindowPos2sv = new GL.Delegates.WindowPos2sv(GL.Imports.WindowPos2sv); + GL.WindowPos3d = new GL.Delegates.WindowPos3d(GL.Imports.WindowPos3d); + GL.WindowPos3dv = new GL.Delegates.WindowPos3dv(GL.Imports.WindowPos3dv); + GL.WindowPos3f = new GL.Delegates.WindowPos3f(GL.Imports.WindowPos3f); + GL.WindowPos3fv = new GL.Delegates.WindowPos3fv(GL.Imports.WindowPos3fv); + GL.WindowPos3i = new GL.Delegates.WindowPos3i(GL.Imports.WindowPos3i); + GL.WindowPos3iv = new GL.Delegates.WindowPos3iv(GL.Imports.WindowPos3iv); + GL.WindowPos3s = new GL.Delegates.WindowPos3s(GL.Imports.WindowPos3s); + GL.WindowPos3sv = new GL.Delegates.WindowPos3sv(GL.Imports.WindowPos3sv); } - - #endregion - - #region Load extensions - - /// - /// Loads the opengl extensions (e.g. ARB, EXT, vendor and platform specific functions). - /// - public override void LoadExtensions() - { - GL.ActiveTextureARB = (GL.Delegates.ActiveTextureARB) GetAddress("glActiveTextureARB", typeof(GL.Delegates.ActiveTextureARB)); - GL.ClientActiveTextureARB = (GL.Delegates.ClientActiveTextureARB) GetAddress("glClientActiveTextureARB", typeof(GL.Delegates.ClientActiveTextureARB)); - GL.MultiTexCoord1dARB = (GL.Delegates.MultiTexCoord1dARB) GetAddress("glMultiTexCoord1dARB", typeof(GL.Delegates.MultiTexCoord1dARB)); - GL.MultiTexCoord1dvARB = (GL.Delegates.MultiTexCoord1dvARB) GetAddress("glMultiTexCoord1dvARB", typeof(GL.Delegates.MultiTexCoord1dvARB)); - GL.MultiTexCoord1fARB = (GL.Delegates.MultiTexCoord1fARB) GetAddress("glMultiTexCoord1fARB", typeof(GL.Delegates.MultiTexCoord1fARB)); - GL.MultiTexCoord1fvARB = (GL.Delegates.MultiTexCoord1fvARB) GetAddress("glMultiTexCoord1fvARB", typeof(GL.Delegates.MultiTexCoord1fvARB)); - GL.MultiTexCoord1iARB = (GL.Delegates.MultiTexCoord1iARB) GetAddress("glMultiTexCoord1iARB", typeof(GL.Delegates.MultiTexCoord1iARB)); - GL.MultiTexCoord1ivARB = (GL.Delegates.MultiTexCoord1ivARB) GetAddress("glMultiTexCoord1ivARB", typeof(GL.Delegates.MultiTexCoord1ivARB)); - GL.MultiTexCoord1sARB = (GL.Delegates.MultiTexCoord1sARB) GetAddress("glMultiTexCoord1sARB", typeof(GL.Delegates.MultiTexCoord1sARB)); - GL.MultiTexCoord1svARB = (GL.Delegates.MultiTexCoord1svARB) GetAddress("glMultiTexCoord1svARB", typeof(GL.Delegates.MultiTexCoord1svARB)); - GL.MultiTexCoord2dARB = (GL.Delegates.MultiTexCoord2dARB) GetAddress("glMultiTexCoord2dARB", typeof(GL.Delegates.MultiTexCoord2dARB)); - GL.MultiTexCoord2dvARB = (GL.Delegates.MultiTexCoord2dvARB) GetAddress("glMultiTexCoord2dvARB", typeof(GL.Delegates.MultiTexCoord2dvARB)); - GL.MultiTexCoord2fARB = (GL.Delegates.MultiTexCoord2fARB) GetAddress("glMultiTexCoord2fARB", typeof(GL.Delegates.MultiTexCoord2fARB)); - GL.MultiTexCoord2fvARB = (GL.Delegates.MultiTexCoord2fvARB) GetAddress("glMultiTexCoord2fvARB", typeof(GL.Delegates.MultiTexCoord2fvARB)); - GL.MultiTexCoord2iARB = (GL.Delegates.MultiTexCoord2iARB) GetAddress("glMultiTexCoord2iARB", typeof(GL.Delegates.MultiTexCoord2iARB)); - GL.MultiTexCoord2ivARB = (GL.Delegates.MultiTexCoord2ivARB) GetAddress("glMultiTexCoord2ivARB", typeof(GL.Delegates.MultiTexCoord2ivARB)); - GL.MultiTexCoord2sARB = (GL.Delegates.MultiTexCoord2sARB) GetAddress("glMultiTexCoord2sARB", typeof(GL.Delegates.MultiTexCoord2sARB)); - GL.MultiTexCoord2svARB = (GL.Delegates.MultiTexCoord2svARB) GetAddress("glMultiTexCoord2svARB", typeof(GL.Delegates.MultiTexCoord2svARB)); - GL.MultiTexCoord3dARB = (GL.Delegates.MultiTexCoord3dARB) GetAddress("glMultiTexCoord3dARB", typeof(GL.Delegates.MultiTexCoord3dARB)); - GL.MultiTexCoord3dvARB = (GL.Delegates.MultiTexCoord3dvARB) GetAddress("glMultiTexCoord3dvARB", typeof(GL.Delegates.MultiTexCoord3dvARB)); - GL.MultiTexCoord3fARB = (GL.Delegates.MultiTexCoord3fARB) GetAddress("glMultiTexCoord3fARB", typeof(GL.Delegates.MultiTexCoord3fARB)); - GL.MultiTexCoord3fvARB = (GL.Delegates.MultiTexCoord3fvARB) GetAddress("glMultiTexCoord3fvARB", typeof(GL.Delegates.MultiTexCoord3fvARB)); - GL.MultiTexCoord3iARB = (GL.Delegates.MultiTexCoord3iARB) GetAddress("glMultiTexCoord3iARB", typeof(GL.Delegates.MultiTexCoord3iARB)); - GL.MultiTexCoord3ivARB = (GL.Delegates.MultiTexCoord3ivARB) GetAddress("glMultiTexCoord3ivARB", typeof(GL.Delegates.MultiTexCoord3ivARB)); - GL.MultiTexCoord3sARB = (GL.Delegates.MultiTexCoord3sARB) GetAddress("glMultiTexCoord3sARB", typeof(GL.Delegates.MultiTexCoord3sARB)); - GL.MultiTexCoord3svARB = (GL.Delegates.MultiTexCoord3svARB) GetAddress("glMultiTexCoord3svARB", typeof(GL.Delegates.MultiTexCoord3svARB)); - GL.MultiTexCoord4dARB = (GL.Delegates.MultiTexCoord4dARB) GetAddress("glMultiTexCoord4dARB", typeof(GL.Delegates.MultiTexCoord4dARB)); - GL.MultiTexCoord4dvARB = (GL.Delegates.MultiTexCoord4dvARB) GetAddress("glMultiTexCoord4dvARB", typeof(GL.Delegates.MultiTexCoord4dvARB)); - GL.MultiTexCoord4fARB = (GL.Delegates.MultiTexCoord4fARB) GetAddress("glMultiTexCoord4fARB", typeof(GL.Delegates.MultiTexCoord4fARB)); - GL.MultiTexCoord4fvARB = (GL.Delegates.MultiTexCoord4fvARB) GetAddress("glMultiTexCoord4fvARB", typeof(GL.Delegates.MultiTexCoord4fvARB)); - GL.MultiTexCoord4iARB = (GL.Delegates.MultiTexCoord4iARB) GetAddress("glMultiTexCoord4iARB", typeof(GL.Delegates.MultiTexCoord4iARB)); - GL.MultiTexCoord4ivARB = (GL.Delegates.MultiTexCoord4ivARB) GetAddress("glMultiTexCoord4ivARB", typeof(GL.Delegates.MultiTexCoord4ivARB)); - GL.MultiTexCoord4sARB = (GL.Delegates.MultiTexCoord4sARB) GetAddress("glMultiTexCoord4sARB", typeof(GL.Delegates.MultiTexCoord4sARB)); - GL.MultiTexCoord4svARB = (GL.Delegates.MultiTexCoord4svARB) GetAddress("glMultiTexCoord4svARB", typeof(GL.Delegates.MultiTexCoord4svARB)); - GL.LoadTransposeMatrixfARB = (GL.Delegates.LoadTransposeMatrixfARB) GetAddress("glLoadTransposeMatrixfARB", typeof(GL.Delegates.LoadTransposeMatrixfARB)); - GL.LoadTransposeMatrixdARB = (GL.Delegates.LoadTransposeMatrixdARB) GetAddress("glLoadTransposeMatrixdARB", typeof(GL.Delegates.LoadTransposeMatrixdARB)); - GL.MultTransposeMatrixfARB = (GL.Delegates.MultTransposeMatrixfARB) GetAddress("glMultTransposeMatrixfARB", typeof(GL.Delegates.MultTransposeMatrixfARB)); - GL.MultTransposeMatrixdARB = (GL.Delegates.MultTransposeMatrixdARB) GetAddress("glMultTransposeMatrixdARB", typeof(GL.Delegates.MultTransposeMatrixdARB)); - GL.SampleCoverageARB = (GL.Delegates.SampleCoverageARB) GetAddress("glSampleCoverageARB", typeof(GL.Delegates.SampleCoverageARB)); - GL.CompressedTexImage3DARB = (GL.Delegates.CompressedTexImage3DARB) GetAddress("glCompressedTexImage3DARB", typeof(GL.Delegates.CompressedTexImage3DARB)); - GL.CompressedTexImage2DARB = (GL.Delegates.CompressedTexImage2DARB) GetAddress("glCompressedTexImage2DARB", typeof(GL.Delegates.CompressedTexImage2DARB)); - GL.CompressedTexImage1DARB = (GL.Delegates.CompressedTexImage1DARB) GetAddress("glCompressedTexImage1DARB", typeof(GL.Delegates.CompressedTexImage1DARB)); - GL.CompressedTexSubImage3DARB = (GL.Delegates.CompressedTexSubImage3DARB) GetAddress("glCompressedTexSubImage3DARB", typeof(GL.Delegates.CompressedTexSubImage3DARB)); - GL.CompressedTexSubImage2DARB = (GL.Delegates.CompressedTexSubImage2DARB) GetAddress("glCompressedTexSubImage2DARB", typeof(GL.Delegates.CompressedTexSubImage2DARB)); - GL.CompressedTexSubImage1DARB = (GL.Delegates.CompressedTexSubImage1DARB) GetAddress("glCompressedTexSubImage1DARB", typeof(GL.Delegates.CompressedTexSubImage1DARB)); - GL.GetCompressedTexImageARB = (GL.Delegates.GetCompressedTexImageARB) GetAddress("glGetCompressedTexImageARB", typeof(GL.Delegates.GetCompressedTexImageARB)); - GL.PointParameterfARB = (GL.Delegates.PointParameterfARB) GetAddress("glPointParameterfARB", typeof(GL.Delegates.PointParameterfARB)); - GL.PointParameterfvARB = (GL.Delegates.PointParameterfvARB) GetAddress("glPointParameterfvARB", typeof(GL.Delegates.PointParameterfvARB)); - GL.WeightbvARB = (GL.Delegates.WeightbvARB) GetAddress("glWeightbvARB", typeof(GL.Delegates.WeightbvARB)); - GL.WeightsvARB = (GL.Delegates.WeightsvARB) GetAddress("glWeightsvARB", typeof(GL.Delegates.WeightsvARB)); - GL.WeightivARB = (GL.Delegates.WeightivARB) GetAddress("glWeightivARB", typeof(GL.Delegates.WeightivARB)); - GL.WeightfvARB = (GL.Delegates.WeightfvARB) GetAddress("glWeightfvARB", typeof(GL.Delegates.WeightfvARB)); - GL.WeightdvARB = (GL.Delegates.WeightdvARB) GetAddress("glWeightdvARB", typeof(GL.Delegates.WeightdvARB)); - GL.WeightubvARB = (GL.Delegates.WeightubvARB) GetAddress("glWeightubvARB", typeof(GL.Delegates.WeightubvARB)); - GL.WeightusvARB = (GL.Delegates.WeightusvARB) GetAddress("glWeightusvARB", typeof(GL.Delegates.WeightusvARB)); - GL.WeightuivARB = (GL.Delegates.WeightuivARB) GetAddress("glWeightuivARB", typeof(GL.Delegates.WeightuivARB)); - GL.WeightPointerARB = (GL.Delegates.WeightPointerARB) GetAddress("glWeightPointerARB", typeof(GL.Delegates.WeightPointerARB)); - GL.VertexBlendARB = (GL.Delegates.VertexBlendARB) GetAddress("glVertexBlendARB", typeof(GL.Delegates.VertexBlendARB)); - GL.CurrentPaletteMatrixARB = (GL.Delegates.CurrentPaletteMatrixARB) GetAddress("glCurrentPaletteMatrixARB", typeof(GL.Delegates.CurrentPaletteMatrixARB)); - GL.MatrixIndexubvARB = (GL.Delegates.MatrixIndexubvARB) GetAddress("glMatrixIndexubvARB", typeof(GL.Delegates.MatrixIndexubvARB)); - GL.MatrixIndexusvARB = (GL.Delegates.MatrixIndexusvARB) GetAddress("glMatrixIndexusvARB", typeof(GL.Delegates.MatrixIndexusvARB)); - GL.MatrixIndexuivARB = (GL.Delegates.MatrixIndexuivARB) GetAddress("glMatrixIndexuivARB", typeof(GL.Delegates.MatrixIndexuivARB)); - GL.MatrixIndexPointerARB = (GL.Delegates.MatrixIndexPointerARB) GetAddress("glMatrixIndexPointerARB", typeof(GL.Delegates.MatrixIndexPointerARB)); - GL.WindowPos2dARB = (GL.Delegates.WindowPos2dARB) GetAddress("glWindowPos2dARB", typeof(GL.Delegates.WindowPos2dARB)); - GL.WindowPos2dvARB = (GL.Delegates.WindowPos2dvARB) GetAddress("glWindowPos2dvARB", typeof(GL.Delegates.WindowPos2dvARB)); - GL.WindowPos2fARB = (GL.Delegates.WindowPos2fARB) GetAddress("glWindowPos2fARB", typeof(GL.Delegates.WindowPos2fARB)); - GL.WindowPos2fvARB = (GL.Delegates.WindowPos2fvARB) GetAddress("glWindowPos2fvARB", typeof(GL.Delegates.WindowPos2fvARB)); - GL.WindowPos2iARB = (GL.Delegates.WindowPos2iARB) GetAddress("glWindowPos2iARB", typeof(GL.Delegates.WindowPos2iARB)); - GL.WindowPos2ivARB = (GL.Delegates.WindowPos2ivARB) GetAddress("glWindowPos2ivARB", typeof(GL.Delegates.WindowPos2ivARB)); - GL.WindowPos2sARB = (GL.Delegates.WindowPos2sARB) GetAddress("glWindowPos2sARB", typeof(GL.Delegates.WindowPos2sARB)); - GL.WindowPos2svARB = (GL.Delegates.WindowPos2svARB) GetAddress("glWindowPos2svARB", typeof(GL.Delegates.WindowPos2svARB)); - GL.WindowPos3dARB = (GL.Delegates.WindowPos3dARB) GetAddress("glWindowPos3dARB", typeof(GL.Delegates.WindowPos3dARB)); - GL.WindowPos3dvARB = (GL.Delegates.WindowPos3dvARB) GetAddress("glWindowPos3dvARB", typeof(GL.Delegates.WindowPos3dvARB)); - GL.WindowPos3fARB = (GL.Delegates.WindowPos3fARB) GetAddress("glWindowPos3fARB", typeof(GL.Delegates.WindowPos3fARB)); - GL.WindowPos3fvARB = (GL.Delegates.WindowPos3fvARB) GetAddress("glWindowPos3fvARB", typeof(GL.Delegates.WindowPos3fvARB)); - GL.WindowPos3iARB = (GL.Delegates.WindowPos3iARB) GetAddress("glWindowPos3iARB", typeof(GL.Delegates.WindowPos3iARB)); - GL.WindowPos3ivARB = (GL.Delegates.WindowPos3ivARB) GetAddress("glWindowPos3ivARB", typeof(GL.Delegates.WindowPos3ivARB)); - GL.WindowPos3sARB = (GL.Delegates.WindowPos3sARB) GetAddress("glWindowPos3sARB", typeof(GL.Delegates.WindowPos3sARB)); - GL.WindowPos3svARB = (GL.Delegates.WindowPos3svARB) GetAddress("glWindowPos3svARB", typeof(GL.Delegates.WindowPos3svARB)); - GL.VertexAttrib1dARB = (GL.Delegates.VertexAttrib1dARB) GetAddress("glVertexAttrib1dARB", typeof(GL.Delegates.VertexAttrib1dARB)); - GL.VertexAttrib1dvARB = (GL.Delegates.VertexAttrib1dvARB) GetAddress("glVertexAttrib1dvARB", typeof(GL.Delegates.VertexAttrib1dvARB)); - GL.VertexAttrib1fARB = (GL.Delegates.VertexAttrib1fARB) GetAddress("glVertexAttrib1fARB", typeof(GL.Delegates.VertexAttrib1fARB)); - GL.VertexAttrib1fvARB = (GL.Delegates.VertexAttrib1fvARB) GetAddress("glVertexAttrib1fvARB", typeof(GL.Delegates.VertexAttrib1fvARB)); - GL.VertexAttrib1sARB = (GL.Delegates.VertexAttrib1sARB) GetAddress("glVertexAttrib1sARB", typeof(GL.Delegates.VertexAttrib1sARB)); - GL.VertexAttrib1svARB = (GL.Delegates.VertexAttrib1svARB) GetAddress("glVertexAttrib1svARB", typeof(GL.Delegates.VertexAttrib1svARB)); - GL.VertexAttrib2dARB = (GL.Delegates.VertexAttrib2dARB) GetAddress("glVertexAttrib2dARB", typeof(GL.Delegates.VertexAttrib2dARB)); - GL.VertexAttrib2dvARB = (GL.Delegates.VertexAttrib2dvARB) GetAddress("glVertexAttrib2dvARB", typeof(GL.Delegates.VertexAttrib2dvARB)); - GL.VertexAttrib2fARB = (GL.Delegates.VertexAttrib2fARB) GetAddress("glVertexAttrib2fARB", typeof(GL.Delegates.VertexAttrib2fARB)); - GL.VertexAttrib2fvARB = (GL.Delegates.VertexAttrib2fvARB) GetAddress("glVertexAttrib2fvARB", typeof(GL.Delegates.VertexAttrib2fvARB)); - GL.VertexAttrib2sARB = (GL.Delegates.VertexAttrib2sARB) GetAddress("glVertexAttrib2sARB", typeof(GL.Delegates.VertexAttrib2sARB)); - GL.VertexAttrib2svARB = (GL.Delegates.VertexAttrib2svARB) GetAddress("glVertexAttrib2svARB", typeof(GL.Delegates.VertexAttrib2svARB)); - GL.VertexAttrib3dARB = (GL.Delegates.VertexAttrib3dARB) GetAddress("glVertexAttrib3dARB", typeof(GL.Delegates.VertexAttrib3dARB)); - GL.VertexAttrib3dvARB = (GL.Delegates.VertexAttrib3dvARB) GetAddress("glVertexAttrib3dvARB", typeof(GL.Delegates.VertexAttrib3dvARB)); - GL.VertexAttrib3fARB = (GL.Delegates.VertexAttrib3fARB) GetAddress("glVertexAttrib3fARB", typeof(GL.Delegates.VertexAttrib3fARB)); - GL.VertexAttrib3fvARB = (GL.Delegates.VertexAttrib3fvARB) GetAddress("glVertexAttrib3fvARB", typeof(GL.Delegates.VertexAttrib3fvARB)); - GL.VertexAttrib3sARB = (GL.Delegates.VertexAttrib3sARB) GetAddress("glVertexAttrib3sARB", typeof(GL.Delegates.VertexAttrib3sARB)); - GL.VertexAttrib3svARB = (GL.Delegates.VertexAttrib3svARB) GetAddress("glVertexAttrib3svARB", typeof(GL.Delegates.VertexAttrib3svARB)); - GL.VertexAttrib4NbvARB = (GL.Delegates.VertexAttrib4NbvARB) GetAddress("glVertexAttrib4NbvARB", typeof(GL.Delegates.VertexAttrib4NbvARB)); - GL.VertexAttrib4NivARB = (GL.Delegates.VertexAttrib4NivARB) GetAddress("glVertexAttrib4NivARB", typeof(GL.Delegates.VertexAttrib4NivARB)); - GL.VertexAttrib4NsvARB = (GL.Delegates.VertexAttrib4NsvARB) GetAddress("glVertexAttrib4NsvARB", typeof(GL.Delegates.VertexAttrib4NsvARB)); - GL.VertexAttrib4NubARB = (GL.Delegates.VertexAttrib4NubARB) GetAddress("glVertexAttrib4NubARB", typeof(GL.Delegates.VertexAttrib4NubARB)); - GL.VertexAttrib4NubvARB = (GL.Delegates.VertexAttrib4NubvARB) GetAddress("glVertexAttrib4NubvARB", typeof(GL.Delegates.VertexAttrib4NubvARB)); - GL.VertexAttrib4NuivARB = (GL.Delegates.VertexAttrib4NuivARB) GetAddress("glVertexAttrib4NuivARB", typeof(GL.Delegates.VertexAttrib4NuivARB)); - GL.VertexAttrib4NusvARB = (GL.Delegates.VertexAttrib4NusvARB) GetAddress("glVertexAttrib4NusvARB", typeof(GL.Delegates.VertexAttrib4NusvARB)); - GL.VertexAttrib4bvARB = (GL.Delegates.VertexAttrib4bvARB) GetAddress("glVertexAttrib4bvARB", typeof(GL.Delegates.VertexAttrib4bvARB)); - GL.VertexAttrib4dARB = (GL.Delegates.VertexAttrib4dARB) GetAddress("glVertexAttrib4dARB", typeof(GL.Delegates.VertexAttrib4dARB)); - GL.VertexAttrib4dvARB = (GL.Delegates.VertexAttrib4dvARB) GetAddress("glVertexAttrib4dvARB", typeof(GL.Delegates.VertexAttrib4dvARB)); - GL.VertexAttrib4fARB = (GL.Delegates.VertexAttrib4fARB) GetAddress("glVertexAttrib4fARB", typeof(GL.Delegates.VertexAttrib4fARB)); - GL.VertexAttrib4fvARB = (GL.Delegates.VertexAttrib4fvARB) GetAddress("glVertexAttrib4fvARB", typeof(GL.Delegates.VertexAttrib4fvARB)); - GL.VertexAttrib4ivARB = (GL.Delegates.VertexAttrib4ivARB) GetAddress("glVertexAttrib4ivARB", typeof(GL.Delegates.VertexAttrib4ivARB)); - GL.VertexAttrib4sARB = (GL.Delegates.VertexAttrib4sARB) GetAddress("glVertexAttrib4sARB", typeof(GL.Delegates.VertexAttrib4sARB)); - GL.VertexAttrib4svARB = (GL.Delegates.VertexAttrib4svARB) GetAddress("glVertexAttrib4svARB", typeof(GL.Delegates.VertexAttrib4svARB)); - GL.VertexAttrib4ubvARB = (GL.Delegates.VertexAttrib4ubvARB) GetAddress("glVertexAttrib4ubvARB", typeof(GL.Delegates.VertexAttrib4ubvARB)); - GL.VertexAttrib4uivARB = (GL.Delegates.VertexAttrib4uivARB) GetAddress("glVertexAttrib4uivARB", typeof(GL.Delegates.VertexAttrib4uivARB)); - GL.VertexAttrib4usvARB = (GL.Delegates.VertexAttrib4usvARB) GetAddress("glVertexAttrib4usvARB", typeof(GL.Delegates.VertexAttrib4usvARB)); - GL.VertexAttribPointerARB = (GL.Delegates.VertexAttribPointerARB) GetAddress("glVertexAttribPointerARB", typeof(GL.Delegates.VertexAttribPointerARB)); - GL.EnableVertexAttribArrayARB = (GL.Delegates.EnableVertexAttribArrayARB) GetAddress("glEnableVertexAttribArrayARB", typeof(GL.Delegates.EnableVertexAttribArrayARB)); - GL.DisableVertexAttribArrayARB = (GL.Delegates.DisableVertexAttribArrayARB) GetAddress("glDisableVertexAttribArrayARB", typeof(GL.Delegates.DisableVertexAttribArrayARB)); - GL.ProgramStringARB = (GL.Delegates.ProgramStringARB) GetAddress("glProgramStringARB", typeof(GL.Delegates.ProgramStringARB)); - GL.BindProgramARB = (GL.Delegates.BindProgramARB) GetAddress("glBindProgramARB", typeof(GL.Delegates.BindProgramARB)); - GL.DeleteProgramsARB = (GL.Delegates.DeleteProgramsARB) GetAddress("glDeleteProgramsARB", typeof(GL.Delegates.DeleteProgramsARB)); - GL.GenProgramsARB = (GL.Delegates.GenProgramsARB) GetAddress("glGenProgramsARB", typeof(GL.Delegates.GenProgramsARB)); - GL.ProgramEnvParameter4dARB = (GL.Delegates.ProgramEnvParameter4dARB) GetAddress("glProgramEnvParameter4dARB", typeof(GL.Delegates.ProgramEnvParameter4dARB)); - GL.ProgramEnvParameter4dvARB = (GL.Delegates.ProgramEnvParameter4dvARB) GetAddress("glProgramEnvParameter4dvARB", typeof(GL.Delegates.ProgramEnvParameter4dvARB)); - GL.ProgramEnvParameter4fARB = (GL.Delegates.ProgramEnvParameter4fARB) GetAddress("glProgramEnvParameter4fARB", typeof(GL.Delegates.ProgramEnvParameter4fARB)); - GL.ProgramEnvParameter4fvARB = (GL.Delegates.ProgramEnvParameter4fvARB) GetAddress("glProgramEnvParameter4fvARB", typeof(GL.Delegates.ProgramEnvParameter4fvARB)); - GL.ProgramLocalParameter4dARB = (GL.Delegates.ProgramLocalParameter4dARB) GetAddress("glProgramLocalParameter4dARB", typeof(GL.Delegates.ProgramLocalParameter4dARB)); - GL.ProgramLocalParameter4dvARB = (GL.Delegates.ProgramLocalParameter4dvARB) GetAddress("glProgramLocalParameter4dvARB", typeof(GL.Delegates.ProgramLocalParameter4dvARB)); - GL.ProgramLocalParameter4fARB = (GL.Delegates.ProgramLocalParameter4fARB) GetAddress("glProgramLocalParameter4fARB", typeof(GL.Delegates.ProgramLocalParameter4fARB)); - GL.ProgramLocalParameter4fvARB = (GL.Delegates.ProgramLocalParameter4fvARB) GetAddress("glProgramLocalParameter4fvARB", typeof(GL.Delegates.ProgramLocalParameter4fvARB)); - GL.GetProgramEnvParameterdvARB = (GL.Delegates.GetProgramEnvParameterdvARB) GetAddress("glGetProgramEnvParameterdvARB", typeof(GL.Delegates.GetProgramEnvParameterdvARB)); - GL.GetProgramEnvParameterfvARB = (GL.Delegates.GetProgramEnvParameterfvARB) GetAddress("glGetProgramEnvParameterfvARB", typeof(GL.Delegates.GetProgramEnvParameterfvARB)); - GL.GetProgramLocalParameterdvARB = (GL.Delegates.GetProgramLocalParameterdvARB) GetAddress("glGetProgramLocalParameterdvARB", typeof(GL.Delegates.GetProgramLocalParameterdvARB)); - GL.GetProgramLocalParameterfvARB = (GL.Delegates.GetProgramLocalParameterfvARB) GetAddress("glGetProgramLocalParameterfvARB", typeof(GL.Delegates.GetProgramLocalParameterfvARB)); - GL.GetProgramivARB = (GL.Delegates.GetProgramivARB) GetAddress("glGetProgramivARB", typeof(GL.Delegates.GetProgramivARB)); - GL.GetProgramStringARB = (GL.Delegates.GetProgramStringARB) GetAddress("glGetProgramStringARB", typeof(GL.Delegates.GetProgramStringARB)); - GL.GetVertexAttribdvARB = (GL.Delegates.GetVertexAttribdvARB) GetAddress("glGetVertexAttribdvARB", typeof(GL.Delegates.GetVertexAttribdvARB)); - GL.GetVertexAttribfvARB = (GL.Delegates.GetVertexAttribfvARB) GetAddress("glGetVertexAttribfvARB", typeof(GL.Delegates.GetVertexAttribfvARB)); - GL.GetVertexAttribivARB = (GL.Delegates.GetVertexAttribivARB) GetAddress("glGetVertexAttribivARB", typeof(GL.Delegates.GetVertexAttribivARB)); - GL.GetVertexAttribPointervARB = (GL.Delegates.GetVertexAttribPointervARB) GetAddress("glGetVertexAttribPointervARB", typeof(GL.Delegates.GetVertexAttribPointervARB)); - GL.IsProgramARB = (GL.Delegates.IsProgramARB) GetAddress("glIsProgramARB", typeof(GL.Delegates.IsProgramARB)); - GL.BindBufferARB = (GL.Delegates.BindBufferARB) GetAddress("glBindBufferARB", typeof(GL.Delegates.BindBufferARB)); - GL.DeleteBuffersARB = (GL.Delegates.DeleteBuffersARB) GetAddress("glDeleteBuffersARB", typeof(GL.Delegates.DeleteBuffersARB)); - GL.GenBuffersARB = (GL.Delegates.GenBuffersARB) GetAddress("glGenBuffersARB", typeof(GL.Delegates.GenBuffersARB)); - GL.IsBufferARB = (GL.Delegates.IsBufferARB) GetAddress("glIsBufferARB", typeof(GL.Delegates.IsBufferARB)); - GL.BufferDataARB = (GL.Delegates.BufferDataARB) GetAddress("glBufferDataARB", typeof(GL.Delegates.BufferDataARB)); - GL.BufferSubDataARB = (GL.Delegates.BufferSubDataARB) GetAddress("glBufferSubDataARB", typeof(GL.Delegates.BufferSubDataARB)); - GL.GetBufferSubDataARB = (GL.Delegates.GetBufferSubDataARB) GetAddress("glGetBufferSubDataARB", typeof(GL.Delegates.GetBufferSubDataARB)); - GL.MapBufferARB_ = (GL.Delegates.MapBufferARB_) GetAddress("glMapBufferARB_", typeof(GL.Delegates.MapBufferARB_)); - GL.UnmapBufferARB = (GL.Delegates.UnmapBufferARB) GetAddress("glUnmapBufferARB", typeof(GL.Delegates.UnmapBufferARB)); - GL.GetBufferParameterivARB = (GL.Delegates.GetBufferParameterivARB) GetAddress("glGetBufferParameterivARB", typeof(GL.Delegates.GetBufferParameterivARB)); - GL.GetBufferPointervARB = (GL.Delegates.GetBufferPointervARB) GetAddress("glGetBufferPointervARB", typeof(GL.Delegates.GetBufferPointervARB)); - GL.GenQueriesARB = (GL.Delegates.GenQueriesARB) GetAddress("glGenQueriesARB", typeof(GL.Delegates.GenQueriesARB)); - GL.DeleteQueriesARB = (GL.Delegates.DeleteQueriesARB) GetAddress("glDeleteQueriesARB", typeof(GL.Delegates.DeleteQueriesARB)); - GL.IsQueryARB = (GL.Delegates.IsQueryARB) GetAddress("glIsQueryARB", typeof(GL.Delegates.IsQueryARB)); - GL.BeginQueryARB = (GL.Delegates.BeginQueryARB) GetAddress("glBeginQueryARB", typeof(GL.Delegates.BeginQueryARB)); - GL.EndQueryARB = (GL.Delegates.EndQueryARB) GetAddress("glEndQueryARB", typeof(GL.Delegates.EndQueryARB)); - GL.GetQueryivARB = (GL.Delegates.GetQueryivARB) GetAddress("glGetQueryivARB", typeof(GL.Delegates.GetQueryivARB)); - GL.GetQueryObjectivARB = (GL.Delegates.GetQueryObjectivARB) GetAddress("glGetQueryObjectivARB", typeof(GL.Delegates.GetQueryObjectivARB)); - GL.GetQueryObjectuivARB = (GL.Delegates.GetQueryObjectuivARB) GetAddress("glGetQueryObjectuivARB", typeof(GL.Delegates.GetQueryObjectuivARB)); - GL.DeleteObjectARB = (GL.Delegates.DeleteObjectARB) GetAddress("glDeleteObjectARB", typeof(GL.Delegates.DeleteObjectARB)); - GL.GetHandleARB = (GL.Delegates.GetHandleARB) GetAddress("glGetHandleARB", typeof(GL.Delegates.GetHandleARB)); - GL.DetachObjectARB = (GL.Delegates.DetachObjectARB) GetAddress("glDetachObjectARB", typeof(GL.Delegates.DetachObjectARB)); - GL.CreateShaderObjectARB = (GL.Delegates.CreateShaderObjectARB) GetAddress("glCreateShaderObjectARB", typeof(GL.Delegates.CreateShaderObjectARB)); - GL.ShaderSourceARB = (GL.Delegates.ShaderSourceARB) GetAddress("glShaderSourceARB", typeof(GL.Delegates.ShaderSourceARB)); - GL.CompileShaderARB = (GL.Delegates.CompileShaderARB) GetAddress("glCompileShaderARB", typeof(GL.Delegates.CompileShaderARB)); - GL.CreateProgramObjectARB = (GL.Delegates.CreateProgramObjectARB) GetAddress("glCreateProgramObjectARB", typeof(GL.Delegates.CreateProgramObjectARB)); - GL.AttachObjectARB = (GL.Delegates.AttachObjectARB) GetAddress("glAttachObjectARB", typeof(GL.Delegates.AttachObjectARB)); - GL.LinkProgramARB = (GL.Delegates.LinkProgramARB) GetAddress("glLinkProgramARB", typeof(GL.Delegates.LinkProgramARB)); - GL.UseProgramObjectARB = (GL.Delegates.UseProgramObjectARB) GetAddress("glUseProgramObjectARB", typeof(GL.Delegates.UseProgramObjectARB)); - GL.ValidateProgramARB = (GL.Delegates.ValidateProgramARB) GetAddress("glValidateProgramARB", typeof(GL.Delegates.ValidateProgramARB)); - GL.Uniform1fARB = (GL.Delegates.Uniform1fARB) GetAddress("glUniform1fARB", typeof(GL.Delegates.Uniform1fARB)); - GL.Uniform2fARB = (GL.Delegates.Uniform2fARB) GetAddress("glUniform2fARB", typeof(GL.Delegates.Uniform2fARB)); - GL.Uniform3fARB = (GL.Delegates.Uniform3fARB) GetAddress("glUniform3fARB", typeof(GL.Delegates.Uniform3fARB)); - GL.Uniform4fARB = (GL.Delegates.Uniform4fARB) GetAddress("glUniform4fARB", typeof(GL.Delegates.Uniform4fARB)); - GL.Uniform1iARB = (GL.Delegates.Uniform1iARB) GetAddress("glUniform1iARB", typeof(GL.Delegates.Uniform1iARB)); - GL.Uniform2iARB = (GL.Delegates.Uniform2iARB) GetAddress("glUniform2iARB", typeof(GL.Delegates.Uniform2iARB)); - GL.Uniform3iARB = (GL.Delegates.Uniform3iARB) GetAddress("glUniform3iARB", typeof(GL.Delegates.Uniform3iARB)); - GL.Uniform4iARB = (GL.Delegates.Uniform4iARB) GetAddress("glUniform4iARB", typeof(GL.Delegates.Uniform4iARB)); - GL.Uniform1fvARB = (GL.Delegates.Uniform1fvARB) GetAddress("glUniform1fvARB", typeof(GL.Delegates.Uniform1fvARB)); - GL.Uniform2fvARB = (GL.Delegates.Uniform2fvARB) GetAddress("glUniform2fvARB", typeof(GL.Delegates.Uniform2fvARB)); - GL.Uniform3fvARB = (GL.Delegates.Uniform3fvARB) GetAddress("glUniform3fvARB", typeof(GL.Delegates.Uniform3fvARB)); - GL.Uniform4fvARB = (GL.Delegates.Uniform4fvARB) GetAddress("glUniform4fvARB", typeof(GL.Delegates.Uniform4fvARB)); - GL.Uniform1ivARB = (GL.Delegates.Uniform1ivARB) GetAddress("glUniform1ivARB", typeof(GL.Delegates.Uniform1ivARB)); - GL.Uniform2ivARB = (GL.Delegates.Uniform2ivARB) GetAddress("glUniform2ivARB", typeof(GL.Delegates.Uniform2ivARB)); - GL.Uniform3ivARB = (GL.Delegates.Uniform3ivARB) GetAddress("glUniform3ivARB", typeof(GL.Delegates.Uniform3ivARB)); - GL.Uniform4ivARB = (GL.Delegates.Uniform4ivARB) GetAddress("glUniform4ivARB", typeof(GL.Delegates.Uniform4ivARB)); - GL.UniformMatrix2fvARB = (GL.Delegates.UniformMatrix2fvARB) GetAddress("glUniformMatrix2fvARB", typeof(GL.Delegates.UniformMatrix2fvARB)); - GL.UniformMatrix3fvARB = (GL.Delegates.UniformMatrix3fvARB) GetAddress("glUniformMatrix3fvARB", typeof(GL.Delegates.UniformMatrix3fvARB)); - GL.UniformMatrix4fvARB = (GL.Delegates.UniformMatrix4fvARB) GetAddress("glUniformMatrix4fvARB", typeof(GL.Delegates.UniformMatrix4fvARB)); - GL.GetObjectParameterfvARB = (GL.Delegates.GetObjectParameterfvARB) GetAddress("glGetObjectParameterfvARB", typeof(GL.Delegates.GetObjectParameterfvARB)); - GL.GetObjectParameterivARB = (GL.Delegates.GetObjectParameterivARB) GetAddress("glGetObjectParameterivARB", typeof(GL.Delegates.GetObjectParameterivARB)); - GL.GetInfoLogARB = (GL.Delegates.GetInfoLogARB) GetAddress("glGetInfoLogARB", typeof(GL.Delegates.GetInfoLogARB)); - GL.GetAttachedObjectsARB = (GL.Delegates.GetAttachedObjectsARB) GetAddress("glGetAttachedObjectsARB", typeof(GL.Delegates.GetAttachedObjectsARB)); - GL.GetUniformLocationARB = (GL.Delegates.GetUniformLocationARB) GetAddress("glGetUniformLocationARB", typeof(GL.Delegates.GetUniformLocationARB)); - GL.GetActiveUniformARB = (GL.Delegates.GetActiveUniformARB) GetAddress("glGetActiveUniformARB", typeof(GL.Delegates.GetActiveUniformARB)); - GL.GetUniformfvARB = (GL.Delegates.GetUniformfvARB) GetAddress("glGetUniformfvARB", typeof(GL.Delegates.GetUniformfvARB)); - GL.GetUniformivARB = (GL.Delegates.GetUniformivARB) GetAddress("glGetUniformivARB", typeof(GL.Delegates.GetUniformivARB)); - GL.GetShaderSourceARB = (GL.Delegates.GetShaderSourceARB) GetAddress("glGetShaderSourceARB", typeof(GL.Delegates.GetShaderSourceARB)); - GL.BindAttribLocationARB = (GL.Delegates.BindAttribLocationARB) GetAddress("glBindAttribLocationARB", typeof(GL.Delegates.BindAttribLocationARB)); - GL.GetActiveAttribARB = (GL.Delegates.GetActiveAttribARB) GetAddress("glGetActiveAttribARB", typeof(GL.Delegates.GetActiveAttribARB)); - GL.GetAttribLocationARB = (GL.Delegates.GetAttribLocationARB) GetAddress("glGetAttribLocationARB", typeof(GL.Delegates.GetAttribLocationARB)); - GL.DrawBuffersARB = (GL.Delegates.DrawBuffersARB) GetAddress("glDrawBuffersARB", typeof(GL.Delegates.DrawBuffersARB)); - GL.ClampColorARB = (GL.Delegates.ClampColorARB) GetAddress("glClampColorARB", typeof(GL.Delegates.ClampColorARB)); - GL.BlendColorEXT = (GL.Delegates.BlendColorEXT) GetAddress("glBlendColorEXT", typeof(GL.Delegates.BlendColorEXT)); - GL.PolygonOffsetEXT = (GL.Delegates.PolygonOffsetEXT) GetAddress("glPolygonOffsetEXT", typeof(GL.Delegates.PolygonOffsetEXT)); - GL.TexImage3DEXT = (GL.Delegates.TexImage3DEXT) GetAddress("glTexImage3DEXT", typeof(GL.Delegates.TexImage3DEXT)); - GL.TexSubImage3DEXT = (GL.Delegates.TexSubImage3DEXT) GetAddress("glTexSubImage3DEXT", typeof(GL.Delegates.TexSubImage3DEXT)); - GL.GetTexFilterFuncSGIS = (GL.Delegates.GetTexFilterFuncSGIS) GetAddress("glGetTexFilterFuncSGIS", typeof(GL.Delegates.GetTexFilterFuncSGIS)); - GL.TexFilterFuncSGIS = (GL.Delegates.TexFilterFuncSGIS) GetAddress("glTexFilterFuncSGIS", typeof(GL.Delegates.TexFilterFuncSGIS)); - GL.TexSubImage1DEXT = (GL.Delegates.TexSubImage1DEXT) GetAddress("glTexSubImage1DEXT", typeof(GL.Delegates.TexSubImage1DEXT)); - GL.TexSubImage2DEXT = (GL.Delegates.TexSubImage2DEXT) GetAddress("glTexSubImage2DEXT", typeof(GL.Delegates.TexSubImage2DEXT)); - GL.CopyTexImage1DEXT = (GL.Delegates.CopyTexImage1DEXT) GetAddress("glCopyTexImage1DEXT", typeof(GL.Delegates.CopyTexImage1DEXT)); - GL.CopyTexImage2DEXT = (GL.Delegates.CopyTexImage2DEXT) GetAddress("glCopyTexImage2DEXT", typeof(GL.Delegates.CopyTexImage2DEXT)); - GL.CopyTexSubImage1DEXT = (GL.Delegates.CopyTexSubImage1DEXT) GetAddress("glCopyTexSubImage1DEXT", typeof(GL.Delegates.CopyTexSubImage1DEXT)); - GL.CopyTexSubImage2DEXT = (GL.Delegates.CopyTexSubImage2DEXT) GetAddress("glCopyTexSubImage2DEXT", typeof(GL.Delegates.CopyTexSubImage2DEXT)); - GL.CopyTexSubImage3DEXT = (GL.Delegates.CopyTexSubImage3DEXT) GetAddress("glCopyTexSubImage3DEXT", typeof(GL.Delegates.CopyTexSubImage3DEXT)); - GL.GetHistogramEXT = (GL.Delegates.GetHistogramEXT) GetAddress("glGetHistogramEXT", typeof(GL.Delegates.GetHistogramEXT)); - GL.GetHistogramParameterfvEXT = (GL.Delegates.GetHistogramParameterfvEXT) GetAddress("glGetHistogramParameterfvEXT", typeof(GL.Delegates.GetHistogramParameterfvEXT)); - GL.GetHistogramParameterivEXT = (GL.Delegates.GetHistogramParameterivEXT) GetAddress("glGetHistogramParameterivEXT", typeof(GL.Delegates.GetHistogramParameterivEXT)); - GL.GetMinmaxEXT = (GL.Delegates.GetMinmaxEXT) GetAddress("glGetMinmaxEXT", typeof(GL.Delegates.GetMinmaxEXT)); - GL.GetMinmaxParameterfvEXT = (GL.Delegates.GetMinmaxParameterfvEXT) GetAddress("glGetMinmaxParameterfvEXT", typeof(GL.Delegates.GetMinmaxParameterfvEXT)); - GL.GetMinmaxParameterivEXT = (GL.Delegates.GetMinmaxParameterivEXT) GetAddress("glGetMinmaxParameterivEXT", typeof(GL.Delegates.GetMinmaxParameterivEXT)); - GL.HistogramEXT = (GL.Delegates.HistogramEXT) GetAddress("glHistogramEXT", typeof(GL.Delegates.HistogramEXT)); - GL.MinmaxEXT = (GL.Delegates.MinmaxEXT) GetAddress("glMinmaxEXT", typeof(GL.Delegates.MinmaxEXT)); - GL.ResetHistogramEXT = (GL.Delegates.ResetHistogramEXT) GetAddress("glResetHistogramEXT", typeof(GL.Delegates.ResetHistogramEXT)); - GL.ResetMinmaxEXT = (GL.Delegates.ResetMinmaxEXT) GetAddress("glResetMinmaxEXT", typeof(GL.Delegates.ResetMinmaxEXT)); - GL.ConvolutionFilter1DEXT = (GL.Delegates.ConvolutionFilter1DEXT) GetAddress("glConvolutionFilter1DEXT", typeof(GL.Delegates.ConvolutionFilter1DEXT)); - GL.ConvolutionFilter2DEXT = (GL.Delegates.ConvolutionFilter2DEXT) GetAddress("glConvolutionFilter2DEXT", typeof(GL.Delegates.ConvolutionFilter2DEXT)); - GL.ConvolutionParameterfEXT = (GL.Delegates.ConvolutionParameterfEXT) GetAddress("glConvolutionParameterfEXT", typeof(GL.Delegates.ConvolutionParameterfEXT)); - GL.ConvolutionParameterfvEXT = (GL.Delegates.ConvolutionParameterfvEXT) GetAddress("glConvolutionParameterfvEXT", typeof(GL.Delegates.ConvolutionParameterfvEXT)); - GL.ConvolutionParameteriEXT = (GL.Delegates.ConvolutionParameteriEXT) GetAddress("glConvolutionParameteriEXT", typeof(GL.Delegates.ConvolutionParameteriEXT)); - GL.ConvolutionParameterivEXT = (GL.Delegates.ConvolutionParameterivEXT) GetAddress("glConvolutionParameterivEXT", typeof(GL.Delegates.ConvolutionParameterivEXT)); - GL.CopyConvolutionFilter1DEXT = (GL.Delegates.CopyConvolutionFilter1DEXT) GetAddress("glCopyConvolutionFilter1DEXT", typeof(GL.Delegates.CopyConvolutionFilter1DEXT)); - GL.CopyConvolutionFilter2DEXT = (GL.Delegates.CopyConvolutionFilter2DEXT) GetAddress("glCopyConvolutionFilter2DEXT", typeof(GL.Delegates.CopyConvolutionFilter2DEXT)); - GL.GetConvolutionFilterEXT = (GL.Delegates.GetConvolutionFilterEXT) GetAddress("glGetConvolutionFilterEXT", typeof(GL.Delegates.GetConvolutionFilterEXT)); - GL.GetConvolutionParameterfvEXT = (GL.Delegates.GetConvolutionParameterfvEXT) GetAddress("glGetConvolutionParameterfvEXT", typeof(GL.Delegates.GetConvolutionParameterfvEXT)); - GL.GetConvolutionParameterivEXT = (GL.Delegates.GetConvolutionParameterivEXT) GetAddress("glGetConvolutionParameterivEXT", typeof(GL.Delegates.GetConvolutionParameterivEXT)); - GL.GetSeparableFilterEXT = (GL.Delegates.GetSeparableFilterEXT) GetAddress("glGetSeparableFilterEXT", typeof(GL.Delegates.GetSeparableFilterEXT)); - GL.SeparableFilter2DEXT = (GL.Delegates.SeparableFilter2DEXT) GetAddress("glSeparableFilter2DEXT", typeof(GL.Delegates.SeparableFilter2DEXT)); - GL.ColorTableSGI = (GL.Delegates.ColorTableSGI) GetAddress("glColorTableSGI", typeof(GL.Delegates.ColorTableSGI)); - GL.ColorTableParameterfvSGI = (GL.Delegates.ColorTableParameterfvSGI) GetAddress("glColorTableParameterfvSGI", typeof(GL.Delegates.ColorTableParameterfvSGI)); - GL.ColorTableParameterivSGI = (GL.Delegates.ColorTableParameterivSGI) GetAddress("glColorTableParameterivSGI", typeof(GL.Delegates.ColorTableParameterivSGI)); - GL.CopyColorTableSGI = (GL.Delegates.CopyColorTableSGI) GetAddress("glCopyColorTableSGI", typeof(GL.Delegates.CopyColorTableSGI)); - GL.GetColorTableSGI = (GL.Delegates.GetColorTableSGI) GetAddress("glGetColorTableSGI", typeof(GL.Delegates.GetColorTableSGI)); - GL.GetColorTableParameterfvSGI = (GL.Delegates.GetColorTableParameterfvSGI) GetAddress("glGetColorTableParameterfvSGI", typeof(GL.Delegates.GetColorTableParameterfvSGI)); - GL.GetColorTableParameterivSGI = (GL.Delegates.GetColorTableParameterivSGI) GetAddress("glGetColorTableParameterivSGI", typeof(GL.Delegates.GetColorTableParameterivSGI)); - GL.PixelTexGenSGIX = (GL.Delegates.PixelTexGenSGIX) GetAddress("glPixelTexGenSGIX", typeof(GL.Delegates.PixelTexGenSGIX)); - GL.PixelTexGenParameteriSGIS = (GL.Delegates.PixelTexGenParameteriSGIS) GetAddress("glPixelTexGenParameteriSGIS", typeof(GL.Delegates.PixelTexGenParameteriSGIS)); - GL.PixelTexGenParameterivSGIS = (GL.Delegates.PixelTexGenParameterivSGIS) GetAddress("glPixelTexGenParameterivSGIS", typeof(GL.Delegates.PixelTexGenParameterivSGIS)); - GL.PixelTexGenParameterfSGIS = (GL.Delegates.PixelTexGenParameterfSGIS) GetAddress("glPixelTexGenParameterfSGIS", typeof(GL.Delegates.PixelTexGenParameterfSGIS)); - GL.PixelTexGenParameterfvSGIS = (GL.Delegates.PixelTexGenParameterfvSGIS) GetAddress("glPixelTexGenParameterfvSGIS", typeof(GL.Delegates.PixelTexGenParameterfvSGIS)); - GL.GetPixelTexGenParameterivSGIS = (GL.Delegates.GetPixelTexGenParameterivSGIS) GetAddress("glGetPixelTexGenParameterivSGIS", typeof(GL.Delegates.GetPixelTexGenParameterivSGIS)); - GL.GetPixelTexGenParameterfvSGIS = (GL.Delegates.GetPixelTexGenParameterfvSGIS) GetAddress("glGetPixelTexGenParameterfvSGIS", typeof(GL.Delegates.GetPixelTexGenParameterfvSGIS)); - GL.TexImage4DSGIS = (GL.Delegates.TexImage4DSGIS) GetAddress("glTexImage4DSGIS", typeof(GL.Delegates.TexImage4DSGIS)); - GL.TexSubImage4DSGIS = (GL.Delegates.TexSubImage4DSGIS) GetAddress("glTexSubImage4DSGIS", typeof(GL.Delegates.TexSubImage4DSGIS)); - GL.AreTexturesResidentEXT = (GL.Delegates.AreTexturesResidentEXT) GetAddress("glAreTexturesResidentEXT", typeof(GL.Delegates.AreTexturesResidentEXT)); - GL.BindTextureEXT = (GL.Delegates.BindTextureEXT) GetAddress("glBindTextureEXT", typeof(GL.Delegates.BindTextureEXT)); - GL.DeleteTexturesEXT = (GL.Delegates.DeleteTexturesEXT) GetAddress("glDeleteTexturesEXT", typeof(GL.Delegates.DeleteTexturesEXT)); - GL.GenTexturesEXT = (GL.Delegates.GenTexturesEXT) GetAddress("glGenTexturesEXT", typeof(GL.Delegates.GenTexturesEXT)); - GL.IsTextureEXT = (GL.Delegates.IsTextureEXT) GetAddress("glIsTextureEXT", typeof(GL.Delegates.IsTextureEXT)); - GL.PrioritizeTexturesEXT = (GL.Delegates.PrioritizeTexturesEXT) GetAddress("glPrioritizeTexturesEXT", typeof(GL.Delegates.PrioritizeTexturesEXT)); - GL.DetailTexFuncSGIS = (GL.Delegates.DetailTexFuncSGIS) GetAddress("glDetailTexFuncSGIS", typeof(GL.Delegates.DetailTexFuncSGIS)); - GL.GetDetailTexFuncSGIS = (GL.Delegates.GetDetailTexFuncSGIS) GetAddress("glGetDetailTexFuncSGIS", typeof(GL.Delegates.GetDetailTexFuncSGIS)); - GL.SharpenTexFuncSGIS = (GL.Delegates.SharpenTexFuncSGIS) GetAddress("glSharpenTexFuncSGIS", typeof(GL.Delegates.SharpenTexFuncSGIS)); - GL.GetSharpenTexFuncSGIS = (GL.Delegates.GetSharpenTexFuncSGIS) GetAddress("glGetSharpenTexFuncSGIS", typeof(GL.Delegates.GetSharpenTexFuncSGIS)); - GL.SampleMaskSGIS = (GL.Delegates.SampleMaskSGIS) GetAddress("glSampleMaskSGIS", typeof(GL.Delegates.SampleMaskSGIS)); - GL.SamplePatternSGIS = (GL.Delegates.SamplePatternSGIS) GetAddress("glSamplePatternSGIS", typeof(GL.Delegates.SamplePatternSGIS)); - GL.ArrayElementEXT = (GL.Delegates.ArrayElementEXT) GetAddress("glArrayElementEXT", typeof(GL.Delegates.ArrayElementEXT)); - GL.ColorPointerEXT = (GL.Delegates.ColorPointerEXT) GetAddress("glColorPointerEXT", typeof(GL.Delegates.ColorPointerEXT)); - GL.DrawArraysEXT = (GL.Delegates.DrawArraysEXT) GetAddress("glDrawArraysEXT", typeof(GL.Delegates.DrawArraysEXT)); - GL.EdgeFlagPointerEXT = (GL.Delegates.EdgeFlagPointerEXT) GetAddress("glEdgeFlagPointerEXT", typeof(GL.Delegates.EdgeFlagPointerEXT)); - GL.GetPointervEXT = (GL.Delegates.GetPointervEXT) GetAddress("glGetPointervEXT", typeof(GL.Delegates.GetPointervEXT)); - GL.IndexPointerEXT = (GL.Delegates.IndexPointerEXT) GetAddress("glIndexPointerEXT", typeof(GL.Delegates.IndexPointerEXT)); - GL.NormalPointerEXT = (GL.Delegates.NormalPointerEXT) GetAddress("glNormalPointerEXT", typeof(GL.Delegates.NormalPointerEXT)); - GL.TexCoordPointerEXT = (GL.Delegates.TexCoordPointerEXT) GetAddress("glTexCoordPointerEXT", typeof(GL.Delegates.TexCoordPointerEXT)); - GL.VertexPointerEXT = (GL.Delegates.VertexPointerEXT) GetAddress("glVertexPointerEXT", typeof(GL.Delegates.VertexPointerEXT)); - GL.BlendEquationEXT = (GL.Delegates.BlendEquationEXT) GetAddress("glBlendEquationEXT", typeof(GL.Delegates.BlendEquationEXT)); - GL.SpriteParameterfSGIX = (GL.Delegates.SpriteParameterfSGIX) GetAddress("glSpriteParameterfSGIX", typeof(GL.Delegates.SpriteParameterfSGIX)); - GL.SpriteParameterfvSGIX = (GL.Delegates.SpriteParameterfvSGIX) GetAddress("glSpriteParameterfvSGIX", typeof(GL.Delegates.SpriteParameterfvSGIX)); - GL.SpriteParameteriSGIX = (GL.Delegates.SpriteParameteriSGIX) GetAddress("glSpriteParameteriSGIX", typeof(GL.Delegates.SpriteParameteriSGIX)); - GL.SpriteParameterivSGIX = (GL.Delegates.SpriteParameterivSGIX) GetAddress("glSpriteParameterivSGIX", typeof(GL.Delegates.SpriteParameterivSGIX)); - GL.PointParameterfEXT = (GL.Delegates.PointParameterfEXT) GetAddress("glPointParameterfEXT", typeof(GL.Delegates.PointParameterfEXT)); - GL.PointParameterfvEXT = (GL.Delegates.PointParameterfvEXT) GetAddress("glPointParameterfvEXT", typeof(GL.Delegates.PointParameterfvEXT)); - GL.PointParameterfSGIS = (GL.Delegates.PointParameterfSGIS) GetAddress("glPointParameterfSGIS", typeof(GL.Delegates.PointParameterfSGIS)); - GL.PointParameterfvSGIS = (GL.Delegates.PointParameterfvSGIS) GetAddress("glPointParameterfvSGIS", typeof(GL.Delegates.PointParameterfvSGIS)); - GL.GetInstrumentsSGIX = (GL.Delegates.GetInstrumentsSGIX) GetAddress("glGetInstrumentsSGIX", typeof(GL.Delegates.GetInstrumentsSGIX)); - GL.InstrumentsBufferSGIX = (GL.Delegates.InstrumentsBufferSGIX) GetAddress("glInstrumentsBufferSGIX", typeof(GL.Delegates.InstrumentsBufferSGIX)); - GL.PollInstrumentsSGIX = (GL.Delegates.PollInstrumentsSGIX) GetAddress("glPollInstrumentsSGIX", typeof(GL.Delegates.PollInstrumentsSGIX)); - GL.ReadInstrumentsSGIX = (GL.Delegates.ReadInstrumentsSGIX) GetAddress("glReadInstrumentsSGIX", typeof(GL.Delegates.ReadInstrumentsSGIX)); - GL.StartInstrumentsSGIX = (GL.Delegates.StartInstrumentsSGIX) GetAddress("glStartInstrumentsSGIX", typeof(GL.Delegates.StartInstrumentsSGIX)); - GL.StopInstrumentsSGIX = (GL.Delegates.StopInstrumentsSGIX) GetAddress("glStopInstrumentsSGIX", typeof(GL.Delegates.StopInstrumentsSGIX)); - GL.FrameZoomSGIX = (GL.Delegates.FrameZoomSGIX) GetAddress("glFrameZoomSGIX", typeof(GL.Delegates.FrameZoomSGIX)); - GL.TagSampleBufferSGIX = (GL.Delegates.TagSampleBufferSGIX) GetAddress("glTagSampleBufferSGIX", typeof(GL.Delegates.TagSampleBufferSGIX)); - GL.DeformationMap3dSGIX = (GL.Delegates.DeformationMap3dSGIX) GetAddress("glDeformationMap3dSGIX", typeof(GL.Delegates.DeformationMap3dSGIX)); - GL.DeformationMap3fSGIX = (GL.Delegates.DeformationMap3fSGIX) GetAddress("glDeformationMap3fSGIX", typeof(GL.Delegates.DeformationMap3fSGIX)); - GL.DeformSGIX = (GL.Delegates.DeformSGIX) GetAddress("glDeformSGIX", typeof(GL.Delegates.DeformSGIX)); - GL.LoadIdentityDeformationMapSGIX = (GL.Delegates.LoadIdentityDeformationMapSGIX) GetAddress("glLoadIdentityDeformationMapSGIX", typeof(GL.Delegates.LoadIdentityDeformationMapSGIX)); - GL.ReferencePlaneSGIX = (GL.Delegates.ReferencePlaneSGIX) GetAddress("glReferencePlaneSGIX", typeof(GL.Delegates.ReferencePlaneSGIX)); - GL.FlushRasterSGIX = (GL.Delegates.FlushRasterSGIX) GetAddress("glFlushRasterSGIX", typeof(GL.Delegates.FlushRasterSGIX)); - GL.FogFuncSGIS = (GL.Delegates.FogFuncSGIS) GetAddress("glFogFuncSGIS", typeof(GL.Delegates.FogFuncSGIS)); - GL.GetFogFuncSGIS = (GL.Delegates.GetFogFuncSGIS) GetAddress("glGetFogFuncSGIS", typeof(GL.Delegates.GetFogFuncSGIS)); - GL.ImageTransformParameteriHP = (GL.Delegates.ImageTransformParameteriHP) GetAddress("glImageTransformParameteriHP", typeof(GL.Delegates.ImageTransformParameteriHP)); - GL.ImageTransformParameterfHP = (GL.Delegates.ImageTransformParameterfHP) GetAddress("glImageTransformParameterfHP", typeof(GL.Delegates.ImageTransformParameterfHP)); - GL.ImageTransformParameterivHP = (GL.Delegates.ImageTransformParameterivHP) GetAddress("glImageTransformParameterivHP", typeof(GL.Delegates.ImageTransformParameterivHP)); - GL.ImageTransformParameterfvHP = (GL.Delegates.ImageTransformParameterfvHP) GetAddress("glImageTransformParameterfvHP", typeof(GL.Delegates.ImageTransformParameterfvHP)); - GL.GetImageTransformParameterivHP = (GL.Delegates.GetImageTransformParameterivHP) GetAddress("glGetImageTransformParameterivHP", typeof(GL.Delegates.GetImageTransformParameterivHP)); - GL.GetImageTransformParameterfvHP = (GL.Delegates.GetImageTransformParameterfvHP) GetAddress("glGetImageTransformParameterfvHP", typeof(GL.Delegates.GetImageTransformParameterfvHP)); - GL.ColorSubTableEXT = (GL.Delegates.ColorSubTableEXT) GetAddress("glColorSubTableEXT", typeof(GL.Delegates.ColorSubTableEXT)); - GL.CopyColorSubTableEXT = (GL.Delegates.CopyColorSubTableEXT) GetAddress("glCopyColorSubTableEXT", typeof(GL.Delegates.CopyColorSubTableEXT)); - GL.HintPGI = (GL.Delegates.HintPGI) GetAddress("glHintPGI", typeof(GL.Delegates.HintPGI)); - GL.ColorTableEXT = (GL.Delegates.ColorTableEXT) GetAddress("glColorTableEXT", typeof(GL.Delegates.ColorTableEXT)); - GL.GetColorTableEXT = (GL.Delegates.GetColorTableEXT) GetAddress("glGetColorTableEXT", typeof(GL.Delegates.GetColorTableEXT)); - GL.GetColorTableParameterivEXT = (GL.Delegates.GetColorTableParameterivEXT) GetAddress("glGetColorTableParameterivEXT", typeof(GL.Delegates.GetColorTableParameterivEXT)); - GL.GetColorTableParameterfvEXT = (GL.Delegates.GetColorTableParameterfvEXT) GetAddress("glGetColorTableParameterfvEXT", typeof(GL.Delegates.GetColorTableParameterfvEXT)); - GL.GetListParameterfvSGIX = (GL.Delegates.GetListParameterfvSGIX) GetAddress("glGetListParameterfvSGIX", typeof(GL.Delegates.GetListParameterfvSGIX)); - GL.GetListParameterivSGIX = (GL.Delegates.GetListParameterivSGIX) GetAddress("glGetListParameterivSGIX", typeof(GL.Delegates.GetListParameterivSGIX)); - GL.ListParameterfSGIX = (GL.Delegates.ListParameterfSGIX) GetAddress("glListParameterfSGIX", typeof(GL.Delegates.ListParameterfSGIX)); - GL.ListParameterfvSGIX = (GL.Delegates.ListParameterfvSGIX) GetAddress("glListParameterfvSGIX", typeof(GL.Delegates.ListParameterfvSGIX)); - GL.ListParameteriSGIX = (GL.Delegates.ListParameteriSGIX) GetAddress("glListParameteriSGIX", typeof(GL.Delegates.ListParameteriSGIX)); - GL.ListParameterivSGIX = (GL.Delegates.ListParameterivSGIX) GetAddress("glListParameterivSGIX", typeof(GL.Delegates.ListParameterivSGIX)); - GL.IndexMaterialEXT = (GL.Delegates.IndexMaterialEXT) GetAddress("glIndexMaterialEXT", typeof(GL.Delegates.IndexMaterialEXT)); - GL.IndexFuncEXT = (GL.Delegates.IndexFuncEXT) GetAddress("glIndexFuncEXT", typeof(GL.Delegates.IndexFuncEXT)); - GL.LockArraysEXT = (GL.Delegates.LockArraysEXT) GetAddress("glLockArraysEXT", typeof(GL.Delegates.LockArraysEXT)); - GL.UnlockArraysEXT = (GL.Delegates.UnlockArraysEXT) GetAddress("glUnlockArraysEXT", typeof(GL.Delegates.UnlockArraysEXT)); - GL.CullParameterdvEXT = (GL.Delegates.CullParameterdvEXT) GetAddress("glCullParameterdvEXT", typeof(GL.Delegates.CullParameterdvEXT)); - GL.CullParameterfvEXT = (GL.Delegates.CullParameterfvEXT) GetAddress("glCullParameterfvEXT", typeof(GL.Delegates.CullParameterfvEXT)); - GL.FragmentColorMaterialSGIX = (GL.Delegates.FragmentColorMaterialSGIX) GetAddress("glFragmentColorMaterialSGIX", typeof(GL.Delegates.FragmentColorMaterialSGIX)); - GL.FragmentLightfSGIX = (GL.Delegates.FragmentLightfSGIX) GetAddress("glFragmentLightfSGIX", typeof(GL.Delegates.FragmentLightfSGIX)); - GL.FragmentLightfvSGIX = (GL.Delegates.FragmentLightfvSGIX) GetAddress("glFragmentLightfvSGIX", typeof(GL.Delegates.FragmentLightfvSGIX)); - GL.FragmentLightiSGIX = (GL.Delegates.FragmentLightiSGIX) GetAddress("glFragmentLightiSGIX", typeof(GL.Delegates.FragmentLightiSGIX)); - GL.FragmentLightivSGIX = (GL.Delegates.FragmentLightivSGIX) GetAddress("glFragmentLightivSGIX", typeof(GL.Delegates.FragmentLightivSGIX)); - GL.FragmentLightModelfSGIX = (GL.Delegates.FragmentLightModelfSGIX) GetAddress("glFragmentLightModelfSGIX", typeof(GL.Delegates.FragmentLightModelfSGIX)); - GL.FragmentLightModelfvSGIX = (GL.Delegates.FragmentLightModelfvSGIX) GetAddress("glFragmentLightModelfvSGIX", typeof(GL.Delegates.FragmentLightModelfvSGIX)); - GL.FragmentLightModeliSGIX = (GL.Delegates.FragmentLightModeliSGIX) GetAddress("glFragmentLightModeliSGIX", typeof(GL.Delegates.FragmentLightModeliSGIX)); - GL.FragmentLightModelivSGIX = (GL.Delegates.FragmentLightModelivSGIX) GetAddress("glFragmentLightModelivSGIX", typeof(GL.Delegates.FragmentLightModelivSGIX)); - GL.FragmentMaterialfSGIX = (GL.Delegates.FragmentMaterialfSGIX) GetAddress("glFragmentMaterialfSGIX", typeof(GL.Delegates.FragmentMaterialfSGIX)); - GL.FragmentMaterialfvSGIX = (GL.Delegates.FragmentMaterialfvSGIX) GetAddress("glFragmentMaterialfvSGIX", typeof(GL.Delegates.FragmentMaterialfvSGIX)); - GL.FragmentMaterialiSGIX = (GL.Delegates.FragmentMaterialiSGIX) GetAddress("glFragmentMaterialiSGIX", typeof(GL.Delegates.FragmentMaterialiSGIX)); - GL.FragmentMaterialivSGIX = (GL.Delegates.FragmentMaterialivSGIX) GetAddress("glFragmentMaterialivSGIX", typeof(GL.Delegates.FragmentMaterialivSGIX)); - GL.GetFragmentLightfvSGIX = (GL.Delegates.GetFragmentLightfvSGIX) GetAddress("glGetFragmentLightfvSGIX", typeof(GL.Delegates.GetFragmentLightfvSGIX)); - GL.GetFragmentLightivSGIX = (GL.Delegates.GetFragmentLightivSGIX) GetAddress("glGetFragmentLightivSGIX", typeof(GL.Delegates.GetFragmentLightivSGIX)); - GL.GetFragmentMaterialfvSGIX = (GL.Delegates.GetFragmentMaterialfvSGIX) GetAddress("glGetFragmentMaterialfvSGIX", typeof(GL.Delegates.GetFragmentMaterialfvSGIX)); - GL.GetFragmentMaterialivSGIX = (GL.Delegates.GetFragmentMaterialivSGIX) GetAddress("glGetFragmentMaterialivSGIX", typeof(GL.Delegates.GetFragmentMaterialivSGIX)); - GL.LightEnviSGIX = (GL.Delegates.LightEnviSGIX) GetAddress("glLightEnviSGIX", typeof(GL.Delegates.LightEnviSGIX)); - GL.DrawRangeElementsEXT = (GL.Delegates.DrawRangeElementsEXT) GetAddress("glDrawRangeElementsEXT", typeof(GL.Delegates.DrawRangeElementsEXT)); - GL.ApplyTextureEXT = (GL.Delegates.ApplyTextureEXT) GetAddress("glApplyTextureEXT", typeof(GL.Delegates.ApplyTextureEXT)); - GL.TextureLightEXT = (GL.Delegates.TextureLightEXT) GetAddress("glTextureLightEXT", typeof(GL.Delegates.TextureLightEXT)); - GL.TextureMaterialEXT = (GL.Delegates.TextureMaterialEXT) GetAddress("glTextureMaterialEXT", typeof(GL.Delegates.TextureMaterialEXT)); - GL.AsyncMarkerSGIX = (GL.Delegates.AsyncMarkerSGIX) GetAddress("glAsyncMarkerSGIX", typeof(GL.Delegates.AsyncMarkerSGIX)); - GL.FinishAsyncSGIX = (GL.Delegates.FinishAsyncSGIX) GetAddress("glFinishAsyncSGIX", typeof(GL.Delegates.FinishAsyncSGIX)); - GL.PollAsyncSGIX = (GL.Delegates.PollAsyncSGIX) GetAddress("glPollAsyncSGIX", typeof(GL.Delegates.PollAsyncSGIX)); - GL.GenAsyncMarkersSGIX = (GL.Delegates.GenAsyncMarkersSGIX) GetAddress("glGenAsyncMarkersSGIX", typeof(GL.Delegates.GenAsyncMarkersSGIX)); - GL.DeleteAsyncMarkersSGIX = (GL.Delegates.DeleteAsyncMarkersSGIX) GetAddress("glDeleteAsyncMarkersSGIX", typeof(GL.Delegates.DeleteAsyncMarkersSGIX)); - GL.IsAsyncMarkerSGIX = (GL.Delegates.IsAsyncMarkerSGIX) GetAddress("glIsAsyncMarkerSGIX", typeof(GL.Delegates.IsAsyncMarkerSGIX)); - GL.VertexPointervINTEL = (GL.Delegates.VertexPointervINTEL) GetAddress("glVertexPointervINTEL", typeof(GL.Delegates.VertexPointervINTEL)); - GL.NormalPointervINTEL = (GL.Delegates.NormalPointervINTEL) GetAddress("glNormalPointervINTEL", typeof(GL.Delegates.NormalPointervINTEL)); - GL.ColorPointervINTEL = (GL.Delegates.ColorPointervINTEL) GetAddress("glColorPointervINTEL", typeof(GL.Delegates.ColorPointervINTEL)); - GL.TexCoordPointervINTEL = (GL.Delegates.TexCoordPointervINTEL) GetAddress("glTexCoordPointervINTEL", typeof(GL.Delegates.TexCoordPointervINTEL)); - GL.PixelTransformParameteriEXT = (GL.Delegates.PixelTransformParameteriEXT) GetAddress("glPixelTransformParameteriEXT", typeof(GL.Delegates.PixelTransformParameteriEXT)); - GL.PixelTransformParameterfEXT = (GL.Delegates.PixelTransformParameterfEXT) GetAddress("glPixelTransformParameterfEXT", typeof(GL.Delegates.PixelTransformParameterfEXT)); - GL.PixelTransformParameterivEXT = (GL.Delegates.PixelTransformParameterivEXT) GetAddress("glPixelTransformParameterivEXT", typeof(GL.Delegates.PixelTransformParameterivEXT)); - GL.PixelTransformParameterfvEXT = (GL.Delegates.PixelTransformParameterfvEXT) GetAddress("glPixelTransformParameterfvEXT", typeof(GL.Delegates.PixelTransformParameterfvEXT)); - GL.SecondaryColor3bEXT = (GL.Delegates.SecondaryColor3bEXT) GetAddress("glSecondaryColor3bEXT", typeof(GL.Delegates.SecondaryColor3bEXT)); - GL.SecondaryColor3bvEXT = (GL.Delegates.SecondaryColor3bvEXT) GetAddress("glSecondaryColor3bvEXT", typeof(GL.Delegates.SecondaryColor3bvEXT)); - GL.SecondaryColor3dEXT = (GL.Delegates.SecondaryColor3dEXT) GetAddress("glSecondaryColor3dEXT", typeof(GL.Delegates.SecondaryColor3dEXT)); - GL.SecondaryColor3dvEXT = (GL.Delegates.SecondaryColor3dvEXT) GetAddress("glSecondaryColor3dvEXT", typeof(GL.Delegates.SecondaryColor3dvEXT)); - GL.SecondaryColor3fEXT = (GL.Delegates.SecondaryColor3fEXT) GetAddress("glSecondaryColor3fEXT", typeof(GL.Delegates.SecondaryColor3fEXT)); - GL.SecondaryColor3fvEXT = (GL.Delegates.SecondaryColor3fvEXT) GetAddress("glSecondaryColor3fvEXT", typeof(GL.Delegates.SecondaryColor3fvEXT)); - GL.SecondaryColor3iEXT = (GL.Delegates.SecondaryColor3iEXT) GetAddress("glSecondaryColor3iEXT", typeof(GL.Delegates.SecondaryColor3iEXT)); - GL.SecondaryColor3ivEXT = (GL.Delegates.SecondaryColor3ivEXT) GetAddress("glSecondaryColor3ivEXT", typeof(GL.Delegates.SecondaryColor3ivEXT)); - GL.SecondaryColor3sEXT = (GL.Delegates.SecondaryColor3sEXT) GetAddress("glSecondaryColor3sEXT", typeof(GL.Delegates.SecondaryColor3sEXT)); - GL.SecondaryColor3svEXT = (GL.Delegates.SecondaryColor3svEXT) GetAddress("glSecondaryColor3svEXT", typeof(GL.Delegates.SecondaryColor3svEXT)); - GL.SecondaryColor3ubEXT = (GL.Delegates.SecondaryColor3ubEXT) GetAddress("glSecondaryColor3ubEXT", typeof(GL.Delegates.SecondaryColor3ubEXT)); - GL.SecondaryColor3ubvEXT = (GL.Delegates.SecondaryColor3ubvEXT) GetAddress("glSecondaryColor3ubvEXT", typeof(GL.Delegates.SecondaryColor3ubvEXT)); - GL.SecondaryColor3uiEXT = (GL.Delegates.SecondaryColor3uiEXT) GetAddress("glSecondaryColor3uiEXT", typeof(GL.Delegates.SecondaryColor3uiEXT)); - GL.SecondaryColor3uivEXT = (GL.Delegates.SecondaryColor3uivEXT) GetAddress("glSecondaryColor3uivEXT", typeof(GL.Delegates.SecondaryColor3uivEXT)); - GL.SecondaryColor3usEXT = (GL.Delegates.SecondaryColor3usEXT) GetAddress("glSecondaryColor3usEXT", typeof(GL.Delegates.SecondaryColor3usEXT)); - GL.SecondaryColor3usvEXT = (GL.Delegates.SecondaryColor3usvEXT) GetAddress("glSecondaryColor3usvEXT", typeof(GL.Delegates.SecondaryColor3usvEXT)); - GL.SecondaryColorPointerEXT = (GL.Delegates.SecondaryColorPointerEXT) GetAddress("glSecondaryColorPointerEXT", typeof(GL.Delegates.SecondaryColorPointerEXT)); - GL.TextureNormalEXT = (GL.Delegates.TextureNormalEXT) GetAddress("glTextureNormalEXT", typeof(GL.Delegates.TextureNormalEXT)); - GL.MultiDrawArraysEXT = (GL.Delegates.MultiDrawArraysEXT) GetAddress("glMultiDrawArraysEXT", typeof(GL.Delegates.MultiDrawArraysEXT)); - GL.MultiDrawElementsEXT = (GL.Delegates.MultiDrawElementsEXT) GetAddress("glMultiDrawElementsEXT", typeof(GL.Delegates.MultiDrawElementsEXT)); - GL.FogCoordfEXT = (GL.Delegates.FogCoordfEXT) GetAddress("glFogCoordfEXT", typeof(GL.Delegates.FogCoordfEXT)); - GL.FogCoordfvEXT = (GL.Delegates.FogCoordfvEXT) GetAddress("glFogCoordfvEXT", typeof(GL.Delegates.FogCoordfvEXT)); - GL.FogCoorddEXT = (GL.Delegates.FogCoorddEXT) GetAddress("glFogCoorddEXT", typeof(GL.Delegates.FogCoorddEXT)); - GL.FogCoorddvEXT = (GL.Delegates.FogCoorddvEXT) GetAddress("glFogCoorddvEXT", typeof(GL.Delegates.FogCoorddvEXT)); - GL.FogCoordPointerEXT = (GL.Delegates.FogCoordPointerEXT) GetAddress("glFogCoordPointerEXT", typeof(GL.Delegates.FogCoordPointerEXT)); - GL.Tangent3bEXT = (GL.Delegates.Tangent3bEXT) GetAddress("glTangent3bEXT", typeof(GL.Delegates.Tangent3bEXT)); - GL.Tangent3bvEXT = (GL.Delegates.Tangent3bvEXT) GetAddress("glTangent3bvEXT", typeof(GL.Delegates.Tangent3bvEXT)); - GL.Tangent3dEXT = (GL.Delegates.Tangent3dEXT) GetAddress("glTangent3dEXT", typeof(GL.Delegates.Tangent3dEXT)); - GL.Tangent3dvEXT = (GL.Delegates.Tangent3dvEXT) GetAddress("glTangent3dvEXT", typeof(GL.Delegates.Tangent3dvEXT)); - GL.Tangent3fEXT = (GL.Delegates.Tangent3fEXT) GetAddress("glTangent3fEXT", typeof(GL.Delegates.Tangent3fEXT)); - GL.Tangent3fvEXT = (GL.Delegates.Tangent3fvEXT) GetAddress("glTangent3fvEXT", typeof(GL.Delegates.Tangent3fvEXT)); - GL.Tangent3iEXT = (GL.Delegates.Tangent3iEXT) GetAddress("glTangent3iEXT", typeof(GL.Delegates.Tangent3iEXT)); - GL.Tangent3ivEXT = (GL.Delegates.Tangent3ivEXT) GetAddress("glTangent3ivEXT", typeof(GL.Delegates.Tangent3ivEXT)); - GL.Tangent3sEXT = (GL.Delegates.Tangent3sEXT) GetAddress("glTangent3sEXT", typeof(GL.Delegates.Tangent3sEXT)); - GL.Tangent3svEXT = (GL.Delegates.Tangent3svEXT) GetAddress("glTangent3svEXT", typeof(GL.Delegates.Tangent3svEXT)); - GL.Binormal3bEXT = (GL.Delegates.Binormal3bEXT) GetAddress("glBinormal3bEXT", typeof(GL.Delegates.Binormal3bEXT)); - GL.Binormal3bvEXT = (GL.Delegates.Binormal3bvEXT) GetAddress("glBinormal3bvEXT", typeof(GL.Delegates.Binormal3bvEXT)); - GL.Binormal3dEXT = (GL.Delegates.Binormal3dEXT) GetAddress("glBinormal3dEXT", typeof(GL.Delegates.Binormal3dEXT)); - GL.Binormal3dvEXT = (GL.Delegates.Binormal3dvEXT) GetAddress("glBinormal3dvEXT", typeof(GL.Delegates.Binormal3dvEXT)); - GL.Binormal3fEXT = (GL.Delegates.Binormal3fEXT) GetAddress("glBinormal3fEXT", typeof(GL.Delegates.Binormal3fEXT)); - GL.Binormal3fvEXT = (GL.Delegates.Binormal3fvEXT) GetAddress("glBinormal3fvEXT", typeof(GL.Delegates.Binormal3fvEXT)); - GL.Binormal3iEXT = (GL.Delegates.Binormal3iEXT) GetAddress("glBinormal3iEXT", typeof(GL.Delegates.Binormal3iEXT)); - GL.Binormal3ivEXT = (GL.Delegates.Binormal3ivEXT) GetAddress("glBinormal3ivEXT", typeof(GL.Delegates.Binormal3ivEXT)); - GL.Binormal3sEXT = (GL.Delegates.Binormal3sEXT) GetAddress("glBinormal3sEXT", typeof(GL.Delegates.Binormal3sEXT)); - GL.Binormal3svEXT = (GL.Delegates.Binormal3svEXT) GetAddress("glBinormal3svEXT", typeof(GL.Delegates.Binormal3svEXT)); - GL.TangentPointerEXT = (GL.Delegates.TangentPointerEXT) GetAddress("glTangentPointerEXT", typeof(GL.Delegates.TangentPointerEXT)); - GL.BinormalPointerEXT = (GL.Delegates.BinormalPointerEXT) GetAddress("glBinormalPointerEXT", typeof(GL.Delegates.BinormalPointerEXT)); - GL.FinishTextureSUNX = (GL.Delegates.FinishTextureSUNX) GetAddress("glFinishTextureSUNX", typeof(GL.Delegates.FinishTextureSUNX)); - GL.GlobalAlphaFactorbSUN = (GL.Delegates.GlobalAlphaFactorbSUN) GetAddress("glGlobalAlphaFactorbSUN", typeof(GL.Delegates.GlobalAlphaFactorbSUN)); - GL.GlobalAlphaFactorsSUN = (GL.Delegates.GlobalAlphaFactorsSUN) GetAddress("glGlobalAlphaFactorsSUN", typeof(GL.Delegates.GlobalAlphaFactorsSUN)); - GL.GlobalAlphaFactoriSUN = (GL.Delegates.GlobalAlphaFactoriSUN) GetAddress("glGlobalAlphaFactoriSUN", typeof(GL.Delegates.GlobalAlphaFactoriSUN)); - GL.GlobalAlphaFactorfSUN = (GL.Delegates.GlobalAlphaFactorfSUN) GetAddress("glGlobalAlphaFactorfSUN", typeof(GL.Delegates.GlobalAlphaFactorfSUN)); - GL.GlobalAlphaFactordSUN = (GL.Delegates.GlobalAlphaFactordSUN) GetAddress("glGlobalAlphaFactordSUN", typeof(GL.Delegates.GlobalAlphaFactordSUN)); - GL.GlobalAlphaFactorubSUN = (GL.Delegates.GlobalAlphaFactorubSUN) GetAddress("glGlobalAlphaFactorubSUN", typeof(GL.Delegates.GlobalAlphaFactorubSUN)); - GL.GlobalAlphaFactorusSUN = (GL.Delegates.GlobalAlphaFactorusSUN) GetAddress("glGlobalAlphaFactorusSUN", typeof(GL.Delegates.GlobalAlphaFactorusSUN)); - GL.GlobalAlphaFactoruiSUN = (GL.Delegates.GlobalAlphaFactoruiSUN) GetAddress("glGlobalAlphaFactoruiSUN", typeof(GL.Delegates.GlobalAlphaFactoruiSUN)); - GL.ReplacementCodeuiSUN = (GL.Delegates.ReplacementCodeuiSUN) GetAddress("glReplacementCodeuiSUN", typeof(GL.Delegates.ReplacementCodeuiSUN)); - GL.ReplacementCodeusSUN = (GL.Delegates.ReplacementCodeusSUN) GetAddress("glReplacementCodeusSUN", typeof(GL.Delegates.ReplacementCodeusSUN)); - GL.ReplacementCodeubSUN = (GL.Delegates.ReplacementCodeubSUN) GetAddress("glReplacementCodeubSUN", typeof(GL.Delegates.ReplacementCodeubSUN)); - GL.ReplacementCodeuivSUN = (GL.Delegates.ReplacementCodeuivSUN) GetAddress("glReplacementCodeuivSUN", typeof(GL.Delegates.ReplacementCodeuivSUN)); - GL.ReplacementCodeusvSUN = (GL.Delegates.ReplacementCodeusvSUN) GetAddress("glReplacementCodeusvSUN", typeof(GL.Delegates.ReplacementCodeusvSUN)); - GL.ReplacementCodeubvSUN = (GL.Delegates.ReplacementCodeubvSUN) GetAddress("glReplacementCodeubvSUN", typeof(GL.Delegates.ReplacementCodeubvSUN)); - GL.ReplacementCodePointerSUN = (GL.Delegates.ReplacementCodePointerSUN) GetAddress("glReplacementCodePointerSUN", typeof(GL.Delegates.ReplacementCodePointerSUN)); - GL.Color4ubVertex2fSUN = (GL.Delegates.Color4ubVertex2fSUN) GetAddress("glColor4ubVertex2fSUN", typeof(GL.Delegates.Color4ubVertex2fSUN)); - GL.Color4ubVertex2fvSUN = (GL.Delegates.Color4ubVertex2fvSUN) GetAddress("glColor4ubVertex2fvSUN", typeof(GL.Delegates.Color4ubVertex2fvSUN)); - GL.Color4ubVertex3fSUN = (GL.Delegates.Color4ubVertex3fSUN) GetAddress("glColor4ubVertex3fSUN", typeof(GL.Delegates.Color4ubVertex3fSUN)); - GL.Color4ubVertex3fvSUN = (GL.Delegates.Color4ubVertex3fvSUN) GetAddress("glColor4ubVertex3fvSUN", typeof(GL.Delegates.Color4ubVertex3fvSUN)); - GL.Color3fVertex3fSUN = (GL.Delegates.Color3fVertex3fSUN) GetAddress("glColor3fVertex3fSUN", typeof(GL.Delegates.Color3fVertex3fSUN)); - GL.Color3fVertex3fvSUN = (GL.Delegates.Color3fVertex3fvSUN) GetAddress("glColor3fVertex3fvSUN", typeof(GL.Delegates.Color3fVertex3fvSUN)); - GL.Normal3fVertex3fSUN = (GL.Delegates.Normal3fVertex3fSUN) GetAddress("glNormal3fVertex3fSUN", typeof(GL.Delegates.Normal3fVertex3fSUN)); - GL.Normal3fVertex3fvSUN = (GL.Delegates.Normal3fVertex3fvSUN) GetAddress("glNormal3fVertex3fvSUN", typeof(GL.Delegates.Normal3fVertex3fvSUN)); - GL.Color4fNormal3fVertex3fSUN = (GL.Delegates.Color4fNormal3fVertex3fSUN) GetAddress("glColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fSUN)); - GL.Color4fNormal3fVertex3fvSUN = (GL.Delegates.Color4fNormal3fVertex3fvSUN) GetAddress("glColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fvSUN)); - GL.TexCoord2fVertex3fSUN = (GL.Delegates.TexCoord2fVertex3fSUN) GetAddress("glTexCoord2fVertex3fSUN", typeof(GL.Delegates.TexCoord2fVertex3fSUN)); - GL.TexCoord2fVertex3fvSUN = (GL.Delegates.TexCoord2fVertex3fvSUN) GetAddress("glTexCoord2fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fVertex3fvSUN)); - GL.TexCoord4fVertex4fSUN = (GL.Delegates.TexCoord4fVertex4fSUN) GetAddress("glTexCoord4fVertex4fSUN", typeof(GL.Delegates.TexCoord4fVertex4fSUN)); - GL.TexCoord4fVertex4fvSUN = (GL.Delegates.TexCoord4fVertex4fvSUN) GetAddress("glTexCoord4fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fVertex4fvSUN)); - GL.TexCoord2fColor4ubVertex3fSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fSUN) GetAddress("glTexCoord2fColor4ubVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fSUN)); - GL.TexCoord2fColor4ubVertex3fvSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fvSUN) GetAddress("glTexCoord2fColor4ubVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fvSUN)); - GL.TexCoord2fColor3fVertex3fSUN = (GL.Delegates.TexCoord2fColor3fVertex3fSUN) GetAddress("glTexCoord2fColor3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fSUN)); - GL.TexCoord2fColor3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor3fVertex3fvSUN) GetAddress("glTexCoord2fColor3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fvSUN)); - GL.TexCoord2fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fSUN) GetAddress("glTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fSUN)); - GL.TexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fvSUN) GetAddress("glTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fvSUN)); - GL.TexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN) GetAddress("glTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN)); - GL.TexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN) GetAddress("glTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN)); - GL.TexCoord4fColor4fNormal3fVertex4fSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN) GetAddress("glTexCoord4fColor4fNormal3fVertex4fSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN)); - GL.TexCoord4fColor4fNormal3fVertex4fvSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN) GetAddress("glTexCoord4fColor4fNormal3fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN)); - GL.ReplacementCodeuiVertex3fSUN = (GL.Delegates.ReplacementCodeuiVertex3fSUN) GetAddress("glReplacementCodeuiVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fSUN)); - GL.ReplacementCodeuiVertex3fvSUN = (GL.Delegates.ReplacementCodeuiVertex3fvSUN) GetAddress("glReplacementCodeuiVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fvSUN)); - GL.ReplacementCodeuiColor4ubVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN) GetAddress("glReplacementCodeuiColor4ubVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN)); - GL.ReplacementCodeuiColor4ubVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN) GetAddress("glReplacementCodeuiColor4ubVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN)); - GL.ReplacementCodeuiColor3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN) GetAddress("glReplacementCodeuiColor3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN)); - GL.ReplacementCodeuiColor3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN) GetAddress("glReplacementCodeuiColor3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN)); - GL.ReplacementCodeuiNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN)); - GL.ReplacementCodeuiNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)); - GL.BlendFuncSeparateEXT = (GL.Delegates.BlendFuncSeparateEXT) GetAddress("glBlendFuncSeparateEXT", typeof(GL.Delegates.BlendFuncSeparateEXT)); - GL.BlendFuncSeparateINGR = (GL.Delegates.BlendFuncSeparateINGR) GetAddress("glBlendFuncSeparateINGR", typeof(GL.Delegates.BlendFuncSeparateINGR)); - GL.VertexWeightfEXT = (GL.Delegates.VertexWeightfEXT) GetAddress("glVertexWeightfEXT", typeof(GL.Delegates.VertexWeightfEXT)); - GL.VertexWeightfvEXT = (GL.Delegates.VertexWeightfvEXT) GetAddress("glVertexWeightfvEXT", typeof(GL.Delegates.VertexWeightfvEXT)); - GL.VertexWeightPointerEXT = (GL.Delegates.VertexWeightPointerEXT) GetAddress("glVertexWeightPointerEXT", typeof(GL.Delegates.VertexWeightPointerEXT)); - GL.FlushVertexArrayRangeNV = (GL.Delegates.FlushVertexArrayRangeNV) GetAddress("glFlushVertexArrayRangeNV", typeof(GL.Delegates.FlushVertexArrayRangeNV)); - GL.VertexArrayRangeNV = (GL.Delegates.VertexArrayRangeNV) GetAddress("glVertexArrayRangeNV", typeof(GL.Delegates.VertexArrayRangeNV)); - GL.CombinerParameterfvNV = (GL.Delegates.CombinerParameterfvNV) GetAddress("glCombinerParameterfvNV", typeof(GL.Delegates.CombinerParameterfvNV)); - GL.CombinerParameterfNV = (GL.Delegates.CombinerParameterfNV) GetAddress("glCombinerParameterfNV", typeof(GL.Delegates.CombinerParameterfNV)); - GL.CombinerParameterivNV = (GL.Delegates.CombinerParameterivNV) GetAddress("glCombinerParameterivNV", typeof(GL.Delegates.CombinerParameterivNV)); - GL.CombinerParameteriNV = (GL.Delegates.CombinerParameteriNV) GetAddress("glCombinerParameteriNV", typeof(GL.Delegates.CombinerParameteriNV)); - GL.CombinerInputNV = (GL.Delegates.CombinerInputNV) GetAddress("glCombinerInputNV", typeof(GL.Delegates.CombinerInputNV)); - GL.CombinerOutputNV = (GL.Delegates.CombinerOutputNV) GetAddress("glCombinerOutputNV", typeof(GL.Delegates.CombinerOutputNV)); - GL.FinalCombinerInputNV = (GL.Delegates.FinalCombinerInputNV) GetAddress("glFinalCombinerInputNV", typeof(GL.Delegates.FinalCombinerInputNV)); - GL.GetCombinerInputParameterfvNV = (GL.Delegates.GetCombinerInputParameterfvNV) GetAddress("glGetCombinerInputParameterfvNV", typeof(GL.Delegates.GetCombinerInputParameterfvNV)); - GL.GetCombinerInputParameterivNV = (GL.Delegates.GetCombinerInputParameterivNV) GetAddress("glGetCombinerInputParameterivNV", typeof(GL.Delegates.GetCombinerInputParameterivNV)); - GL.GetCombinerOutputParameterfvNV = (GL.Delegates.GetCombinerOutputParameterfvNV) GetAddress("glGetCombinerOutputParameterfvNV", typeof(GL.Delegates.GetCombinerOutputParameterfvNV)); - GL.GetCombinerOutputParameterivNV = (GL.Delegates.GetCombinerOutputParameterivNV) GetAddress("glGetCombinerOutputParameterivNV", typeof(GL.Delegates.GetCombinerOutputParameterivNV)); - GL.GetFinalCombinerInputParameterfvNV = (GL.Delegates.GetFinalCombinerInputParameterfvNV) GetAddress("glGetFinalCombinerInputParameterfvNV", typeof(GL.Delegates.GetFinalCombinerInputParameterfvNV)); - GL.GetFinalCombinerInputParameterivNV = (GL.Delegates.GetFinalCombinerInputParameterivNV) GetAddress("glGetFinalCombinerInputParameterivNV", typeof(GL.Delegates.GetFinalCombinerInputParameterivNV)); - GL.ResizeBuffersMESA = (GL.Delegates.ResizeBuffersMESA) GetAddress("glResizeBuffersMESA", typeof(GL.Delegates.ResizeBuffersMESA)); - GL.WindowPos2dMESA = (GL.Delegates.WindowPos2dMESA) GetAddress("glWindowPos2dMESA", typeof(GL.Delegates.WindowPos2dMESA)); - GL.WindowPos2dvMESA = (GL.Delegates.WindowPos2dvMESA) GetAddress("glWindowPos2dvMESA", typeof(GL.Delegates.WindowPos2dvMESA)); - GL.WindowPos2fMESA = (GL.Delegates.WindowPos2fMESA) GetAddress("glWindowPos2fMESA", typeof(GL.Delegates.WindowPos2fMESA)); - GL.WindowPos2fvMESA = (GL.Delegates.WindowPos2fvMESA) GetAddress("glWindowPos2fvMESA", typeof(GL.Delegates.WindowPos2fvMESA)); - GL.WindowPos2iMESA = (GL.Delegates.WindowPos2iMESA) GetAddress("glWindowPos2iMESA", typeof(GL.Delegates.WindowPos2iMESA)); - GL.WindowPos2ivMESA = (GL.Delegates.WindowPos2ivMESA) GetAddress("glWindowPos2ivMESA", typeof(GL.Delegates.WindowPos2ivMESA)); - GL.WindowPos2sMESA = (GL.Delegates.WindowPos2sMESA) GetAddress("glWindowPos2sMESA", typeof(GL.Delegates.WindowPos2sMESA)); - GL.WindowPos2svMESA = (GL.Delegates.WindowPos2svMESA) GetAddress("glWindowPos2svMESA", typeof(GL.Delegates.WindowPos2svMESA)); - GL.WindowPos3dMESA = (GL.Delegates.WindowPos3dMESA) GetAddress("glWindowPos3dMESA", typeof(GL.Delegates.WindowPos3dMESA)); - GL.WindowPos3dvMESA = (GL.Delegates.WindowPos3dvMESA) GetAddress("glWindowPos3dvMESA", typeof(GL.Delegates.WindowPos3dvMESA)); - GL.WindowPos3fMESA = (GL.Delegates.WindowPos3fMESA) GetAddress("glWindowPos3fMESA", typeof(GL.Delegates.WindowPos3fMESA)); - GL.WindowPos3fvMESA = (GL.Delegates.WindowPos3fvMESA) GetAddress("glWindowPos3fvMESA", typeof(GL.Delegates.WindowPos3fvMESA)); - GL.WindowPos3iMESA = (GL.Delegates.WindowPos3iMESA) GetAddress("glWindowPos3iMESA", typeof(GL.Delegates.WindowPos3iMESA)); - GL.WindowPos3ivMESA = (GL.Delegates.WindowPos3ivMESA) GetAddress("glWindowPos3ivMESA", typeof(GL.Delegates.WindowPos3ivMESA)); - GL.WindowPos3sMESA = (GL.Delegates.WindowPos3sMESA) GetAddress("glWindowPos3sMESA", typeof(GL.Delegates.WindowPos3sMESA)); - GL.WindowPos3svMESA = (GL.Delegates.WindowPos3svMESA) GetAddress("glWindowPos3svMESA", typeof(GL.Delegates.WindowPos3svMESA)); - GL.WindowPos4dMESA = (GL.Delegates.WindowPos4dMESA) GetAddress("glWindowPos4dMESA", typeof(GL.Delegates.WindowPos4dMESA)); - GL.WindowPos4dvMESA = (GL.Delegates.WindowPos4dvMESA) GetAddress("glWindowPos4dvMESA", typeof(GL.Delegates.WindowPos4dvMESA)); - GL.WindowPos4fMESA = (GL.Delegates.WindowPos4fMESA) GetAddress("glWindowPos4fMESA", typeof(GL.Delegates.WindowPos4fMESA)); - GL.WindowPos4fvMESA = (GL.Delegates.WindowPos4fvMESA) GetAddress("glWindowPos4fvMESA", typeof(GL.Delegates.WindowPos4fvMESA)); - GL.WindowPos4iMESA = (GL.Delegates.WindowPos4iMESA) GetAddress("glWindowPos4iMESA", typeof(GL.Delegates.WindowPos4iMESA)); - GL.WindowPos4ivMESA = (GL.Delegates.WindowPos4ivMESA) GetAddress("glWindowPos4ivMESA", typeof(GL.Delegates.WindowPos4ivMESA)); - GL.WindowPos4sMESA = (GL.Delegates.WindowPos4sMESA) GetAddress("glWindowPos4sMESA", typeof(GL.Delegates.WindowPos4sMESA)); - GL.WindowPos4svMESA = (GL.Delegates.WindowPos4svMESA) GetAddress("glWindowPos4svMESA", typeof(GL.Delegates.WindowPos4svMESA)); - GL.MultiModeDrawArraysIBM = (GL.Delegates.MultiModeDrawArraysIBM) GetAddress("glMultiModeDrawArraysIBM", typeof(GL.Delegates.MultiModeDrawArraysIBM)); - GL.MultiModeDrawElementsIBM = (GL.Delegates.MultiModeDrawElementsIBM) GetAddress("glMultiModeDrawElementsIBM", typeof(GL.Delegates.MultiModeDrawElementsIBM)); - GL.ColorPointerListIBM = (GL.Delegates.ColorPointerListIBM) GetAddress("glColorPointerListIBM", typeof(GL.Delegates.ColorPointerListIBM)); - GL.SecondaryColorPointerListIBM = (GL.Delegates.SecondaryColorPointerListIBM) GetAddress("glSecondaryColorPointerListIBM", typeof(GL.Delegates.SecondaryColorPointerListIBM)); - GL.EdgeFlagPointerListIBM = (GL.Delegates.EdgeFlagPointerListIBM) GetAddress("glEdgeFlagPointerListIBM", typeof(GL.Delegates.EdgeFlagPointerListIBM)); - GL.FogCoordPointerListIBM = (GL.Delegates.FogCoordPointerListIBM) GetAddress("glFogCoordPointerListIBM", typeof(GL.Delegates.FogCoordPointerListIBM)); - GL.IndexPointerListIBM = (GL.Delegates.IndexPointerListIBM) GetAddress("glIndexPointerListIBM", typeof(GL.Delegates.IndexPointerListIBM)); - GL.NormalPointerListIBM = (GL.Delegates.NormalPointerListIBM) GetAddress("glNormalPointerListIBM", typeof(GL.Delegates.NormalPointerListIBM)); - GL.TexCoordPointerListIBM = (GL.Delegates.TexCoordPointerListIBM) GetAddress("glTexCoordPointerListIBM", typeof(GL.Delegates.TexCoordPointerListIBM)); - GL.VertexPointerListIBM = (GL.Delegates.VertexPointerListIBM) GetAddress("glVertexPointerListIBM", typeof(GL.Delegates.VertexPointerListIBM)); - GL.TbufferMask3DFX = (GL.Delegates.TbufferMask3DFX) GetAddress("glTbufferMask3DFX", typeof(GL.Delegates.TbufferMask3DFX)); - GL.SampleMaskEXT = (GL.Delegates.SampleMaskEXT) GetAddress("glSampleMaskEXT", typeof(GL.Delegates.SampleMaskEXT)); - GL.SamplePatternEXT = (GL.Delegates.SamplePatternEXT) GetAddress("glSamplePatternEXT", typeof(GL.Delegates.SamplePatternEXT)); - GL.TextureColorMaskSGIS = (GL.Delegates.TextureColorMaskSGIS) GetAddress("glTextureColorMaskSGIS", typeof(GL.Delegates.TextureColorMaskSGIS)); - GL.IglooInterfaceSGIX = (GL.Delegates.IglooInterfaceSGIX) GetAddress("glIglooInterfaceSGIX", typeof(GL.Delegates.IglooInterfaceSGIX)); - GL.DeleteFencesNV = (GL.Delegates.DeleteFencesNV) GetAddress("glDeleteFencesNV", typeof(GL.Delegates.DeleteFencesNV)); - GL.GenFencesNV = (GL.Delegates.GenFencesNV) GetAddress("glGenFencesNV", typeof(GL.Delegates.GenFencesNV)); - GL.IsFenceNV = (GL.Delegates.IsFenceNV) GetAddress("glIsFenceNV", typeof(GL.Delegates.IsFenceNV)); - GL.TestFenceNV = (GL.Delegates.TestFenceNV) GetAddress("glTestFenceNV", typeof(GL.Delegates.TestFenceNV)); - GL.GetFenceivNV = (GL.Delegates.GetFenceivNV) GetAddress("glGetFenceivNV", typeof(GL.Delegates.GetFenceivNV)); - GL.FinishFenceNV = (GL.Delegates.FinishFenceNV) GetAddress("glFinishFenceNV", typeof(GL.Delegates.FinishFenceNV)); - GL.SetFenceNV = (GL.Delegates.SetFenceNV) GetAddress("glSetFenceNV", typeof(GL.Delegates.SetFenceNV)); - GL.MapControlPointsNV = (GL.Delegates.MapControlPointsNV) GetAddress("glMapControlPointsNV", typeof(GL.Delegates.MapControlPointsNV)); - GL.MapParameterivNV = (GL.Delegates.MapParameterivNV) GetAddress("glMapParameterivNV", typeof(GL.Delegates.MapParameterivNV)); - GL.MapParameterfvNV = (GL.Delegates.MapParameterfvNV) GetAddress("glMapParameterfvNV", typeof(GL.Delegates.MapParameterfvNV)); - GL.GetMapControlPointsNV = (GL.Delegates.GetMapControlPointsNV) GetAddress("glGetMapControlPointsNV", typeof(GL.Delegates.GetMapControlPointsNV)); - GL.GetMapParameterivNV = (GL.Delegates.GetMapParameterivNV) GetAddress("glGetMapParameterivNV", typeof(GL.Delegates.GetMapParameterivNV)); - GL.GetMapParameterfvNV = (GL.Delegates.GetMapParameterfvNV) GetAddress("glGetMapParameterfvNV", typeof(GL.Delegates.GetMapParameterfvNV)); - GL.GetMapAttribParameterivNV = (GL.Delegates.GetMapAttribParameterivNV) GetAddress("glGetMapAttribParameterivNV", typeof(GL.Delegates.GetMapAttribParameterivNV)); - GL.GetMapAttribParameterfvNV = (GL.Delegates.GetMapAttribParameterfvNV) GetAddress("glGetMapAttribParameterfvNV", typeof(GL.Delegates.GetMapAttribParameterfvNV)); - GL.EvalMapsNV = (GL.Delegates.EvalMapsNV) GetAddress("glEvalMapsNV", typeof(GL.Delegates.EvalMapsNV)); - GL.CombinerStageParameterfvNV = (GL.Delegates.CombinerStageParameterfvNV) GetAddress("glCombinerStageParameterfvNV", typeof(GL.Delegates.CombinerStageParameterfvNV)); - GL.GetCombinerStageParameterfvNV = (GL.Delegates.GetCombinerStageParameterfvNV) GetAddress("glGetCombinerStageParameterfvNV", typeof(GL.Delegates.GetCombinerStageParameterfvNV)); - GL.AreProgramsResidentNV = (GL.Delegates.AreProgramsResidentNV) GetAddress("glAreProgramsResidentNV", typeof(GL.Delegates.AreProgramsResidentNV)); - GL.BindProgramNV = (GL.Delegates.BindProgramNV) GetAddress("glBindProgramNV", typeof(GL.Delegates.BindProgramNV)); - GL.DeleteProgramsNV = (GL.Delegates.DeleteProgramsNV) GetAddress("glDeleteProgramsNV", typeof(GL.Delegates.DeleteProgramsNV)); - GL.ExecuteProgramNV = (GL.Delegates.ExecuteProgramNV) GetAddress("glExecuteProgramNV", typeof(GL.Delegates.ExecuteProgramNV)); - GL.GenProgramsNV = (GL.Delegates.GenProgramsNV) GetAddress("glGenProgramsNV", typeof(GL.Delegates.GenProgramsNV)); - GL.GetProgramParameterdvNV = (GL.Delegates.GetProgramParameterdvNV) GetAddress("glGetProgramParameterdvNV", typeof(GL.Delegates.GetProgramParameterdvNV)); - GL.GetProgramParameterfvNV = (GL.Delegates.GetProgramParameterfvNV) GetAddress("glGetProgramParameterfvNV", typeof(GL.Delegates.GetProgramParameterfvNV)); - GL.GetProgramivNV = (GL.Delegates.GetProgramivNV) GetAddress("glGetProgramivNV", typeof(GL.Delegates.GetProgramivNV)); - GL.GetProgramStringNV = (GL.Delegates.GetProgramStringNV) GetAddress("glGetProgramStringNV", typeof(GL.Delegates.GetProgramStringNV)); - GL.GetTrackMatrixivNV = (GL.Delegates.GetTrackMatrixivNV) GetAddress("glGetTrackMatrixivNV", typeof(GL.Delegates.GetTrackMatrixivNV)); - GL.GetVertexAttribdvNV = (GL.Delegates.GetVertexAttribdvNV) GetAddress("glGetVertexAttribdvNV", typeof(GL.Delegates.GetVertexAttribdvNV)); - GL.GetVertexAttribfvNV = (GL.Delegates.GetVertexAttribfvNV) GetAddress("glGetVertexAttribfvNV", typeof(GL.Delegates.GetVertexAttribfvNV)); - GL.GetVertexAttribivNV = (GL.Delegates.GetVertexAttribivNV) GetAddress("glGetVertexAttribivNV", typeof(GL.Delegates.GetVertexAttribivNV)); - GL.GetVertexAttribPointervNV = (GL.Delegates.GetVertexAttribPointervNV) GetAddress("glGetVertexAttribPointervNV", typeof(GL.Delegates.GetVertexAttribPointervNV)); - GL.IsProgramNV = (GL.Delegates.IsProgramNV) GetAddress("glIsProgramNV", typeof(GL.Delegates.IsProgramNV)); - GL.LoadProgramNV = (GL.Delegates.LoadProgramNV) GetAddress("glLoadProgramNV", typeof(GL.Delegates.LoadProgramNV)); - GL.ProgramParameter4dNV = (GL.Delegates.ProgramParameter4dNV) GetAddress("glProgramParameter4dNV", typeof(GL.Delegates.ProgramParameter4dNV)); - GL.ProgramParameter4dvNV = (GL.Delegates.ProgramParameter4dvNV) GetAddress("glProgramParameter4dvNV", typeof(GL.Delegates.ProgramParameter4dvNV)); - GL.ProgramParameter4fNV = (GL.Delegates.ProgramParameter4fNV) GetAddress("glProgramParameter4fNV", typeof(GL.Delegates.ProgramParameter4fNV)); - GL.ProgramParameter4fvNV = (GL.Delegates.ProgramParameter4fvNV) GetAddress("glProgramParameter4fvNV", typeof(GL.Delegates.ProgramParameter4fvNV)); - GL.ProgramParameters4dvNV = (GL.Delegates.ProgramParameters4dvNV) GetAddress("glProgramParameters4dvNV", typeof(GL.Delegates.ProgramParameters4dvNV)); - GL.ProgramParameters4fvNV = (GL.Delegates.ProgramParameters4fvNV) GetAddress("glProgramParameters4fvNV", typeof(GL.Delegates.ProgramParameters4fvNV)); - GL.RequestResidentProgramsNV = (GL.Delegates.RequestResidentProgramsNV) GetAddress("glRequestResidentProgramsNV", typeof(GL.Delegates.RequestResidentProgramsNV)); - GL.TrackMatrixNV = (GL.Delegates.TrackMatrixNV) GetAddress("glTrackMatrixNV", typeof(GL.Delegates.TrackMatrixNV)); - GL.VertexAttribPointerNV = (GL.Delegates.VertexAttribPointerNV) GetAddress("glVertexAttribPointerNV", typeof(GL.Delegates.VertexAttribPointerNV)); - GL.VertexAttrib1dNV = (GL.Delegates.VertexAttrib1dNV) GetAddress("glVertexAttrib1dNV", typeof(GL.Delegates.VertexAttrib1dNV)); - GL.VertexAttrib1dvNV = (GL.Delegates.VertexAttrib1dvNV) GetAddress("glVertexAttrib1dvNV", typeof(GL.Delegates.VertexAttrib1dvNV)); - GL.VertexAttrib1fNV = (GL.Delegates.VertexAttrib1fNV) GetAddress("glVertexAttrib1fNV", typeof(GL.Delegates.VertexAttrib1fNV)); - GL.VertexAttrib1fvNV = (GL.Delegates.VertexAttrib1fvNV) GetAddress("glVertexAttrib1fvNV", typeof(GL.Delegates.VertexAttrib1fvNV)); - GL.VertexAttrib1sNV = (GL.Delegates.VertexAttrib1sNV) GetAddress("glVertexAttrib1sNV", typeof(GL.Delegates.VertexAttrib1sNV)); - GL.VertexAttrib1svNV = (GL.Delegates.VertexAttrib1svNV) GetAddress("glVertexAttrib1svNV", typeof(GL.Delegates.VertexAttrib1svNV)); - GL.VertexAttrib2dNV = (GL.Delegates.VertexAttrib2dNV) GetAddress("glVertexAttrib2dNV", typeof(GL.Delegates.VertexAttrib2dNV)); - GL.VertexAttrib2dvNV = (GL.Delegates.VertexAttrib2dvNV) GetAddress("glVertexAttrib2dvNV", typeof(GL.Delegates.VertexAttrib2dvNV)); - GL.VertexAttrib2fNV = (GL.Delegates.VertexAttrib2fNV) GetAddress("glVertexAttrib2fNV", typeof(GL.Delegates.VertexAttrib2fNV)); - GL.VertexAttrib2fvNV = (GL.Delegates.VertexAttrib2fvNV) GetAddress("glVertexAttrib2fvNV", typeof(GL.Delegates.VertexAttrib2fvNV)); - GL.VertexAttrib2sNV = (GL.Delegates.VertexAttrib2sNV) GetAddress("glVertexAttrib2sNV", typeof(GL.Delegates.VertexAttrib2sNV)); - GL.VertexAttrib2svNV = (GL.Delegates.VertexAttrib2svNV) GetAddress("glVertexAttrib2svNV", typeof(GL.Delegates.VertexAttrib2svNV)); - GL.VertexAttrib3dNV = (GL.Delegates.VertexAttrib3dNV) GetAddress("glVertexAttrib3dNV", typeof(GL.Delegates.VertexAttrib3dNV)); - GL.VertexAttrib3dvNV = (GL.Delegates.VertexAttrib3dvNV) GetAddress("glVertexAttrib3dvNV", typeof(GL.Delegates.VertexAttrib3dvNV)); - GL.VertexAttrib3fNV = (GL.Delegates.VertexAttrib3fNV) GetAddress("glVertexAttrib3fNV", typeof(GL.Delegates.VertexAttrib3fNV)); - GL.VertexAttrib3fvNV = (GL.Delegates.VertexAttrib3fvNV) GetAddress("glVertexAttrib3fvNV", typeof(GL.Delegates.VertexAttrib3fvNV)); - GL.VertexAttrib3sNV = (GL.Delegates.VertexAttrib3sNV) GetAddress("glVertexAttrib3sNV", typeof(GL.Delegates.VertexAttrib3sNV)); - GL.VertexAttrib3svNV = (GL.Delegates.VertexAttrib3svNV) GetAddress("glVertexAttrib3svNV", typeof(GL.Delegates.VertexAttrib3svNV)); - GL.VertexAttrib4dNV = (GL.Delegates.VertexAttrib4dNV) GetAddress("glVertexAttrib4dNV", typeof(GL.Delegates.VertexAttrib4dNV)); - GL.VertexAttrib4dvNV = (GL.Delegates.VertexAttrib4dvNV) GetAddress("glVertexAttrib4dvNV", typeof(GL.Delegates.VertexAttrib4dvNV)); - GL.VertexAttrib4fNV = (GL.Delegates.VertexAttrib4fNV) GetAddress("glVertexAttrib4fNV", typeof(GL.Delegates.VertexAttrib4fNV)); - GL.VertexAttrib4fvNV = (GL.Delegates.VertexAttrib4fvNV) GetAddress("glVertexAttrib4fvNV", typeof(GL.Delegates.VertexAttrib4fvNV)); - GL.VertexAttrib4sNV = (GL.Delegates.VertexAttrib4sNV) GetAddress("glVertexAttrib4sNV", typeof(GL.Delegates.VertexAttrib4sNV)); - GL.VertexAttrib4svNV = (GL.Delegates.VertexAttrib4svNV) GetAddress("glVertexAttrib4svNV", typeof(GL.Delegates.VertexAttrib4svNV)); - GL.VertexAttrib4ubNV = (GL.Delegates.VertexAttrib4ubNV) GetAddress("glVertexAttrib4ubNV", typeof(GL.Delegates.VertexAttrib4ubNV)); - GL.VertexAttrib4ubvNV = (GL.Delegates.VertexAttrib4ubvNV) GetAddress("glVertexAttrib4ubvNV", typeof(GL.Delegates.VertexAttrib4ubvNV)); - GL.VertexAttribs1dvNV = (GL.Delegates.VertexAttribs1dvNV) GetAddress("glVertexAttribs1dvNV", typeof(GL.Delegates.VertexAttribs1dvNV)); - GL.VertexAttribs1fvNV = (GL.Delegates.VertexAttribs1fvNV) GetAddress("glVertexAttribs1fvNV", typeof(GL.Delegates.VertexAttribs1fvNV)); - GL.VertexAttribs1svNV = (GL.Delegates.VertexAttribs1svNV) GetAddress("glVertexAttribs1svNV", typeof(GL.Delegates.VertexAttribs1svNV)); - GL.VertexAttribs2dvNV = (GL.Delegates.VertexAttribs2dvNV) GetAddress("glVertexAttribs2dvNV", typeof(GL.Delegates.VertexAttribs2dvNV)); - GL.VertexAttribs2fvNV = (GL.Delegates.VertexAttribs2fvNV) GetAddress("glVertexAttribs2fvNV", typeof(GL.Delegates.VertexAttribs2fvNV)); - GL.VertexAttribs2svNV = (GL.Delegates.VertexAttribs2svNV) GetAddress("glVertexAttribs2svNV", typeof(GL.Delegates.VertexAttribs2svNV)); - GL.VertexAttribs3dvNV = (GL.Delegates.VertexAttribs3dvNV) GetAddress("glVertexAttribs3dvNV", typeof(GL.Delegates.VertexAttribs3dvNV)); - GL.VertexAttribs3fvNV = (GL.Delegates.VertexAttribs3fvNV) GetAddress("glVertexAttribs3fvNV", typeof(GL.Delegates.VertexAttribs3fvNV)); - GL.VertexAttribs3svNV = (GL.Delegates.VertexAttribs3svNV) GetAddress("glVertexAttribs3svNV", typeof(GL.Delegates.VertexAttribs3svNV)); - GL.VertexAttribs4dvNV = (GL.Delegates.VertexAttribs4dvNV) GetAddress("glVertexAttribs4dvNV", typeof(GL.Delegates.VertexAttribs4dvNV)); - GL.VertexAttribs4fvNV = (GL.Delegates.VertexAttribs4fvNV) GetAddress("glVertexAttribs4fvNV", typeof(GL.Delegates.VertexAttribs4fvNV)); - GL.VertexAttribs4svNV = (GL.Delegates.VertexAttribs4svNV) GetAddress("glVertexAttribs4svNV", typeof(GL.Delegates.VertexAttribs4svNV)); - GL.VertexAttribs4ubvNV = (GL.Delegates.VertexAttribs4ubvNV) GetAddress("glVertexAttribs4ubvNV", typeof(GL.Delegates.VertexAttribs4ubvNV)); - GL.TexBumpParameterivATI = (GL.Delegates.TexBumpParameterivATI) GetAddress("glTexBumpParameterivATI", typeof(GL.Delegates.TexBumpParameterivATI)); - GL.TexBumpParameterfvATI = (GL.Delegates.TexBumpParameterfvATI) GetAddress("glTexBumpParameterfvATI", typeof(GL.Delegates.TexBumpParameterfvATI)); - GL.GetTexBumpParameterivATI = (GL.Delegates.GetTexBumpParameterivATI) GetAddress("glGetTexBumpParameterivATI", typeof(GL.Delegates.GetTexBumpParameterivATI)); - GL.GetTexBumpParameterfvATI = (GL.Delegates.GetTexBumpParameterfvATI) GetAddress("glGetTexBumpParameterfvATI", typeof(GL.Delegates.GetTexBumpParameterfvATI)); - GL.GenFragmentShadersATI = (GL.Delegates.GenFragmentShadersATI) GetAddress("glGenFragmentShadersATI", typeof(GL.Delegates.GenFragmentShadersATI)); - GL.BindFragmentShaderATI = (GL.Delegates.BindFragmentShaderATI) GetAddress("glBindFragmentShaderATI", typeof(GL.Delegates.BindFragmentShaderATI)); - GL.DeleteFragmentShaderATI = (GL.Delegates.DeleteFragmentShaderATI) GetAddress("glDeleteFragmentShaderATI", typeof(GL.Delegates.DeleteFragmentShaderATI)); - GL.BeginFragmentShaderATI = (GL.Delegates.BeginFragmentShaderATI) GetAddress("glBeginFragmentShaderATI", typeof(GL.Delegates.BeginFragmentShaderATI)); - GL.EndFragmentShaderATI = (GL.Delegates.EndFragmentShaderATI) GetAddress("glEndFragmentShaderATI", typeof(GL.Delegates.EndFragmentShaderATI)); - GL.PassTexCoordATI = (GL.Delegates.PassTexCoordATI) GetAddress("glPassTexCoordATI", typeof(GL.Delegates.PassTexCoordATI)); - GL.SampleMapATI = (GL.Delegates.SampleMapATI) GetAddress("glSampleMapATI", typeof(GL.Delegates.SampleMapATI)); - GL.ColorFragmentOp1ATI = (GL.Delegates.ColorFragmentOp1ATI) GetAddress("glColorFragmentOp1ATI", typeof(GL.Delegates.ColorFragmentOp1ATI)); - GL.ColorFragmentOp2ATI = (GL.Delegates.ColorFragmentOp2ATI) GetAddress("glColorFragmentOp2ATI", typeof(GL.Delegates.ColorFragmentOp2ATI)); - GL.ColorFragmentOp3ATI = (GL.Delegates.ColorFragmentOp3ATI) GetAddress("glColorFragmentOp3ATI", typeof(GL.Delegates.ColorFragmentOp3ATI)); - GL.AlphaFragmentOp1ATI = (GL.Delegates.AlphaFragmentOp1ATI) GetAddress("glAlphaFragmentOp1ATI", typeof(GL.Delegates.AlphaFragmentOp1ATI)); - GL.AlphaFragmentOp2ATI = (GL.Delegates.AlphaFragmentOp2ATI) GetAddress("glAlphaFragmentOp2ATI", typeof(GL.Delegates.AlphaFragmentOp2ATI)); - GL.AlphaFragmentOp3ATI = (GL.Delegates.AlphaFragmentOp3ATI) GetAddress("glAlphaFragmentOp3ATI", typeof(GL.Delegates.AlphaFragmentOp3ATI)); - GL.SetFragmentShaderConstantATI = (GL.Delegates.SetFragmentShaderConstantATI) GetAddress("glSetFragmentShaderConstantATI", typeof(GL.Delegates.SetFragmentShaderConstantATI)); - GL.PNTrianglesiATI = (GL.Delegates.PNTrianglesiATI) GetAddress("glPNTrianglesiATI", typeof(GL.Delegates.PNTrianglesiATI)); - GL.PNTrianglesfATI = (GL.Delegates.PNTrianglesfATI) GetAddress("glPNTrianglesfATI", typeof(GL.Delegates.PNTrianglesfATI)); - GL.NewObjectBufferATI = (GL.Delegates.NewObjectBufferATI) GetAddress("glNewObjectBufferATI", typeof(GL.Delegates.NewObjectBufferATI)); - GL.IsObjectBufferATI = (GL.Delegates.IsObjectBufferATI) GetAddress("glIsObjectBufferATI", typeof(GL.Delegates.IsObjectBufferATI)); - GL.UpdateObjectBufferATI = (GL.Delegates.UpdateObjectBufferATI) GetAddress("glUpdateObjectBufferATI", typeof(GL.Delegates.UpdateObjectBufferATI)); - GL.GetObjectBufferfvATI = (GL.Delegates.GetObjectBufferfvATI) GetAddress("glGetObjectBufferfvATI", typeof(GL.Delegates.GetObjectBufferfvATI)); - GL.GetObjectBufferivATI = (GL.Delegates.GetObjectBufferivATI) GetAddress("glGetObjectBufferivATI", typeof(GL.Delegates.GetObjectBufferivATI)); - GL.FreeObjectBufferATI = (GL.Delegates.FreeObjectBufferATI) GetAddress("glFreeObjectBufferATI", typeof(GL.Delegates.FreeObjectBufferATI)); - GL.ArrayObjectATI = (GL.Delegates.ArrayObjectATI) GetAddress("glArrayObjectATI", typeof(GL.Delegates.ArrayObjectATI)); - GL.GetArrayObjectfvATI = (GL.Delegates.GetArrayObjectfvATI) GetAddress("glGetArrayObjectfvATI", typeof(GL.Delegates.GetArrayObjectfvATI)); - GL.GetArrayObjectivATI = (GL.Delegates.GetArrayObjectivATI) GetAddress("glGetArrayObjectivATI", typeof(GL.Delegates.GetArrayObjectivATI)); - GL.VariantArrayObjectATI = (GL.Delegates.VariantArrayObjectATI) GetAddress("glVariantArrayObjectATI", typeof(GL.Delegates.VariantArrayObjectATI)); - GL.GetVariantArrayObjectfvATI = (GL.Delegates.GetVariantArrayObjectfvATI) GetAddress("glGetVariantArrayObjectfvATI", typeof(GL.Delegates.GetVariantArrayObjectfvATI)); - GL.GetVariantArrayObjectivATI = (GL.Delegates.GetVariantArrayObjectivATI) GetAddress("glGetVariantArrayObjectivATI", typeof(GL.Delegates.GetVariantArrayObjectivATI)); - GL.BeginVertexShaderEXT = (GL.Delegates.BeginVertexShaderEXT) GetAddress("glBeginVertexShaderEXT", typeof(GL.Delegates.BeginVertexShaderEXT)); - GL.EndVertexShaderEXT = (GL.Delegates.EndVertexShaderEXT) GetAddress("glEndVertexShaderEXT", typeof(GL.Delegates.EndVertexShaderEXT)); - GL.BindVertexShaderEXT = (GL.Delegates.BindVertexShaderEXT) GetAddress("glBindVertexShaderEXT", typeof(GL.Delegates.BindVertexShaderEXT)); - GL.GenVertexShadersEXT = (GL.Delegates.GenVertexShadersEXT) GetAddress("glGenVertexShadersEXT", typeof(GL.Delegates.GenVertexShadersEXT)); - GL.DeleteVertexShaderEXT = (GL.Delegates.DeleteVertexShaderEXT) GetAddress("glDeleteVertexShaderEXT", typeof(GL.Delegates.DeleteVertexShaderEXT)); - GL.ShaderOp1EXT = (GL.Delegates.ShaderOp1EXT) GetAddress("glShaderOp1EXT", typeof(GL.Delegates.ShaderOp1EXT)); - GL.ShaderOp2EXT = (GL.Delegates.ShaderOp2EXT) GetAddress("glShaderOp2EXT", typeof(GL.Delegates.ShaderOp2EXT)); - GL.ShaderOp3EXT = (GL.Delegates.ShaderOp3EXT) GetAddress("glShaderOp3EXT", typeof(GL.Delegates.ShaderOp3EXT)); - GL.SwizzleEXT = (GL.Delegates.SwizzleEXT) GetAddress("glSwizzleEXT", typeof(GL.Delegates.SwizzleEXT)); - GL.WriteMaskEXT = (GL.Delegates.WriteMaskEXT) GetAddress("glWriteMaskEXT", typeof(GL.Delegates.WriteMaskEXT)); - GL.InsertComponentEXT = (GL.Delegates.InsertComponentEXT) GetAddress("glInsertComponentEXT", typeof(GL.Delegates.InsertComponentEXT)); - GL.ExtractComponentEXT = (GL.Delegates.ExtractComponentEXT) GetAddress("glExtractComponentEXT", typeof(GL.Delegates.ExtractComponentEXT)); - GL.GenSymbolsEXT = (GL.Delegates.GenSymbolsEXT) GetAddress("glGenSymbolsEXT", typeof(GL.Delegates.GenSymbolsEXT)); - GL.SetInvariantEXT = (GL.Delegates.SetInvariantEXT) GetAddress("glSetInvariantEXT", typeof(GL.Delegates.SetInvariantEXT)); - GL.SetLocalConstantEXT = (GL.Delegates.SetLocalConstantEXT) GetAddress("glSetLocalConstantEXT", typeof(GL.Delegates.SetLocalConstantEXT)); - GL.VariantbvEXT = (GL.Delegates.VariantbvEXT) GetAddress("glVariantbvEXT", typeof(GL.Delegates.VariantbvEXT)); - GL.VariantsvEXT = (GL.Delegates.VariantsvEXT) GetAddress("glVariantsvEXT", typeof(GL.Delegates.VariantsvEXT)); - GL.VariantivEXT = (GL.Delegates.VariantivEXT) GetAddress("glVariantivEXT", typeof(GL.Delegates.VariantivEXT)); - GL.VariantfvEXT = (GL.Delegates.VariantfvEXT) GetAddress("glVariantfvEXT", typeof(GL.Delegates.VariantfvEXT)); - GL.VariantdvEXT = (GL.Delegates.VariantdvEXT) GetAddress("glVariantdvEXT", typeof(GL.Delegates.VariantdvEXT)); - GL.VariantubvEXT = (GL.Delegates.VariantubvEXT) GetAddress("glVariantubvEXT", typeof(GL.Delegates.VariantubvEXT)); - GL.VariantusvEXT = (GL.Delegates.VariantusvEXT) GetAddress("glVariantusvEXT", typeof(GL.Delegates.VariantusvEXT)); - GL.VariantuivEXT = (GL.Delegates.VariantuivEXT) GetAddress("glVariantuivEXT", typeof(GL.Delegates.VariantuivEXT)); - GL.VariantPointerEXT = (GL.Delegates.VariantPointerEXT) GetAddress("glVariantPointerEXT", typeof(GL.Delegates.VariantPointerEXT)); - GL.EnableVariantClientStateEXT = (GL.Delegates.EnableVariantClientStateEXT) GetAddress("glEnableVariantClientStateEXT", typeof(GL.Delegates.EnableVariantClientStateEXT)); - GL.DisableVariantClientStateEXT = (GL.Delegates.DisableVariantClientStateEXT) GetAddress("glDisableVariantClientStateEXT", typeof(GL.Delegates.DisableVariantClientStateEXT)); - GL.BindLightParameterEXT = (GL.Delegates.BindLightParameterEXT) GetAddress("glBindLightParameterEXT", typeof(GL.Delegates.BindLightParameterEXT)); - GL.BindMaterialParameterEXT = (GL.Delegates.BindMaterialParameterEXT) GetAddress("glBindMaterialParameterEXT", typeof(GL.Delegates.BindMaterialParameterEXT)); - GL.BindTexGenParameterEXT = (GL.Delegates.BindTexGenParameterEXT) GetAddress("glBindTexGenParameterEXT", typeof(GL.Delegates.BindTexGenParameterEXT)); - GL.BindTextureUnitParameterEXT = (GL.Delegates.BindTextureUnitParameterEXT) GetAddress("glBindTextureUnitParameterEXT", typeof(GL.Delegates.BindTextureUnitParameterEXT)); - GL.BindParameterEXT = (GL.Delegates.BindParameterEXT) GetAddress("glBindParameterEXT", typeof(GL.Delegates.BindParameterEXT)); - GL.IsVariantEnabledEXT = (GL.Delegates.IsVariantEnabledEXT) GetAddress("glIsVariantEnabledEXT", typeof(GL.Delegates.IsVariantEnabledEXT)); - GL.GetVariantBooleanvEXT = (GL.Delegates.GetVariantBooleanvEXT) GetAddress("glGetVariantBooleanvEXT", typeof(GL.Delegates.GetVariantBooleanvEXT)); - GL.GetVariantIntegervEXT = (GL.Delegates.GetVariantIntegervEXT) GetAddress("glGetVariantIntegervEXT", typeof(GL.Delegates.GetVariantIntegervEXT)); - GL.GetVariantFloatvEXT = (GL.Delegates.GetVariantFloatvEXT) GetAddress("glGetVariantFloatvEXT", typeof(GL.Delegates.GetVariantFloatvEXT)); - GL.GetVariantPointervEXT = (GL.Delegates.GetVariantPointervEXT) GetAddress("glGetVariantPointervEXT", typeof(GL.Delegates.GetVariantPointervEXT)); - GL.GetInvariantBooleanvEXT = (GL.Delegates.GetInvariantBooleanvEXT) GetAddress("glGetInvariantBooleanvEXT", typeof(GL.Delegates.GetInvariantBooleanvEXT)); - GL.GetInvariantIntegervEXT = (GL.Delegates.GetInvariantIntegervEXT) GetAddress("glGetInvariantIntegervEXT", typeof(GL.Delegates.GetInvariantIntegervEXT)); - GL.GetInvariantFloatvEXT = (GL.Delegates.GetInvariantFloatvEXT) GetAddress("glGetInvariantFloatvEXT", typeof(GL.Delegates.GetInvariantFloatvEXT)); - GL.GetLocalConstantBooleanvEXT = (GL.Delegates.GetLocalConstantBooleanvEXT) GetAddress("glGetLocalConstantBooleanvEXT", typeof(GL.Delegates.GetLocalConstantBooleanvEXT)); - GL.GetLocalConstantIntegervEXT = (GL.Delegates.GetLocalConstantIntegervEXT) GetAddress("glGetLocalConstantIntegervEXT", typeof(GL.Delegates.GetLocalConstantIntegervEXT)); - GL.GetLocalConstantFloatvEXT = (GL.Delegates.GetLocalConstantFloatvEXT) GetAddress("glGetLocalConstantFloatvEXT", typeof(GL.Delegates.GetLocalConstantFloatvEXT)); - GL.VertexStream1sATI = (GL.Delegates.VertexStream1sATI) GetAddress("glVertexStream1sATI", typeof(GL.Delegates.VertexStream1sATI)); - GL.VertexStream1svATI = (GL.Delegates.VertexStream1svATI) GetAddress("glVertexStream1svATI", typeof(GL.Delegates.VertexStream1svATI)); - GL.VertexStream1iATI = (GL.Delegates.VertexStream1iATI) GetAddress("glVertexStream1iATI", typeof(GL.Delegates.VertexStream1iATI)); - GL.VertexStream1ivATI = (GL.Delegates.VertexStream1ivATI) GetAddress("glVertexStream1ivATI", typeof(GL.Delegates.VertexStream1ivATI)); - GL.VertexStream1fATI = (GL.Delegates.VertexStream1fATI) GetAddress("glVertexStream1fATI", typeof(GL.Delegates.VertexStream1fATI)); - GL.VertexStream1fvATI = (GL.Delegates.VertexStream1fvATI) GetAddress("glVertexStream1fvATI", typeof(GL.Delegates.VertexStream1fvATI)); - GL.VertexStream1dATI = (GL.Delegates.VertexStream1dATI) GetAddress("glVertexStream1dATI", typeof(GL.Delegates.VertexStream1dATI)); - GL.VertexStream1dvATI = (GL.Delegates.VertexStream1dvATI) GetAddress("glVertexStream1dvATI", typeof(GL.Delegates.VertexStream1dvATI)); - GL.VertexStream2sATI = (GL.Delegates.VertexStream2sATI) GetAddress("glVertexStream2sATI", typeof(GL.Delegates.VertexStream2sATI)); - GL.VertexStream2svATI = (GL.Delegates.VertexStream2svATI) GetAddress("glVertexStream2svATI", typeof(GL.Delegates.VertexStream2svATI)); - GL.VertexStream2iATI = (GL.Delegates.VertexStream2iATI) GetAddress("glVertexStream2iATI", typeof(GL.Delegates.VertexStream2iATI)); - GL.VertexStream2ivATI = (GL.Delegates.VertexStream2ivATI) GetAddress("glVertexStream2ivATI", typeof(GL.Delegates.VertexStream2ivATI)); - GL.VertexStream2fATI = (GL.Delegates.VertexStream2fATI) GetAddress("glVertexStream2fATI", typeof(GL.Delegates.VertexStream2fATI)); - GL.VertexStream2fvATI = (GL.Delegates.VertexStream2fvATI) GetAddress("glVertexStream2fvATI", typeof(GL.Delegates.VertexStream2fvATI)); - GL.VertexStream2dATI = (GL.Delegates.VertexStream2dATI) GetAddress("glVertexStream2dATI", typeof(GL.Delegates.VertexStream2dATI)); - GL.VertexStream2dvATI = (GL.Delegates.VertexStream2dvATI) GetAddress("glVertexStream2dvATI", typeof(GL.Delegates.VertexStream2dvATI)); - GL.VertexStream3sATI = (GL.Delegates.VertexStream3sATI) GetAddress("glVertexStream3sATI", typeof(GL.Delegates.VertexStream3sATI)); - GL.VertexStream3svATI = (GL.Delegates.VertexStream3svATI) GetAddress("glVertexStream3svATI", typeof(GL.Delegates.VertexStream3svATI)); - GL.VertexStream3iATI = (GL.Delegates.VertexStream3iATI) GetAddress("glVertexStream3iATI", typeof(GL.Delegates.VertexStream3iATI)); - GL.VertexStream3ivATI = (GL.Delegates.VertexStream3ivATI) GetAddress("glVertexStream3ivATI", typeof(GL.Delegates.VertexStream3ivATI)); - GL.VertexStream3fATI = (GL.Delegates.VertexStream3fATI) GetAddress("glVertexStream3fATI", typeof(GL.Delegates.VertexStream3fATI)); - GL.VertexStream3fvATI = (GL.Delegates.VertexStream3fvATI) GetAddress("glVertexStream3fvATI", typeof(GL.Delegates.VertexStream3fvATI)); - GL.VertexStream3dATI = (GL.Delegates.VertexStream3dATI) GetAddress("glVertexStream3dATI", typeof(GL.Delegates.VertexStream3dATI)); - GL.VertexStream3dvATI = (GL.Delegates.VertexStream3dvATI) GetAddress("glVertexStream3dvATI", typeof(GL.Delegates.VertexStream3dvATI)); - GL.VertexStream4sATI = (GL.Delegates.VertexStream4sATI) GetAddress("glVertexStream4sATI", typeof(GL.Delegates.VertexStream4sATI)); - GL.VertexStream4svATI = (GL.Delegates.VertexStream4svATI) GetAddress("glVertexStream4svATI", typeof(GL.Delegates.VertexStream4svATI)); - GL.VertexStream4iATI = (GL.Delegates.VertexStream4iATI) GetAddress("glVertexStream4iATI", typeof(GL.Delegates.VertexStream4iATI)); - GL.VertexStream4ivATI = (GL.Delegates.VertexStream4ivATI) GetAddress("glVertexStream4ivATI", typeof(GL.Delegates.VertexStream4ivATI)); - GL.VertexStream4fATI = (GL.Delegates.VertexStream4fATI) GetAddress("glVertexStream4fATI", typeof(GL.Delegates.VertexStream4fATI)); - GL.VertexStream4fvATI = (GL.Delegates.VertexStream4fvATI) GetAddress("glVertexStream4fvATI", typeof(GL.Delegates.VertexStream4fvATI)); - GL.VertexStream4dATI = (GL.Delegates.VertexStream4dATI) GetAddress("glVertexStream4dATI", typeof(GL.Delegates.VertexStream4dATI)); - GL.VertexStream4dvATI = (GL.Delegates.VertexStream4dvATI) GetAddress("glVertexStream4dvATI", typeof(GL.Delegates.VertexStream4dvATI)); - GL.NormalStream3bATI = (GL.Delegates.NormalStream3bATI) GetAddress("glNormalStream3bATI", typeof(GL.Delegates.NormalStream3bATI)); - GL.NormalStream3bvATI = (GL.Delegates.NormalStream3bvATI) GetAddress("glNormalStream3bvATI", typeof(GL.Delegates.NormalStream3bvATI)); - GL.NormalStream3sATI = (GL.Delegates.NormalStream3sATI) GetAddress("glNormalStream3sATI", typeof(GL.Delegates.NormalStream3sATI)); - GL.NormalStream3svATI = (GL.Delegates.NormalStream3svATI) GetAddress("glNormalStream3svATI", typeof(GL.Delegates.NormalStream3svATI)); - GL.NormalStream3iATI = (GL.Delegates.NormalStream3iATI) GetAddress("glNormalStream3iATI", typeof(GL.Delegates.NormalStream3iATI)); - GL.NormalStream3ivATI = (GL.Delegates.NormalStream3ivATI) GetAddress("glNormalStream3ivATI", typeof(GL.Delegates.NormalStream3ivATI)); - GL.NormalStream3fATI = (GL.Delegates.NormalStream3fATI) GetAddress("glNormalStream3fATI", typeof(GL.Delegates.NormalStream3fATI)); - GL.NormalStream3fvATI = (GL.Delegates.NormalStream3fvATI) GetAddress("glNormalStream3fvATI", typeof(GL.Delegates.NormalStream3fvATI)); - GL.NormalStream3dATI = (GL.Delegates.NormalStream3dATI) GetAddress("glNormalStream3dATI", typeof(GL.Delegates.NormalStream3dATI)); - GL.NormalStream3dvATI = (GL.Delegates.NormalStream3dvATI) GetAddress("glNormalStream3dvATI", typeof(GL.Delegates.NormalStream3dvATI)); - GL.ClientActiveVertexStreamATI = (GL.Delegates.ClientActiveVertexStreamATI) GetAddress("glClientActiveVertexStreamATI", typeof(GL.Delegates.ClientActiveVertexStreamATI)); - GL.VertexBlendEnviATI = (GL.Delegates.VertexBlendEnviATI) GetAddress("glVertexBlendEnviATI", typeof(GL.Delegates.VertexBlendEnviATI)); - GL.VertexBlendEnvfATI = (GL.Delegates.VertexBlendEnvfATI) GetAddress("glVertexBlendEnvfATI", typeof(GL.Delegates.VertexBlendEnvfATI)); - GL.ElementPointerATI = (GL.Delegates.ElementPointerATI) GetAddress("glElementPointerATI", typeof(GL.Delegates.ElementPointerATI)); - GL.DrawElementArrayATI = (GL.Delegates.DrawElementArrayATI) GetAddress("glDrawElementArrayATI", typeof(GL.Delegates.DrawElementArrayATI)); - GL.DrawRangeElementArrayATI = (GL.Delegates.DrawRangeElementArrayATI) GetAddress("glDrawRangeElementArrayATI", typeof(GL.Delegates.DrawRangeElementArrayATI)); - GL.DrawMeshArraysSUN = (GL.Delegates.DrawMeshArraysSUN) GetAddress("glDrawMeshArraysSUN", typeof(GL.Delegates.DrawMeshArraysSUN)); - GL.GenOcclusionQueriesNV = (GL.Delegates.GenOcclusionQueriesNV) GetAddress("glGenOcclusionQueriesNV", typeof(GL.Delegates.GenOcclusionQueriesNV)); - GL.DeleteOcclusionQueriesNV = (GL.Delegates.DeleteOcclusionQueriesNV) GetAddress("glDeleteOcclusionQueriesNV", typeof(GL.Delegates.DeleteOcclusionQueriesNV)); - GL.IsOcclusionQueryNV = (GL.Delegates.IsOcclusionQueryNV) GetAddress("glIsOcclusionQueryNV", typeof(GL.Delegates.IsOcclusionQueryNV)); - GL.BeginOcclusionQueryNV = (GL.Delegates.BeginOcclusionQueryNV) GetAddress("glBeginOcclusionQueryNV", typeof(GL.Delegates.BeginOcclusionQueryNV)); - GL.EndOcclusionQueryNV = (GL.Delegates.EndOcclusionQueryNV) GetAddress("glEndOcclusionQueryNV", typeof(GL.Delegates.EndOcclusionQueryNV)); - GL.GetOcclusionQueryivNV = (GL.Delegates.GetOcclusionQueryivNV) GetAddress("glGetOcclusionQueryivNV", typeof(GL.Delegates.GetOcclusionQueryivNV)); - GL.GetOcclusionQueryuivNV = (GL.Delegates.GetOcclusionQueryuivNV) GetAddress("glGetOcclusionQueryuivNV", typeof(GL.Delegates.GetOcclusionQueryuivNV)); - GL.PointParameteriNV = (GL.Delegates.PointParameteriNV) GetAddress("glPointParameteriNV", typeof(GL.Delegates.PointParameteriNV)); - GL.PointParameterivNV = (GL.Delegates.PointParameterivNV) GetAddress("glPointParameterivNV", typeof(GL.Delegates.PointParameterivNV)); - GL.ActiveStencilFaceEXT = (GL.Delegates.ActiveStencilFaceEXT) GetAddress("glActiveStencilFaceEXT", typeof(GL.Delegates.ActiveStencilFaceEXT)); - GL.ElementPointerAPPLE = (GL.Delegates.ElementPointerAPPLE) GetAddress("glElementPointerAPPLE", typeof(GL.Delegates.ElementPointerAPPLE)); - GL.DrawElementArrayAPPLE = (GL.Delegates.DrawElementArrayAPPLE) GetAddress("glDrawElementArrayAPPLE", typeof(GL.Delegates.DrawElementArrayAPPLE)); - GL.DrawRangeElementArrayAPPLE = (GL.Delegates.DrawRangeElementArrayAPPLE) GetAddress("glDrawRangeElementArrayAPPLE", typeof(GL.Delegates.DrawRangeElementArrayAPPLE)); - GL.MultiDrawElementArrayAPPLE = (GL.Delegates.MultiDrawElementArrayAPPLE) GetAddress("glMultiDrawElementArrayAPPLE", typeof(GL.Delegates.MultiDrawElementArrayAPPLE)); - GL.MultiDrawRangeElementArrayAPPLE = (GL.Delegates.MultiDrawRangeElementArrayAPPLE) GetAddress("glMultiDrawRangeElementArrayAPPLE", typeof(GL.Delegates.MultiDrawRangeElementArrayAPPLE)); - GL.GenFencesAPPLE = (GL.Delegates.GenFencesAPPLE) GetAddress("glGenFencesAPPLE", typeof(GL.Delegates.GenFencesAPPLE)); - GL.DeleteFencesAPPLE = (GL.Delegates.DeleteFencesAPPLE) GetAddress("glDeleteFencesAPPLE", typeof(GL.Delegates.DeleteFencesAPPLE)); - GL.SetFenceAPPLE = (GL.Delegates.SetFenceAPPLE) GetAddress("glSetFenceAPPLE", typeof(GL.Delegates.SetFenceAPPLE)); - GL.IsFenceAPPLE = (GL.Delegates.IsFenceAPPLE) GetAddress("glIsFenceAPPLE", typeof(GL.Delegates.IsFenceAPPLE)); - GL.TestFenceAPPLE = (GL.Delegates.TestFenceAPPLE) GetAddress("glTestFenceAPPLE", typeof(GL.Delegates.TestFenceAPPLE)); - GL.FinishFenceAPPLE = (GL.Delegates.FinishFenceAPPLE) GetAddress("glFinishFenceAPPLE", typeof(GL.Delegates.FinishFenceAPPLE)); - GL.TestObjectAPPLE = (GL.Delegates.TestObjectAPPLE) GetAddress("glTestObjectAPPLE", typeof(GL.Delegates.TestObjectAPPLE)); - GL.FinishObjectAPPLE = (GL.Delegates.FinishObjectAPPLE) GetAddress("glFinishObjectAPPLE", typeof(GL.Delegates.FinishObjectAPPLE)); - GL.BindVertexArrayAPPLE = (GL.Delegates.BindVertexArrayAPPLE) GetAddress("glBindVertexArrayAPPLE", typeof(GL.Delegates.BindVertexArrayAPPLE)); - GL.DeleteVertexArraysAPPLE = (GL.Delegates.DeleteVertexArraysAPPLE) GetAddress("glDeleteVertexArraysAPPLE", typeof(GL.Delegates.DeleteVertexArraysAPPLE)); - GL.GenVertexArraysAPPLE = (GL.Delegates.GenVertexArraysAPPLE) GetAddress("glGenVertexArraysAPPLE", typeof(GL.Delegates.GenVertexArraysAPPLE)); - GL.IsVertexArrayAPPLE = (GL.Delegates.IsVertexArrayAPPLE) GetAddress("glIsVertexArrayAPPLE", typeof(GL.Delegates.IsVertexArrayAPPLE)); - GL.VertexArrayRangeAPPLE = (GL.Delegates.VertexArrayRangeAPPLE) GetAddress("glVertexArrayRangeAPPLE", typeof(GL.Delegates.VertexArrayRangeAPPLE)); - GL.FlushVertexArrayRangeAPPLE = (GL.Delegates.FlushVertexArrayRangeAPPLE) GetAddress("glFlushVertexArrayRangeAPPLE", typeof(GL.Delegates.FlushVertexArrayRangeAPPLE)); - GL.VertexArrayParameteriAPPLE = (GL.Delegates.VertexArrayParameteriAPPLE) GetAddress("glVertexArrayParameteriAPPLE", typeof(GL.Delegates.VertexArrayParameteriAPPLE)); - GL.DrawBuffersATI = (GL.Delegates.DrawBuffersATI) GetAddress("glDrawBuffersATI", typeof(GL.Delegates.DrawBuffersATI)); - GL.ProgramNamedParameter4fNV = (GL.Delegates.ProgramNamedParameter4fNV) GetAddress("glProgramNamedParameter4fNV", typeof(GL.Delegates.ProgramNamedParameter4fNV)); - GL.ProgramNamedParameter4dNV = (GL.Delegates.ProgramNamedParameter4dNV) GetAddress("glProgramNamedParameter4dNV", typeof(GL.Delegates.ProgramNamedParameter4dNV)); - GL.ProgramNamedParameter4fvNV = (GL.Delegates.ProgramNamedParameter4fvNV) GetAddress("glProgramNamedParameter4fvNV", typeof(GL.Delegates.ProgramNamedParameter4fvNV)); - GL.ProgramNamedParameter4dvNV = (GL.Delegates.ProgramNamedParameter4dvNV) GetAddress("glProgramNamedParameter4dvNV", typeof(GL.Delegates.ProgramNamedParameter4dvNV)); - GL.GetProgramNamedParameterfvNV = (GL.Delegates.GetProgramNamedParameterfvNV) GetAddress("glGetProgramNamedParameterfvNV", typeof(GL.Delegates.GetProgramNamedParameterfvNV)); - GL.GetProgramNamedParameterdvNV = (GL.Delegates.GetProgramNamedParameterdvNV) GetAddress("glGetProgramNamedParameterdvNV", typeof(GL.Delegates.GetProgramNamedParameterdvNV)); - GL.Vertex2hNV = (GL.Delegates.Vertex2hNV) GetAddress("glVertex2hNV", typeof(GL.Delegates.Vertex2hNV)); - GL.Vertex2hvNV = (GL.Delegates.Vertex2hvNV) GetAddress("glVertex2hvNV", typeof(GL.Delegates.Vertex2hvNV)); - GL.Vertex3hNV = (GL.Delegates.Vertex3hNV) GetAddress("glVertex3hNV", typeof(GL.Delegates.Vertex3hNV)); - GL.Vertex3hvNV = (GL.Delegates.Vertex3hvNV) GetAddress("glVertex3hvNV", typeof(GL.Delegates.Vertex3hvNV)); - GL.Vertex4hNV = (GL.Delegates.Vertex4hNV) GetAddress("glVertex4hNV", typeof(GL.Delegates.Vertex4hNV)); - GL.Vertex4hvNV = (GL.Delegates.Vertex4hvNV) GetAddress("glVertex4hvNV", typeof(GL.Delegates.Vertex4hvNV)); - GL.Normal3hNV = (GL.Delegates.Normal3hNV) GetAddress("glNormal3hNV", typeof(GL.Delegates.Normal3hNV)); - GL.Normal3hvNV = (GL.Delegates.Normal3hvNV) GetAddress("glNormal3hvNV", typeof(GL.Delegates.Normal3hvNV)); - GL.Color3hNV = (GL.Delegates.Color3hNV) GetAddress("glColor3hNV", typeof(GL.Delegates.Color3hNV)); - GL.Color3hvNV = (GL.Delegates.Color3hvNV) GetAddress("glColor3hvNV", typeof(GL.Delegates.Color3hvNV)); - GL.Color4hNV = (GL.Delegates.Color4hNV) GetAddress("glColor4hNV", typeof(GL.Delegates.Color4hNV)); - GL.Color4hvNV = (GL.Delegates.Color4hvNV) GetAddress("glColor4hvNV", typeof(GL.Delegates.Color4hvNV)); - GL.TexCoord1hNV = (GL.Delegates.TexCoord1hNV) GetAddress("glTexCoord1hNV", typeof(GL.Delegates.TexCoord1hNV)); - GL.TexCoord1hvNV = (GL.Delegates.TexCoord1hvNV) GetAddress("glTexCoord1hvNV", typeof(GL.Delegates.TexCoord1hvNV)); - GL.TexCoord2hNV = (GL.Delegates.TexCoord2hNV) GetAddress("glTexCoord2hNV", typeof(GL.Delegates.TexCoord2hNV)); - GL.TexCoord2hvNV = (GL.Delegates.TexCoord2hvNV) GetAddress("glTexCoord2hvNV", typeof(GL.Delegates.TexCoord2hvNV)); - GL.TexCoord3hNV = (GL.Delegates.TexCoord3hNV) GetAddress("glTexCoord3hNV", typeof(GL.Delegates.TexCoord3hNV)); - GL.TexCoord3hvNV = (GL.Delegates.TexCoord3hvNV) GetAddress("glTexCoord3hvNV", typeof(GL.Delegates.TexCoord3hvNV)); - GL.TexCoord4hNV = (GL.Delegates.TexCoord4hNV) GetAddress("glTexCoord4hNV", typeof(GL.Delegates.TexCoord4hNV)); - GL.TexCoord4hvNV = (GL.Delegates.TexCoord4hvNV) GetAddress("glTexCoord4hvNV", typeof(GL.Delegates.TexCoord4hvNV)); - GL.MultiTexCoord1hNV = (GL.Delegates.MultiTexCoord1hNV) GetAddress("glMultiTexCoord1hNV", typeof(GL.Delegates.MultiTexCoord1hNV)); - GL.MultiTexCoord1hvNV = (GL.Delegates.MultiTexCoord1hvNV) GetAddress("glMultiTexCoord1hvNV", typeof(GL.Delegates.MultiTexCoord1hvNV)); - GL.MultiTexCoord2hNV = (GL.Delegates.MultiTexCoord2hNV) GetAddress("glMultiTexCoord2hNV", typeof(GL.Delegates.MultiTexCoord2hNV)); - GL.MultiTexCoord2hvNV = (GL.Delegates.MultiTexCoord2hvNV) GetAddress("glMultiTexCoord2hvNV", typeof(GL.Delegates.MultiTexCoord2hvNV)); - GL.MultiTexCoord3hNV = (GL.Delegates.MultiTexCoord3hNV) GetAddress("glMultiTexCoord3hNV", typeof(GL.Delegates.MultiTexCoord3hNV)); - GL.MultiTexCoord3hvNV = (GL.Delegates.MultiTexCoord3hvNV) GetAddress("glMultiTexCoord3hvNV", typeof(GL.Delegates.MultiTexCoord3hvNV)); - GL.MultiTexCoord4hNV = (GL.Delegates.MultiTexCoord4hNV) GetAddress("glMultiTexCoord4hNV", typeof(GL.Delegates.MultiTexCoord4hNV)); - GL.MultiTexCoord4hvNV = (GL.Delegates.MultiTexCoord4hvNV) GetAddress("glMultiTexCoord4hvNV", typeof(GL.Delegates.MultiTexCoord4hvNV)); - GL.FogCoordhNV = (GL.Delegates.FogCoordhNV) GetAddress("glFogCoordhNV", typeof(GL.Delegates.FogCoordhNV)); - GL.FogCoordhvNV = (GL.Delegates.FogCoordhvNV) GetAddress("glFogCoordhvNV", typeof(GL.Delegates.FogCoordhvNV)); - GL.SecondaryColor3hNV = (GL.Delegates.SecondaryColor3hNV) GetAddress("glSecondaryColor3hNV", typeof(GL.Delegates.SecondaryColor3hNV)); - GL.SecondaryColor3hvNV = (GL.Delegates.SecondaryColor3hvNV) GetAddress("glSecondaryColor3hvNV", typeof(GL.Delegates.SecondaryColor3hvNV)); - GL.VertexWeighthNV = (GL.Delegates.VertexWeighthNV) GetAddress("glVertexWeighthNV", typeof(GL.Delegates.VertexWeighthNV)); - GL.VertexWeighthvNV = (GL.Delegates.VertexWeighthvNV) GetAddress("glVertexWeighthvNV", typeof(GL.Delegates.VertexWeighthvNV)); - GL.VertexAttrib1hNV = (GL.Delegates.VertexAttrib1hNV) GetAddress("glVertexAttrib1hNV", typeof(GL.Delegates.VertexAttrib1hNV)); - GL.VertexAttrib1hvNV = (GL.Delegates.VertexAttrib1hvNV) GetAddress("glVertexAttrib1hvNV", typeof(GL.Delegates.VertexAttrib1hvNV)); - GL.VertexAttrib2hNV = (GL.Delegates.VertexAttrib2hNV) GetAddress("glVertexAttrib2hNV", typeof(GL.Delegates.VertexAttrib2hNV)); - GL.VertexAttrib2hvNV = (GL.Delegates.VertexAttrib2hvNV) GetAddress("glVertexAttrib2hvNV", typeof(GL.Delegates.VertexAttrib2hvNV)); - GL.VertexAttrib3hNV = (GL.Delegates.VertexAttrib3hNV) GetAddress("glVertexAttrib3hNV", typeof(GL.Delegates.VertexAttrib3hNV)); - GL.VertexAttrib3hvNV = (GL.Delegates.VertexAttrib3hvNV) GetAddress("glVertexAttrib3hvNV", typeof(GL.Delegates.VertexAttrib3hvNV)); - GL.VertexAttrib4hNV = (GL.Delegates.VertexAttrib4hNV) GetAddress("glVertexAttrib4hNV", typeof(GL.Delegates.VertexAttrib4hNV)); - GL.VertexAttrib4hvNV = (GL.Delegates.VertexAttrib4hvNV) GetAddress("glVertexAttrib4hvNV", typeof(GL.Delegates.VertexAttrib4hvNV)); - GL.VertexAttribs1hvNV = (GL.Delegates.VertexAttribs1hvNV) GetAddress("glVertexAttribs1hvNV", typeof(GL.Delegates.VertexAttribs1hvNV)); - GL.VertexAttribs2hvNV = (GL.Delegates.VertexAttribs2hvNV) GetAddress("glVertexAttribs2hvNV", typeof(GL.Delegates.VertexAttribs2hvNV)); - GL.VertexAttribs3hvNV = (GL.Delegates.VertexAttribs3hvNV) GetAddress("glVertexAttribs3hvNV", typeof(GL.Delegates.VertexAttribs3hvNV)); - GL.VertexAttribs4hvNV = (GL.Delegates.VertexAttribs4hvNV) GetAddress("glVertexAttribs4hvNV", typeof(GL.Delegates.VertexAttribs4hvNV)); - GL.PixelDataRangeNV = (GL.Delegates.PixelDataRangeNV) GetAddress("glPixelDataRangeNV", typeof(GL.Delegates.PixelDataRangeNV)); - GL.FlushPixelDataRangeNV = (GL.Delegates.FlushPixelDataRangeNV) GetAddress("glFlushPixelDataRangeNV", typeof(GL.Delegates.FlushPixelDataRangeNV)); - GL.PrimitiveRestartNV = (GL.Delegates.PrimitiveRestartNV) GetAddress("glPrimitiveRestartNV", typeof(GL.Delegates.PrimitiveRestartNV)); - GL.PrimitiveRestartIndexNV = (GL.Delegates.PrimitiveRestartIndexNV) GetAddress("glPrimitiveRestartIndexNV", typeof(GL.Delegates.PrimitiveRestartIndexNV)); - GL.MapObjectBufferATI_ = (GL.Delegates.MapObjectBufferATI_) GetAddress("glMapObjectBufferATI_", typeof(GL.Delegates.MapObjectBufferATI_)); - GL.UnmapObjectBufferATI = (GL.Delegates.UnmapObjectBufferATI) GetAddress("glUnmapObjectBufferATI", typeof(GL.Delegates.UnmapObjectBufferATI)); - GL.StencilOpSeparateATI = (GL.Delegates.StencilOpSeparateATI) GetAddress("glStencilOpSeparateATI", typeof(GL.Delegates.StencilOpSeparateATI)); - GL.StencilFuncSeparateATI = (GL.Delegates.StencilFuncSeparateATI) GetAddress("glStencilFuncSeparateATI", typeof(GL.Delegates.StencilFuncSeparateATI)); - GL.VertexAttribArrayObjectATI = (GL.Delegates.VertexAttribArrayObjectATI) GetAddress("glVertexAttribArrayObjectATI", typeof(GL.Delegates.VertexAttribArrayObjectATI)); - GL.GetVertexAttribArrayObjectfvATI = (GL.Delegates.GetVertexAttribArrayObjectfvATI) GetAddress("glGetVertexAttribArrayObjectfvATI", typeof(GL.Delegates.GetVertexAttribArrayObjectfvATI)); - GL.GetVertexAttribArrayObjectivATI = (GL.Delegates.GetVertexAttribArrayObjectivATI) GetAddress("glGetVertexAttribArrayObjectivATI", typeof(GL.Delegates.GetVertexAttribArrayObjectivATI)); - GL.DepthBoundsEXT = (GL.Delegates.DepthBoundsEXT) GetAddress("glDepthBoundsEXT", typeof(GL.Delegates.DepthBoundsEXT)); - GL.BlendEquationSeparateEXT = (GL.Delegates.BlendEquationSeparateEXT) GetAddress("glBlendEquationSeparateEXT", typeof(GL.Delegates.BlendEquationSeparateEXT)); - GL.IsRenderbufferEXT = (GL.Delegates.IsRenderbufferEXT) GetAddress("glIsRenderbufferEXT", typeof(GL.Delegates.IsRenderbufferEXT)); - GL.BindRenderbufferEXT = (GL.Delegates.BindRenderbufferEXT) GetAddress("glBindRenderbufferEXT", typeof(GL.Delegates.BindRenderbufferEXT)); - GL.DeleteRenderbuffersEXT = (GL.Delegates.DeleteRenderbuffersEXT) GetAddress("glDeleteRenderbuffersEXT", typeof(GL.Delegates.DeleteRenderbuffersEXT)); - GL.GenRenderbuffersEXT = (GL.Delegates.GenRenderbuffersEXT) GetAddress("glGenRenderbuffersEXT", typeof(GL.Delegates.GenRenderbuffersEXT)); - GL.RenderbufferStorageEXT = (GL.Delegates.RenderbufferStorageEXT) GetAddress("glRenderbufferStorageEXT", typeof(GL.Delegates.RenderbufferStorageEXT)); - GL.GetRenderbufferParameterivEXT = (GL.Delegates.GetRenderbufferParameterivEXT) GetAddress("glGetRenderbufferParameterivEXT", typeof(GL.Delegates.GetRenderbufferParameterivEXT)); - GL.IsFramebufferEXT = (GL.Delegates.IsFramebufferEXT) GetAddress("glIsFramebufferEXT", typeof(GL.Delegates.IsFramebufferEXT)); - GL.BindFramebufferEXT = (GL.Delegates.BindFramebufferEXT) GetAddress("glBindFramebufferEXT", typeof(GL.Delegates.BindFramebufferEXT)); - GL.DeleteFramebuffersEXT = (GL.Delegates.DeleteFramebuffersEXT) GetAddress("glDeleteFramebuffersEXT", typeof(GL.Delegates.DeleteFramebuffersEXT)); - GL.GenFramebuffersEXT = (GL.Delegates.GenFramebuffersEXT) GetAddress("glGenFramebuffersEXT", typeof(GL.Delegates.GenFramebuffersEXT)); - GL.CheckFramebufferStatusEXT = (GL.Delegates.CheckFramebufferStatusEXT) GetAddress("glCheckFramebufferStatusEXT", typeof(GL.Delegates.CheckFramebufferStatusEXT)); - GL.FramebufferTexture1DEXT = (GL.Delegates.FramebufferTexture1DEXT) GetAddress("glFramebufferTexture1DEXT", typeof(GL.Delegates.FramebufferTexture1DEXT)); - GL.FramebufferTexture2DEXT = (GL.Delegates.FramebufferTexture2DEXT) GetAddress("glFramebufferTexture2DEXT", typeof(GL.Delegates.FramebufferTexture2DEXT)); - GL.FramebufferTexture3DEXT = (GL.Delegates.FramebufferTexture3DEXT) GetAddress("glFramebufferTexture3DEXT", typeof(GL.Delegates.FramebufferTexture3DEXT)); - GL.FramebufferRenderbufferEXT = (GL.Delegates.FramebufferRenderbufferEXT) GetAddress("glFramebufferRenderbufferEXT", typeof(GL.Delegates.FramebufferRenderbufferEXT)); - GL.GetFramebufferAttachmentParameterivEXT = (GL.Delegates.GetFramebufferAttachmentParameterivEXT) GetAddress("glGetFramebufferAttachmentParameterivEXT", typeof(GL.Delegates.GetFramebufferAttachmentParameterivEXT)); - GL.GenerateMipmapEXT = (GL.Delegates.GenerateMipmapEXT) GetAddress("glGenerateMipmapEXT", typeof(GL.Delegates.GenerateMipmapEXT)); - GL.StringMarkerGREMEDY = (GL.Delegates.StringMarkerGREMEDY) GetAddress("glStringMarkerGREMEDY", typeof(GL.Delegates.StringMarkerGREMEDY)); - CoreLoaded = true; - } - #endregion } } + diff --git a/Source/OpenGL/OpenGL/Bindings/X11ContextLoad.cs b/Source/OpenGL/OpenGL/Bindings/X11ContextLoad.cs index 3895570a..c44bfcf4 100644 --- a/Source/OpenGL/OpenGL/Bindings/X11ContextLoad.cs +++ b/Source/OpenGL/OpenGL/Bindings/X11ContextLoad.cs @@ -1,3195 +1,594 @@ using System; using System.Runtime.InteropServices; -using OpenTK.OpenGL; namespace OpenTK.OpenGL.Platform { public partial class X11Context { - #region DllImports + #region OpenGL core and extension function loading - internal class Imports - { - [DllImport(_dll_name, EntryPoint = "glNewList")] - public static extern void NewList(uint list, Enums.ListMode mode); - - [DllImport(_dll_name, EntryPoint = "glEndList")] - public static extern void EndList(); - - [DllImport(_dll_name, EntryPoint = "glCallList")] - public static extern void CallList(uint list); - - [DllImport(_dll_name, EntryPoint = "glCallLists")] - public static extern void CallLists(int n, Enums.ListNameType type, [MarshalAs(UnmanagedType.AsAny)] object lists); - - [DllImport(_dll_name, EntryPoint = "glDeleteLists")] - public static extern void DeleteLists(uint list, int range); - - [DllImport(_dll_name, EntryPoint = "glGenLists")] - public static extern uint GenLists(int range); - - [DllImport(_dll_name, EntryPoint = "glListBase")] - public static extern void ListBase(uint @base); - - [DllImport(_dll_name, EntryPoint = "glBegin")] - public static extern void Begin(Enums.BeginMode mode); - - [DllImport(_dll_name, EntryPoint = "glBitmap")] - public static extern void Bitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, byte[] bitmap); - - [DllImport(_dll_name, EntryPoint = "glColor3b")] - public static extern void Color3b(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glColor3bv")] - public static extern void Color3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3d")] - public static extern void Color3d(double red, double green, double blue); - - [DllImport(_dll_name, EntryPoint = "glColor3dv")] - public static extern void Color3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3f")] - public static extern void Color3f(float red, float green, float blue); - - [DllImport(_dll_name, EntryPoint = "glColor3fv")] - public static extern void Color3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3i")] - public static extern void Color3i(int red, int green, int blue); - - [DllImport(_dll_name, EntryPoint = "glColor3iv")] - public static extern void Color3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3s")] - public static extern void Color3s(short red, short green, short blue); - - [DllImport(_dll_name, EntryPoint = "glColor3sv")] - public static extern void Color3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3ub")] - public static extern void Color3ub(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glColor3ubv")] - public static extern void Color3ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3ui")] - public static extern void Color3ui(uint red, uint green, uint blue); - - [DllImport(_dll_name, EntryPoint = "glColor3uiv")] - public static extern void Color3uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glColor3us")] - public static extern void Color3us(ushort red, ushort green, ushort blue); - - [DllImport(_dll_name, EntryPoint = "glColor3usv")] - public static extern void Color3usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4b")] - public static extern void Color4b(byte red, byte green, byte blue, byte alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4bv")] - public static extern void Color4bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4d")] - public static extern void Color4d(double red, double green, double blue, double alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4dv")] - public static extern void Color4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4f")] - public static extern void Color4f(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4fv")] - public static extern void Color4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4i")] - public static extern void Color4i(int red, int green, int blue, int alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4iv")] - public static extern void Color4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4s")] - public static extern void Color4s(short red, short green, short blue, short alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4sv")] - public static extern void Color4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4ub")] - public static extern void Color4ub(byte red, byte green, byte blue, byte alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4ubv")] - public static extern void Color4ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4ui")] - public static extern void Color4ui(uint red, uint green, uint blue, uint alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4uiv")] - public static extern void Color4uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glColor4us")] - public static extern void Color4us(ushort red, ushort green, ushort blue, ushort alpha); - - [DllImport(_dll_name, EntryPoint = "glColor4usv")] - public static extern void Color4usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlag")] - public static extern void EdgeFlag(bool flag); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlagv")] - public static extern void EdgeFlagv(bool[] flag); - - [DllImport(_dll_name, EntryPoint = "glEnd")] - public static extern void End(); - - [DllImport(_dll_name, EntryPoint = "glIndexd")] - public static extern void Indexd(double c); - - [DllImport(_dll_name, EntryPoint = "glIndexdv")] - public static extern void Indexdv(double[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexf")] - public static extern void Indexf(float c); - - [DllImport(_dll_name, EntryPoint = "glIndexfv")] - public static extern void Indexfv(float[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexi")] - public static extern void Indexi(int c); - - [DllImport(_dll_name, EntryPoint = "glIndexiv")] - public static extern void Indexiv(int[] c); - - [DllImport(_dll_name, EntryPoint = "glIndexs")] - public static extern void Indexs(short c); - - [DllImport(_dll_name, EntryPoint = "glIndexsv")] - public static extern void Indexsv(short[] c); - - [DllImport(_dll_name, EntryPoint = "glNormal3b")] - public static extern void Normal3b(byte nx, byte ny, byte nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3bv")] - public static extern void Normal3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3d")] - public static extern void Normal3d(double nx, double ny, double nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3dv")] - public static extern void Normal3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3f")] - public static extern void Normal3f(float nx, float ny, float nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3fv")] - public static extern void Normal3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3i")] - public static extern void Normal3i(int nx, int ny, int nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3iv")] - public static extern void Normal3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glNormal3s")] - public static extern void Normal3s(short nx, short ny, short nz); - - [DllImport(_dll_name, EntryPoint = "glNormal3sv")] - public static extern void Normal3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2d")] - public static extern void RasterPos2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2dv")] - public static extern void RasterPos2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2f")] - public static extern void RasterPos2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2fv")] - public static extern void RasterPos2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2i")] - public static extern void RasterPos2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2iv")] - public static extern void RasterPos2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2s")] - public static extern void RasterPos2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glRasterPos2sv")] - public static extern void RasterPos2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3d")] - public static extern void RasterPos3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3dv")] - public static extern void RasterPos3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3f")] - public static extern void RasterPos3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3fv")] - public static extern void RasterPos3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3i")] - public static extern void RasterPos3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3iv")] - public static extern void RasterPos3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3s")] - public static extern void RasterPos3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glRasterPos3sv")] - public static extern void RasterPos3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4d")] - public static extern void RasterPos4d(double x, double y, double z, double w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4dv")] - public static extern void RasterPos4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4f")] - public static extern void RasterPos4f(float x, float y, float z, float w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4fv")] - public static extern void RasterPos4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4i")] - public static extern void RasterPos4i(int x, int y, int z, int w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4iv")] - public static extern void RasterPos4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4s")] - public static extern void RasterPos4s(short x, short y, short z, short w); - - [DllImport(_dll_name, EntryPoint = "glRasterPos4sv")] - public static extern void RasterPos4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glRectd")] - public static extern void Rectd(double x1, double y1, double x2, double y2); - - [DllImport(_dll_name, EntryPoint = "glRectdv")] - public static extern void Rectdv(double[] v1, double[] v2); - - [DllImport(_dll_name, EntryPoint = "glRectf")] - public static extern void Rectf(float x1, float y1, float x2, float y2); - - [DllImport(_dll_name, EntryPoint = "glRectfv")] - public static extern void Rectfv(float[] v1, float[] v2); - - [DllImport(_dll_name, EntryPoint = "glRecti")] - public static extern void Recti(int x1, int y1, int x2, int y2); - - [DllImport(_dll_name, EntryPoint = "glRectiv")] - public static extern void Rectiv(int[] v1, int[] v2); - - [DllImport(_dll_name, EntryPoint = "glRects")] - public static extern void Rects(short x1, short y1, short x2, short y2); - - [DllImport(_dll_name, EntryPoint = "glRectsv")] - public static extern void Rectsv(short[] v1, short[] v2); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1d")] - public static extern void TexCoord1d(double s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1dv")] - public static extern void TexCoord1dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1f")] - public static extern void TexCoord1f(float s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1fv")] - public static extern void TexCoord1fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1i")] - public static extern void TexCoord1i(int s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1iv")] - public static extern void TexCoord1iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1s")] - public static extern void TexCoord1s(short s); - - [DllImport(_dll_name, EntryPoint = "glTexCoord1sv")] - public static extern void TexCoord1sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2d")] - public static extern void TexCoord2d(double s, double t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2dv")] - public static extern void TexCoord2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2f")] - public static extern void TexCoord2f(float s, float t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2fv")] - public static extern void TexCoord2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2i")] - public static extern void TexCoord2i(int s, int t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2iv")] - public static extern void TexCoord2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2s")] - public static extern void TexCoord2s(short s, short t); - - [DllImport(_dll_name, EntryPoint = "glTexCoord2sv")] - public static extern void TexCoord2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3d")] - public static extern void TexCoord3d(double s, double t, double r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3dv")] - public static extern void TexCoord3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3f")] - public static extern void TexCoord3f(float s, float t, float r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3fv")] - public static extern void TexCoord3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3i")] - public static extern void TexCoord3i(int s, int t, int r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3iv")] - public static extern void TexCoord3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3s")] - public static extern void TexCoord3s(short s, short t, short r); - - [DllImport(_dll_name, EntryPoint = "glTexCoord3sv")] - public static extern void TexCoord3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4d")] - public static extern void TexCoord4d(double s, double t, double r, double q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4dv")] - public static extern void TexCoord4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4f")] - public static extern void TexCoord4f(float s, float t, float r, float q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4fv")] - public static extern void TexCoord4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4i")] - public static extern void TexCoord4i(int s, int t, int r, int q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4iv")] - public static extern void TexCoord4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4s")] - public static extern void TexCoord4s(short s, short t, short r, short q); - - [DllImport(_dll_name, EntryPoint = "glTexCoord4sv")] - public static extern void TexCoord4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2d")] - public static extern void Vertex2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glVertex2dv")] - public static extern void Vertex2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2f")] - public static extern void Vertex2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glVertex2fv")] - public static extern void Vertex2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2i")] - public static extern void Vertex2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glVertex2iv")] - public static extern void Vertex2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex2s")] - public static extern void Vertex2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glVertex2sv")] - public static extern void Vertex2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3d")] - public static extern void Vertex3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glVertex3dv")] - public static extern void Vertex3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3f")] - public static extern void Vertex3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glVertex3fv")] - public static extern void Vertex3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3i")] - public static extern void Vertex3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glVertex3iv")] - public static extern void Vertex3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex3s")] - public static extern void Vertex3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glVertex3sv")] - public static extern void Vertex3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4d")] - public static extern void Vertex4d(double x, double y, double z, double w); - - [DllImport(_dll_name, EntryPoint = "glVertex4dv")] - public static extern void Vertex4dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4f")] - public static extern void Vertex4f(float x, float y, float z, float w); - - [DllImport(_dll_name, EntryPoint = "glVertex4fv")] - public static extern void Vertex4fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4i")] - public static extern void Vertex4i(int x, int y, int z, int w); - - [DllImport(_dll_name, EntryPoint = "glVertex4iv")] - public static extern void Vertex4iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertex4s")] - public static extern void Vertex4s(short x, short y, short z, short w); - - [DllImport(_dll_name, EntryPoint = "glVertex4sv")] - public static extern void Vertex4sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glClipPlane")] - public static extern void ClipPlane(Enums.ClipPlaneName plane, double[] equation); - - [DllImport(_dll_name, EntryPoint = "glColorMaterial")] - public static extern void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode); - - [DllImport(_dll_name, EntryPoint = "glCullFace")] - public static extern void CullFace(Enums.CullFaceMode mode); - - [DllImport(_dll_name, EntryPoint = "glFogf")] - public static extern void Fogf(Enums.FogParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glFogfv")] - public static extern void Fogfv(Enums.FogParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFogi")] - public static extern void Fogi(Enums.FogParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glFogiv")] - public static extern void Fogiv(Enums.FogParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFrontFace")] - public static extern void FrontFace(Enums.FrontFaceDirection mode); - - [DllImport(_dll_name, EntryPoint = "glHint")] - public static extern void Hint(Enums.HintTarget target, Enums.HintMode mode); - - [DllImport(_dll_name, EntryPoint = "glLightf")] - public static extern void Lightf(Enums.LightName light, Enums.LightParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glLightfv")] - public static extern void Lightfv(Enums.LightName light, Enums.LightParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLighti")] - public static extern void Lighti(Enums.LightName light, Enums.LightParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glLightiv")] - public static extern void Lightiv(Enums.LightName light, Enums.LightParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLightModelf")] - public static extern void LightModelf(Enums.LightModelParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glLightModelfv")] - public static extern void LightModelfv(Enums.LightModelParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLightModeli")] - public static extern void LightModeli(Enums.LightModelParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glLightModeliv")] - public static extern void LightModeliv(Enums.LightModelParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glLineStipple")] - public static extern void LineStipple(int factor, ushort pattern); - - [DllImport(_dll_name, EntryPoint = "glLineWidth")] - public static extern void LineWidth(float width); - - [DllImport(_dll_name, EntryPoint = "glMaterialf")] - public static extern void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glMaterialfv")] - public static extern void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glMateriali")] - public static extern void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glMaterialiv")] - public static extern void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glPointSize")] - public static extern void PointSize(float size); - - [DllImport(_dll_name, EntryPoint = "glPolygonMode")] - public static extern void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode); - - [DllImport(_dll_name, EntryPoint = "glPolygonStipple")] - public static extern void PolygonStipple(byte[] mask); - - [DllImport(_dll_name, EntryPoint = "glScissor")] - public static extern void Scissor(int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glShadeModel")] - public static extern void ShadeModel(Enums.ShadingModel mode); - - [DllImport(_dll_name, EntryPoint = "glTexParameterf")] - public static extern void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexParameterfv")] - public static extern void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexParameteri")] - public static extern void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexParameteriv")] - public static extern void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexImage1D")] - public static extern void TexImage1D(Enums.TextureTarget target, int level, int internalformat, int width, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexImage2D")] - public static extern void TexImage2D(Enums.TextureTarget target, int level, int internalformat, int width, int height, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexEnvf")] - public static extern void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexEnvfv")] - public static extern void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexEnvi")] - public static extern void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexEnviv")] - public static extern void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGend")] - public static extern void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, double param); - - [DllImport(_dll_name, EntryPoint = "glTexGendv")] - public static extern void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGenf")] - public static extern void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glTexGenfv")] - public static extern void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glTexGeni")] - public static extern void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glTexGeniv")] - public static extern void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glFeedbackBuffer")] - public static extern void FeedbackBuffer(int size, Enums.FeedbackType type, out float[] buffer); - - [DllImport(_dll_name, EntryPoint = "glSelectBuffer")] - public static extern void SelectBuffer(int size, out uint[] buffer); - - [DllImport(_dll_name, EntryPoint = "glRenderMode")] - public static extern int RenderMode(Enums.RenderingMode mode); - - [DllImport(_dll_name, EntryPoint = "glInitNames")] - public static extern void InitNames(); - - [DllImport(_dll_name, EntryPoint = "glLoadName")] - public static extern void LoadName(uint name); - - [DllImport(_dll_name, EntryPoint = "glPassThrough")] - public static extern void PassThrough(float token); - - [DllImport(_dll_name, EntryPoint = "glPopName")] - public static extern void PopName(); - - [DllImport(_dll_name, EntryPoint = "glPushName")] - public static extern void PushName(uint name); - - [DllImport(_dll_name, EntryPoint = "glDrawBuffer")] - public static extern void DrawBuffer(Enums.DrawBufferMode mode); - - [DllImport(_dll_name, EntryPoint = "glClear")] - public static extern void Clear(Enums.ClearBufferMask mask); - - [DllImport(_dll_name, EntryPoint = "glClearAccum")] - public static extern void ClearAccum(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glClearIndex")] - public static extern void ClearIndex(float c); - - [DllImport(_dll_name, EntryPoint = "glClearColor")] - public static extern void ClearColor(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glClearStencil")] - public static extern void ClearStencil(int s); - - [DllImport(_dll_name, EntryPoint = "glClearDepth")] - public static extern void ClearDepth(double depth); - - [DllImport(_dll_name, EntryPoint = "glStencilMask")] - public static extern void StencilMask(uint mask); - - [DllImport(_dll_name, EntryPoint = "glColorMask")] - public static extern void ColorMask(bool red, bool green, bool blue, bool alpha); - - [DllImport(_dll_name, EntryPoint = "glDepthMask")] - public static extern void DepthMask(bool flag); - - [DllImport(_dll_name, EntryPoint = "glIndexMask")] - public static extern void IndexMask(uint mask); - - [DllImport(_dll_name, EntryPoint = "glAccum")] - public static extern void Accum(Enums.AccumOp op, float value); - - [DllImport(_dll_name, EntryPoint = "glDisable")] - public static extern void Disable(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glEnable")] - public static extern void Enable(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glFinish")] - public static extern void Finish(); - - [DllImport(_dll_name, EntryPoint = "glFlush")] - public static extern void Flush(); - - [DllImport(_dll_name, EntryPoint = "glPopAttrib")] - public static extern void PopAttrib(); - - [DllImport(_dll_name, EntryPoint = "glPushAttrib")] - public static extern void PushAttrib(Enums.AttribMask mask); - - [DllImport(_dll_name, EntryPoint = "glMap1d")] - public static extern void Map1d(Enums.MapTarget target, double u1, double u2, int stride, int order, double[] points); - - [DllImport(_dll_name, EntryPoint = "glMap1f")] - public static extern void Map1f(Enums.MapTarget target, float u1, float u2, int stride, int order, float[] points); - - [DllImport(_dll_name, EntryPoint = "glMap2d")] - public static extern void Map2d(Enums.MapTarget target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, double[] points); - - [DllImport(_dll_name, EntryPoint = "glMap2f")] - public static extern void Map2f(Enums.MapTarget target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, float[] points); - - [DllImport(_dll_name, EntryPoint = "glMapGrid1d")] - public static extern void MapGrid1d(int un, double u1, double u2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid1f")] - public static extern void MapGrid1f(int un, float u1, float u2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid2d")] - public static extern void MapGrid2d(int un, double u1, double u2, int vn, double v1, double v2); - - [DllImport(_dll_name, EntryPoint = "glMapGrid2f")] - public static extern void MapGrid2f(int un, float u1, float u2, int vn, float v1, float v2); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1d")] - public static extern void EvalCoord1d(double u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1dv")] - public static extern void EvalCoord1dv(double[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1f")] - public static extern void EvalCoord1f(float u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord1fv")] - public static extern void EvalCoord1fv(float[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2d")] - public static extern void EvalCoord2d(double u, double v); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2dv")] - public static extern void EvalCoord2dv(double[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2f")] - public static extern void EvalCoord2f(float u, float v); - - [DllImport(_dll_name, EntryPoint = "glEvalCoord2fv")] - public static extern void EvalCoord2fv(float[] u); - - [DllImport(_dll_name, EntryPoint = "glEvalMesh1")] - public static extern void EvalMesh1(Enums.MeshMode1 mode, int i1, int i2); - - [DllImport(_dll_name, EntryPoint = "glEvalPoint1")] - public static extern void EvalPoint1(int i); - - [DllImport(_dll_name, EntryPoint = "glEvalMesh2")] - public static extern void EvalMesh2(Enums.MeshMode2 mode, int i1, int i2, int j1, int j2); - - [DllImport(_dll_name, EntryPoint = "glEvalPoint2")] - public static extern void EvalPoint2(int i, int j); - - [DllImport(_dll_name, EntryPoint = "glAlphaFunc")] - public static extern void AlphaFunc(Enums.AlphaFunction func, float reference); - - [DllImport(_dll_name, EntryPoint = "glBlendFunc")] - public static extern void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor); - - [DllImport(_dll_name, EntryPoint = "glLogicOp")] - public static extern void LogicOp(Enums.LogicOp opcode); - - [DllImport(_dll_name, EntryPoint = "glStencilFunc")] - public static extern void StencilFunc(Enums.StencilFunction func, int reference, uint mask); - - [DllImport(_dll_name, EntryPoint = "glStencilOp")] - public static extern void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass); - - [DllImport(_dll_name, EntryPoint = "glDepthFunc")] - public static extern void DepthFunc(Enums.DepthFunction func); - - [DllImport(_dll_name, EntryPoint = "glPixelZoom")] - public static extern void PixelZoom(float xfactor, float yfactor); - - [DllImport(_dll_name, EntryPoint = "glPixelTransferf")] - public static extern void PixelTransferf(Enums.PixelTransferParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPixelTransferi")] - public static extern void PixelTransferi(Enums.PixelTransferParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPixelStoref")] - public static extern void PixelStoref(Enums.PixelStoreParameter pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPixelStorei")] - public static extern void PixelStorei(Enums.PixelStoreParameter pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPixelMapfv")] - public static extern void PixelMapfv(Enums.PixelMap map, int mapsize, float[] values); - - [DllImport(_dll_name, EntryPoint = "glPixelMapuiv")] - public static extern void PixelMapuiv(Enums.PixelMap map, int mapsize, uint[] values); - - [DllImport(_dll_name, EntryPoint = "glPixelMapusv")] - public static extern void PixelMapusv(Enums.PixelMap map, int mapsize, ushort[] values); - - [DllImport(_dll_name, EntryPoint = "glReadBuffer")] - public static extern void ReadBuffer(Enums.ReadBufferMode mode); - - [DllImport(_dll_name, EntryPoint = "glCopyPixels")] - public static extern void CopyPixels(int x, int y, int width, int height, Enums.PixelCopyType type); - - [DllImport(_dll_name, EntryPoint = "glReadPixels")] - public static extern void ReadPixels(int x, int y, int width, int height, Enums.PixelFormat format, Enums.PixelType type, out object pixels); - - [DllImport(_dll_name, EntryPoint = "glDrawPixels")] - public static extern void DrawPixels(int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glGetBooleanv")] - public static extern void GetBooleanv(Enums.GetPName pname, out bool[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetClipPlane")] - public static extern void GetClipPlane(Enums.ClipPlaneName plane, out double[] equation); - - [DllImport(_dll_name, EntryPoint = "glGetDoublev")] - public static extern void GetDoublev(Enums.GetPName pname, out double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetError")] - public static extern Enums.ErrorCode GetError(); - - [DllImport(_dll_name, EntryPoint = "glGetFloatv")] - public static extern void GetFloatv(Enums.GetPName pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetIntegerv")] - public static extern void GetIntegerv(Enums.GetPName pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetLightfv")] - public static extern void GetLightfv(Enums.LightName light, Enums.LightParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetLightiv")] - public static extern void GetLightiv(Enums.LightName light, Enums.LightParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMapdv")] - public static extern void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, out double[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMapfv")] - public static extern void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, out float[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMapiv")] - public static extern void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, out int[] v); - - [DllImport(_dll_name, EntryPoint = "glGetMaterialfv")] - public static extern void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMaterialiv")] - public static extern void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapfv")] - public static extern void GetPixelMapfv(Enums.PixelMap map, out float[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapuiv")] - public static extern void GetPixelMapuiv(Enums.PixelMap map, out uint[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPixelMapusv")] - public static extern void GetPixelMapusv(Enums.PixelMap map, out ushort[] values); - - [DllImport(_dll_name, EntryPoint = "glGetPolygonStipple")] - public static extern void GetPolygonStipple(out byte[] mask); - - [DllImport(_dll_name, EntryPoint = "glGetString")] - public static extern string GetString(Enums.StringName name); - - [DllImport(_dll_name, EntryPoint = "glGetTexEnvfv")] - public static extern void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexEnviv")] - public static extern void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGendv")] - public static extern void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGenfv")] - public static extern void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexGeniv")] - public static extern void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexImage")] - public static extern void GetTexImage(Enums.TextureTarget target, int level, Enums.PixelFormat format, Enums.PixelType type, out object pixels); - - [DllImport(_dll_name, EntryPoint = "glGetTexParameterfv")] - public static extern void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexParameteriv")] - public static extern void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexLevelParameterfv")] - public static extern void GetTexLevelParameterfv(Enums.TextureTarget target, int level, Enums.GetTextureParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetTexLevelParameteriv")] - public static extern void GetTexLevelParameteriv(Enums.TextureTarget target, int level, Enums.GetTextureParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glIsEnabled")] - public static extern bool IsEnabled(Enums.EnableCap cap); - - [DllImport(_dll_name, EntryPoint = "glIsList")] - public static extern bool IsList(uint list); - - [DllImport(_dll_name, EntryPoint = "glDepthRange")] - public static extern void DepthRange(double near, double far); - - [DllImport(_dll_name, EntryPoint = "glFrustum")] - public static extern void Frustum(double left, double right, double bottom, double top, double zNear, double zFar); - - [DllImport(_dll_name, EntryPoint = "glLoadIdentity")] - public static extern void LoadIdentity(); - - [DllImport(_dll_name, EntryPoint = "glLoadMatrixf")] - public static extern void LoadMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glLoadMatrixd")] - public static extern void LoadMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glMatrixMode")] - public static extern void MatrixMode(Enums.MatrixMode mode); - - [DllImport(_dll_name, EntryPoint = "glMultMatrixf")] - public static extern void MultMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glMultMatrixd")] - public static extern void MultMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glOrtho")] - public static extern void Ortho(double left, double right, double bottom, double top, double zNear, double zFar); - - [DllImport(_dll_name, EntryPoint = "glPopMatrix")] - public static extern void PopMatrix(); - - [DllImport(_dll_name, EntryPoint = "glPushMatrix")] - public static extern void PushMatrix(); - - [DllImport(_dll_name, EntryPoint = "glRotated")] - public static extern void Rotated(double angle, double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glRotatef")] - public static extern void Rotatef(float angle, float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glScaled")] - public static extern void Scaled(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glScalef")] - public static extern void Scalef(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glTranslated")] - public static extern void Translated(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glTranslatef")] - public static extern void Translatef(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glViewport")] - public static extern void Viewport(int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glArrayElement")] - public static extern void ArrayElement(int i); - - [DllImport(_dll_name, EntryPoint = "glColorPointer")] - public static extern void ColorPointer(int size, Enums.ColorPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glDisableClientState")] - public static extern void DisableClientState(Enums.EnableCap array); - - [DllImport(_dll_name, EntryPoint = "glDrawArrays")] - public static extern void DrawArrays(Enums.BeginMode mode, int first, int count); - - [DllImport(_dll_name, EntryPoint = "glDrawElements")] - public static extern void DrawElements(Enums.BeginMode mode, int count, uint type, [MarshalAs(UnmanagedType.AsAny)] object indices); - - [DllImport(_dll_name, EntryPoint = "glEdgeFlagPointer")] - public static extern void EdgeFlagPointer(int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glEnableClientState")] - public static extern void EnableClientState(Enums.EnableCap array); - - [DllImport(_dll_name, EntryPoint = "glGetPointerv")] - public static extern void GetPointerv(Enums.GetPointervPName pname, out object parameters); - - [DllImport(_dll_name, EntryPoint = "glIndexPointer")] - public static extern void IndexPointer(Enums.IndexPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glInterleavedArrays")] - public static extern void InterleavedArrays(Enums.InterleavedArrayFormat format, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glNormalPointer")] - public static extern void NormalPointer(Enums.NormalPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glTexCoordPointer")] - public static extern void TexCoordPointer(int size, Enums.TexCoordPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glVertexPointer")] - public static extern void VertexPointer(int size, Enums.VertexPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glPolygonOffset")] - public static extern void PolygonOffset(float factor, float units); - - [DllImport(_dll_name, EntryPoint = "glCopyTexImage1D")] - public static extern void CopyTexImage1D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int x, int y, int width, int border); - - [DllImport(_dll_name, EntryPoint = "glCopyTexImage2D")] - public static extern void CopyTexImage2D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int x, int y, int width, int height, int border); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage1D")] - public static extern void CopyTexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage2D")] - public static extern void CopyTexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage1D")] - public static extern void TexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int width, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage2D")] - public static extern void TexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glAreTexturesResident")] - public static extern bool AreTexturesResident(int n, uint[] textures, out bool[] residences); - - [DllImport(_dll_name, EntryPoint = "glBindTexture")] - public static extern void BindTexture(Enums.TextureTarget target, uint texture); - - [DllImport(_dll_name, EntryPoint = "glDeleteTextures")] - public static extern void DeleteTextures(int n, uint[] textures); - - [DllImport(_dll_name, EntryPoint = "glGenTextures")] - public static extern void GenTextures(int n, out uint[] textures); - - [DllImport(_dll_name, EntryPoint = "glIsTexture")] - public static extern bool IsTexture(uint texture); - - [DllImport(_dll_name, EntryPoint = "glPrioritizeTextures")] - public static extern void PrioritizeTextures(int n, uint[] textures, float[] priorities); - - [DllImport(_dll_name, EntryPoint = "glIndexub")] - public static extern void Indexub(byte c); - - [DllImport(_dll_name, EntryPoint = "glIndexubv")] - public static extern void Indexubv(byte[] c); - - [DllImport(_dll_name, EntryPoint = "glPopClientAttrib")] - public static extern void PopClientAttrib(); - - [DllImport(_dll_name, EntryPoint = "glPushClientAttrib")] - public static extern void PushClientAttrib(Enums.ClientAttribMask mask); - - [DllImport(_dll_name, EntryPoint = "glBlendColor")] - public static extern void BlendColor(float red, float green, float blue, float alpha); - - [DllImport(_dll_name, EntryPoint = "glBlendEquation")] - public static extern void BlendEquation(Enums.BlendEquationModeEXT mode); - - [DllImport(_dll_name, EntryPoint = "glDrawRangeElements")] - public static extern void DrawRangeElements(Enums.BeginMode mode, uint start, uint end, int count, uint type, [MarshalAs(UnmanagedType.AsAny)] object indices); - - [DllImport(_dll_name, EntryPoint = "glColorTable")] - public static extern void ColorTable(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, int width, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object table); - - [DllImport(_dll_name, EntryPoint = "glColorTableParameterfv")] - public static extern void ColorTableParameterfv(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glColorTableParameteriv")] - public static extern void ColorTableParameteriv(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glCopyColorTable")] - public static extern void CopyColorTable(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glGetColorTable")] - public static extern void GetColorTable(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, out object table); - - [DllImport(_dll_name, EntryPoint = "glGetColorTableParameterfv")] - public static extern void GetColorTableParameterfv(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetColorTableParameteriv")] - public static extern void GetColorTableParameteriv(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glColorSubTable")] - public static extern void ColorSubTable(Enums.ColorTableTargetSGI target, int start, int count, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCopyColorSubTable")] - public static extern void CopyColorSubTable(Enums.ColorTableTargetSGI target, int start, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glConvolutionFilter1D")] - public static extern void ConvolutionFilter1D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int width, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object image); - - [DllImport(_dll_name, EntryPoint = "glConvolutionFilter2D")] - public static extern void ConvolutionFilter2D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object image); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameterf")] - public static extern void ConvolutionParameterf(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, float parameters); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameterfv")] - public static extern void ConvolutionParameterfv(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameteri")] - public static extern void ConvolutionParameteri(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, int parameters); - - [DllImport(_dll_name, EntryPoint = "glConvolutionParameteriv")] - public static extern void ConvolutionParameteriv(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glCopyConvolutionFilter1D")] - public static extern void CopyConvolutionFilter1D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int x, int y, int width); - - [DllImport(_dll_name, EntryPoint = "glCopyConvolutionFilter2D")] - public static extern void CopyConvolutionFilter2D(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glGetConvolutionFilter")] - public static extern void GetConvolutionFilter(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, out object image); - - [DllImport(_dll_name, EntryPoint = "glGetConvolutionParameterfv")] - public static extern void GetConvolutionParameterfv(Enums.ConvolutionTargetEXT target, Enums.GetConvolutionParameter pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetConvolutionParameteriv")] - public static extern void GetConvolutionParameteriv(Enums.ConvolutionTargetEXT target, Enums.GetConvolutionParameter pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetSeparableFilter")] - public static extern void GetSeparableFilter(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, out object row, out object column, out object span); - - [DllImport(_dll_name, EntryPoint = "glSeparableFilter2D")] - public static extern void SeparableFilter2D(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, int width, int height, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object row, [MarshalAs(UnmanagedType.AsAny)] object column); - - [DllImport(_dll_name, EntryPoint = "glGetHistogram")] - public static extern void GetHistogram(Enums.HistogramTargetEXT target, bool reset, Enums.PixelFormat format, Enums.PixelType type, out object values); - - [DllImport(_dll_name, EntryPoint = "glGetHistogramParameterfv")] - public static extern void GetHistogramParameterfv(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetHistogramParameteriv")] - public static extern void GetHistogramParameteriv(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMinmax")] - public static extern void GetMinmax(Enums.MinmaxTargetEXT target, bool reset, Enums.PixelFormat format, Enums.PixelType type, out object values); - - [DllImport(_dll_name, EntryPoint = "glGetMinmaxParameterfv")] - public static extern void GetMinmaxParameterfv(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetMinmaxParameteriv")] - public static extern void GetMinmaxParameteriv(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glHistogram")] - public static extern void Histogram(Enums.HistogramTargetEXT target, int width, Enums.PixelInternalFormat internalformat, bool sink); - - [DllImport(_dll_name, EntryPoint = "glMinmax")] - public static extern void Minmax(Enums.MinmaxTargetEXT target, Enums.PixelInternalFormat internalformat, bool sink); - - [DllImport(_dll_name, EntryPoint = "glResetHistogram")] - public static extern void ResetHistogram(Enums.HistogramTargetEXT target); - - [DllImport(_dll_name, EntryPoint = "glResetMinmax")] - public static extern void ResetMinmax(Enums.MinmaxTargetEXT target); - - [DllImport(_dll_name, EntryPoint = "glTexImage3D")] - public static extern void TexImage3D(Enums.TextureTarget target, int level, int internalformat, int width, int height, int depth, int border, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glTexSubImage3D")] - public static extern void TexSubImage3D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, Enums.PixelFormat format, Enums.PixelType type, [MarshalAs(UnmanagedType.AsAny)] object pixels); - - [DllImport(_dll_name, EntryPoint = "glCopyTexSubImage3D")] - public static extern void CopyTexSubImage3D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height); - - [DllImport(_dll_name, EntryPoint = "glActiveTexture")] - public static extern void ActiveTexture(uint texture); - - [DllImport(_dll_name, EntryPoint = "glClientActiveTexture")] - public static extern void ClientActiveTexture(uint texture); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1d")] - public static extern void MultiTexCoord1d(uint target, double s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1dv")] - public static extern void MultiTexCoord1dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1f")] - public static extern void MultiTexCoord1f(uint target, float s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1fv")] - public static extern void MultiTexCoord1fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1i")] - public static extern void MultiTexCoord1i(uint target, int s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1iv")] - public static extern void MultiTexCoord1iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1s")] - public static extern void MultiTexCoord1s(uint target, short s); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord1sv")] - public static extern void MultiTexCoord1sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2d")] - public static extern void MultiTexCoord2d(uint target, double s, double t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2dv")] - public static extern void MultiTexCoord2dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2f")] - public static extern void MultiTexCoord2f(uint target, float s, float t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2fv")] - public static extern void MultiTexCoord2fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2i")] - public static extern void MultiTexCoord2i(uint target, int s, int t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2iv")] - public static extern void MultiTexCoord2iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2s")] - public static extern void MultiTexCoord2s(uint target, short s, short t); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord2sv")] - public static extern void MultiTexCoord2sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3d")] - public static extern void MultiTexCoord3d(uint target, double s, double t, double r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3dv")] - public static extern void MultiTexCoord3dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3f")] - public static extern void MultiTexCoord3f(uint target, float s, float t, float r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3fv")] - public static extern void MultiTexCoord3fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3i")] - public static extern void MultiTexCoord3i(uint target, int s, int t, int r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3iv")] - public static extern void MultiTexCoord3iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3s")] - public static extern void MultiTexCoord3s(uint target, short s, short t, short r); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord3sv")] - public static extern void MultiTexCoord3sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4d")] - public static extern void MultiTexCoord4d(uint target, double s, double t, double r, double q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4dv")] - public static extern void MultiTexCoord4dv(uint target, double[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4f")] - public static extern void MultiTexCoord4f(uint target, float s, float t, float r, float q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4fv")] - public static extern void MultiTexCoord4fv(uint target, float[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4i")] - public static extern void MultiTexCoord4i(uint target, int s, int t, int r, int q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4iv")] - public static extern void MultiTexCoord4iv(uint target, int[] v); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4s")] - public static extern void MultiTexCoord4s(uint target, short s, short t, short r, short q); - - [DllImport(_dll_name, EntryPoint = "glMultiTexCoord4sv")] - public static extern void MultiTexCoord4sv(uint target, short[] v); - - [DllImport(_dll_name, EntryPoint = "glLoadTransposeMatrixf")] - public static extern void LoadTransposeMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glLoadTransposeMatrixd")] - public static extern void LoadTransposeMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glMultTransposeMatrixf")] - public static extern void MultTransposeMatrixf(float[] m); - - [DllImport(_dll_name, EntryPoint = "glMultTransposeMatrixd")] - public static extern void MultTransposeMatrixd(double[] m); - - [DllImport(_dll_name, EntryPoint = "glSampleCoverage")] - public static extern void SampleCoverage(float value, bool invert); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexImage3D")] - public static extern void CompressedTexImage3D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int width, int height, int depth, int border, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexImage2D")] - public static extern void CompressedTexImage2D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int width, int height, int border, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexImage1D")] - public static extern void CompressedTexImage1D(Enums.TextureTarget target, int level, Enums.PixelInternalFormat internalformat, int width, int border, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexSubImage3D")] - public static extern void CompressedTexSubImage3D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, Enums.PixelFormat format, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexSubImage2D")] - public static extern void CompressedTexSubImage2D(Enums.TextureTarget target, int level, int xoffset, int yoffset, int width, int height, Enums.PixelFormat format, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glCompressedTexSubImage1D")] - public static extern void CompressedTexSubImage1D(Enums.TextureTarget target, int level, int xoffset, int width, Enums.PixelFormat format, int imageSize, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glGetCompressedTexImage")] - public static extern void GetCompressedTexImage(Enums.TextureTarget target, int level, out object img); - - [DllImport(_dll_name, EntryPoint = "glBlendFuncSeparate")] - public static extern void BlendFuncSeparate(uint sfactorRGB, uint dfactorRGB, uint sfactorAlpha, uint dfactorAlpha); - - [DllImport(_dll_name, EntryPoint = "glFogCoordf")] - public static extern void FogCoordf(float coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoordfv")] - public static extern void FogCoordfv(float[] coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoordd")] - public static extern void FogCoordd(double coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoorddv")] - public static extern void FogCoorddv(double[] coord); - - [DllImport(_dll_name, EntryPoint = "glFogCoordPointer")] - public static extern void FogCoordPointer(uint type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glMultiDrawArrays")] - public static extern void MultiDrawArrays(Enums.BeginMode mode, out int[] first, out int[] count, int primcount); - - [DllImport(_dll_name, EntryPoint = "glMultiDrawElements")] - public static extern void MultiDrawElements(Enums.BeginMode mode, int[] count, uint type, [MarshalAs(UnmanagedType.AsAny)] object indices, int primcount); - - [DllImport(_dll_name, EntryPoint = "glPointParameterf")] - public static extern void PointParameterf(Enums.PointParameterNameSGIS pname, float param); - - [DllImport(_dll_name, EntryPoint = "glPointParameterfv")] - public static extern void PointParameterfv(Enums.PointParameterNameSGIS pname, float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glPointParameteri")] - public static extern void PointParameteri(Enums.PointParameterNameSGIS pname, int param); - - [DllImport(_dll_name, EntryPoint = "glPointParameteriv")] - public static extern void PointParameteriv(Enums.PointParameterNameSGIS pname, int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3b")] - public static extern void SecondaryColor3b(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3bv")] - public static extern void SecondaryColor3bv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3d")] - public static extern void SecondaryColor3d(double red, double green, double blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3dv")] - public static extern void SecondaryColor3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3f")] - public static extern void SecondaryColor3f(float red, float green, float blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3fv")] - public static extern void SecondaryColor3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3i")] - public static extern void SecondaryColor3i(int red, int green, int blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3iv")] - public static extern void SecondaryColor3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3s")] - public static extern void SecondaryColor3s(short red, short green, short blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3sv")] - public static extern void SecondaryColor3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3ub")] - public static extern void SecondaryColor3ub(byte red, byte green, byte blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3ubv")] - public static extern void SecondaryColor3ubv(byte[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3ui")] - public static extern void SecondaryColor3ui(uint red, uint green, uint blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3uiv")] - public static extern void SecondaryColor3uiv(uint[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3us")] - public static extern void SecondaryColor3us(ushort red, ushort green, ushort blue); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColor3usv")] - public static extern void SecondaryColor3usv(ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glSecondaryColorPointer")] - public static extern void SecondaryColorPointer(int size, Enums.ColorPointerType type, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2d")] - public static extern void WindowPos2d(double x, double y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2dv")] - public static extern void WindowPos2dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2f")] - public static extern void WindowPos2f(float x, float y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2fv")] - public static extern void WindowPos2fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2i")] - public static extern void WindowPos2i(int x, int y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2iv")] - public static extern void WindowPos2iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2s")] - public static extern void WindowPos2s(short x, short y); - - [DllImport(_dll_name, EntryPoint = "glWindowPos2sv")] - public static extern void WindowPos2sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3d")] - public static extern void WindowPos3d(double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3dv")] - public static extern void WindowPos3dv(double[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3f")] - public static extern void WindowPos3f(float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3fv")] - public static extern void WindowPos3fv(float[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3i")] - public static extern void WindowPos3i(int x, int y, int z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3iv")] - public static extern void WindowPos3iv(int[] v); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3s")] - public static extern void WindowPos3s(short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glWindowPos3sv")] - public static extern void WindowPos3sv(short[] v); - - [DllImport(_dll_name, EntryPoint = "glGenQueries")] - public static extern void GenQueries(int n, out uint[] ids); - - [DllImport(_dll_name, EntryPoint = "glDeleteQueries")] - public static extern void DeleteQueries(int n, uint[] ids); - - [DllImport(_dll_name, EntryPoint = "glIsQuery")] - public static extern bool IsQuery(uint id); - - [DllImport(_dll_name, EntryPoint = "glBeginQuery")] - public static extern void BeginQuery(uint target, uint id); - - [DllImport(_dll_name, EntryPoint = "glEndQuery")] - public static extern void EndQuery(uint target); - - [DllImport(_dll_name, EntryPoint = "glGetQueryiv")] - public static extern void GetQueryiv(uint target, uint pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetQueryObjectiv")] - public static extern void GetQueryObjectiv(uint id, uint pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetQueryObjectuiv")] - public static extern void GetQueryObjectuiv(uint id, uint pname, out uint[] parameters); - - [DllImport(_dll_name, EntryPoint = "glBindBuffer")] - public static extern void BindBuffer(uint target, uint buffer); - - [DllImport(_dll_name, EntryPoint = "glDeleteBuffers")] - public static extern void DeleteBuffers(int n, uint[] buffers); - - [DllImport(_dll_name, EntryPoint = "glGenBuffers")] - public static extern void GenBuffers(int n, out uint[] buffers); - - [DllImport(_dll_name, EntryPoint = "glIsBuffer")] - public static extern bool IsBuffer(uint buffer); - - [DllImport(_dll_name, EntryPoint = "glBufferData")] - public static extern void BufferData(uint target, IntPtr size, [MarshalAs(UnmanagedType.AsAny)] object data, uint usage); - - [DllImport(_dll_name, EntryPoint = "glBufferSubData")] - public static extern void BufferSubData(uint target, IntPtr offset, IntPtr size, [MarshalAs(UnmanagedType.AsAny)] object data); - - [DllImport(_dll_name, EntryPoint = "glGetBufferSubData")] - public static extern void GetBufferSubData(uint target, IntPtr offset, IntPtr size, out object data); - - [DllImport(_dll_name, EntryPoint = "glMapBuffer_")] - public static extern IntPtr MapBuffer_(uint target, uint access); - - [DllImport(_dll_name, EntryPoint = "glUnmapBuffer")] - public static extern bool UnmapBuffer(uint target); - - [DllImport(_dll_name, EntryPoint = "glGetBufferParameteriv")] - public static extern void GetBufferParameteriv(uint target, uint pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetBufferPointerv")] - public static extern void GetBufferPointerv(uint target, uint pname, out object parameters); - - [DllImport(_dll_name, EntryPoint = "glBlendEquationSeparate")] - public static extern void BlendEquationSeparate(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha); - - [DllImport(_dll_name, EntryPoint = "glDrawBuffers")] - public static extern void DrawBuffers(int n, Enums.DrawBufferMode[] bufs); - - [DllImport(_dll_name, EntryPoint = "glStencilOpSeparate")] - public static extern void StencilOpSeparate(uint face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass); - - [DllImport(_dll_name, EntryPoint = "glStencilFuncSeparate")] - public static extern void StencilFuncSeparate(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, int reference, uint mask); - - [DllImport(_dll_name, EntryPoint = "glStencilMaskSeparate")] - public static extern void StencilMaskSeparate(uint face, uint mask); - - [DllImport(_dll_name, EntryPoint = "glAttachShader")] - public static extern void AttachShader(uint program, uint shader); - - [DllImport(_dll_name, EntryPoint = "glBindAttribLocation")] - public static extern void BindAttribLocation(uint program, uint index, char[] name); - - [DllImport(_dll_name, EntryPoint = "glCompileShader")] - public static extern void CompileShader(uint shader); - - [DllImport(_dll_name, EntryPoint = "glCreateProgram")] - public static extern uint CreateProgram(); - - [DllImport(_dll_name, EntryPoint = "glCreateShader")] - public static extern uint CreateShader(uint type); - - [DllImport(_dll_name, EntryPoint = "glDeleteProgram")] - public static extern void DeleteProgram(uint program); - - [DllImport(_dll_name, EntryPoint = "glDeleteShader")] - public static extern void DeleteShader(uint shader); - - [DllImport(_dll_name, EntryPoint = "glDetachShader")] - public static extern void DetachShader(uint program, uint shader); - - [DllImport(_dll_name, EntryPoint = "glDisableVertexAttribArray")] - public static extern void DisableVertexAttribArray(uint index); - - [DllImport(_dll_name, EntryPoint = "glEnableVertexAttribArray")] - public static extern void EnableVertexAttribArray(uint index); - - [DllImport(_dll_name, EntryPoint = "glGetActiveAttrib")] - public static extern void GetActiveAttrib(uint program, uint index, int bufSize, out int[] length, out int[] size, out uint[] type, out char[] name); - - [DllImport(_dll_name, EntryPoint = "glGetActiveUniform")] - public static extern void GetActiveUniform(uint program, uint index, int bufSize, out int[] length, out int[] size, out uint[] type, out char[] name); - - [DllImport(_dll_name, EntryPoint = "glGetAttachedShaders")] - public static extern void GetAttachedShaders(uint program, int maxCount, out int[] count, out uint[] obj); - - [DllImport(_dll_name, EntryPoint = "glGetAttribLocation")] - public static extern int GetAttribLocation(uint program, char[] name); - - [DllImport(_dll_name, EntryPoint = "glGetProgramiv")] - public static extern void GetProgramiv(uint program, uint pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetProgramInfoLog")] - public static extern void GetProgramInfoLog(uint program, int bufSize, out int[] length, out char[] infoLog); - - [DllImport(_dll_name, EntryPoint = "glGetShaderiv")] - public static extern void GetShaderiv(uint shader, uint pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetShaderInfoLog")] - public static extern void GetShaderInfoLog(uint shader, int bufSize, out int[] length, out char[] infoLog); - - [DllImport(_dll_name, EntryPoint = "glGetShaderSource")] - public static extern void GetShaderSource(uint shader, int bufSize, out int[] length, out char[] source); - - [DllImport(_dll_name, EntryPoint = "glGetUniformLocation")] - public static extern int GetUniformLocation(uint program, char[] name); - - [DllImport(_dll_name, EntryPoint = "glGetUniformfv")] - public static extern void GetUniformfv(uint program, int location, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetUniformiv")] - public static extern void GetUniformiv(uint program, int location, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetVertexAttribdv")] - public static extern void GetVertexAttribdv(uint index, uint pname, out double[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetVertexAttribfv")] - public static extern void GetVertexAttribfv(uint index, uint pname, out float[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetVertexAttribiv")] - public static extern void GetVertexAttribiv(uint index, uint pname, out int[] parameters); - - [DllImport(_dll_name, EntryPoint = "glGetVertexAttribPointerv")] - public static extern void GetVertexAttribPointerv(uint index, uint pname, out object pointer); - - [DllImport(_dll_name, EntryPoint = "glIsProgram")] - public static extern bool IsProgram(uint program); - - [DllImport(_dll_name, EntryPoint = "glIsShader")] - public static extern bool IsShader(uint shader); - - [DllImport(_dll_name, EntryPoint = "glLinkProgram")] - public static extern void LinkProgram(uint program); - - [DllImport(_dll_name, EntryPoint = "glShaderSource")] - public static extern void ShaderSource(uint shader, int count, string[] @string, int[] length); - - [DllImport(_dll_name, EntryPoint = "glUseProgram")] - public static extern void UseProgram(uint program); - - [DllImport(_dll_name, EntryPoint = "glUniform1f")] - public static extern void Uniform1f(int location, float v0); - - [DllImport(_dll_name, EntryPoint = "glUniform2f")] - public static extern void Uniform2f(int location, float v0, float v1); - - [DllImport(_dll_name, EntryPoint = "glUniform3f")] - public static extern void Uniform3f(int location, float v0, float v1, float v2); - - [DllImport(_dll_name, EntryPoint = "glUniform4f")] - public static extern void Uniform4f(int location, float v0, float v1, float v2, float v3); - - [DllImport(_dll_name, EntryPoint = "glUniform1i")] - public static extern void Uniform1i(int location, int v0); - - [DllImport(_dll_name, EntryPoint = "glUniform2i")] - public static extern void Uniform2i(int location, int v0, int v1); - - [DllImport(_dll_name, EntryPoint = "glUniform3i")] - public static extern void Uniform3i(int location, int v0, int v1, int v2); - - [DllImport(_dll_name, EntryPoint = "glUniform4i")] - public static extern void Uniform4i(int location, int v0, int v1, int v2, int v3); - - [DllImport(_dll_name, EntryPoint = "glUniform1fv")] - public static extern void Uniform1fv(int location, int count, float[] value); - - [DllImport(_dll_name, EntryPoint = "glUniform2fv")] - public static extern void Uniform2fv(int location, int count, float[] value); - - [DllImport(_dll_name, EntryPoint = "glUniform3fv")] - public static extern void Uniform3fv(int location, int count, float[] value); - - [DllImport(_dll_name, EntryPoint = "glUniform4fv")] - public static extern void Uniform4fv(int location, int count, float[] value); - - [DllImport(_dll_name, EntryPoint = "glUniform1iv")] - public static extern void Uniform1iv(int location, int count, int[] value); - - [DllImport(_dll_name, EntryPoint = "glUniform2iv")] - public static extern void Uniform2iv(int location, int count, int[] value); - - [DllImport(_dll_name, EntryPoint = "glUniform3iv")] - public static extern void Uniform3iv(int location, int count, int[] value); - - [DllImport(_dll_name, EntryPoint = "glUniform4iv")] - public static extern void Uniform4iv(int location, int count, int[] value); - - [DllImport(_dll_name, EntryPoint = "glUniformMatrix2fv")] - public static extern void UniformMatrix2fv(int location, int count, bool transpose, float[] value); - - [DllImport(_dll_name, EntryPoint = "glUniformMatrix3fv")] - public static extern void UniformMatrix3fv(int location, int count, bool transpose, float[] value); - - [DllImport(_dll_name, EntryPoint = "glUniformMatrix4fv")] - public static extern void UniformMatrix4fv(int location, int count, bool transpose, float[] value); - - [DllImport(_dll_name, EntryPoint = "glValidateProgram")] - public static extern void ValidateProgram(uint program); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib1d")] - public static extern void VertexAttrib1d(uint index, double x); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib1dv")] - public static extern void VertexAttrib1dv(uint index, double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib1f")] - public static extern void VertexAttrib1f(uint index, float x); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib1fv")] - public static extern void VertexAttrib1fv(uint index, float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib1s")] - public static extern void VertexAttrib1s(uint index, short x); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib1sv")] - public static extern void VertexAttrib1sv(uint index, short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib2d")] - public static extern void VertexAttrib2d(uint index, double x, double y); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib2dv")] - public static extern void VertexAttrib2dv(uint index, double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib2f")] - public static extern void VertexAttrib2f(uint index, float x, float y); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib2fv")] - public static extern void VertexAttrib2fv(uint index, float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib2s")] - public static extern void VertexAttrib2s(uint index, short x, short y); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib2sv")] - public static extern void VertexAttrib2sv(uint index, short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib3d")] - public static extern void VertexAttrib3d(uint index, double x, double y, double z); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib3dv")] - public static extern void VertexAttrib3dv(uint index, double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib3f")] - public static extern void VertexAttrib3f(uint index, float x, float y, float z); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib3fv")] - public static extern void VertexAttrib3fv(uint index, float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib3s")] - public static extern void VertexAttrib3s(uint index, short x, short y, short z); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib3sv")] - public static extern void VertexAttrib3sv(uint index, short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4Nbv")] - public static extern void VertexAttrib4Nbv(uint index, byte[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4Niv")] - public static extern void VertexAttrib4Niv(uint index, int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4Nsv")] - public static extern void VertexAttrib4Nsv(uint index, short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4Nub")] - public static extern void VertexAttrib4Nub(uint index, byte x, byte y, byte z, byte w); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4Nubv")] - public static extern void VertexAttrib4Nubv(uint index, byte[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4Nuiv")] - public static extern void VertexAttrib4Nuiv(uint index, uint[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4Nusv")] - public static extern void VertexAttrib4Nusv(uint index, ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4bv")] - public static extern void VertexAttrib4bv(uint index, byte[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4d")] - public static extern void VertexAttrib4d(uint index, double x, double y, double z, double w); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4dv")] - public static extern void VertexAttrib4dv(uint index, double[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4f")] - public static extern void VertexAttrib4f(uint index, float x, float y, float z, float w); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4fv")] - public static extern void VertexAttrib4fv(uint index, float[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4iv")] - public static extern void VertexAttrib4iv(uint index, int[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4s")] - public static extern void VertexAttrib4s(uint index, short x, short y, short z, short w); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4sv")] - public static extern void VertexAttrib4sv(uint index, short[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4ubv")] - public static extern void VertexAttrib4ubv(uint index, byte[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4uiv")] - public static extern void VertexAttrib4uiv(uint index, uint[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttrib4usv")] - public static extern void VertexAttrib4usv(uint index, ushort[] v); - - [DllImport(_dll_name, EntryPoint = "glVertexAttribPointer")] - public static extern void VertexAttribPointer(uint index, int size, uint type, bool normalized, int stride, [MarshalAs(UnmanagedType.AsAny)] object pointer); - - } - #endregion - - #region Load core - - /// - /// Loads the core opengl functions (versions 1.0-2.0). - /// public override void Load() { - if (GL.CoreLoaded) return; - if (GL.ExtensionsLoaded) return; - GL.NewList = new GL.Delegates.NewList(Imports.NewList); - GL.EndList = new GL.Delegates.EndList(Imports.EndList); - GL.CallList = new GL.Delegates.CallList(Imports.CallList); - GL.CallLists = new GL.Delegates.CallLists(Imports.CallLists); - GL.DeleteLists = new GL.Delegates.DeleteLists(Imports.DeleteLists); - GL.GenLists = new GL.Delegates.GenLists(Imports.GenLists); - GL.ListBase = new GL.Delegates.ListBase(Imports.ListBase); - GL.Begin = new GL.Delegates.Begin(Imports.Begin); - GL.Bitmap = new GL.Delegates.Bitmap(Imports.Bitmap); - GL.Color3b = new GL.Delegates.Color3b(Imports.Color3b); - GL.Color3bv = new GL.Delegates.Color3bv(Imports.Color3bv); - GL.Color3d = new GL.Delegates.Color3d(Imports.Color3d); - GL.Color3dv = new GL.Delegates.Color3dv(Imports.Color3dv); - GL.Color3f = new GL.Delegates.Color3f(Imports.Color3f); - GL.Color3fv = new GL.Delegates.Color3fv(Imports.Color3fv); - GL.Color3i = new GL.Delegates.Color3i(Imports.Color3i); - GL.Color3iv = new GL.Delegates.Color3iv(Imports.Color3iv); - GL.Color3s = new GL.Delegates.Color3s(Imports.Color3s); - GL.Color3sv = new GL.Delegates.Color3sv(Imports.Color3sv); - GL.Color3ub = new GL.Delegates.Color3ub(Imports.Color3ub); - GL.Color3ubv = new GL.Delegates.Color3ubv(Imports.Color3ubv); - GL.Color3ui = new GL.Delegates.Color3ui(Imports.Color3ui); - GL.Color3uiv = new GL.Delegates.Color3uiv(Imports.Color3uiv); - GL.Color3us = new GL.Delegates.Color3us(Imports.Color3us); - GL.Color3usv = new GL.Delegates.Color3usv(Imports.Color3usv); - GL.Color4b = new GL.Delegates.Color4b(Imports.Color4b); - GL.Color4bv = new GL.Delegates.Color4bv(Imports.Color4bv); - GL.Color4d = new GL.Delegates.Color4d(Imports.Color4d); - GL.Color4dv = new GL.Delegates.Color4dv(Imports.Color4dv); - GL.Color4f = new GL.Delegates.Color4f(Imports.Color4f); - GL.Color4fv = new GL.Delegates.Color4fv(Imports.Color4fv); - GL.Color4i = new GL.Delegates.Color4i(Imports.Color4i); - GL.Color4iv = new GL.Delegates.Color4iv(Imports.Color4iv); - GL.Color4s = new GL.Delegates.Color4s(Imports.Color4s); - GL.Color4sv = new GL.Delegates.Color4sv(Imports.Color4sv); - GL.Color4ub = new GL.Delegates.Color4ub(Imports.Color4ub); - GL.Color4ubv = new GL.Delegates.Color4ubv(Imports.Color4ubv); - GL.Color4ui = new GL.Delegates.Color4ui(Imports.Color4ui); - GL.Color4uiv = new GL.Delegates.Color4uiv(Imports.Color4uiv); - GL.Color4us = new GL.Delegates.Color4us(Imports.Color4us); - GL.Color4usv = new GL.Delegates.Color4usv(Imports.Color4usv); - GL.EdgeFlag = new GL.Delegates.EdgeFlag(Imports.EdgeFlag); - GL.EdgeFlagv = new GL.Delegates.EdgeFlagv(Imports.EdgeFlagv); - GL.End = new GL.Delegates.End(Imports.End); - GL.Indexd = new GL.Delegates.Indexd(Imports.Indexd); - GL.Indexdv = new GL.Delegates.Indexdv(Imports.Indexdv); - GL.Indexf = new GL.Delegates.Indexf(Imports.Indexf); - GL.Indexfv = new GL.Delegates.Indexfv(Imports.Indexfv); - GL.Indexi = new GL.Delegates.Indexi(Imports.Indexi); - GL.Indexiv = new GL.Delegates.Indexiv(Imports.Indexiv); - GL.Indexs = new GL.Delegates.Indexs(Imports.Indexs); - GL.Indexsv = new GL.Delegates.Indexsv(Imports.Indexsv); - GL.Normal3b = new GL.Delegates.Normal3b(Imports.Normal3b); - GL.Normal3bv = new GL.Delegates.Normal3bv(Imports.Normal3bv); - GL.Normal3d = new GL.Delegates.Normal3d(Imports.Normal3d); - GL.Normal3dv = new GL.Delegates.Normal3dv(Imports.Normal3dv); - GL.Normal3f = new GL.Delegates.Normal3f(Imports.Normal3f); - GL.Normal3fv = new GL.Delegates.Normal3fv(Imports.Normal3fv); - GL.Normal3i = new GL.Delegates.Normal3i(Imports.Normal3i); - GL.Normal3iv = new GL.Delegates.Normal3iv(Imports.Normal3iv); - GL.Normal3s = new GL.Delegates.Normal3s(Imports.Normal3s); - GL.Normal3sv = new GL.Delegates.Normal3sv(Imports.Normal3sv); - GL.RasterPos2d = new GL.Delegates.RasterPos2d(Imports.RasterPos2d); - GL.RasterPos2dv = new GL.Delegates.RasterPos2dv(Imports.RasterPos2dv); - GL.RasterPos2f = new GL.Delegates.RasterPos2f(Imports.RasterPos2f); - GL.RasterPos2fv = new GL.Delegates.RasterPos2fv(Imports.RasterPos2fv); - GL.RasterPos2i = new GL.Delegates.RasterPos2i(Imports.RasterPos2i); - GL.RasterPos2iv = new GL.Delegates.RasterPos2iv(Imports.RasterPos2iv); - GL.RasterPos2s = new GL.Delegates.RasterPos2s(Imports.RasterPos2s); - GL.RasterPos2sv = new GL.Delegates.RasterPos2sv(Imports.RasterPos2sv); - GL.RasterPos3d = new GL.Delegates.RasterPos3d(Imports.RasterPos3d); - GL.RasterPos3dv = new GL.Delegates.RasterPos3dv(Imports.RasterPos3dv); - GL.RasterPos3f = new GL.Delegates.RasterPos3f(Imports.RasterPos3f); - GL.RasterPos3fv = new GL.Delegates.RasterPos3fv(Imports.RasterPos3fv); - GL.RasterPos3i = new GL.Delegates.RasterPos3i(Imports.RasterPos3i); - GL.RasterPos3iv = new GL.Delegates.RasterPos3iv(Imports.RasterPos3iv); - GL.RasterPos3s = new GL.Delegates.RasterPos3s(Imports.RasterPos3s); - GL.RasterPos3sv = new GL.Delegates.RasterPos3sv(Imports.RasterPos3sv); - GL.RasterPos4d = new GL.Delegates.RasterPos4d(Imports.RasterPos4d); - GL.RasterPos4dv = new GL.Delegates.RasterPos4dv(Imports.RasterPos4dv); - GL.RasterPos4f = new GL.Delegates.RasterPos4f(Imports.RasterPos4f); - GL.RasterPos4fv = new GL.Delegates.RasterPos4fv(Imports.RasterPos4fv); - GL.RasterPos4i = new GL.Delegates.RasterPos4i(Imports.RasterPos4i); - GL.RasterPos4iv = new GL.Delegates.RasterPos4iv(Imports.RasterPos4iv); - GL.RasterPos4s = new GL.Delegates.RasterPos4s(Imports.RasterPos4s); - GL.RasterPos4sv = new GL.Delegates.RasterPos4sv(Imports.RasterPos4sv); - GL.Rectd = new GL.Delegates.Rectd(Imports.Rectd); - GL.Rectdv = new GL.Delegates.Rectdv(Imports.Rectdv); - GL.Rectf = new GL.Delegates.Rectf(Imports.Rectf); - GL.Rectfv = new GL.Delegates.Rectfv(Imports.Rectfv); - GL.Recti = new GL.Delegates.Recti(Imports.Recti); - GL.Rectiv = new GL.Delegates.Rectiv(Imports.Rectiv); - GL.Rects = new GL.Delegates.Rects(Imports.Rects); - GL.Rectsv = new GL.Delegates.Rectsv(Imports.Rectsv); - GL.TexCoord1d = new GL.Delegates.TexCoord1d(Imports.TexCoord1d); - GL.TexCoord1dv = new GL.Delegates.TexCoord1dv(Imports.TexCoord1dv); - GL.TexCoord1f = new GL.Delegates.TexCoord1f(Imports.TexCoord1f); - GL.TexCoord1fv = new GL.Delegates.TexCoord1fv(Imports.TexCoord1fv); - GL.TexCoord1i = new GL.Delegates.TexCoord1i(Imports.TexCoord1i); - GL.TexCoord1iv = new GL.Delegates.TexCoord1iv(Imports.TexCoord1iv); - GL.TexCoord1s = new GL.Delegates.TexCoord1s(Imports.TexCoord1s); - GL.TexCoord1sv = new GL.Delegates.TexCoord1sv(Imports.TexCoord1sv); - GL.TexCoord2d = new GL.Delegates.TexCoord2d(Imports.TexCoord2d); - GL.TexCoord2dv = new GL.Delegates.TexCoord2dv(Imports.TexCoord2dv); - GL.TexCoord2f = new GL.Delegates.TexCoord2f(Imports.TexCoord2f); - GL.TexCoord2fv = new GL.Delegates.TexCoord2fv(Imports.TexCoord2fv); - GL.TexCoord2i = new GL.Delegates.TexCoord2i(Imports.TexCoord2i); - GL.TexCoord2iv = new GL.Delegates.TexCoord2iv(Imports.TexCoord2iv); - GL.TexCoord2s = new GL.Delegates.TexCoord2s(Imports.TexCoord2s); - GL.TexCoord2sv = new GL.Delegates.TexCoord2sv(Imports.TexCoord2sv); - GL.TexCoord3d = new GL.Delegates.TexCoord3d(Imports.TexCoord3d); - GL.TexCoord3dv = new GL.Delegates.TexCoord3dv(Imports.TexCoord3dv); - GL.TexCoord3f = new GL.Delegates.TexCoord3f(Imports.TexCoord3f); - GL.TexCoord3fv = new GL.Delegates.TexCoord3fv(Imports.TexCoord3fv); - GL.TexCoord3i = new GL.Delegates.TexCoord3i(Imports.TexCoord3i); - GL.TexCoord3iv = new GL.Delegates.TexCoord3iv(Imports.TexCoord3iv); - GL.TexCoord3s = new GL.Delegates.TexCoord3s(Imports.TexCoord3s); - GL.TexCoord3sv = new GL.Delegates.TexCoord3sv(Imports.TexCoord3sv); - GL.TexCoord4d = new GL.Delegates.TexCoord4d(Imports.TexCoord4d); - GL.TexCoord4dv = new GL.Delegates.TexCoord4dv(Imports.TexCoord4dv); - GL.TexCoord4f = new GL.Delegates.TexCoord4f(Imports.TexCoord4f); - GL.TexCoord4fv = new GL.Delegates.TexCoord4fv(Imports.TexCoord4fv); - GL.TexCoord4i = new GL.Delegates.TexCoord4i(Imports.TexCoord4i); - GL.TexCoord4iv = new GL.Delegates.TexCoord4iv(Imports.TexCoord4iv); - GL.TexCoord4s = new GL.Delegates.TexCoord4s(Imports.TexCoord4s); - GL.TexCoord4sv = new GL.Delegates.TexCoord4sv(Imports.TexCoord4sv); - GL.Vertex2d = new GL.Delegates.Vertex2d(Imports.Vertex2d); - GL.Vertex2dv = new GL.Delegates.Vertex2dv(Imports.Vertex2dv); - GL.Vertex2f = new GL.Delegates.Vertex2f(Imports.Vertex2f); - GL.Vertex2fv = new GL.Delegates.Vertex2fv(Imports.Vertex2fv); - GL.Vertex2i = new GL.Delegates.Vertex2i(Imports.Vertex2i); - GL.Vertex2iv = new GL.Delegates.Vertex2iv(Imports.Vertex2iv); - GL.Vertex2s = new GL.Delegates.Vertex2s(Imports.Vertex2s); - GL.Vertex2sv = new GL.Delegates.Vertex2sv(Imports.Vertex2sv); - GL.Vertex3d = new GL.Delegates.Vertex3d(Imports.Vertex3d); - GL.Vertex3dv = new GL.Delegates.Vertex3dv(Imports.Vertex3dv); - GL.Vertex3f = new GL.Delegates.Vertex3f(Imports.Vertex3f); - GL.Vertex3fv = new GL.Delegates.Vertex3fv(Imports.Vertex3fv); - GL.Vertex3i = new GL.Delegates.Vertex3i(Imports.Vertex3i); - GL.Vertex3iv = new GL.Delegates.Vertex3iv(Imports.Vertex3iv); - GL.Vertex3s = new GL.Delegates.Vertex3s(Imports.Vertex3s); - GL.Vertex3sv = new GL.Delegates.Vertex3sv(Imports.Vertex3sv); - GL.Vertex4d = new GL.Delegates.Vertex4d(Imports.Vertex4d); - GL.Vertex4dv = new GL.Delegates.Vertex4dv(Imports.Vertex4dv); - GL.Vertex4f = new GL.Delegates.Vertex4f(Imports.Vertex4f); - GL.Vertex4fv = new GL.Delegates.Vertex4fv(Imports.Vertex4fv); - GL.Vertex4i = new GL.Delegates.Vertex4i(Imports.Vertex4i); - GL.Vertex4iv = new GL.Delegates.Vertex4iv(Imports.Vertex4iv); - GL.Vertex4s = new GL.Delegates.Vertex4s(Imports.Vertex4s); - GL.Vertex4sv = new GL.Delegates.Vertex4sv(Imports.Vertex4sv); - GL.ClipPlane = new GL.Delegates.ClipPlane(Imports.ClipPlane); - GL.ColorMaterial = new GL.Delegates.ColorMaterial(Imports.ColorMaterial); - GL.CullFace = new GL.Delegates.CullFace(Imports.CullFace); - GL.Fogf = new GL.Delegates.Fogf(Imports.Fogf); - GL.Fogfv = new GL.Delegates.Fogfv(Imports.Fogfv); - GL.Fogi = new GL.Delegates.Fogi(Imports.Fogi); - GL.Fogiv = new GL.Delegates.Fogiv(Imports.Fogiv); - GL.FrontFace = new GL.Delegates.FrontFace(Imports.FrontFace); - GL.Hint = new GL.Delegates.Hint(Imports.Hint); - GL.Lightf = new GL.Delegates.Lightf(Imports.Lightf); - GL.Lightfv = new GL.Delegates.Lightfv(Imports.Lightfv); - GL.Lighti = new GL.Delegates.Lighti(Imports.Lighti); - GL.Lightiv = new GL.Delegates.Lightiv(Imports.Lightiv); - GL.LightModelf = new GL.Delegates.LightModelf(Imports.LightModelf); - GL.LightModelfv = new GL.Delegates.LightModelfv(Imports.LightModelfv); - GL.LightModeli = new GL.Delegates.LightModeli(Imports.LightModeli); - GL.LightModeliv = new GL.Delegates.LightModeliv(Imports.LightModeliv); - GL.LineStipple = new GL.Delegates.LineStipple(Imports.LineStipple); - GL.LineWidth = new GL.Delegates.LineWidth(Imports.LineWidth); - GL.Materialf = new GL.Delegates.Materialf(Imports.Materialf); - GL.Materialfv = new GL.Delegates.Materialfv(Imports.Materialfv); - GL.Materiali = new GL.Delegates.Materiali(Imports.Materiali); - GL.Materialiv = new GL.Delegates.Materialiv(Imports.Materialiv); - GL.PointSize = new GL.Delegates.PointSize(Imports.PointSize); - GL.PolygonMode = new GL.Delegates.PolygonMode(Imports.PolygonMode); - GL.PolygonStipple = new GL.Delegates.PolygonStipple(Imports.PolygonStipple); - GL.Scissor = new GL.Delegates.Scissor(Imports.Scissor); - GL.ShadeModel = new GL.Delegates.ShadeModel(Imports.ShadeModel); - GL.TexParameterf = new GL.Delegates.TexParameterf(Imports.TexParameterf); - GL.TexParameterfv = new GL.Delegates.TexParameterfv(Imports.TexParameterfv); - GL.TexParameteri = new GL.Delegates.TexParameteri(Imports.TexParameteri); - GL.TexParameteriv = new GL.Delegates.TexParameteriv(Imports.TexParameteriv); - GL.TexImage1D = new GL.Delegates.TexImage1D(Imports.TexImage1D); - GL.TexImage2D = new GL.Delegates.TexImage2D(Imports.TexImage2D); - GL.TexEnvf = new GL.Delegates.TexEnvf(Imports.TexEnvf); - GL.TexEnvfv = new GL.Delegates.TexEnvfv(Imports.TexEnvfv); - GL.TexEnvi = new GL.Delegates.TexEnvi(Imports.TexEnvi); - GL.TexEnviv = new GL.Delegates.TexEnviv(Imports.TexEnviv); - GL.TexGend = new GL.Delegates.TexGend(Imports.TexGend); - GL.TexGendv = new GL.Delegates.TexGendv(Imports.TexGendv); - GL.TexGenf = new GL.Delegates.TexGenf(Imports.TexGenf); - GL.TexGenfv = new GL.Delegates.TexGenfv(Imports.TexGenfv); - GL.TexGeni = new GL.Delegates.TexGeni(Imports.TexGeni); - GL.TexGeniv = new GL.Delegates.TexGeniv(Imports.TexGeniv); - GL.FeedbackBuffer = new GL.Delegates.FeedbackBuffer(Imports.FeedbackBuffer); - GL.SelectBuffer = new GL.Delegates.SelectBuffer(Imports.SelectBuffer); - GL.RenderMode = new GL.Delegates.RenderMode(Imports.RenderMode); - GL.InitNames = new GL.Delegates.InitNames(Imports.InitNames); - GL.LoadName = new GL.Delegates.LoadName(Imports.LoadName); - GL.PassThrough = new GL.Delegates.PassThrough(Imports.PassThrough); - GL.PopName = new GL.Delegates.PopName(Imports.PopName); - GL.PushName = new GL.Delegates.PushName(Imports.PushName); - GL.DrawBuffer = new GL.Delegates.DrawBuffer(Imports.DrawBuffer); - GL.Clear = new GL.Delegates.Clear(Imports.Clear); - GL.ClearAccum = new GL.Delegates.ClearAccum(Imports.ClearAccum); - GL.ClearIndex = new GL.Delegates.ClearIndex(Imports.ClearIndex); - GL.ClearColor = new GL.Delegates.ClearColor(Imports.ClearColor); - GL.ClearStencil = new GL.Delegates.ClearStencil(Imports.ClearStencil); - GL.ClearDepth = new GL.Delegates.ClearDepth(Imports.ClearDepth); - GL.StencilMask = new GL.Delegates.StencilMask(Imports.StencilMask); - GL.ColorMask = new GL.Delegates.ColorMask(Imports.ColorMask); - GL.DepthMask = new GL.Delegates.DepthMask(Imports.DepthMask); - GL.IndexMask = new GL.Delegates.IndexMask(Imports.IndexMask); - GL.Accum = new GL.Delegates.Accum(Imports.Accum); - GL.Disable = new GL.Delegates.Disable(Imports.Disable); - GL.Enable = new GL.Delegates.Enable(Imports.Enable); - GL.Finish = new GL.Delegates.Finish(Imports.Finish); - GL.Flush = new GL.Delegates.Flush(Imports.Flush); - GL.PopAttrib = new GL.Delegates.PopAttrib(Imports.PopAttrib); - GL.PushAttrib = new GL.Delegates.PushAttrib(Imports.PushAttrib); - GL.Map1d = new GL.Delegates.Map1d(Imports.Map1d); - GL.Map1f = new GL.Delegates.Map1f(Imports.Map1f); - GL.Map2d = new GL.Delegates.Map2d(Imports.Map2d); - GL.Map2f = new GL.Delegates.Map2f(Imports.Map2f); - GL.MapGrid1d = new GL.Delegates.MapGrid1d(Imports.MapGrid1d); - GL.MapGrid1f = new GL.Delegates.MapGrid1f(Imports.MapGrid1f); - GL.MapGrid2d = new GL.Delegates.MapGrid2d(Imports.MapGrid2d); - GL.MapGrid2f = new GL.Delegates.MapGrid2f(Imports.MapGrid2f); - GL.EvalCoord1d = new GL.Delegates.EvalCoord1d(Imports.EvalCoord1d); - GL.EvalCoord1dv = new GL.Delegates.EvalCoord1dv(Imports.EvalCoord1dv); - GL.EvalCoord1f = new GL.Delegates.EvalCoord1f(Imports.EvalCoord1f); - GL.EvalCoord1fv = new GL.Delegates.EvalCoord1fv(Imports.EvalCoord1fv); - GL.EvalCoord2d = new GL.Delegates.EvalCoord2d(Imports.EvalCoord2d); - GL.EvalCoord2dv = new GL.Delegates.EvalCoord2dv(Imports.EvalCoord2dv); - GL.EvalCoord2f = new GL.Delegates.EvalCoord2f(Imports.EvalCoord2f); - GL.EvalCoord2fv = new GL.Delegates.EvalCoord2fv(Imports.EvalCoord2fv); - GL.EvalMesh1 = new GL.Delegates.EvalMesh1(Imports.EvalMesh1); - GL.EvalPoint1 = new GL.Delegates.EvalPoint1(Imports.EvalPoint1); - GL.EvalMesh2 = new GL.Delegates.EvalMesh2(Imports.EvalMesh2); - GL.EvalPoint2 = new GL.Delegates.EvalPoint2(Imports.EvalPoint2); - GL.AlphaFunc = new GL.Delegates.AlphaFunc(Imports.AlphaFunc); - GL.BlendFunc = new GL.Delegates.BlendFunc(Imports.BlendFunc); - GL.LogicOp = new GL.Delegates.LogicOp(Imports.LogicOp); - GL.StencilFunc = new GL.Delegates.StencilFunc(Imports.StencilFunc); - GL.StencilOp = new GL.Delegates.StencilOp(Imports.StencilOp); - GL.DepthFunc = new GL.Delegates.DepthFunc(Imports.DepthFunc); - GL.PixelZoom = new GL.Delegates.PixelZoom(Imports.PixelZoom); - GL.PixelTransferf = new GL.Delegates.PixelTransferf(Imports.PixelTransferf); - GL.PixelTransferi = new GL.Delegates.PixelTransferi(Imports.PixelTransferi); - GL.PixelStoref = new GL.Delegates.PixelStoref(Imports.PixelStoref); - GL.PixelStorei = new GL.Delegates.PixelStorei(Imports.PixelStorei); - GL.PixelMapfv = new GL.Delegates.PixelMapfv(Imports.PixelMapfv); - GL.PixelMapuiv = new GL.Delegates.PixelMapuiv(Imports.PixelMapuiv); - GL.PixelMapusv = new GL.Delegates.PixelMapusv(Imports.PixelMapusv); - GL.ReadBuffer = new GL.Delegates.ReadBuffer(Imports.ReadBuffer); - GL.CopyPixels = new GL.Delegates.CopyPixels(Imports.CopyPixels); - GL.ReadPixels = new GL.Delegates.ReadPixels(Imports.ReadPixels); - GL.DrawPixels = new GL.Delegates.DrawPixels(Imports.DrawPixels); - GL.GetBooleanv = new GL.Delegates.GetBooleanv(Imports.GetBooleanv); - GL.GetClipPlane = new GL.Delegates.GetClipPlane(Imports.GetClipPlane); - GL.GetDoublev = new GL.Delegates.GetDoublev(Imports.GetDoublev); - GL.GetError = new GL.Delegates.GetError(Imports.GetError); - GL.GetFloatv = new GL.Delegates.GetFloatv(Imports.GetFloatv); - GL.GetIntegerv = new GL.Delegates.GetIntegerv(Imports.GetIntegerv); - GL.GetLightfv = new GL.Delegates.GetLightfv(Imports.GetLightfv); - GL.GetLightiv = new GL.Delegates.GetLightiv(Imports.GetLightiv); - GL.GetMapdv = new GL.Delegates.GetMapdv(Imports.GetMapdv); - GL.GetMapfv = new GL.Delegates.GetMapfv(Imports.GetMapfv); - GL.GetMapiv = new GL.Delegates.GetMapiv(Imports.GetMapiv); - GL.GetMaterialfv = new GL.Delegates.GetMaterialfv(Imports.GetMaterialfv); - GL.GetMaterialiv = new GL.Delegates.GetMaterialiv(Imports.GetMaterialiv); - GL.GetPixelMapfv = new GL.Delegates.GetPixelMapfv(Imports.GetPixelMapfv); - GL.GetPixelMapuiv = new GL.Delegates.GetPixelMapuiv(Imports.GetPixelMapuiv); - GL.GetPixelMapusv = new GL.Delegates.GetPixelMapusv(Imports.GetPixelMapusv); - GL.GetPolygonStipple = new GL.Delegates.GetPolygonStipple(Imports.GetPolygonStipple); - GL.GetString = new GL.Delegates.GetString(Imports.GetString); - GL.GetTexEnvfv = new GL.Delegates.GetTexEnvfv(Imports.GetTexEnvfv); - GL.GetTexEnviv = new GL.Delegates.GetTexEnviv(Imports.GetTexEnviv); - GL.GetTexGendv = new GL.Delegates.GetTexGendv(Imports.GetTexGendv); - GL.GetTexGenfv = new GL.Delegates.GetTexGenfv(Imports.GetTexGenfv); - GL.GetTexGeniv = new GL.Delegates.GetTexGeniv(Imports.GetTexGeniv); - GL.GetTexImage = new GL.Delegates.GetTexImage(Imports.GetTexImage); - GL.GetTexParameterfv = new GL.Delegates.GetTexParameterfv(Imports.GetTexParameterfv); - GL.GetTexParameteriv = new GL.Delegates.GetTexParameteriv(Imports.GetTexParameteriv); - GL.GetTexLevelParameterfv = new GL.Delegates.GetTexLevelParameterfv(Imports.GetTexLevelParameterfv); - GL.GetTexLevelParameteriv = new GL.Delegates.GetTexLevelParameteriv(Imports.GetTexLevelParameteriv); - GL.IsEnabled = new GL.Delegates.IsEnabled(Imports.IsEnabled); - GL.IsList = new GL.Delegates.IsList(Imports.IsList); - GL.DepthRange = new GL.Delegates.DepthRange(Imports.DepthRange); - GL.Frustum = new GL.Delegates.Frustum(Imports.Frustum); - GL.LoadIdentity = new GL.Delegates.LoadIdentity(Imports.LoadIdentity); - GL.LoadMatrixf = new GL.Delegates.LoadMatrixf(Imports.LoadMatrixf); - GL.LoadMatrixd = new GL.Delegates.LoadMatrixd(Imports.LoadMatrixd); - GL.MatrixMode = new GL.Delegates.MatrixMode(Imports.MatrixMode); - GL.MultMatrixf = new GL.Delegates.MultMatrixf(Imports.MultMatrixf); - GL.MultMatrixd = new GL.Delegates.MultMatrixd(Imports.MultMatrixd); - GL.Ortho = new GL.Delegates.Ortho(Imports.Ortho); - GL.PopMatrix = new GL.Delegates.PopMatrix(Imports.PopMatrix); - GL.PushMatrix = new GL.Delegates.PushMatrix(Imports.PushMatrix); - GL.Rotated = new GL.Delegates.Rotated(Imports.Rotated); - GL.Rotatef = new GL.Delegates.Rotatef(Imports.Rotatef); - GL.Scaled = new GL.Delegates.Scaled(Imports.Scaled); - GL.Scalef = new GL.Delegates.Scalef(Imports.Scalef); - GL.Translated = new GL.Delegates.Translated(Imports.Translated); - GL.Translatef = new GL.Delegates.Translatef(Imports.Translatef); - GL.Viewport = new GL.Delegates.Viewport(Imports.Viewport); - GL.ArrayElement = new GL.Delegates.ArrayElement(Imports.ArrayElement); - GL.ColorPointer = new GL.Delegates.ColorPointer(Imports.ColorPointer); - GL.DisableClientState = new GL.Delegates.DisableClientState(Imports.DisableClientState); - GL.DrawArrays = new GL.Delegates.DrawArrays(Imports.DrawArrays); - GL.DrawElements = new GL.Delegates.DrawElements(Imports.DrawElements); - GL.EdgeFlagPointer = new GL.Delegates.EdgeFlagPointer(Imports.EdgeFlagPointer); - GL.EnableClientState = new GL.Delegates.EnableClientState(Imports.EnableClientState); - GL.GetPointerv = new GL.Delegates.GetPointerv(Imports.GetPointerv); - GL.IndexPointer = new GL.Delegates.IndexPointer(Imports.IndexPointer); - GL.InterleavedArrays = new GL.Delegates.InterleavedArrays(Imports.InterleavedArrays); - GL.NormalPointer = new GL.Delegates.NormalPointer(Imports.NormalPointer); - GL.TexCoordPointer = new GL.Delegates.TexCoordPointer(Imports.TexCoordPointer); - GL.VertexPointer = new GL.Delegates.VertexPointer(Imports.VertexPointer); - GL.PolygonOffset = new GL.Delegates.PolygonOffset(Imports.PolygonOffset); - GL.CopyTexImage1D = new GL.Delegates.CopyTexImage1D(Imports.CopyTexImage1D); - GL.CopyTexImage2D = new GL.Delegates.CopyTexImage2D(Imports.CopyTexImage2D); - GL.CopyTexSubImage1D = new GL.Delegates.CopyTexSubImage1D(Imports.CopyTexSubImage1D); - GL.CopyTexSubImage2D = new GL.Delegates.CopyTexSubImage2D(Imports.CopyTexSubImage2D); - GL.TexSubImage1D = new GL.Delegates.TexSubImage1D(Imports.TexSubImage1D); - GL.TexSubImage2D = new GL.Delegates.TexSubImage2D(Imports.TexSubImage2D); - GL.AreTexturesResident = new GL.Delegates.AreTexturesResident(Imports.AreTexturesResident); - GL.BindTexture = new GL.Delegates.BindTexture(Imports.BindTexture); - GL.DeleteTextures = new GL.Delegates.DeleteTextures(Imports.DeleteTextures); - GL.GenTextures = new GL.Delegates.GenTextures(Imports.GenTextures); - GL.IsTexture = new GL.Delegates.IsTexture(Imports.IsTexture); - GL.PrioritizeTextures = new GL.Delegates.PrioritizeTextures(Imports.PrioritizeTextures); - GL.Indexub = new GL.Delegates.Indexub(Imports.Indexub); - GL.Indexubv = new GL.Delegates.Indexubv(Imports.Indexubv); - GL.PopClientAttrib = new GL.Delegates.PopClientAttrib(Imports.PopClientAttrib); - GL.PushClientAttrib = new GL.Delegates.PushClientAttrib(Imports.PushClientAttrib); - GL.BlendColor = new GL.Delegates.BlendColor(Imports.BlendColor); - GL.BlendEquation = new GL.Delegates.BlendEquation(Imports.BlendEquation); - GL.DrawRangeElements = new GL.Delegates.DrawRangeElements(Imports.DrawRangeElements); - GL.ColorTable = new GL.Delegates.ColorTable(Imports.ColorTable); - GL.ColorTableParameterfv = new GL.Delegates.ColorTableParameterfv(Imports.ColorTableParameterfv); - GL.ColorTableParameteriv = new GL.Delegates.ColorTableParameteriv(Imports.ColorTableParameteriv); - GL.CopyColorTable = new GL.Delegates.CopyColorTable(Imports.CopyColorTable); - GL.GetColorTable = new GL.Delegates.GetColorTable(Imports.GetColorTable); - GL.GetColorTableParameterfv = new GL.Delegates.GetColorTableParameterfv(Imports.GetColorTableParameterfv); - GL.GetColorTableParameteriv = new GL.Delegates.GetColorTableParameteriv(Imports.GetColorTableParameteriv); - GL.ColorSubTable = new GL.Delegates.ColorSubTable(Imports.ColorSubTable); - GL.CopyColorSubTable = new GL.Delegates.CopyColorSubTable(Imports.CopyColorSubTable); - GL.ConvolutionFilter1D = new GL.Delegates.ConvolutionFilter1D(Imports.ConvolutionFilter1D); - GL.ConvolutionFilter2D = new GL.Delegates.ConvolutionFilter2D(Imports.ConvolutionFilter2D); - GL.ConvolutionParameterf = new GL.Delegates.ConvolutionParameterf(Imports.ConvolutionParameterf); - GL.ConvolutionParameterfv = new GL.Delegates.ConvolutionParameterfv(Imports.ConvolutionParameterfv); - GL.ConvolutionParameteri = new GL.Delegates.ConvolutionParameteri(Imports.ConvolutionParameteri); - GL.ConvolutionParameteriv = new GL.Delegates.ConvolutionParameteriv(Imports.ConvolutionParameteriv); - GL.CopyConvolutionFilter1D = new GL.Delegates.CopyConvolutionFilter1D(Imports.CopyConvolutionFilter1D); - GL.CopyConvolutionFilter2D = new GL.Delegates.CopyConvolutionFilter2D(Imports.CopyConvolutionFilter2D); - GL.GetConvolutionFilter = new GL.Delegates.GetConvolutionFilter(Imports.GetConvolutionFilter); - GL.GetConvolutionParameterfv = new GL.Delegates.GetConvolutionParameterfv(Imports.GetConvolutionParameterfv); - GL.GetConvolutionParameteriv = new GL.Delegates.GetConvolutionParameteriv(Imports.GetConvolutionParameteriv); - GL.GetSeparableFilter = new GL.Delegates.GetSeparableFilter(Imports.GetSeparableFilter); - GL.SeparableFilter2D = new GL.Delegates.SeparableFilter2D(Imports.SeparableFilter2D); - GL.GetHistogram = new GL.Delegates.GetHistogram(Imports.GetHistogram); - GL.GetHistogramParameterfv = new GL.Delegates.GetHistogramParameterfv(Imports.GetHistogramParameterfv); - GL.GetHistogramParameteriv = new GL.Delegates.GetHistogramParameteriv(Imports.GetHistogramParameteriv); - GL.GetMinmax = new GL.Delegates.GetMinmax(Imports.GetMinmax); - GL.GetMinmaxParameterfv = new GL.Delegates.GetMinmaxParameterfv(Imports.GetMinmaxParameterfv); - GL.GetMinmaxParameteriv = new GL.Delegates.GetMinmaxParameteriv(Imports.GetMinmaxParameteriv); - GL.Histogram = new GL.Delegates.Histogram(Imports.Histogram); - GL.Minmax = new GL.Delegates.Minmax(Imports.Minmax); - GL.ResetHistogram = new GL.Delegates.ResetHistogram(Imports.ResetHistogram); - GL.ResetMinmax = new GL.Delegates.ResetMinmax(Imports.ResetMinmax); - GL.TexImage3D = new GL.Delegates.TexImage3D(Imports.TexImage3D); - GL.TexSubImage3D = new GL.Delegates.TexSubImage3D(Imports.TexSubImage3D); - GL.CopyTexSubImage3D = new GL.Delegates.CopyTexSubImage3D(Imports.CopyTexSubImage3D); - GL.ActiveTexture = new GL.Delegates.ActiveTexture(Imports.ActiveTexture); - GL.ClientActiveTexture = new GL.Delegates.ClientActiveTexture(Imports.ClientActiveTexture); - GL.MultiTexCoord1d = new GL.Delegates.MultiTexCoord1d(Imports.MultiTexCoord1d); - GL.MultiTexCoord1dv = new GL.Delegates.MultiTexCoord1dv(Imports.MultiTexCoord1dv); - GL.MultiTexCoord1f = new GL.Delegates.MultiTexCoord1f(Imports.MultiTexCoord1f); - GL.MultiTexCoord1fv = new GL.Delegates.MultiTexCoord1fv(Imports.MultiTexCoord1fv); - GL.MultiTexCoord1i = new GL.Delegates.MultiTexCoord1i(Imports.MultiTexCoord1i); - GL.MultiTexCoord1iv = new GL.Delegates.MultiTexCoord1iv(Imports.MultiTexCoord1iv); - GL.MultiTexCoord1s = new GL.Delegates.MultiTexCoord1s(Imports.MultiTexCoord1s); - GL.MultiTexCoord1sv = new GL.Delegates.MultiTexCoord1sv(Imports.MultiTexCoord1sv); - GL.MultiTexCoord2d = new GL.Delegates.MultiTexCoord2d(Imports.MultiTexCoord2d); - GL.MultiTexCoord2dv = new GL.Delegates.MultiTexCoord2dv(Imports.MultiTexCoord2dv); - GL.MultiTexCoord2f = new GL.Delegates.MultiTexCoord2f(Imports.MultiTexCoord2f); - GL.MultiTexCoord2fv = new GL.Delegates.MultiTexCoord2fv(Imports.MultiTexCoord2fv); - GL.MultiTexCoord2i = new GL.Delegates.MultiTexCoord2i(Imports.MultiTexCoord2i); - GL.MultiTexCoord2iv = new GL.Delegates.MultiTexCoord2iv(Imports.MultiTexCoord2iv); - GL.MultiTexCoord2s = new GL.Delegates.MultiTexCoord2s(Imports.MultiTexCoord2s); - GL.MultiTexCoord2sv = new GL.Delegates.MultiTexCoord2sv(Imports.MultiTexCoord2sv); - GL.MultiTexCoord3d = new GL.Delegates.MultiTexCoord3d(Imports.MultiTexCoord3d); - GL.MultiTexCoord3dv = new GL.Delegates.MultiTexCoord3dv(Imports.MultiTexCoord3dv); - GL.MultiTexCoord3f = new GL.Delegates.MultiTexCoord3f(Imports.MultiTexCoord3f); - GL.MultiTexCoord3fv = new GL.Delegates.MultiTexCoord3fv(Imports.MultiTexCoord3fv); - GL.MultiTexCoord3i = new GL.Delegates.MultiTexCoord3i(Imports.MultiTexCoord3i); - GL.MultiTexCoord3iv = new GL.Delegates.MultiTexCoord3iv(Imports.MultiTexCoord3iv); - GL.MultiTexCoord3s = new GL.Delegates.MultiTexCoord3s(Imports.MultiTexCoord3s); - GL.MultiTexCoord3sv = new GL.Delegates.MultiTexCoord3sv(Imports.MultiTexCoord3sv); - GL.MultiTexCoord4d = new GL.Delegates.MultiTexCoord4d(Imports.MultiTexCoord4d); - GL.MultiTexCoord4dv = new GL.Delegates.MultiTexCoord4dv(Imports.MultiTexCoord4dv); - GL.MultiTexCoord4f = new GL.Delegates.MultiTexCoord4f(Imports.MultiTexCoord4f); - GL.MultiTexCoord4fv = new GL.Delegates.MultiTexCoord4fv(Imports.MultiTexCoord4fv); - GL.MultiTexCoord4i = new GL.Delegates.MultiTexCoord4i(Imports.MultiTexCoord4i); - GL.MultiTexCoord4iv = new GL.Delegates.MultiTexCoord4iv(Imports.MultiTexCoord4iv); - GL.MultiTexCoord4s = new GL.Delegates.MultiTexCoord4s(Imports.MultiTexCoord4s); - GL.MultiTexCoord4sv = new GL.Delegates.MultiTexCoord4sv(Imports.MultiTexCoord4sv); - GL.LoadTransposeMatrixf = new GL.Delegates.LoadTransposeMatrixf(Imports.LoadTransposeMatrixf); - GL.LoadTransposeMatrixd = new GL.Delegates.LoadTransposeMatrixd(Imports.LoadTransposeMatrixd); - GL.MultTransposeMatrixf = new GL.Delegates.MultTransposeMatrixf(Imports.MultTransposeMatrixf); - GL.MultTransposeMatrixd = new GL.Delegates.MultTransposeMatrixd(Imports.MultTransposeMatrixd); - GL.SampleCoverage = new GL.Delegates.SampleCoverage(Imports.SampleCoverage); - GL.CompressedTexImage3D = new GL.Delegates.CompressedTexImage3D(Imports.CompressedTexImage3D); - GL.CompressedTexImage2D = new GL.Delegates.CompressedTexImage2D(Imports.CompressedTexImage2D); - GL.CompressedTexImage1D = new GL.Delegates.CompressedTexImage1D(Imports.CompressedTexImage1D); - GL.CompressedTexSubImage3D = new GL.Delegates.CompressedTexSubImage3D(Imports.CompressedTexSubImage3D); - GL.CompressedTexSubImage2D = new GL.Delegates.CompressedTexSubImage2D(Imports.CompressedTexSubImage2D); - GL.CompressedTexSubImage1D = new GL.Delegates.CompressedTexSubImage1D(Imports.CompressedTexSubImage1D); - GL.GetCompressedTexImage = new GL.Delegates.GetCompressedTexImage(Imports.GetCompressedTexImage); - GL.BlendFuncSeparate = new GL.Delegates.BlendFuncSeparate(Imports.BlendFuncSeparate); - GL.FogCoordf = new GL.Delegates.FogCoordf(Imports.FogCoordf); - GL.FogCoordfv = new GL.Delegates.FogCoordfv(Imports.FogCoordfv); - GL.FogCoordd = new GL.Delegates.FogCoordd(Imports.FogCoordd); - GL.FogCoorddv = new GL.Delegates.FogCoorddv(Imports.FogCoorddv); - GL.FogCoordPointer = new GL.Delegates.FogCoordPointer(Imports.FogCoordPointer); - GL.MultiDrawArrays = new GL.Delegates.MultiDrawArrays(Imports.MultiDrawArrays); - GL.MultiDrawElements = new GL.Delegates.MultiDrawElements(Imports.MultiDrawElements); - GL.PointParameterf = new GL.Delegates.PointParameterf(Imports.PointParameterf); - GL.PointParameterfv = new GL.Delegates.PointParameterfv(Imports.PointParameterfv); - GL.PointParameteri = new GL.Delegates.PointParameteri(Imports.PointParameteri); - GL.PointParameteriv = new GL.Delegates.PointParameteriv(Imports.PointParameteriv); - GL.SecondaryColor3b = new GL.Delegates.SecondaryColor3b(Imports.SecondaryColor3b); - GL.SecondaryColor3bv = new GL.Delegates.SecondaryColor3bv(Imports.SecondaryColor3bv); - GL.SecondaryColor3d = new GL.Delegates.SecondaryColor3d(Imports.SecondaryColor3d); - GL.SecondaryColor3dv = new GL.Delegates.SecondaryColor3dv(Imports.SecondaryColor3dv); - GL.SecondaryColor3f = new GL.Delegates.SecondaryColor3f(Imports.SecondaryColor3f); - GL.SecondaryColor3fv = new GL.Delegates.SecondaryColor3fv(Imports.SecondaryColor3fv); - GL.SecondaryColor3i = new GL.Delegates.SecondaryColor3i(Imports.SecondaryColor3i); - GL.SecondaryColor3iv = new GL.Delegates.SecondaryColor3iv(Imports.SecondaryColor3iv); - GL.SecondaryColor3s = new GL.Delegates.SecondaryColor3s(Imports.SecondaryColor3s); - GL.SecondaryColor3sv = new GL.Delegates.SecondaryColor3sv(Imports.SecondaryColor3sv); - GL.SecondaryColor3ub = new GL.Delegates.SecondaryColor3ub(Imports.SecondaryColor3ub); - GL.SecondaryColor3ubv = new GL.Delegates.SecondaryColor3ubv(Imports.SecondaryColor3ubv); - GL.SecondaryColor3ui = new GL.Delegates.SecondaryColor3ui(Imports.SecondaryColor3ui); - GL.SecondaryColor3uiv = new GL.Delegates.SecondaryColor3uiv(Imports.SecondaryColor3uiv); - GL.SecondaryColor3us = new GL.Delegates.SecondaryColor3us(Imports.SecondaryColor3us); - GL.SecondaryColor3usv = new GL.Delegates.SecondaryColor3usv(Imports.SecondaryColor3usv); - GL.SecondaryColorPointer = new GL.Delegates.SecondaryColorPointer(Imports.SecondaryColorPointer); - GL.WindowPos2d = new GL.Delegates.WindowPos2d(Imports.WindowPos2d); - GL.WindowPos2dv = new GL.Delegates.WindowPos2dv(Imports.WindowPos2dv); - GL.WindowPos2f = new GL.Delegates.WindowPos2f(Imports.WindowPos2f); - GL.WindowPos2fv = new GL.Delegates.WindowPos2fv(Imports.WindowPos2fv); - GL.WindowPos2i = new GL.Delegates.WindowPos2i(Imports.WindowPos2i); - GL.WindowPos2iv = new GL.Delegates.WindowPos2iv(Imports.WindowPos2iv); - GL.WindowPos2s = new GL.Delegates.WindowPos2s(Imports.WindowPos2s); - GL.WindowPos2sv = new GL.Delegates.WindowPos2sv(Imports.WindowPos2sv); - GL.WindowPos3d = new GL.Delegates.WindowPos3d(Imports.WindowPos3d); - GL.WindowPos3dv = new GL.Delegates.WindowPos3dv(Imports.WindowPos3dv); - GL.WindowPos3f = new GL.Delegates.WindowPos3f(Imports.WindowPos3f); - GL.WindowPos3fv = new GL.Delegates.WindowPos3fv(Imports.WindowPos3fv); - GL.WindowPos3i = new GL.Delegates.WindowPos3i(Imports.WindowPos3i); - GL.WindowPos3iv = new GL.Delegates.WindowPos3iv(Imports.WindowPos3iv); - GL.WindowPos3s = new GL.Delegates.WindowPos3s(Imports.WindowPos3s); - GL.WindowPos3sv = new GL.Delegates.WindowPos3sv(Imports.WindowPos3sv); - GL.GenQueries = new GL.Delegates.GenQueries(Imports.GenQueries); - GL.DeleteQueries = new GL.Delegates.DeleteQueries(Imports.DeleteQueries); - GL.IsQuery = new GL.Delegates.IsQuery(Imports.IsQuery); - GL.BeginQuery = new GL.Delegates.BeginQuery(Imports.BeginQuery); - GL.EndQuery = new GL.Delegates.EndQuery(Imports.EndQuery); - GL.GetQueryiv = new GL.Delegates.GetQueryiv(Imports.GetQueryiv); - GL.GetQueryObjectiv = new GL.Delegates.GetQueryObjectiv(Imports.GetQueryObjectiv); - GL.GetQueryObjectuiv = new GL.Delegates.GetQueryObjectuiv(Imports.GetQueryObjectuiv); - GL.BindBuffer = new GL.Delegates.BindBuffer(Imports.BindBuffer); - GL.DeleteBuffers = new GL.Delegates.DeleteBuffers(Imports.DeleteBuffers); - GL.GenBuffers = new GL.Delegates.GenBuffers(Imports.GenBuffers); - GL.IsBuffer = new GL.Delegates.IsBuffer(Imports.IsBuffer); - GL.BufferData = new GL.Delegates.BufferData(Imports.BufferData); - GL.BufferSubData = new GL.Delegates.BufferSubData(Imports.BufferSubData); - GL.GetBufferSubData = new GL.Delegates.GetBufferSubData(Imports.GetBufferSubData); - GL.MapBuffer_ = new GL.Delegates.MapBuffer_(Imports.MapBuffer_); - GL.UnmapBuffer = new GL.Delegates.UnmapBuffer(Imports.UnmapBuffer); - GL.GetBufferParameteriv = new GL.Delegates.GetBufferParameteriv(Imports.GetBufferParameteriv); - GL.GetBufferPointerv = new GL.Delegates.GetBufferPointerv(Imports.GetBufferPointerv); - GL.BlendEquationSeparate = new GL.Delegates.BlendEquationSeparate(Imports.BlendEquationSeparate); - GL.DrawBuffers = new GL.Delegates.DrawBuffers(Imports.DrawBuffers); - GL.StencilOpSeparate = new GL.Delegates.StencilOpSeparate(Imports.StencilOpSeparate); - GL.StencilFuncSeparate = new GL.Delegates.StencilFuncSeparate(Imports.StencilFuncSeparate); - GL.StencilMaskSeparate = new GL.Delegates.StencilMaskSeparate(Imports.StencilMaskSeparate); - GL.AttachShader = new GL.Delegates.AttachShader(Imports.AttachShader); - GL.BindAttribLocation = new GL.Delegates.BindAttribLocation(Imports.BindAttribLocation); - GL.CompileShader = new GL.Delegates.CompileShader(Imports.CompileShader); - GL.CreateProgram = new GL.Delegates.CreateProgram(Imports.CreateProgram); - GL.CreateShader = new GL.Delegates.CreateShader(Imports.CreateShader); - GL.DeleteProgram = new GL.Delegates.DeleteProgram(Imports.DeleteProgram); - GL.DeleteShader = new GL.Delegates.DeleteShader(Imports.DeleteShader); - GL.DetachShader = new GL.Delegates.DetachShader(Imports.DetachShader); - GL.DisableVertexAttribArray = new GL.Delegates.DisableVertexAttribArray(Imports.DisableVertexAttribArray); - GL.EnableVertexAttribArray = new GL.Delegates.EnableVertexAttribArray(Imports.EnableVertexAttribArray); - GL.GetActiveAttrib = new GL.Delegates.GetActiveAttrib(Imports.GetActiveAttrib); - GL.GetActiveUniform = new GL.Delegates.GetActiveUniform(Imports.GetActiveUniform); - GL.GetAttachedShaders = new GL.Delegates.GetAttachedShaders(Imports.GetAttachedShaders); - GL.GetAttribLocation = new GL.Delegates.GetAttribLocation(Imports.GetAttribLocation); - GL.GetProgramiv = new GL.Delegates.GetProgramiv(Imports.GetProgramiv); - GL.GetProgramInfoLog = new GL.Delegates.GetProgramInfoLog(Imports.GetProgramInfoLog); - GL.GetShaderiv = new GL.Delegates.GetShaderiv(Imports.GetShaderiv); - GL.GetShaderInfoLog = new GL.Delegates.GetShaderInfoLog(Imports.GetShaderInfoLog); - GL.GetShaderSource = new GL.Delegates.GetShaderSource(Imports.GetShaderSource); - GL.GetUniformLocation = new GL.Delegates.GetUniformLocation(Imports.GetUniformLocation); - GL.GetUniformfv = new GL.Delegates.GetUniformfv(Imports.GetUniformfv); - GL.GetUniformiv = new GL.Delegates.GetUniformiv(Imports.GetUniformiv); - GL.GetVertexAttribdv = new GL.Delegates.GetVertexAttribdv(Imports.GetVertexAttribdv); - GL.GetVertexAttribfv = new GL.Delegates.GetVertexAttribfv(Imports.GetVertexAttribfv); - GL.GetVertexAttribiv = new GL.Delegates.GetVertexAttribiv(Imports.GetVertexAttribiv); - GL.GetVertexAttribPointerv = new GL.Delegates.GetVertexAttribPointerv(Imports.GetVertexAttribPointerv); - GL.IsProgram = new GL.Delegates.IsProgram(Imports.IsProgram); - GL.IsShader = new GL.Delegates.IsShader(Imports.IsShader); - GL.LinkProgram = new GL.Delegates.LinkProgram(Imports.LinkProgram); - GL.ShaderSource = new GL.Delegates.ShaderSource(Imports.ShaderSource); - GL.UseProgram = new GL.Delegates.UseProgram(Imports.UseProgram); - GL.Uniform1f = new GL.Delegates.Uniform1f(Imports.Uniform1f); - GL.Uniform2f = new GL.Delegates.Uniform2f(Imports.Uniform2f); - GL.Uniform3f = new GL.Delegates.Uniform3f(Imports.Uniform3f); - GL.Uniform4f = new GL.Delegates.Uniform4f(Imports.Uniform4f); - GL.Uniform1i = new GL.Delegates.Uniform1i(Imports.Uniform1i); - GL.Uniform2i = new GL.Delegates.Uniform2i(Imports.Uniform2i); - GL.Uniform3i = new GL.Delegates.Uniform3i(Imports.Uniform3i); - GL.Uniform4i = new GL.Delegates.Uniform4i(Imports.Uniform4i); - GL.Uniform1fv = new GL.Delegates.Uniform1fv(Imports.Uniform1fv); - GL.Uniform2fv = new GL.Delegates.Uniform2fv(Imports.Uniform2fv); - GL.Uniform3fv = new GL.Delegates.Uniform3fv(Imports.Uniform3fv); - GL.Uniform4fv = new GL.Delegates.Uniform4fv(Imports.Uniform4fv); - GL.Uniform1iv = new GL.Delegates.Uniform1iv(Imports.Uniform1iv); - GL.Uniform2iv = new GL.Delegates.Uniform2iv(Imports.Uniform2iv); - GL.Uniform3iv = new GL.Delegates.Uniform3iv(Imports.Uniform3iv); - GL.Uniform4iv = new GL.Delegates.Uniform4iv(Imports.Uniform4iv); - GL.UniformMatrix2fv = new GL.Delegates.UniformMatrix2fv(Imports.UniformMatrix2fv); - GL.UniformMatrix3fv = new GL.Delegates.UniformMatrix3fv(Imports.UniformMatrix3fv); - GL.UniformMatrix4fv = new GL.Delegates.UniformMatrix4fv(Imports.UniformMatrix4fv); - GL.ValidateProgram = new GL.Delegates.ValidateProgram(Imports.ValidateProgram); - GL.VertexAttrib1d = new GL.Delegates.VertexAttrib1d(Imports.VertexAttrib1d); - GL.VertexAttrib1dv = new GL.Delegates.VertexAttrib1dv(Imports.VertexAttrib1dv); - GL.VertexAttrib1f = new GL.Delegates.VertexAttrib1f(Imports.VertexAttrib1f); - GL.VertexAttrib1fv = new GL.Delegates.VertexAttrib1fv(Imports.VertexAttrib1fv); - GL.VertexAttrib1s = new GL.Delegates.VertexAttrib1s(Imports.VertexAttrib1s); - GL.VertexAttrib1sv = new GL.Delegates.VertexAttrib1sv(Imports.VertexAttrib1sv); - GL.VertexAttrib2d = new GL.Delegates.VertexAttrib2d(Imports.VertexAttrib2d); - GL.VertexAttrib2dv = new GL.Delegates.VertexAttrib2dv(Imports.VertexAttrib2dv); - GL.VertexAttrib2f = new GL.Delegates.VertexAttrib2f(Imports.VertexAttrib2f); - GL.VertexAttrib2fv = new GL.Delegates.VertexAttrib2fv(Imports.VertexAttrib2fv); - GL.VertexAttrib2s = new GL.Delegates.VertexAttrib2s(Imports.VertexAttrib2s); - GL.VertexAttrib2sv = new GL.Delegates.VertexAttrib2sv(Imports.VertexAttrib2sv); - GL.VertexAttrib3d = new GL.Delegates.VertexAttrib3d(Imports.VertexAttrib3d); - GL.VertexAttrib3dv = new GL.Delegates.VertexAttrib3dv(Imports.VertexAttrib3dv); - GL.VertexAttrib3f = new GL.Delegates.VertexAttrib3f(Imports.VertexAttrib3f); - GL.VertexAttrib3fv = new GL.Delegates.VertexAttrib3fv(Imports.VertexAttrib3fv); - GL.VertexAttrib3s = new GL.Delegates.VertexAttrib3s(Imports.VertexAttrib3s); - GL.VertexAttrib3sv = new GL.Delegates.VertexAttrib3sv(Imports.VertexAttrib3sv); - GL.VertexAttrib4Nbv = new GL.Delegates.VertexAttrib4Nbv(Imports.VertexAttrib4Nbv); - GL.VertexAttrib4Niv = new GL.Delegates.VertexAttrib4Niv(Imports.VertexAttrib4Niv); - GL.VertexAttrib4Nsv = new GL.Delegates.VertexAttrib4Nsv(Imports.VertexAttrib4Nsv); - GL.VertexAttrib4Nub = new GL.Delegates.VertexAttrib4Nub(Imports.VertexAttrib4Nub); - GL.VertexAttrib4Nubv = new GL.Delegates.VertexAttrib4Nubv(Imports.VertexAttrib4Nubv); - GL.VertexAttrib4Nuiv = new GL.Delegates.VertexAttrib4Nuiv(Imports.VertexAttrib4Nuiv); - GL.VertexAttrib4Nusv = new GL.Delegates.VertexAttrib4Nusv(Imports.VertexAttrib4Nusv); - GL.VertexAttrib4bv = new GL.Delegates.VertexAttrib4bv(Imports.VertexAttrib4bv); - GL.VertexAttrib4d = new GL.Delegates.VertexAttrib4d(Imports.VertexAttrib4d); - GL.VertexAttrib4dv = new GL.Delegates.VertexAttrib4dv(Imports.VertexAttrib4dv); - GL.VertexAttrib4f = new GL.Delegates.VertexAttrib4f(Imports.VertexAttrib4f); - GL.VertexAttrib4fv = new GL.Delegates.VertexAttrib4fv(Imports.VertexAttrib4fv); - GL.VertexAttrib4iv = new GL.Delegates.VertexAttrib4iv(Imports.VertexAttrib4iv); - GL.VertexAttrib4s = new GL.Delegates.VertexAttrib4s(Imports.VertexAttrib4s); - GL.VertexAttrib4sv = new GL.Delegates.VertexAttrib4sv(Imports.VertexAttrib4sv); - GL.VertexAttrib4ubv = new GL.Delegates.VertexAttrib4ubv(Imports.VertexAttrib4ubv); - GL.VertexAttrib4uiv = new GL.Delegates.VertexAttrib4uiv(Imports.VertexAttrib4uiv); - GL.VertexAttrib4usv = new GL.Delegates.VertexAttrib4usv(Imports.VertexAttrib4usv); - GL.VertexAttribPointer = new GL.Delegates.VertexAttribPointer(Imports.VertexAttribPointer); - CoreLoaded = true; + base.Load(); + GL.NewList = new GL.Delegates.NewList(GL.Imports.NewList); + GL.EndList = new GL.Delegates.EndList(GL.Imports.EndList); + GL.CallList = new GL.Delegates.CallList(GL.Imports.CallList); + GL.CallLists_ = new GL.Delegates.CallLists_(GL.Imports.CallLists_); + GL.DeleteLists = new GL.Delegates.DeleteLists(GL.Imports.DeleteLists); + GL.GenLists = new GL.Delegates.GenLists(GL.Imports.GenLists); + GL.ListBase = new GL.Delegates.ListBase(GL.Imports.ListBase); + GL.Begin = new GL.Delegates.Begin(GL.Imports.Begin); + GL.Bitmap = new GL.Delegates.Bitmap(GL.Imports.Bitmap); + GL.Color3b = new GL.Delegates.Color3b(GL.Imports.Color3b); + GL.Color3bv = new GL.Delegates.Color3bv(GL.Imports.Color3bv); + GL.Color3d = new GL.Delegates.Color3d(GL.Imports.Color3d); + GL.Color3dv = new GL.Delegates.Color3dv(GL.Imports.Color3dv); + GL.Color3f = new GL.Delegates.Color3f(GL.Imports.Color3f); + GL.Color3fv = new GL.Delegates.Color3fv(GL.Imports.Color3fv); + GL.Color3i = new GL.Delegates.Color3i(GL.Imports.Color3i); + GL.Color3iv = new GL.Delegates.Color3iv(GL.Imports.Color3iv); + GL.Color3s = new GL.Delegates.Color3s(GL.Imports.Color3s); + GL.Color3sv = new GL.Delegates.Color3sv(GL.Imports.Color3sv); + GL.Color3ub = new GL.Delegates.Color3ub(GL.Imports.Color3ub); + GL.Color3ubv = new GL.Delegates.Color3ubv(GL.Imports.Color3ubv); + GL.Color3ui = new GL.Delegates.Color3ui(GL.Imports.Color3ui); + GL.Color3uiv = new GL.Delegates.Color3uiv(GL.Imports.Color3uiv); + GL.Color3us = new GL.Delegates.Color3us(GL.Imports.Color3us); + GL.Color3usv = new GL.Delegates.Color3usv(GL.Imports.Color3usv); + GL.Color4b = new GL.Delegates.Color4b(GL.Imports.Color4b); + GL.Color4bv = new GL.Delegates.Color4bv(GL.Imports.Color4bv); + GL.Color4d = new GL.Delegates.Color4d(GL.Imports.Color4d); + GL.Color4dv = new GL.Delegates.Color4dv(GL.Imports.Color4dv); + GL.Color4f = new GL.Delegates.Color4f(GL.Imports.Color4f); + GL.Color4fv = new GL.Delegates.Color4fv(GL.Imports.Color4fv); + GL.Color4i = new GL.Delegates.Color4i(GL.Imports.Color4i); + GL.Color4iv = new GL.Delegates.Color4iv(GL.Imports.Color4iv); + GL.Color4s = new GL.Delegates.Color4s(GL.Imports.Color4s); + GL.Color4sv = new GL.Delegates.Color4sv(GL.Imports.Color4sv); + GL.Color4ub = new GL.Delegates.Color4ub(GL.Imports.Color4ub); + GL.Color4ubv = new GL.Delegates.Color4ubv(GL.Imports.Color4ubv); + GL.Color4ui = new GL.Delegates.Color4ui(GL.Imports.Color4ui); + GL.Color4uiv = new GL.Delegates.Color4uiv(GL.Imports.Color4uiv); + GL.Color4us = new GL.Delegates.Color4us(GL.Imports.Color4us); + GL.Color4usv = new GL.Delegates.Color4usv(GL.Imports.Color4usv); + GL.EdgeFlag = new GL.Delegates.EdgeFlag(GL.Imports.EdgeFlag); + GL.EdgeFlagv = new GL.Delegates.EdgeFlagv(GL.Imports.EdgeFlagv); + GL.End = new GL.Delegates.End(GL.Imports.End); + GL.Indexd = new GL.Delegates.Indexd(GL.Imports.Indexd); + GL.Indexdv = new GL.Delegates.Indexdv(GL.Imports.Indexdv); + GL.Indexf = new GL.Delegates.Indexf(GL.Imports.Indexf); + GL.Indexfv = new GL.Delegates.Indexfv(GL.Imports.Indexfv); + GL.Indexi = new GL.Delegates.Indexi(GL.Imports.Indexi); + GL.Indexiv = new GL.Delegates.Indexiv(GL.Imports.Indexiv); + GL.Indexs = new GL.Delegates.Indexs(GL.Imports.Indexs); + GL.Indexsv = new GL.Delegates.Indexsv(GL.Imports.Indexsv); + GL.Normal3b = new GL.Delegates.Normal3b(GL.Imports.Normal3b); + GL.Normal3bv = new GL.Delegates.Normal3bv(GL.Imports.Normal3bv); + GL.Normal3d = new GL.Delegates.Normal3d(GL.Imports.Normal3d); + GL.Normal3dv = new GL.Delegates.Normal3dv(GL.Imports.Normal3dv); + GL.Normal3f = new GL.Delegates.Normal3f(GL.Imports.Normal3f); + GL.Normal3fv = new GL.Delegates.Normal3fv(GL.Imports.Normal3fv); + GL.Normal3i = new GL.Delegates.Normal3i(GL.Imports.Normal3i); + GL.Normal3iv = new GL.Delegates.Normal3iv(GL.Imports.Normal3iv); + GL.Normal3s = new GL.Delegates.Normal3s(GL.Imports.Normal3s); + GL.Normal3sv = new GL.Delegates.Normal3sv(GL.Imports.Normal3sv); + GL.RasterPos2d = new GL.Delegates.RasterPos2d(GL.Imports.RasterPos2d); + GL.RasterPos2dv = new GL.Delegates.RasterPos2dv(GL.Imports.RasterPos2dv); + GL.RasterPos2f = new GL.Delegates.RasterPos2f(GL.Imports.RasterPos2f); + GL.RasterPos2fv = new GL.Delegates.RasterPos2fv(GL.Imports.RasterPos2fv); + GL.RasterPos2i = new GL.Delegates.RasterPos2i(GL.Imports.RasterPos2i); + GL.RasterPos2iv = new GL.Delegates.RasterPos2iv(GL.Imports.RasterPos2iv); + GL.RasterPos2s = new GL.Delegates.RasterPos2s(GL.Imports.RasterPos2s); + GL.RasterPos2sv = new GL.Delegates.RasterPos2sv(GL.Imports.RasterPos2sv); + GL.RasterPos3d = new GL.Delegates.RasterPos3d(GL.Imports.RasterPos3d); + GL.RasterPos3dv = new GL.Delegates.RasterPos3dv(GL.Imports.RasterPos3dv); + GL.RasterPos3f = new GL.Delegates.RasterPos3f(GL.Imports.RasterPos3f); + GL.RasterPos3fv = new GL.Delegates.RasterPos3fv(GL.Imports.RasterPos3fv); + GL.RasterPos3i = new GL.Delegates.RasterPos3i(GL.Imports.RasterPos3i); + GL.RasterPos3iv = new GL.Delegates.RasterPos3iv(GL.Imports.RasterPos3iv); + GL.RasterPos3s = new GL.Delegates.RasterPos3s(GL.Imports.RasterPos3s); + GL.RasterPos3sv = new GL.Delegates.RasterPos3sv(GL.Imports.RasterPos3sv); + GL.RasterPos4d = new GL.Delegates.RasterPos4d(GL.Imports.RasterPos4d); + GL.RasterPos4dv = new GL.Delegates.RasterPos4dv(GL.Imports.RasterPos4dv); + GL.RasterPos4f = new GL.Delegates.RasterPos4f(GL.Imports.RasterPos4f); + GL.RasterPos4fv = new GL.Delegates.RasterPos4fv(GL.Imports.RasterPos4fv); + GL.RasterPos4i = new GL.Delegates.RasterPos4i(GL.Imports.RasterPos4i); + GL.RasterPos4iv = new GL.Delegates.RasterPos4iv(GL.Imports.RasterPos4iv); + GL.RasterPos4s = new GL.Delegates.RasterPos4s(GL.Imports.RasterPos4s); + GL.RasterPos4sv = new GL.Delegates.RasterPos4sv(GL.Imports.RasterPos4sv); + GL.Rectd = new GL.Delegates.Rectd(GL.Imports.Rectd); + GL.Rectdv = new GL.Delegates.Rectdv(GL.Imports.Rectdv); + GL.Rectf = new GL.Delegates.Rectf(GL.Imports.Rectf); + GL.Rectfv = new GL.Delegates.Rectfv(GL.Imports.Rectfv); + GL.Recti = new GL.Delegates.Recti(GL.Imports.Recti); + GL.Rectiv = new GL.Delegates.Rectiv(GL.Imports.Rectiv); + GL.Rects = new GL.Delegates.Rects(GL.Imports.Rects); + GL.Rectsv = new GL.Delegates.Rectsv(GL.Imports.Rectsv); + GL.TexCoord1d = new GL.Delegates.TexCoord1d(GL.Imports.TexCoord1d); + GL.TexCoord1dv = new GL.Delegates.TexCoord1dv(GL.Imports.TexCoord1dv); + GL.TexCoord1f = new GL.Delegates.TexCoord1f(GL.Imports.TexCoord1f); + GL.TexCoord1fv = new GL.Delegates.TexCoord1fv(GL.Imports.TexCoord1fv); + GL.TexCoord1i = new GL.Delegates.TexCoord1i(GL.Imports.TexCoord1i); + GL.TexCoord1iv = new GL.Delegates.TexCoord1iv(GL.Imports.TexCoord1iv); + GL.TexCoord1s = new GL.Delegates.TexCoord1s(GL.Imports.TexCoord1s); + GL.TexCoord1sv = new GL.Delegates.TexCoord1sv(GL.Imports.TexCoord1sv); + GL.TexCoord2d = new GL.Delegates.TexCoord2d(GL.Imports.TexCoord2d); + GL.TexCoord2dv = new GL.Delegates.TexCoord2dv(GL.Imports.TexCoord2dv); + GL.TexCoord2f = new GL.Delegates.TexCoord2f(GL.Imports.TexCoord2f); + GL.TexCoord2fv = new GL.Delegates.TexCoord2fv(GL.Imports.TexCoord2fv); + GL.TexCoord2i = new GL.Delegates.TexCoord2i(GL.Imports.TexCoord2i); + GL.TexCoord2iv = new GL.Delegates.TexCoord2iv(GL.Imports.TexCoord2iv); + GL.TexCoord2s = new GL.Delegates.TexCoord2s(GL.Imports.TexCoord2s); + GL.TexCoord2sv = new GL.Delegates.TexCoord2sv(GL.Imports.TexCoord2sv); + GL.TexCoord3d = new GL.Delegates.TexCoord3d(GL.Imports.TexCoord3d); + GL.TexCoord3dv = new GL.Delegates.TexCoord3dv(GL.Imports.TexCoord3dv); + GL.TexCoord3f = new GL.Delegates.TexCoord3f(GL.Imports.TexCoord3f); + GL.TexCoord3fv = new GL.Delegates.TexCoord3fv(GL.Imports.TexCoord3fv); + GL.TexCoord3i = new GL.Delegates.TexCoord3i(GL.Imports.TexCoord3i); + GL.TexCoord3iv = new GL.Delegates.TexCoord3iv(GL.Imports.TexCoord3iv); + GL.TexCoord3s = new GL.Delegates.TexCoord3s(GL.Imports.TexCoord3s); + GL.TexCoord3sv = new GL.Delegates.TexCoord3sv(GL.Imports.TexCoord3sv); + GL.TexCoord4d = new GL.Delegates.TexCoord4d(GL.Imports.TexCoord4d); + GL.TexCoord4dv = new GL.Delegates.TexCoord4dv(GL.Imports.TexCoord4dv); + GL.TexCoord4f = new GL.Delegates.TexCoord4f(GL.Imports.TexCoord4f); + GL.TexCoord4fv = new GL.Delegates.TexCoord4fv(GL.Imports.TexCoord4fv); + GL.TexCoord4i = new GL.Delegates.TexCoord4i(GL.Imports.TexCoord4i); + GL.TexCoord4iv = new GL.Delegates.TexCoord4iv(GL.Imports.TexCoord4iv); + GL.TexCoord4s = new GL.Delegates.TexCoord4s(GL.Imports.TexCoord4s); + GL.TexCoord4sv = new GL.Delegates.TexCoord4sv(GL.Imports.TexCoord4sv); + GL.Vertex2d = new GL.Delegates.Vertex2d(GL.Imports.Vertex2d); + GL.Vertex2dv = new GL.Delegates.Vertex2dv(GL.Imports.Vertex2dv); + GL.Vertex2f = new GL.Delegates.Vertex2f(GL.Imports.Vertex2f); + GL.Vertex2fv = new GL.Delegates.Vertex2fv(GL.Imports.Vertex2fv); + GL.Vertex2i = new GL.Delegates.Vertex2i(GL.Imports.Vertex2i); + GL.Vertex2iv = new GL.Delegates.Vertex2iv(GL.Imports.Vertex2iv); + GL.Vertex2s = new GL.Delegates.Vertex2s(GL.Imports.Vertex2s); + GL.Vertex2sv = new GL.Delegates.Vertex2sv(GL.Imports.Vertex2sv); + GL.Vertex3d = new GL.Delegates.Vertex3d(GL.Imports.Vertex3d); + GL.Vertex3dv = new GL.Delegates.Vertex3dv(GL.Imports.Vertex3dv); + GL.Vertex3f = new GL.Delegates.Vertex3f(GL.Imports.Vertex3f); + GL.Vertex3fv = new GL.Delegates.Vertex3fv(GL.Imports.Vertex3fv); + GL.Vertex3i = new GL.Delegates.Vertex3i(GL.Imports.Vertex3i); + GL.Vertex3iv = new GL.Delegates.Vertex3iv(GL.Imports.Vertex3iv); + GL.Vertex3s = new GL.Delegates.Vertex3s(GL.Imports.Vertex3s); + GL.Vertex3sv = new GL.Delegates.Vertex3sv(GL.Imports.Vertex3sv); + GL.Vertex4d = new GL.Delegates.Vertex4d(GL.Imports.Vertex4d); + GL.Vertex4dv = new GL.Delegates.Vertex4dv(GL.Imports.Vertex4dv); + GL.Vertex4f = new GL.Delegates.Vertex4f(GL.Imports.Vertex4f); + GL.Vertex4fv = new GL.Delegates.Vertex4fv(GL.Imports.Vertex4fv); + GL.Vertex4i = new GL.Delegates.Vertex4i(GL.Imports.Vertex4i); + GL.Vertex4iv = new GL.Delegates.Vertex4iv(GL.Imports.Vertex4iv); + GL.Vertex4s = new GL.Delegates.Vertex4s(GL.Imports.Vertex4s); + GL.Vertex4sv = new GL.Delegates.Vertex4sv(GL.Imports.Vertex4sv); + GL.ClipPlane = new GL.Delegates.ClipPlane(GL.Imports.ClipPlane); + GL.ColorMaterial = new GL.Delegates.ColorMaterial(GL.Imports.ColorMaterial); + GL.CullFace = new GL.Delegates.CullFace(GL.Imports.CullFace); + GL.Fogf = new GL.Delegates.Fogf(GL.Imports.Fogf); + GL.Fogfv = new GL.Delegates.Fogfv(GL.Imports.Fogfv); + GL.Fogi = new GL.Delegates.Fogi(GL.Imports.Fogi); + GL.Fogiv = new GL.Delegates.Fogiv(GL.Imports.Fogiv); + GL.FrontFace = new GL.Delegates.FrontFace(GL.Imports.FrontFace); + GL.Hint = new GL.Delegates.Hint(GL.Imports.Hint); + GL.Lightf = new GL.Delegates.Lightf(GL.Imports.Lightf); + GL.Lightfv = new GL.Delegates.Lightfv(GL.Imports.Lightfv); + GL.Lighti = new GL.Delegates.Lighti(GL.Imports.Lighti); + GL.Lightiv = new GL.Delegates.Lightiv(GL.Imports.Lightiv); + GL.LightModelf = new GL.Delegates.LightModelf(GL.Imports.LightModelf); + GL.LightModelfv = new GL.Delegates.LightModelfv(GL.Imports.LightModelfv); + GL.LightModeli = new GL.Delegates.LightModeli(GL.Imports.LightModeli); + GL.LightModeliv = new GL.Delegates.LightModeliv(GL.Imports.LightModeliv); + GL.LineStipple = new GL.Delegates.LineStipple(GL.Imports.LineStipple); + GL.LineWidth = new GL.Delegates.LineWidth(GL.Imports.LineWidth); + GL.Materialf = new GL.Delegates.Materialf(GL.Imports.Materialf); + GL.Materialfv = new GL.Delegates.Materialfv(GL.Imports.Materialfv); + GL.Materiali = new GL.Delegates.Materiali(GL.Imports.Materiali); + GL.Materialiv = new GL.Delegates.Materialiv(GL.Imports.Materialiv); + GL.PointSize = new GL.Delegates.PointSize(GL.Imports.PointSize); + GL.PolygonMode = new GL.Delegates.PolygonMode(GL.Imports.PolygonMode); + GL.PolygonStipple = new GL.Delegates.PolygonStipple(GL.Imports.PolygonStipple); + GL.Scissor = new GL.Delegates.Scissor(GL.Imports.Scissor); + GL.ShadeModel = new GL.Delegates.ShadeModel(GL.Imports.ShadeModel); + GL.TexParameterf = new GL.Delegates.TexParameterf(GL.Imports.TexParameterf); + GL.TexParameterfv = new GL.Delegates.TexParameterfv(GL.Imports.TexParameterfv); + GL.TexParameteri = new GL.Delegates.TexParameteri(GL.Imports.TexParameteri); + GL.TexParameteriv = new GL.Delegates.TexParameteriv(GL.Imports.TexParameteriv); + GL.TexImage1D = new GL.Delegates.TexImage1D(GL.Imports.TexImage1D); + GL.TexImage2D = new GL.Delegates.TexImage2D(GL.Imports.TexImage2D); + GL.TexEnvf = new GL.Delegates.TexEnvf(GL.Imports.TexEnvf); + GL.TexEnvfv = new GL.Delegates.TexEnvfv(GL.Imports.TexEnvfv); + GL.TexEnvi = new GL.Delegates.TexEnvi(GL.Imports.TexEnvi); + GL.TexEnviv = new GL.Delegates.TexEnviv(GL.Imports.TexEnviv); + GL.TexGend = new GL.Delegates.TexGend(GL.Imports.TexGend); + GL.TexGendv = new GL.Delegates.TexGendv(GL.Imports.TexGendv); + GL.TexGenf = new GL.Delegates.TexGenf(GL.Imports.TexGenf); + GL.TexGenfv = new GL.Delegates.TexGenfv(GL.Imports.TexGenfv); + GL.TexGeni = new GL.Delegates.TexGeni(GL.Imports.TexGeni); + GL.TexGeniv = new GL.Delegates.TexGeniv(GL.Imports.TexGeniv); + GL.FeedbackBuffer = new GL.Delegates.FeedbackBuffer(GL.Imports.FeedbackBuffer); + GL.SelectBuffer = new GL.Delegates.SelectBuffer(GL.Imports.SelectBuffer); + GL.RenderMode = new GL.Delegates.RenderMode(GL.Imports.RenderMode); + GL.InitNames = new GL.Delegates.InitNames(GL.Imports.InitNames); + GL.LoadName = new GL.Delegates.LoadName(GL.Imports.LoadName); + GL.PassThrough = new GL.Delegates.PassThrough(GL.Imports.PassThrough); + GL.PopName = new GL.Delegates.PopName(GL.Imports.PopName); + GL.PushName = new GL.Delegates.PushName(GL.Imports.PushName); + GL.DrawBuffer = new GL.Delegates.DrawBuffer(GL.Imports.DrawBuffer); + GL.Clear = new GL.Delegates.Clear(GL.Imports.Clear); + GL.ClearAccum = new GL.Delegates.ClearAccum(GL.Imports.ClearAccum); + GL.ClearIndex = new GL.Delegates.ClearIndex(GL.Imports.ClearIndex); + GL.ClearColor = new GL.Delegates.ClearColor(GL.Imports.ClearColor); + GL.ClearStencil = new GL.Delegates.ClearStencil(GL.Imports.ClearStencil); + GL.ClearDepth = new GL.Delegates.ClearDepth(GL.Imports.ClearDepth); + GL.StencilMask = new GL.Delegates.StencilMask(GL.Imports.StencilMask); + GL.ColorMask = new GL.Delegates.ColorMask(GL.Imports.ColorMask); + GL.DepthMask = new GL.Delegates.DepthMask(GL.Imports.DepthMask); + GL.IndexMask = new GL.Delegates.IndexMask(GL.Imports.IndexMask); + GL.Accum = new GL.Delegates.Accum(GL.Imports.Accum); + GL.Disable = new GL.Delegates.Disable(GL.Imports.Disable); + GL.Enable = new GL.Delegates.Enable(GL.Imports.Enable); + GL.Finish = new GL.Delegates.Finish(GL.Imports.Finish); + GL.Flush = new GL.Delegates.Flush(GL.Imports.Flush); + GL.PopAttrib = new GL.Delegates.PopAttrib(GL.Imports.PopAttrib); + GL.PushAttrib = new GL.Delegates.PushAttrib(GL.Imports.PushAttrib); + GL.Map1d = new GL.Delegates.Map1d(GL.Imports.Map1d); + GL.Map1f = new GL.Delegates.Map1f(GL.Imports.Map1f); + GL.Map2d = new GL.Delegates.Map2d(GL.Imports.Map2d); + GL.Map2f = new GL.Delegates.Map2f(GL.Imports.Map2f); + GL.MapGrid1d = new GL.Delegates.MapGrid1d(GL.Imports.MapGrid1d); + GL.MapGrid1f = new GL.Delegates.MapGrid1f(GL.Imports.MapGrid1f); + GL.MapGrid2d = new GL.Delegates.MapGrid2d(GL.Imports.MapGrid2d); + GL.MapGrid2f = new GL.Delegates.MapGrid2f(GL.Imports.MapGrid2f); + GL.EvalCoord1d = new GL.Delegates.EvalCoord1d(GL.Imports.EvalCoord1d); + GL.EvalCoord1dv = new GL.Delegates.EvalCoord1dv(GL.Imports.EvalCoord1dv); + GL.EvalCoord1f = new GL.Delegates.EvalCoord1f(GL.Imports.EvalCoord1f); + GL.EvalCoord1fv = new GL.Delegates.EvalCoord1fv(GL.Imports.EvalCoord1fv); + GL.EvalCoord2d = new GL.Delegates.EvalCoord2d(GL.Imports.EvalCoord2d); + GL.EvalCoord2dv = new GL.Delegates.EvalCoord2dv(GL.Imports.EvalCoord2dv); + GL.EvalCoord2f = new GL.Delegates.EvalCoord2f(GL.Imports.EvalCoord2f); + GL.EvalCoord2fv = new GL.Delegates.EvalCoord2fv(GL.Imports.EvalCoord2fv); + GL.EvalMesh1 = new GL.Delegates.EvalMesh1(GL.Imports.EvalMesh1); + GL.EvalPoint1 = new GL.Delegates.EvalPoint1(GL.Imports.EvalPoint1); + GL.EvalMesh2 = new GL.Delegates.EvalMesh2(GL.Imports.EvalMesh2); + GL.EvalPoint2 = new GL.Delegates.EvalPoint2(GL.Imports.EvalPoint2); + GL.AlphaFunc = new GL.Delegates.AlphaFunc(GL.Imports.AlphaFunc); + GL.BlendFunc = new GL.Delegates.BlendFunc(GL.Imports.BlendFunc); + GL.LogicOp = new GL.Delegates.LogicOp(GL.Imports.LogicOp); + GL.StencilFunc = new GL.Delegates.StencilFunc(GL.Imports.StencilFunc); + GL.StencilOp = new GL.Delegates.StencilOp(GL.Imports.StencilOp); + GL.DepthFunc = new GL.Delegates.DepthFunc(GL.Imports.DepthFunc); + GL.PixelZoom = new GL.Delegates.PixelZoom(GL.Imports.PixelZoom); + GL.PixelTransferf = new GL.Delegates.PixelTransferf(GL.Imports.PixelTransferf); + GL.PixelTransferi = new GL.Delegates.PixelTransferi(GL.Imports.PixelTransferi); + GL.PixelStoref = new GL.Delegates.PixelStoref(GL.Imports.PixelStoref); + GL.PixelStorei = new GL.Delegates.PixelStorei(GL.Imports.PixelStorei); + GL.PixelMapfv = new GL.Delegates.PixelMapfv(GL.Imports.PixelMapfv); + GL.PixelMapuiv = new GL.Delegates.PixelMapuiv(GL.Imports.PixelMapuiv); + GL.PixelMapusv = new GL.Delegates.PixelMapusv(GL.Imports.PixelMapusv); + GL.ReadBuffer = new GL.Delegates.ReadBuffer(GL.Imports.ReadBuffer); + GL.CopyPixels = new GL.Delegates.CopyPixels(GL.Imports.CopyPixels); + GL.ReadPixels_ = new GL.Delegates.ReadPixels_(GL.Imports.ReadPixels_); + GL.DrawPixels_ = new GL.Delegates.DrawPixels_(GL.Imports.DrawPixels_); + GL.GetBooleanv = new GL.Delegates.GetBooleanv(GL.Imports.GetBooleanv); + GL.GetClipPlane = new GL.Delegates.GetClipPlane(GL.Imports.GetClipPlane); + GL.GetDoublev = new GL.Delegates.GetDoublev(GL.Imports.GetDoublev); + GL.GetError = new GL.Delegates.GetError(GL.Imports.GetError); + GL.GetFloatv = new GL.Delegates.GetFloatv(GL.Imports.GetFloatv); + GL.GetIntegerv = new GL.Delegates.GetIntegerv(GL.Imports.GetIntegerv); + GL.GetLightfv = new GL.Delegates.GetLightfv(GL.Imports.GetLightfv); + GL.GetLightiv = new GL.Delegates.GetLightiv(GL.Imports.GetLightiv); + GL.GetMapdv = new GL.Delegates.GetMapdv(GL.Imports.GetMapdv); + GL.GetMapfv = new GL.Delegates.GetMapfv(GL.Imports.GetMapfv); + GL.GetMapiv = new GL.Delegates.GetMapiv(GL.Imports.GetMapiv); + GL.GetMaterialfv = new GL.Delegates.GetMaterialfv(GL.Imports.GetMaterialfv); + GL.GetMaterialiv = new GL.Delegates.GetMaterialiv(GL.Imports.GetMaterialiv); + GL.GetPixelMapfv = new GL.Delegates.GetPixelMapfv(GL.Imports.GetPixelMapfv); + GL.GetPixelMapuiv = new GL.Delegates.GetPixelMapuiv(GL.Imports.GetPixelMapuiv); + GL.GetPixelMapusv = new GL.Delegates.GetPixelMapusv(GL.Imports.GetPixelMapusv); + GL.GetPolygonStipple = new GL.Delegates.GetPolygonStipple(GL.Imports.GetPolygonStipple); + GL.GetString = new GL.Delegates.GetString(GL.Imports.GetString); + GL.GetTexEnvfv = new GL.Delegates.GetTexEnvfv(GL.Imports.GetTexEnvfv); + GL.GetTexEnviv = new GL.Delegates.GetTexEnviv(GL.Imports.GetTexEnviv); + GL.GetTexGendv = new GL.Delegates.GetTexGendv(GL.Imports.GetTexGendv); + GL.GetTexGenfv = new GL.Delegates.GetTexGenfv(GL.Imports.GetTexGenfv); + GL.GetTexGeniv = new GL.Delegates.GetTexGeniv(GL.Imports.GetTexGeniv); + GL.GetTexImage = new GL.Delegates.GetTexImage(GL.Imports.GetTexImage); + GL.GetTexParameterfv = new GL.Delegates.GetTexParameterfv(GL.Imports.GetTexParameterfv); + GL.GetTexParameteriv = new GL.Delegates.GetTexParameteriv(GL.Imports.GetTexParameteriv); + GL.GetTexLevelParameterfv = new GL.Delegates.GetTexLevelParameterfv(GL.Imports.GetTexLevelParameterfv); + GL.GetTexLevelParameteriv = new GL.Delegates.GetTexLevelParameteriv(GL.Imports.GetTexLevelParameteriv); + GL.IsEnabled = new GL.Delegates.IsEnabled(GL.Imports.IsEnabled); + GL.IsList = new GL.Delegates.IsList(GL.Imports.IsList); + GL.DepthRange = new GL.Delegates.DepthRange(GL.Imports.DepthRange); + GL.Frustum = new GL.Delegates.Frustum(GL.Imports.Frustum); + GL.LoadIdentity = new GL.Delegates.LoadIdentity(GL.Imports.LoadIdentity); + GL.LoadMatrixf = new GL.Delegates.LoadMatrixf(GL.Imports.LoadMatrixf); + GL.LoadMatrixd = new GL.Delegates.LoadMatrixd(GL.Imports.LoadMatrixd); + GL.MatrixMode = new GL.Delegates.MatrixMode(GL.Imports.MatrixMode); + GL.MultMatrixf = new GL.Delegates.MultMatrixf(GL.Imports.MultMatrixf); + GL.MultMatrixd = new GL.Delegates.MultMatrixd(GL.Imports.MultMatrixd); + GL.Ortho = new GL.Delegates.Ortho(GL.Imports.Ortho); + GL.PopMatrix = new GL.Delegates.PopMatrix(GL.Imports.PopMatrix); + GL.PushMatrix = new GL.Delegates.PushMatrix(GL.Imports.PushMatrix); + GL.Rotated = new GL.Delegates.Rotated(GL.Imports.Rotated); + GL.Rotatef = new GL.Delegates.Rotatef(GL.Imports.Rotatef); + GL.Scaled = new GL.Delegates.Scaled(GL.Imports.Scaled); + GL.Scalef = new GL.Delegates.Scalef(GL.Imports.Scalef); + GL.Translated = new GL.Delegates.Translated(GL.Imports.Translated); + GL.Translatef = new GL.Delegates.Translatef(GL.Imports.Translatef); + GL.Viewport = new GL.Delegates.Viewport(GL.Imports.Viewport); + GL.ArrayElement = new GL.Delegates.ArrayElement(GL.Imports.ArrayElement); + GL.ColorPointer_ = new GL.Delegates.ColorPointer_(GL.Imports.ColorPointer_); + GL.DisableClientState = new GL.Delegates.DisableClientState(GL.Imports.DisableClientState); + GL.DrawArrays = new GL.Delegates.DrawArrays(GL.Imports.DrawArrays); + GL.DrawElements_ = new GL.Delegates.DrawElements_(GL.Imports.DrawElements_); + GL.EdgeFlagPointer_ = new GL.Delegates.EdgeFlagPointer_(GL.Imports.EdgeFlagPointer_); + GL.EnableClientState = new GL.Delegates.EnableClientState(GL.Imports.EnableClientState); + GL.GetPointerv = new GL.Delegates.GetPointerv(GL.Imports.GetPointerv); + GL.IndexPointer_ = new GL.Delegates.IndexPointer_(GL.Imports.IndexPointer_); + GL.InterleavedArrays_ = new GL.Delegates.InterleavedArrays_(GL.Imports.InterleavedArrays_); + GL.NormalPointer_ = new GL.Delegates.NormalPointer_(GL.Imports.NormalPointer_); + GL.TexCoordPointer_ = new GL.Delegates.TexCoordPointer_(GL.Imports.TexCoordPointer_); + GL.VertexPointer_ = new GL.Delegates.VertexPointer_(GL.Imports.VertexPointer_); + GL.PolygonOffset = new GL.Delegates.PolygonOffset(GL.Imports.PolygonOffset); + GL.CopyTexImage1D = new GL.Delegates.CopyTexImage1D(GL.Imports.CopyTexImage1D); + GL.CopyTexImage2D = new GL.Delegates.CopyTexImage2D(GL.Imports.CopyTexImage2D); + GL.CopyTexSubImage1D = new GL.Delegates.CopyTexSubImage1D(GL.Imports.CopyTexSubImage1D); + GL.CopyTexSubImage2D = new GL.Delegates.CopyTexSubImage2D(GL.Imports.CopyTexSubImage2D); + GL.TexSubImage1D = new GL.Delegates.TexSubImage1D(GL.Imports.TexSubImage1D); + GL.TexSubImage2D = new GL.Delegates.TexSubImage2D(GL.Imports.TexSubImage2D); + GL.AreTexturesResident = new GL.Delegates.AreTexturesResident(GL.Imports.AreTexturesResident); + GL.BindTexture = new GL.Delegates.BindTexture(GL.Imports.BindTexture); + GL.DeleteTextures = new GL.Delegates.DeleteTextures(GL.Imports.DeleteTextures); + GL.GenTextures = new GL.Delegates.GenTextures(GL.Imports.GenTextures); + GL.IsTexture = new GL.Delegates.IsTexture(GL.Imports.IsTexture); + GL.PrioritizeTextures = new GL.Delegates.PrioritizeTextures(GL.Imports.PrioritizeTextures); + GL.Indexub = new GL.Delegates.Indexub(GL.Imports.Indexub); + GL.Indexubv = new GL.Delegates.Indexubv(GL.Imports.Indexubv); + GL.PopClientAttrib = new GL.Delegates.PopClientAttrib(GL.Imports.PopClientAttrib); + GL.PushClientAttrib = new GL.Delegates.PushClientAttrib(GL.Imports.PushClientAttrib); + GL.BlendColor = new GL.Delegates.BlendColor(GL.Imports.BlendColor); + GL.BlendEquation = new GL.Delegates.BlendEquation(GL.Imports.BlendEquation); + GL.DrawRangeElements_ = new GL.Delegates.DrawRangeElements_(GL.Imports.DrawRangeElements_); + GL.ColorTable_ = new GL.Delegates.ColorTable_(GL.Imports.ColorTable_); + GL.ColorTableParameterfv = new GL.Delegates.ColorTableParameterfv(GL.Imports.ColorTableParameterfv); + GL.ColorTableParameteriv = new GL.Delegates.ColorTableParameteriv(GL.Imports.ColorTableParameteriv); + GL.CopyColorTable = new GL.Delegates.CopyColorTable(GL.Imports.CopyColorTable); + GL.GetColorTable_ = new GL.Delegates.GetColorTable_(GL.Imports.GetColorTable_); + GL.GetColorTableParameterfv = new GL.Delegates.GetColorTableParameterfv(GL.Imports.GetColorTableParameterfv); + GL.GetColorTableParameteriv = new GL.Delegates.GetColorTableParameteriv(GL.Imports.GetColorTableParameteriv); + GL.ColorSubTable_ = new GL.Delegates.ColorSubTable_(GL.Imports.ColorSubTable_); + GL.CopyColorSubTable = new GL.Delegates.CopyColorSubTable(GL.Imports.CopyColorSubTable); + GL.ConvolutionFilter1D_ = new GL.Delegates.ConvolutionFilter1D_(GL.Imports.ConvolutionFilter1D_); + GL.ConvolutionFilter2D_ = new GL.Delegates.ConvolutionFilter2D_(GL.Imports.ConvolutionFilter2D_); + GL.ConvolutionParameterf = new GL.Delegates.ConvolutionParameterf(GL.Imports.ConvolutionParameterf); + GL.ConvolutionParameterfv = new GL.Delegates.ConvolutionParameterfv(GL.Imports.ConvolutionParameterfv); + GL.ConvolutionParameteri = new GL.Delegates.ConvolutionParameteri(GL.Imports.ConvolutionParameteri); + GL.ConvolutionParameteriv = new GL.Delegates.ConvolutionParameteriv(GL.Imports.ConvolutionParameteriv); + GL.CopyConvolutionFilter1D = new GL.Delegates.CopyConvolutionFilter1D(GL.Imports.CopyConvolutionFilter1D); + GL.CopyConvolutionFilter2D = new GL.Delegates.CopyConvolutionFilter2D(GL.Imports.CopyConvolutionFilter2D); + GL.GetConvolutionFilter_ = new GL.Delegates.GetConvolutionFilter_(GL.Imports.GetConvolutionFilter_); + GL.GetConvolutionParameterfv = new GL.Delegates.GetConvolutionParameterfv(GL.Imports.GetConvolutionParameterfv); + GL.GetConvolutionParameteriv = new GL.Delegates.GetConvolutionParameteriv(GL.Imports.GetConvolutionParameteriv); + GL.GetSeparableFilter_ = new GL.Delegates.GetSeparableFilter_(GL.Imports.GetSeparableFilter_); + GL.SeparableFilter2D_ = new GL.Delegates.SeparableFilter2D_(GL.Imports.SeparableFilter2D_); + GL.GetHistogram_ = new GL.Delegates.GetHistogram_(GL.Imports.GetHistogram_); + GL.GetHistogramParameterfv = new GL.Delegates.GetHistogramParameterfv(GL.Imports.GetHistogramParameterfv); + GL.GetHistogramParameteriv = new GL.Delegates.GetHistogramParameteriv(GL.Imports.GetHistogramParameteriv); + GL.GetMinmax_ = new GL.Delegates.GetMinmax_(GL.Imports.GetMinmax_); + GL.GetMinmaxParameterfv = new GL.Delegates.GetMinmaxParameterfv(GL.Imports.GetMinmaxParameterfv); + GL.GetMinmaxParameteriv = new GL.Delegates.GetMinmaxParameteriv(GL.Imports.GetMinmaxParameteriv); + GL.Histogram = new GL.Delegates.Histogram(GL.Imports.Histogram); + GL.Minmax = new GL.Delegates.Minmax(GL.Imports.Minmax); + GL.ResetHistogram = new GL.Delegates.ResetHistogram(GL.Imports.ResetHistogram); + GL.ResetMinmax = new GL.Delegates.ResetMinmax(GL.Imports.ResetMinmax); + GL.TexImage3D = new GL.Delegates.TexImage3D(GL.Imports.TexImage3D); + GL.TexSubImage3D = new GL.Delegates.TexSubImage3D(GL.Imports.TexSubImage3D); + GL.CopyTexSubImage3D = new GL.Delegates.CopyTexSubImage3D(GL.Imports.CopyTexSubImage3D); + GL.ActiveTexture = new GL.Delegates.ActiveTexture(GL.Imports.ActiveTexture); + GL.ClientActiveTexture = new GL.Delegates.ClientActiveTexture(GL.Imports.ClientActiveTexture); + GL.MultiTexCoord1d = new GL.Delegates.MultiTexCoord1d(GL.Imports.MultiTexCoord1d); + GL.MultiTexCoord1dv = new GL.Delegates.MultiTexCoord1dv(GL.Imports.MultiTexCoord1dv); + GL.MultiTexCoord1f = new GL.Delegates.MultiTexCoord1f(GL.Imports.MultiTexCoord1f); + GL.MultiTexCoord1fv = new GL.Delegates.MultiTexCoord1fv(GL.Imports.MultiTexCoord1fv); + GL.MultiTexCoord1i = new GL.Delegates.MultiTexCoord1i(GL.Imports.MultiTexCoord1i); + GL.MultiTexCoord1iv = new GL.Delegates.MultiTexCoord1iv(GL.Imports.MultiTexCoord1iv); + GL.MultiTexCoord1s = new GL.Delegates.MultiTexCoord1s(GL.Imports.MultiTexCoord1s); + GL.MultiTexCoord1sv = new GL.Delegates.MultiTexCoord1sv(GL.Imports.MultiTexCoord1sv); + GL.MultiTexCoord2d = new GL.Delegates.MultiTexCoord2d(GL.Imports.MultiTexCoord2d); + GL.MultiTexCoord2dv = new GL.Delegates.MultiTexCoord2dv(GL.Imports.MultiTexCoord2dv); + GL.MultiTexCoord2f = new GL.Delegates.MultiTexCoord2f(GL.Imports.MultiTexCoord2f); + GL.MultiTexCoord2fv = new GL.Delegates.MultiTexCoord2fv(GL.Imports.MultiTexCoord2fv); + GL.MultiTexCoord2i = new GL.Delegates.MultiTexCoord2i(GL.Imports.MultiTexCoord2i); + GL.MultiTexCoord2iv = new GL.Delegates.MultiTexCoord2iv(GL.Imports.MultiTexCoord2iv); + GL.MultiTexCoord2s = new GL.Delegates.MultiTexCoord2s(GL.Imports.MultiTexCoord2s); + GL.MultiTexCoord2sv = new GL.Delegates.MultiTexCoord2sv(GL.Imports.MultiTexCoord2sv); + GL.MultiTexCoord3d = new GL.Delegates.MultiTexCoord3d(GL.Imports.MultiTexCoord3d); + GL.MultiTexCoord3dv = new GL.Delegates.MultiTexCoord3dv(GL.Imports.MultiTexCoord3dv); + GL.MultiTexCoord3f = new GL.Delegates.MultiTexCoord3f(GL.Imports.MultiTexCoord3f); + GL.MultiTexCoord3fv = new GL.Delegates.MultiTexCoord3fv(GL.Imports.MultiTexCoord3fv); + GL.MultiTexCoord3i = new GL.Delegates.MultiTexCoord3i(GL.Imports.MultiTexCoord3i); + GL.MultiTexCoord3iv = new GL.Delegates.MultiTexCoord3iv(GL.Imports.MultiTexCoord3iv); + GL.MultiTexCoord3s = new GL.Delegates.MultiTexCoord3s(GL.Imports.MultiTexCoord3s); + GL.MultiTexCoord3sv = new GL.Delegates.MultiTexCoord3sv(GL.Imports.MultiTexCoord3sv); + GL.MultiTexCoord4d = new GL.Delegates.MultiTexCoord4d(GL.Imports.MultiTexCoord4d); + GL.MultiTexCoord4dv = new GL.Delegates.MultiTexCoord4dv(GL.Imports.MultiTexCoord4dv); + GL.MultiTexCoord4f = new GL.Delegates.MultiTexCoord4f(GL.Imports.MultiTexCoord4f); + GL.MultiTexCoord4fv = new GL.Delegates.MultiTexCoord4fv(GL.Imports.MultiTexCoord4fv); + GL.MultiTexCoord4i = new GL.Delegates.MultiTexCoord4i(GL.Imports.MultiTexCoord4i); + GL.MultiTexCoord4iv = new GL.Delegates.MultiTexCoord4iv(GL.Imports.MultiTexCoord4iv); + GL.MultiTexCoord4s = new GL.Delegates.MultiTexCoord4s(GL.Imports.MultiTexCoord4s); + GL.MultiTexCoord4sv = new GL.Delegates.MultiTexCoord4sv(GL.Imports.MultiTexCoord4sv); + GL.LoadTransposeMatrixf = new GL.Delegates.LoadTransposeMatrixf(GL.Imports.LoadTransposeMatrixf); + GL.LoadTransposeMatrixd = new GL.Delegates.LoadTransposeMatrixd(GL.Imports.LoadTransposeMatrixd); + GL.MultTransposeMatrixf = new GL.Delegates.MultTransposeMatrixf(GL.Imports.MultTransposeMatrixf); + GL.MultTransposeMatrixd = new GL.Delegates.MultTransposeMatrixd(GL.Imports.MultTransposeMatrixd); + GL.SampleCoverage = new GL.Delegates.SampleCoverage(GL.Imports.SampleCoverage); + GL.CompressedTexImage3D = new GL.Delegates.CompressedTexImage3D(GL.Imports.CompressedTexImage3D); + GL.CompressedTexImage2D = new GL.Delegates.CompressedTexImage2D(GL.Imports.CompressedTexImage2D); + GL.CompressedTexImage1D = new GL.Delegates.CompressedTexImage1D(GL.Imports.CompressedTexImage1D); + GL.CompressedTexSubImage3D = new GL.Delegates.CompressedTexSubImage3D(GL.Imports.CompressedTexSubImage3D); + GL.CompressedTexSubImage2D = new GL.Delegates.CompressedTexSubImage2D(GL.Imports.CompressedTexSubImage2D); + GL.CompressedTexSubImage1D = new GL.Delegates.CompressedTexSubImage1D(GL.Imports.CompressedTexSubImage1D); + GL.GetCompressedTexImage = new GL.Delegates.GetCompressedTexImage(GL.Imports.GetCompressedTexImage); + GL.BlendFuncSeparate = new GL.Delegates.BlendFuncSeparate(GL.Imports.BlendFuncSeparate); + GL.FogCoordf = new GL.Delegates.FogCoordf(GL.Imports.FogCoordf); + GL.FogCoordfv = new GL.Delegates.FogCoordfv(GL.Imports.FogCoordfv); + GL.FogCoordd = new GL.Delegates.FogCoordd(GL.Imports.FogCoordd); + GL.FogCoorddv = new GL.Delegates.FogCoorddv(GL.Imports.FogCoorddv); + GL.FogCoordPointer_ = new GL.Delegates.FogCoordPointer_(GL.Imports.FogCoordPointer_); + GL.MultiDrawArrays = new GL.Delegates.MultiDrawArrays(GL.Imports.MultiDrawArrays); + GL.MultiDrawElements = new GL.Delegates.MultiDrawElements(GL.Imports.MultiDrawElements); + GL.PointParameterf = new GL.Delegates.PointParameterf(GL.Imports.PointParameterf); + GL.PointParameterfv = new GL.Delegates.PointParameterfv(GL.Imports.PointParameterfv); + GL.PointParameteri = new GL.Delegates.PointParameteri(GL.Imports.PointParameteri); + GL.PointParameteriv = new GL.Delegates.PointParameteriv(GL.Imports.PointParameteriv); + GL.SecondaryColor3b = new GL.Delegates.SecondaryColor3b(GL.Imports.SecondaryColor3b); + GL.SecondaryColor3bv = new GL.Delegates.SecondaryColor3bv(GL.Imports.SecondaryColor3bv); + GL.SecondaryColor3d = new GL.Delegates.SecondaryColor3d(GL.Imports.SecondaryColor3d); + GL.SecondaryColor3dv = new GL.Delegates.SecondaryColor3dv(GL.Imports.SecondaryColor3dv); + GL.SecondaryColor3f = new GL.Delegates.SecondaryColor3f(GL.Imports.SecondaryColor3f); + GL.SecondaryColor3fv = new GL.Delegates.SecondaryColor3fv(GL.Imports.SecondaryColor3fv); + GL.SecondaryColor3i = new GL.Delegates.SecondaryColor3i(GL.Imports.SecondaryColor3i); + GL.SecondaryColor3iv = new GL.Delegates.SecondaryColor3iv(GL.Imports.SecondaryColor3iv); + GL.SecondaryColor3s = new GL.Delegates.SecondaryColor3s(GL.Imports.SecondaryColor3s); + GL.SecondaryColor3sv = new GL.Delegates.SecondaryColor3sv(GL.Imports.SecondaryColor3sv); + GL.SecondaryColor3ub = new GL.Delegates.SecondaryColor3ub(GL.Imports.SecondaryColor3ub); + GL.SecondaryColor3ubv = new GL.Delegates.SecondaryColor3ubv(GL.Imports.SecondaryColor3ubv); + GL.SecondaryColor3ui = new GL.Delegates.SecondaryColor3ui(GL.Imports.SecondaryColor3ui); + GL.SecondaryColor3uiv = new GL.Delegates.SecondaryColor3uiv(GL.Imports.SecondaryColor3uiv); + GL.SecondaryColor3us = new GL.Delegates.SecondaryColor3us(GL.Imports.SecondaryColor3us); + GL.SecondaryColor3usv = new GL.Delegates.SecondaryColor3usv(GL.Imports.SecondaryColor3usv); + GL.SecondaryColorPointer_ = new GL.Delegates.SecondaryColorPointer_(GL.Imports.SecondaryColorPointer_); + GL.WindowPos2d = new GL.Delegates.WindowPos2d(GL.Imports.WindowPos2d); + GL.WindowPos2dv = new GL.Delegates.WindowPos2dv(GL.Imports.WindowPos2dv); + GL.WindowPos2f = new GL.Delegates.WindowPos2f(GL.Imports.WindowPos2f); + GL.WindowPos2fv = new GL.Delegates.WindowPos2fv(GL.Imports.WindowPos2fv); + GL.WindowPos2i = new GL.Delegates.WindowPos2i(GL.Imports.WindowPos2i); + GL.WindowPos2iv = new GL.Delegates.WindowPos2iv(GL.Imports.WindowPos2iv); + GL.WindowPos2s = new GL.Delegates.WindowPos2s(GL.Imports.WindowPos2s); + GL.WindowPos2sv = new GL.Delegates.WindowPos2sv(GL.Imports.WindowPos2sv); + GL.WindowPos3d = new GL.Delegates.WindowPos3d(GL.Imports.WindowPos3d); + GL.WindowPos3dv = new GL.Delegates.WindowPos3dv(GL.Imports.WindowPos3dv); + GL.WindowPos3f = new GL.Delegates.WindowPos3f(GL.Imports.WindowPos3f); + GL.WindowPos3fv = new GL.Delegates.WindowPos3fv(GL.Imports.WindowPos3fv); + GL.WindowPos3i = new GL.Delegates.WindowPos3i(GL.Imports.WindowPos3i); + GL.WindowPos3iv = new GL.Delegates.WindowPos3iv(GL.Imports.WindowPos3iv); + GL.WindowPos3s = new GL.Delegates.WindowPos3s(GL.Imports.WindowPos3s); + GL.WindowPos3sv = new GL.Delegates.WindowPos3sv(GL.Imports.WindowPos3sv); + GL.GenQueries = new GL.Delegates.GenQueries(GL.Imports.GenQueries); + GL.DeleteQueries = new GL.Delegates.DeleteQueries(GL.Imports.DeleteQueries); + GL.IsQuery = new GL.Delegates.IsQuery(GL.Imports.IsQuery); + GL.BeginQuery = new GL.Delegates.BeginQuery(GL.Imports.BeginQuery); + GL.EndQuery = new GL.Delegates.EndQuery(GL.Imports.EndQuery); + GL.GetQueryiv = new GL.Delegates.GetQueryiv(GL.Imports.GetQueryiv); + GL.GetQueryObjectiv = new GL.Delegates.GetQueryObjectiv(GL.Imports.GetQueryObjectiv); + GL.GetQueryObjectuiv = new GL.Delegates.GetQueryObjectuiv(GL.Imports.GetQueryObjectuiv); + GL.BindBuffer = new GL.Delegates.BindBuffer(GL.Imports.BindBuffer); + GL.DeleteBuffers = new GL.Delegates.DeleteBuffers(GL.Imports.DeleteBuffers); + GL.GenBuffers = new GL.Delegates.GenBuffers(GL.Imports.GenBuffers); + GL.IsBuffer = new GL.Delegates.IsBuffer(GL.Imports.IsBuffer); + GL.BufferData_ = new GL.Delegates.BufferData_(GL.Imports.BufferData_); + GL.BufferSubData_ = new GL.Delegates.BufferSubData_(GL.Imports.BufferSubData_); + GL.GetBufferSubData_ = new GL.Delegates.GetBufferSubData_(GL.Imports.GetBufferSubData_); + GL.MapBuffer_ = new GL.Delegates.MapBuffer_(GL.Imports.MapBuffer_); + GL.UnmapBuffer = new GL.Delegates.UnmapBuffer(GL.Imports.UnmapBuffer); + GL.GetBufferParameteriv = new GL.Delegates.GetBufferParameteriv(GL.Imports.GetBufferParameteriv); + GL.GetBufferPointerv = new GL.Delegates.GetBufferPointerv(GL.Imports.GetBufferPointerv); + GL.BlendEquationSeparate = new GL.Delegates.BlendEquationSeparate(GL.Imports.BlendEquationSeparate); + GL.DrawBuffers = new GL.Delegates.DrawBuffers(GL.Imports.DrawBuffers); + GL.StencilOpSeparate = new GL.Delegates.StencilOpSeparate(GL.Imports.StencilOpSeparate); + GL.StencilFuncSeparate = new GL.Delegates.StencilFuncSeparate(GL.Imports.StencilFuncSeparate); + GL.StencilMaskSeparate = new GL.Delegates.StencilMaskSeparate(GL.Imports.StencilMaskSeparate); + GL.AttachShader = new GL.Delegates.AttachShader(GL.Imports.AttachShader); + GL.BindAttribLocation = new GL.Delegates.BindAttribLocation(GL.Imports.BindAttribLocation); + GL.CompileShader = new GL.Delegates.CompileShader(GL.Imports.CompileShader); + GL.CreateProgram = new GL.Delegates.CreateProgram(GL.Imports.CreateProgram); + GL.CreateShader = new GL.Delegates.CreateShader(GL.Imports.CreateShader); + GL.DeleteProgram = new GL.Delegates.DeleteProgram(GL.Imports.DeleteProgram); + GL.DeleteShader = new GL.Delegates.DeleteShader(GL.Imports.DeleteShader); + GL.DetachShader = new GL.Delegates.DetachShader(GL.Imports.DetachShader); + GL.DisableVertexAttribArray = new GL.Delegates.DisableVertexAttribArray(GL.Imports.DisableVertexAttribArray); + GL.EnableVertexAttribArray = new GL.Delegates.EnableVertexAttribArray(GL.Imports.EnableVertexAttribArray); + GL.GetActiveAttrib = new GL.Delegates.GetActiveAttrib(GL.Imports.GetActiveAttrib); + GL.GetActiveUniform = new GL.Delegates.GetActiveUniform(GL.Imports.GetActiveUniform); + GL.GetAttachedShaders = new GL.Delegates.GetAttachedShaders(GL.Imports.GetAttachedShaders); + GL.GetAttribLocation = new GL.Delegates.GetAttribLocation(GL.Imports.GetAttribLocation); + GL.GetProgramiv = new GL.Delegates.GetProgramiv(GL.Imports.GetProgramiv); + GL.GetProgramInfoLog = new GL.Delegates.GetProgramInfoLog(GL.Imports.GetProgramInfoLog); + GL.GetShaderiv = new GL.Delegates.GetShaderiv(GL.Imports.GetShaderiv); + GL.GetShaderInfoLog = new GL.Delegates.GetShaderInfoLog(GL.Imports.GetShaderInfoLog); + GL.GetShaderSource = new GL.Delegates.GetShaderSource(GL.Imports.GetShaderSource); + GL.GetUniformLocation = new GL.Delegates.GetUniformLocation(GL.Imports.GetUniformLocation); + GL.GetUniformfv = new GL.Delegates.GetUniformfv(GL.Imports.GetUniformfv); + GL.GetUniformiv = new GL.Delegates.GetUniformiv(GL.Imports.GetUniformiv); + GL.GetVertexAttribdv = new GL.Delegates.GetVertexAttribdv(GL.Imports.GetVertexAttribdv); + GL.GetVertexAttribfv = new GL.Delegates.GetVertexAttribfv(GL.Imports.GetVertexAttribfv); + GL.GetVertexAttribiv = new GL.Delegates.GetVertexAttribiv(GL.Imports.GetVertexAttribiv); + GL.GetVertexAttribPointerv = new GL.Delegates.GetVertexAttribPointerv(GL.Imports.GetVertexAttribPointerv); + GL.IsProgram = new GL.Delegates.IsProgram(GL.Imports.IsProgram); + GL.IsShader = new GL.Delegates.IsShader(GL.Imports.IsShader); + GL.LinkProgram = new GL.Delegates.LinkProgram(GL.Imports.LinkProgram); + GL.ShaderSource = new GL.Delegates.ShaderSource(GL.Imports.ShaderSource); + GL.UseProgram = new GL.Delegates.UseProgram(GL.Imports.UseProgram); + GL.Uniform1f = new GL.Delegates.Uniform1f(GL.Imports.Uniform1f); + GL.Uniform2f = new GL.Delegates.Uniform2f(GL.Imports.Uniform2f); + GL.Uniform3f = new GL.Delegates.Uniform3f(GL.Imports.Uniform3f); + GL.Uniform4f = new GL.Delegates.Uniform4f(GL.Imports.Uniform4f); + GL.Uniform1i = new GL.Delegates.Uniform1i(GL.Imports.Uniform1i); + GL.Uniform2i = new GL.Delegates.Uniform2i(GL.Imports.Uniform2i); + GL.Uniform3i = new GL.Delegates.Uniform3i(GL.Imports.Uniform3i); + GL.Uniform4i = new GL.Delegates.Uniform4i(GL.Imports.Uniform4i); + GL.Uniform1fv = new GL.Delegates.Uniform1fv(GL.Imports.Uniform1fv); + GL.Uniform2fv = new GL.Delegates.Uniform2fv(GL.Imports.Uniform2fv); + GL.Uniform3fv = new GL.Delegates.Uniform3fv(GL.Imports.Uniform3fv); + GL.Uniform4fv = new GL.Delegates.Uniform4fv(GL.Imports.Uniform4fv); + GL.Uniform1iv = new GL.Delegates.Uniform1iv(GL.Imports.Uniform1iv); + GL.Uniform2iv = new GL.Delegates.Uniform2iv(GL.Imports.Uniform2iv); + GL.Uniform3iv = new GL.Delegates.Uniform3iv(GL.Imports.Uniform3iv); + GL.Uniform4iv = new GL.Delegates.Uniform4iv(GL.Imports.Uniform4iv); + GL.UniformMatrix2fv = new GL.Delegates.UniformMatrix2fv(GL.Imports.UniformMatrix2fv); + GL.UniformMatrix3fv = new GL.Delegates.UniformMatrix3fv(GL.Imports.UniformMatrix3fv); + GL.UniformMatrix4fv = new GL.Delegates.UniformMatrix4fv(GL.Imports.UniformMatrix4fv); + GL.ValidateProgram = new GL.Delegates.ValidateProgram(GL.Imports.ValidateProgram); + GL.VertexAttrib1d = new GL.Delegates.VertexAttrib1d(GL.Imports.VertexAttrib1d); + GL.VertexAttrib1dv = new GL.Delegates.VertexAttrib1dv(GL.Imports.VertexAttrib1dv); + GL.VertexAttrib1f = new GL.Delegates.VertexAttrib1f(GL.Imports.VertexAttrib1f); + GL.VertexAttrib1fv = new GL.Delegates.VertexAttrib1fv(GL.Imports.VertexAttrib1fv); + GL.VertexAttrib1s = new GL.Delegates.VertexAttrib1s(GL.Imports.VertexAttrib1s); + GL.VertexAttrib1sv = new GL.Delegates.VertexAttrib1sv(GL.Imports.VertexAttrib1sv); + GL.VertexAttrib2d = new GL.Delegates.VertexAttrib2d(GL.Imports.VertexAttrib2d); + GL.VertexAttrib2dv = new GL.Delegates.VertexAttrib2dv(GL.Imports.VertexAttrib2dv); + GL.VertexAttrib2f = new GL.Delegates.VertexAttrib2f(GL.Imports.VertexAttrib2f); + GL.VertexAttrib2fv = new GL.Delegates.VertexAttrib2fv(GL.Imports.VertexAttrib2fv); + GL.VertexAttrib2s = new GL.Delegates.VertexAttrib2s(GL.Imports.VertexAttrib2s); + GL.VertexAttrib2sv = new GL.Delegates.VertexAttrib2sv(GL.Imports.VertexAttrib2sv); + GL.VertexAttrib3d = new GL.Delegates.VertexAttrib3d(GL.Imports.VertexAttrib3d); + GL.VertexAttrib3dv = new GL.Delegates.VertexAttrib3dv(GL.Imports.VertexAttrib3dv); + GL.VertexAttrib3f = new GL.Delegates.VertexAttrib3f(GL.Imports.VertexAttrib3f); + GL.VertexAttrib3fv = new GL.Delegates.VertexAttrib3fv(GL.Imports.VertexAttrib3fv); + GL.VertexAttrib3s = new GL.Delegates.VertexAttrib3s(GL.Imports.VertexAttrib3s); + GL.VertexAttrib3sv = new GL.Delegates.VertexAttrib3sv(GL.Imports.VertexAttrib3sv); + GL.VertexAttrib4Nbv = new GL.Delegates.VertexAttrib4Nbv(GL.Imports.VertexAttrib4Nbv); + GL.VertexAttrib4Niv = new GL.Delegates.VertexAttrib4Niv(GL.Imports.VertexAttrib4Niv); + GL.VertexAttrib4Nsv = new GL.Delegates.VertexAttrib4Nsv(GL.Imports.VertexAttrib4Nsv); + GL.VertexAttrib4Nub = new GL.Delegates.VertexAttrib4Nub(GL.Imports.VertexAttrib4Nub); + GL.VertexAttrib4Nubv = new GL.Delegates.VertexAttrib4Nubv(GL.Imports.VertexAttrib4Nubv); + GL.VertexAttrib4Nuiv = new GL.Delegates.VertexAttrib4Nuiv(GL.Imports.VertexAttrib4Nuiv); + GL.VertexAttrib4Nusv = new GL.Delegates.VertexAttrib4Nusv(GL.Imports.VertexAttrib4Nusv); + GL.VertexAttrib4bv = new GL.Delegates.VertexAttrib4bv(GL.Imports.VertexAttrib4bv); + GL.VertexAttrib4d = new GL.Delegates.VertexAttrib4d(GL.Imports.VertexAttrib4d); + GL.VertexAttrib4dv = new GL.Delegates.VertexAttrib4dv(GL.Imports.VertexAttrib4dv); + GL.VertexAttrib4f = new GL.Delegates.VertexAttrib4f(GL.Imports.VertexAttrib4f); + GL.VertexAttrib4fv = new GL.Delegates.VertexAttrib4fv(GL.Imports.VertexAttrib4fv); + GL.VertexAttrib4iv = new GL.Delegates.VertexAttrib4iv(GL.Imports.VertexAttrib4iv); + GL.VertexAttrib4s = new GL.Delegates.VertexAttrib4s(GL.Imports.VertexAttrib4s); + GL.VertexAttrib4sv = new GL.Delegates.VertexAttrib4sv(GL.Imports.VertexAttrib4sv); + GL.VertexAttrib4ubv = new GL.Delegates.VertexAttrib4ubv(GL.Imports.VertexAttrib4ubv); + GL.VertexAttrib4uiv = new GL.Delegates.VertexAttrib4uiv(GL.Imports.VertexAttrib4uiv); + GL.VertexAttrib4usv = new GL.Delegates.VertexAttrib4usv(GL.Imports.VertexAttrib4usv); + GL.VertexAttribPointer_ = new GL.Delegates.VertexAttribPointer_(GL.Imports.VertexAttribPointer_); } - - #endregion - - #region Load extensions - - /// - /// Loads the opengl extensions (e.g. ARB, EXT, vendor and platform specific functions). - /// - public override void LoadExtensions() - { - GL.ActiveTextureARB = (GL.Delegates.ActiveTextureARB) GetAddress("glActiveTextureARB", typeof(GL.Delegates.ActiveTextureARB)); - GL.ClientActiveTextureARB = (GL.Delegates.ClientActiveTextureARB) GetAddress("glClientActiveTextureARB", typeof(GL.Delegates.ClientActiveTextureARB)); - GL.MultiTexCoord1dARB = (GL.Delegates.MultiTexCoord1dARB) GetAddress("glMultiTexCoord1dARB", typeof(GL.Delegates.MultiTexCoord1dARB)); - GL.MultiTexCoord1dvARB = (GL.Delegates.MultiTexCoord1dvARB) GetAddress("glMultiTexCoord1dvARB", typeof(GL.Delegates.MultiTexCoord1dvARB)); - GL.MultiTexCoord1fARB = (GL.Delegates.MultiTexCoord1fARB) GetAddress("glMultiTexCoord1fARB", typeof(GL.Delegates.MultiTexCoord1fARB)); - GL.MultiTexCoord1fvARB = (GL.Delegates.MultiTexCoord1fvARB) GetAddress("glMultiTexCoord1fvARB", typeof(GL.Delegates.MultiTexCoord1fvARB)); - GL.MultiTexCoord1iARB = (GL.Delegates.MultiTexCoord1iARB) GetAddress("glMultiTexCoord1iARB", typeof(GL.Delegates.MultiTexCoord1iARB)); - GL.MultiTexCoord1ivARB = (GL.Delegates.MultiTexCoord1ivARB) GetAddress("glMultiTexCoord1ivARB", typeof(GL.Delegates.MultiTexCoord1ivARB)); - GL.MultiTexCoord1sARB = (GL.Delegates.MultiTexCoord1sARB) GetAddress("glMultiTexCoord1sARB", typeof(GL.Delegates.MultiTexCoord1sARB)); - GL.MultiTexCoord1svARB = (GL.Delegates.MultiTexCoord1svARB) GetAddress("glMultiTexCoord1svARB", typeof(GL.Delegates.MultiTexCoord1svARB)); - GL.MultiTexCoord2dARB = (GL.Delegates.MultiTexCoord2dARB) GetAddress("glMultiTexCoord2dARB", typeof(GL.Delegates.MultiTexCoord2dARB)); - GL.MultiTexCoord2dvARB = (GL.Delegates.MultiTexCoord2dvARB) GetAddress("glMultiTexCoord2dvARB", typeof(GL.Delegates.MultiTexCoord2dvARB)); - GL.MultiTexCoord2fARB = (GL.Delegates.MultiTexCoord2fARB) GetAddress("glMultiTexCoord2fARB", typeof(GL.Delegates.MultiTexCoord2fARB)); - GL.MultiTexCoord2fvARB = (GL.Delegates.MultiTexCoord2fvARB) GetAddress("glMultiTexCoord2fvARB", typeof(GL.Delegates.MultiTexCoord2fvARB)); - GL.MultiTexCoord2iARB = (GL.Delegates.MultiTexCoord2iARB) GetAddress("glMultiTexCoord2iARB", typeof(GL.Delegates.MultiTexCoord2iARB)); - GL.MultiTexCoord2ivARB = (GL.Delegates.MultiTexCoord2ivARB) GetAddress("glMultiTexCoord2ivARB", typeof(GL.Delegates.MultiTexCoord2ivARB)); - GL.MultiTexCoord2sARB = (GL.Delegates.MultiTexCoord2sARB) GetAddress("glMultiTexCoord2sARB", typeof(GL.Delegates.MultiTexCoord2sARB)); - GL.MultiTexCoord2svARB = (GL.Delegates.MultiTexCoord2svARB) GetAddress("glMultiTexCoord2svARB", typeof(GL.Delegates.MultiTexCoord2svARB)); - GL.MultiTexCoord3dARB = (GL.Delegates.MultiTexCoord3dARB) GetAddress("glMultiTexCoord3dARB", typeof(GL.Delegates.MultiTexCoord3dARB)); - GL.MultiTexCoord3dvARB = (GL.Delegates.MultiTexCoord3dvARB) GetAddress("glMultiTexCoord3dvARB", typeof(GL.Delegates.MultiTexCoord3dvARB)); - GL.MultiTexCoord3fARB = (GL.Delegates.MultiTexCoord3fARB) GetAddress("glMultiTexCoord3fARB", typeof(GL.Delegates.MultiTexCoord3fARB)); - GL.MultiTexCoord3fvARB = (GL.Delegates.MultiTexCoord3fvARB) GetAddress("glMultiTexCoord3fvARB", typeof(GL.Delegates.MultiTexCoord3fvARB)); - GL.MultiTexCoord3iARB = (GL.Delegates.MultiTexCoord3iARB) GetAddress("glMultiTexCoord3iARB", typeof(GL.Delegates.MultiTexCoord3iARB)); - GL.MultiTexCoord3ivARB = (GL.Delegates.MultiTexCoord3ivARB) GetAddress("glMultiTexCoord3ivARB", typeof(GL.Delegates.MultiTexCoord3ivARB)); - GL.MultiTexCoord3sARB = (GL.Delegates.MultiTexCoord3sARB) GetAddress("glMultiTexCoord3sARB", typeof(GL.Delegates.MultiTexCoord3sARB)); - GL.MultiTexCoord3svARB = (GL.Delegates.MultiTexCoord3svARB) GetAddress("glMultiTexCoord3svARB", typeof(GL.Delegates.MultiTexCoord3svARB)); - GL.MultiTexCoord4dARB = (GL.Delegates.MultiTexCoord4dARB) GetAddress("glMultiTexCoord4dARB", typeof(GL.Delegates.MultiTexCoord4dARB)); - GL.MultiTexCoord4dvARB = (GL.Delegates.MultiTexCoord4dvARB) GetAddress("glMultiTexCoord4dvARB", typeof(GL.Delegates.MultiTexCoord4dvARB)); - GL.MultiTexCoord4fARB = (GL.Delegates.MultiTexCoord4fARB) GetAddress("glMultiTexCoord4fARB", typeof(GL.Delegates.MultiTexCoord4fARB)); - GL.MultiTexCoord4fvARB = (GL.Delegates.MultiTexCoord4fvARB) GetAddress("glMultiTexCoord4fvARB", typeof(GL.Delegates.MultiTexCoord4fvARB)); - GL.MultiTexCoord4iARB = (GL.Delegates.MultiTexCoord4iARB) GetAddress("glMultiTexCoord4iARB", typeof(GL.Delegates.MultiTexCoord4iARB)); - GL.MultiTexCoord4ivARB = (GL.Delegates.MultiTexCoord4ivARB) GetAddress("glMultiTexCoord4ivARB", typeof(GL.Delegates.MultiTexCoord4ivARB)); - GL.MultiTexCoord4sARB = (GL.Delegates.MultiTexCoord4sARB) GetAddress("glMultiTexCoord4sARB", typeof(GL.Delegates.MultiTexCoord4sARB)); - GL.MultiTexCoord4svARB = (GL.Delegates.MultiTexCoord4svARB) GetAddress("glMultiTexCoord4svARB", typeof(GL.Delegates.MultiTexCoord4svARB)); - GL.LoadTransposeMatrixfARB = (GL.Delegates.LoadTransposeMatrixfARB) GetAddress("glLoadTransposeMatrixfARB", typeof(GL.Delegates.LoadTransposeMatrixfARB)); - GL.LoadTransposeMatrixdARB = (GL.Delegates.LoadTransposeMatrixdARB) GetAddress("glLoadTransposeMatrixdARB", typeof(GL.Delegates.LoadTransposeMatrixdARB)); - GL.MultTransposeMatrixfARB = (GL.Delegates.MultTransposeMatrixfARB) GetAddress("glMultTransposeMatrixfARB", typeof(GL.Delegates.MultTransposeMatrixfARB)); - GL.MultTransposeMatrixdARB = (GL.Delegates.MultTransposeMatrixdARB) GetAddress("glMultTransposeMatrixdARB", typeof(GL.Delegates.MultTransposeMatrixdARB)); - GL.SampleCoverageARB = (GL.Delegates.SampleCoverageARB) GetAddress("glSampleCoverageARB", typeof(GL.Delegates.SampleCoverageARB)); - GL.CompressedTexImage3DARB = (GL.Delegates.CompressedTexImage3DARB) GetAddress("glCompressedTexImage3DARB", typeof(GL.Delegates.CompressedTexImage3DARB)); - GL.CompressedTexImage2DARB = (GL.Delegates.CompressedTexImage2DARB) GetAddress("glCompressedTexImage2DARB", typeof(GL.Delegates.CompressedTexImage2DARB)); - GL.CompressedTexImage1DARB = (GL.Delegates.CompressedTexImage1DARB) GetAddress("glCompressedTexImage1DARB", typeof(GL.Delegates.CompressedTexImage1DARB)); - GL.CompressedTexSubImage3DARB = (GL.Delegates.CompressedTexSubImage3DARB) GetAddress("glCompressedTexSubImage3DARB", typeof(GL.Delegates.CompressedTexSubImage3DARB)); - GL.CompressedTexSubImage2DARB = (GL.Delegates.CompressedTexSubImage2DARB) GetAddress("glCompressedTexSubImage2DARB", typeof(GL.Delegates.CompressedTexSubImage2DARB)); - GL.CompressedTexSubImage1DARB = (GL.Delegates.CompressedTexSubImage1DARB) GetAddress("glCompressedTexSubImage1DARB", typeof(GL.Delegates.CompressedTexSubImage1DARB)); - GL.GetCompressedTexImageARB = (GL.Delegates.GetCompressedTexImageARB) GetAddress("glGetCompressedTexImageARB", typeof(GL.Delegates.GetCompressedTexImageARB)); - GL.PointParameterfARB = (GL.Delegates.PointParameterfARB) GetAddress("glPointParameterfARB", typeof(GL.Delegates.PointParameterfARB)); - GL.PointParameterfvARB = (GL.Delegates.PointParameterfvARB) GetAddress("glPointParameterfvARB", typeof(GL.Delegates.PointParameterfvARB)); - GL.WeightbvARB = (GL.Delegates.WeightbvARB) GetAddress("glWeightbvARB", typeof(GL.Delegates.WeightbvARB)); - GL.WeightsvARB = (GL.Delegates.WeightsvARB) GetAddress("glWeightsvARB", typeof(GL.Delegates.WeightsvARB)); - GL.WeightivARB = (GL.Delegates.WeightivARB) GetAddress("glWeightivARB", typeof(GL.Delegates.WeightivARB)); - GL.WeightfvARB = (GL.Delegates.WeightfvARB) GetAddress("glWeightfvARB", typeof(GL.Delegates.WeightfvARB)); - GL.WeightdvARB = (GL.Delegates.WeightdvARB) GetAddress("glWeightdvARB", typeof(GL.Delegates.WeightdvARB)); - GL.WeightubvARB = (GL.Delegates.WeightubvARB) GetAddress("glWeightubvARB", typeof(GL.Delegates.WeightubvARB)); - GL.WeightusvARB = (GL.Delegates.WeightusvARB) GetAddress("glWeightusvARB", typeof(GL.Delegates.WeightusvARB)); - GL.WeightuivARB = (GL.Delegates.WeightuivARB) GetAddress("glWeightuivARB", typeof(GL.Delegates.WeightuivARB)); - GL.WeightPointerARB = (GL.Delegates.WeightPointerARB) GetAddress("glWeightPointerARB", typeof(GL.Delegates.WeightPointerARB)); - GL.VertexBlendARB = (GL.Delegates.VertexBlendARB) GetAddress("glVertexBlendARB", typeof(GL.Delegates.VertexBlendARB)); - GL.CurrentPaletteMatrixARB = (GL.Delegates.CurrentPaletteMatrixARB) GetAddress("glCurrentPaletteMatrixARB", typeof(GL.Delegates.CurrentPaletteMatrixARB)); - GL.MatrixIndexubvARB = (GL.Delegates.MatrixIndexubvARB) GetAddress("glMatrixIndexubvARB", typeof(GL.Delegates.MatrixIndexubvARB)); - GL.MatrixIndexusvARB = (GL.Delegates.MatrixIndexusvARB) GetAddress("glMatrixIndexusvARB", typeof(GL.Delegates.MatrixIndexusvARB)); - GL.MatrixIndexuivARB = (GL.Delegates.MatrixIndexuivARB) GetAddress("glMatrixIndexuivARB", typeof(GL.Delegates.MatrixIndexuivARB)); - GL.MatrixIndexPointerARB = (GL.Delegates.MatrixIndexPointerARB) GetAddress("glMatrixIndexPointerARB", typeof(GL.Delegates.MatrixIndexPointerARB)); - GL.WindowPos2dARB = (GL.Delegates.WindowPos2dARB) GetAddress("glWindowPos2dARB", typeof(GL.Delegates.WindowPos2dARB)); - GL.WindowPos2dvARB = (GL.Delegates.WindowPos2dvARB) GetAddress("glWindowPos2dvARB", typeof(GL.Delegates.WindowPos2dvARB)); - GL.WindowPos2fARB = (GL.Delegates.WindowPos2fARB) GetAddress("glWindowPos2fARB", typeof(GL.Delegates.WindowPos2fARB)); - GL.WindowPos2fvARB = (GL.Delegates.WindowPos2fvARB) GetAddress("glWindowPos2fvARB", typeof(GL.Delegates.WindowPos2fvARB)); - GL.WindowPos2iARB = (GL.Delegates.WindowPos2iARB) GetAddress("glWindowPos2iARB", typeof(GL.Delegates.WindowPos2iARB)); - GL.WindowPos2ivARB = (GL.Delegates.WindowPos2ivARB) GetAddress("glWindowPos2ivARB", typeof(GL.Delegates.WindowPos2ivARB)); - GL.WindowPos2sARB = (GL.Delegates.WindowPos2sARB) GetAddress("glWindowPos2sARB", typeof(GL.Delegates.WindowPos2sARB)); - GL.WindowPos2svARB = (GL.Delegates.WindowPos2svARB) GetAddress("glWindowPos2svARB", typeof(GL.Delegates.WindowPos2svARB)); - GL.WindowPos3dARB = (GL.Delegates.WindowPos3dARB) GetAddress("glWindowPos3dARB", typeof(GL.Delegates.WindowPos3dARB)); - GL.WindowPos3dvARB = (GL.Delegates.WindowPos3dvARB) GetAddress("glWindowPos3dvARB", typeof(GL.Delegates.WindowPos3dvARB)); - GL.WindowPos3fARB = (GL.Delegates.WindowPos3fARB) GetAddress("glWindowPos3fARB", typeof(GL.Delegates.WindowPos3fARB)); - GL.WindowPos3fvARB = (GL.Delegates.WindowPos3fvARB) GetAddress("glWindowPos3fvARB", typeof(GL.Delegates.WindowPos3fvARB)); - GL.WindowPos3iARB = (GL.Delegates.WindowPos3iARB) GetAddress("glWindowPos3iARB", typeof(GL.Delegates.WindowPos3iARB)); - GL.WindowPos3ivARB = (GL.Delegates.WindowPos3ivARB) GetAddress("glWindowPos3ivARB", typeof(GL.Delegates.WindowPos3ivARB)); - GL.WindowPos3sARB = (GL.Delegates.WindowPos3sARB) GetAddress("glWindowPos3sARB", typeof(GL.Delegates.WindowPos3sARB)); - GL.WindowPos3svARB = (GL.Delegates.WindowPos3svARB) GetAddress("glWindowPos3svARB", typeof(GL.Delegates.WindowPos3svARB)); - GL.VertexAttrib1dARB = (GL.Delegates.VertexAttrib1dARB) GetAddress("glVertexAttrib1dARB", typeof(GL.Delegates.VertexAttrib1dARB)); - GL.VertexAttrib1dvARB = (GL.Delegates.VertexAttrib1dvARB) GetAddress("glVertexAttrib1dvARB", typeof(GL.Delegates.VertexAttrib1dvARB)); - GL.VertexAttrib1fARB = (GL.Delegates.VertexAttrib1fARB) GetAddress("glVertexAttrib1fARB", typeof(GL.Delegates.VertexAttrib1fARB)); - GL.VertexAttrib1fvARB = (GL.Delegates.VertexAttrib1fvARB) GetAddress("glVertexAttrib1fvARB", typeof(GL.Delegates.VertexAttrib1fvARB)); - GL.VertexAttrib1sARB = (GL.Delegates.VertexAttrib1sARB) GetAddress("glVertexAttrib1sARB", typeof(GL.Delegates.VertexAttrib1sARB)); - GL.VertexAttrib1svARB = (GL.Delegates.VertexAttrib1svARB) GetAddress("glVertexAttrib1svARB", typeof(GL.Delegates.VertexAttrib1svARB)); - GL.VertexAttrib2dARB = (GL.Delegates.VertexAttrib2dARB) GetAddress("glVertexAttrib2dARB", typeof(GL.Delegates.VertexAttrib2dARB)); - GL.VertexAttrib2dvARB = (GL.Delegates.VertexAttrib2dvARB) GetAddress("glVertexAttrib2dvARB", typeof(GL.Delegates.VertexAttrib2dvARB)); - GL.VertexAttrib2fARB = (GL.Delegates.VertexAttrib2fARB) GetAddress("glVertexAttrib2fARB", typeof(GL.Delegates.VertexAttrib2fARB)); - GL.VertexAttrib2fvARB = (GL.Delegates.VertexAttrib2fvARB) GetAddress("glVertexAttrib2fvARB", typeof(GL.Delegates.VertexAttrib2fvARB)); - GL.VertexAttrib2sARB = (GL.Delegates.VertexAttrib2sARB) GetAddress("glVertexAttrib2sARB", typeof(GL.Delegates.VertexAttrib2sARB)); - GL.VertexAttrib2svARB = (GL.Delegates.VertexAttrib2svARB) GetAddress("glVertexAttrib2svARB", typeof(GL.Delegates.VertexAttrib2svARB)); - GL.VertexAttrib3dARB = (GL.Delegates.VertexAttrib3dARB) GetAddress("glVertexAttrib3dARB", typeof(GL.Delegates.VertexAttrib3dARB)); - GL.VertexAttrib3dvARB = (GL.Delegates.VertexAttrib3dvARB) GetAddress("glVertexAttrib3dvARB", typeof(GL.Delegates.VertexAttrib3dvARB)); - GL.VertexAttrib3fARB = (GL.Delegates.VertexAttrib3fARB) GetAddress("glVertexAttrib3fARB", typeof(GL.Delegates.VertexAttrib3fARB)); - GL.VertexAttrib3fvARB = (GL.Delegates.VertexAttrib3fvARB) GetAddress("glVertexAttrib3fvARB", typeof(GL.Delegates.VertexAttrib3fvARB)); - GL.VertexAttrib3sARB = (GL.Delegates.VertexAttrib3sARB) GetAddress("glVertexAttrib3sARB", typeof(GL.Delegates.VertexAttrib3sARB)); - GL.VertexAttrib3svARB = (GL.Delegates.VertexAttrib3svARB) GetAddress("glVertexAttrib3svARB", typeof(GL.Delegates.VertexAttrib3svARB)); - GL.VertexAttrib4NbvARB = (GL.Delegates.VertexAttrib4NbvARB) GetAddress("glVertexAttrib4NbvARB", typeof(GL.Delegates.VertexAttrib4NbvARB)); - GL.VertexAttrib4NivARB = (GL.Delegates.VertexAttrib4NivARB) GetAddress("glVertexAttrib4NivARB", typeof(GL.Delegates.VertexAttrib4NivARB)); - GL.VertexAttrib4NsvARB = (GL.Delegates.VertexAttrib4NsvARB) GetAddress("glVertexAttrib4NsvARB", typeof(GL.Delegates.VertexAttrib4NsvARB)); - GL.VertexAttrib4NubARB = (GL.Delegates.VertexAttrib4NubARB) GetAddress("glVertexAttrib4NubARB", typeof(GL.Delegates.VertexAttrib4NubARB)); - GL.VertexAttrib4NubvARB = (GL.Delegates.VertexAttrib4NubvARB) GetAddress("glVertexAttrib4NubvARB", typeof(GL.Delegates.VertexAttrib4NubvARB)); - GL.VertexAttrib4NuivARB = (GL.Delegates.VertexAttrib4NuivARB) GetAddress("glVertexAttrib4NuivARB", typeof(GL.Delegates.VertexAttrib4NuivARB)); - GL.VertexAttrib4NusvARB = (GL.Delegates.VertexAttrib4NusvARB) GetAddress("glVertexAttrib4NusvARB", typeof(GL.Delegates.VertexAttrib4NusvARB)); - GL.VertexAttrib4bvARB = (GL.Delegates.VertexAttrib4bvARB) GetAddress("glVertexAttrib4bvARB", typeof(GL.Delegates.VertexAttrib4bvARB)); - GL.VertexAttrib4dARB = (GL.Delegates.VertexAttrib4dARB) GetAddress("glVertexAttrib4dARB", typeof(GL.Delegates.VertexAttrib4dARB)); - GL.VertexAttrib4dvARB = (GL.Delegates.VertexAttrib4dvARB) GetAddress("glVertexAttrib4dvARB", typeof(GL.Delegates.VertexAttrib4dvARB)); - GL.VertexAttrib4fARB = (GL.Delegates.VertexAttrib4fARB) GetAddress("glVertexAttrib4fARB", typeof(GL.Delegates.VertexAttrib4fARB)); - GL.VertexAttrib4fvARB = (GL.Delegates.VertexAttrib4fvARB) GetAddress("glVertexAttrib4fvARB", typeof(GL.Delegates.VertexAttrib4fvARB)); - GL.VertexAttrib4ivARB = (GL.Delegates.VertexAttrib4ivARB) GetAddress("glVertexAttrib4ivARB", typeof(GL.Delegates.VertexAttrib4ivARB)); - GL.VertexAttrib4sARB = (GL.Delegates.VertexAttrib4sARB) GetAddress("glVertexAttrib4sARB", typeof(GL.Delegates.VertexAttrib4sARB)); - GL.VertexAttrib4svARB = (GL.Delegates.VertexAttrib4svARB) GetAddress("glVertexAttrib4svARB", typeof(GL.Delegates.VertexAttrib4svARB)); - GL.VertexAttrib4ubvARB = (GL.Delegates.VertexAttrib4ubvARB) GetAddress("glVertexAttrib4ubvARB", typeof(GL.Delegates.VertexAttrib4ubvARB)); - GL.VertexAttrib4uivARB = (GL.Delegates.VertexAttrib4uivARB) GetAddress("glVertexAttrib4uivARB", typeof(GL.Delegates.VertexAttrib4uivARB)); - GL.VertexAttrib4usvARB = (GL.Delegates.VertexAttrib4usvARB) GetAddress("glVertexAttrib4usvARB", typeof(GL.Delegates.VertexAttrib4usvARB)); - GL.VertexAttribPointerARB = (GL.Delegates.VertexAttribPointerARB) GetAddress("glVertexAttribPointerARB", typeof(GL.Delegates.VertexAttribPointerARB)); - GL.EnableVertexAttribArrayARB = (GL.Delegates.EnableVertexAttribArrayARB) GetAddress("glEnableVertexAttribArrayARB", typeof(GL.Delegates.EnableVertexAttribArrayARB)); - GL.DisableVertexAttribArrayARB = (GL.Delegates.DisableVertexAttribArrayARB) GetAddress("glDisableVertexAttribArrayARB", typeof(GL.Delegates.DisableVertexAttribArrayARB)); - GL.ProgramStringARB = (GL.Delegates.ProgramStringARB) GetAddress("glProgramStringARB", typeof(GL.Delegates.ProgramStringARB)); - GL.BindProgramARB = (GL.Delegates.BindProgramARB) GetAddress("glBindProgramARB", typeof(GL.Delegates.BindProgramARB)); - GL.DeleteProgramsARB = (GL.Delegates.DeleteProgramsARB) GetAddress("glDeleteProgramsARB", typeof(GL.Delegates.DeleteProgramsARB)); - GL.GenProgramsARB = (GL.Delegates.GenProgramsARB) GetAddress("glGenProgramsARB", typeof(GL.Delegates.GenProgramsARB)); - GL.ProgramEnvParameter4dARB = (GL.Delegates.ProgramEnvParameter4dARB) GetAddress("glProgramEnvParameter4dARB", typeof(GL.Delegates.ProgramEnvParameter4dARB)); - GL.ProgramEnvParameter4dvARB = (GL.Delegates.ProgramEnvParameter4dvARB) GetAddress("glProgramEnvParameter4dvARB", typeof(GL.Delegates.ProgramEnvParameter4dvARB)); - GL.ProgramEnvParameter4fARB = (GL.Delegates.ProgramEnvParameter4fARB) GetAddress("glProgramEnvParameter4fARB", typeof(GL.Delegates.ProgramEnvParameter4fARB)); - GL.ProgramEnvParameter4fvARB = (GL.Delegates.ProgramEnvParameter4fvARB) GetAddress("glProgramEnvParameter4fvARB", typeof(GL.Delegates.ProgramEnvParameter4fvARB)); - GL.ProgramLocalParameter4dARB = (GL.Delegates.ProgramLocalParameter4dARB) GetAddress("glProgramLocalParameter4dARB", typeof(GL.Delegates.ProgramLocalParameter4dARB)); - GL.ProgramLocalParameter4dvARB = (GL.Delegates.ProgramLocalParameter4dvARB) GetAddress("glProgramLocalParameter4dvARB", typeof(GL.Delegates.ProgramLocalParameter4dvARB)); - GL.ProgramLocalParameter4fARB = (GL.Delegates.ProgramLocalParameter4fARB) GetAddress("glProgramLocalParameter4fARB", typeof(GL.Delegates.ProgramLocalParameter4fARB)); - GL.ProgramLocalParameter4fvARB = (GL.Delegates.ProgramLocalParameter4fvARB) GetAddress("glProgramLocalParameter4fvARB", typeof(GL.Delegates.ProgramLocalParameter4fvARB)); - GL.GetProgramEnvParameterdvARB = (GL.Delegates.GetProgramEnvParameterdvARB) GetAddress("glGetProgramEnvParameterdvARB", typeof(GL.Delegates.GetProgramEnvParameterdvARB)); - GL.GetProgramEnvParameterfvARB = (GL.Delegates.GetProgramEnvParameterfvARB) GetAddress("glGetProgramEnvParameterfvARB", typeof(GL.Delegates.GetProgramEnvParameterfvARB)); - GL.GetProgramLocalParameterdvARB = (GL.Delegates.GetProgramLocalParameterdvARB) GetAddress("glGetProgramLocalParameterdvARB", typeof(GL.Delegates.GetProgramLocalParameterdvARB)); - GL.GetProgramLocalParameterfvARB = (GL.Delegates.GetProgramLocalParameterfvARB) GetAddress("glGetProgramLocalParameterfvARB", typeof(GL.Delegates.GetProgramLocalParameterfvARB)); - GL.GetProgramivARB = (GL.Delegates.GetProgramivARB) GetAddress("glGetProgramivARB", typeof(GL.Delegates.GetProgramivARB)); - GL.GetProgramStringARB = (GL.Delegates.GetProgramStringARB) GetAddress("glGetProgramStringARB", typeof(GL.Delegates.GetProgramStringARB)); - GL.GetVertexAttribdvARB = (GL.Delegates.GetVertexAttribdvARB) GetAddress("glGetVertexAttribdvARB", typeof(GL.Delegates.GetVertexAttribdvARB)); - GL.GetVertexAttribfvARB = (GL.Delegates.GetVertexAttribfvARB) GetAddress("glGetVertexAttribfvARB", typeof(GL.Delegates.GetVertexAttribfvARB)); - GL.GetVertexAttribivARB = (GL.Delegates.GetVertexAttribivARB) GetAddress("glGetVertexAttribivARB", typeof(GL.Delegates.GetVertexAttribivARB)); - GL.GetVertexAttribPointervARB = (GL.Delegates.GetVertexAttribPointervARB) GetAddress("glGetVertexAttribPointervARB", typeof(GL.Delegates.GetVertexAttribPointervARB)); - GL.IsProgramARB = (GL.Delegates.IsProgramARB) GetAddress("glIsProgramARB", typeof(GL.Delegates.IsProgramARB)); - GL.BindBufferARB = (GL.Delegates.BindBufferARB) GetAddress("glBindBufferARB", typeof(GL.Delegates.BindBufferARB)); - GL.DeleteBuffersARB = (GL.Delegates.DeleteBuffersARB) GetAddress("glDeleteBuffersARB", typeof(GL.Delegates.DeleteBuffersARB)); - GL.GenBuffersARB = (GL.Delegates.GenBuffersARB) GetAddress("glGenBuffersARB", typeof(GL.Delegates.GenBuffersARB)); - GL.IsBufferARB = (GL.Delegates.IsBufferARB) GetAddress("glIsBufferARB", typeof(GL.Delegates.IsBufferARB)); - GL.BufferDataARB = (GL.Delegates.BufferDataARB) GetAddress("glBufferDataARB", typeof(GL.Delegates.BufferDataARB)); - GL.BufferSubDataARB = (GL.Delegates.BufferSubDataARB) GetAddress("glBufferSubDataARB", typeof(GL.Delegates.BufferSubDataARB)); - GL.GetBufferSubDataARB = (GL.Delegates.GetBufferSubDataARB) GetAddress("glGetBufferSubDataARB", typeof(GL.Delegates.GetBufferSubDataARB)); - GL.MapBufferARB_ = (GL.Delegates.MapBufferARB_) GetAddress("glMapBufferARB_", typeof(GL.Delegates.MapBufferARB_)); - GL.UnmapBufferARB = (GL.Delegates.UnmapBufferARB) GetAddress("glUnmapBufferARB", typeof(GL.Delegates.UnmapBufferARB)); - GL.GetBufferParameterivARB = (GL.Delegates.GetBufferParameterivARB) GetAddress("glGetBufferParameterivARB", typeof(GL.Delegates.GetBufferParameterivARB)); - GL.GetBufferPointervARB = (GL.Delegates.GetBufferPointervARB) GetAddress("glGetBufferPointervARB", typeof(GL.Delegates.GetBufferPointervARB)); - GL.GenQueriesARB = (GL.Delegates.GenQueriesARB) GetAddress("glGenQueriesARB", typeof(GL.Delegates.GenQueriesARB)); - GL.DeleteQueriesARB = (GL.Delegates.DeleteQueriesARB) GetAddress("glDeleteQueriesARB", typeof(GL.Delegates.DeleteQueriesARB)); - GL.IsQueryARB = (GL.Delegates.IsQueryARB) GetAddress("glIsQueryARB", typeof(GL.Delegates.IsQueryARB)); - GL.BeginQueryARB = (GL.Delegates.BeginQueryARB) GetAddress("glBeginQueryARB", typeof(GL.Delegates.BeginQueryARB)); - GL.EndQueryARB = (GL.Delegates.EndQueryARB) GetAddress("glEndQueryARB", typeof(GL.Delegates.EndQueryARB)); - GL.GetQueryivARB = (GL.Delegates.GetQueryivARB) GetAddress("glGetQueryivARB", typeof(GL.Delegates.GetQueryivARB)); - GL.GetQueryObjectivARB = (GL.Delegates.GetQueryObjectivARB) GetAddress("glGetQueryObjectivARB", typeof(GL.Delegates.GetQueryObjectivARB)); - GL.GetQueryObjectuivARB = (GL.Delegates.GetQueryObjectuivARB) GetAddress("glGetQueryObjectuivARB", typeof(GL.Delegates.GetQueryObjectuivARB)); - GL.DeleteObjectARB = (GL.Delegates.DeleteObjectARB) GetAddress("glDeleteObjectARB", typeof(GL.Delegates.DeleteObjectARB)); - GL.GetHandleARB = (GL.Delegates.GetHandleARB) GetAddress("glGetHandleARB", typeof(GL.Delegates.GetHandleARB)); - GL.DetachObjectARB = (GL.Delegates.DetachObjectARB) GetAddress("glDetachObjectARB", typeof(GL.Delegates.DetachObjectARB)); - GL.CreateShaderObjectARB = (GL.Delegates.CreateShaderObjectARB) GetAddress("glCreateShaderObjectARB", typeof(GL.Delegates.CreateShaderObjectARB)); - GL.ShaderSourceARB = (GL.Delegates.ShaderSourceARB) GetAddress("glShaderSourceARB", typeof(GL.Delegates.ShaderSourceARB)); - GL.CompileShaderARB = (GL.Delegates.CompileShaderARB) GetAddress("glCompileShaderARB", typeof(GL.Delegates.CompileShaderARB)); - GL.CreateProgramObjectARB = (GL.Delegates.CreateProgramObjectARB) GetAddress("glCreateProgramObjectARB", typeof(GL.Delegates.CreateProgramObjectARB)); - GL.AttachObjectARB = (GL.Delegates.AttachObjectARB) GetAddress("glAttachObjectARB", typeof(GL.Delegates.AttachObjectARB)); - GL.LinkProgramARB = (GL.Delegates.LinkProgramARB) GetAddress("glLinkProgramARB", typeof(GL.Delegates.LinkProgramARB)); - GL.UseProgramObjectARB = (GL.Delegates.UseProgramObjectARB) GetAddress("glUseProgramObjectARB", typeof(GL.Delegates.UseProgramObjectARB)); - GL.ValidateProgramARB = (GL.Delegates.ValidateProgramARB) GetAddress("glValidateProgramARB", typeof(GL.Delegates.ValidateProgramARB)); - GL.Uniform1fARB = (GL.Delegates.Uniform1fARB) GetAddress("glUniform1fARB", typeof(GL.Delegates.Uniform1fARB)); - GL.Uniform2fARB = (GL.Delegates.Uniform2fARB) GetAddress("glUniform2fARB", typeof(GL.Delegates.Uniform2fARB)); - GL.Uniform3fARB = (GL.Delegates.Uniform3fARB) GetAddress("glUniform3fARB", typeof(GL.Delegates.Uniform3fARB)); - GL.Uniform4fARB = (GL.Delegates.Uniform4fARB) GetAddress("glUniform4fARB", typeof(GL.Delegates.Uniform4fARB)); - GL.Uniform1iARB = (GL.Delegates.Uniform1iARB) GetAddress("glUniform1iARB", typeof(GL.Delegates.Uniform1iARB)); - GL.Uniform2iARB = (GL.Delegates.Uniform2iARB) GetAddress("glUniform2iARB", typeof(GL.Delegates.Uniform2iARB)); - GL.Uniform3iARB = (GL.Delegates.Uniform3iARB) GetAddress("glUniform3iARB", typeof(GL.Delegates.Uniform3iARB)); - GL.Uniform4iARB = (GL.Delegates.Uniform4iARB) GetAddress("glUniform4iARB", typeof(GL.Delegates.Uniform4iARB)); - GL.Uniform1fvARB = (GL.Delegates.Uniform1fvARB) GetAddress("glUniform1fvARB", typeof(GL.Delegates.Uniform1fvARB)); - GL.Uniform2fvARB = (GL.Delegates.Uniform2fvARB) GetAddress("glUniform2fvARB", typeof(GL.Delegates.Uniform2fvARB)); - GL.Uniform3fvARB = (GL.Delegates.Uniform3fvARB) GetAddress("glUniform3fvARB", typeof(GL.Delegates.Uniform3fvARB)); - GL.Uniform4fvARB = (GL.Delegates.Uniform4fvARB) GetAddress("glUniform4fvARB", typeof(GL.Delegates.Uniform4fvARB)); - GL.Uniform1ivARB = (GL.Delegates.Uniform1ivARB) GetAddress("glUniform1ivARB", typeof(GL.Delegates.Uniform1ivARB)); - GL.Uniform2ivARB = (GL.Delegates.Uniform2ivARB) GetAddress("glUniform2ivARB", typeof(GL.Delegates.Uniform2ivARB)); - GL.Uniform3ivARB = (GL.Delegates.Uniform3ivARB) GetAddress("glUniform3ivARB", typeof(GL.Delegates.Uniform3ivARB)); - GL.Uniform4ivARB = (GL.Delegates.Uniform4ivARB) GetAddress("glUniform4ivARB", typeof(GL.Delegates.Uniform4ivARB)); - GL.UniformMatrix2fvARB = (GL.Delegates.UniformMatrix2fvARB) GetAddress("glUniformMatrix2fvARB", typeof(GL.Delegates.UniformMatrix2fvARB)); - GL.UniformMatrix3fvARB = (GL.Delegates.UniformMatrix3fvARB) GetAddress("glUniformMatrix3fvARB", typeof(GL.Delegates.UniformMatrix3fvARB)); - GL.UniformMatrix4fvARB = (GL.Delegates.UniformMatrix4fvARB) GetAddress("glUniformMatrix4fvARB", typeof(GL.Delegates.UniformMatrix4fvARB)); - GL.GetObjectParameterfvARB = (GL.Delegates.GetObjectParameterfvARB) GetAddress("glGetObjectParameterfvARB", typeof(GL.Delegates.GetObjectParameterfvARB)); - GL.GetObjectParameterivARB = (GL.Delegates.GetObjectParameterivARB) GetAddress("glGetObjectParameterivARB", typeof(GL.Delegates.GetObjectParameterivARB)); - GL.GetInfoLogARB = (GL.Delegates.GetInfoLogARB) GetAddress("glGetInfoLogARB", typeof(GL.Delegates.GetInfoLogARB)); - GL.GetAttachedObjectsARB = (GL.Delegates.GetAttachedObjectsARB) GetAddress("glGetAttachedObjectsARB", typeof(GL.Delegates.GetAttachedObjectsARB)); - GL.GetUniformLocationARB = (GL.Delegates.GetUniformLocationARB) GetAddress("glGetUniformLocationARB", typeof(GL.Delegates.GetUniformLocationARB)); - GL.GetActiveUniformARB = (GL.Delegates.GetActiveUniformARB) GetAddress("glGetActiveUniformARB", typeof(GL.Delegates.GetActiveUniformARB)); - GL.GetUniformfvARB = (GL.Delegates.GetUniformfvARB) GetAddress("glGetUniformfvARB", typeof(GL.Delegates.GetUniformfvARB)); - GL.GetUniformivARB = (GL.Delegates.GetUniformivARB) GetAddress("glGetUniformivARB", typeof(GL.Delegates.GetUniformivARB)); - GL.GetShaderSourceARB = (GL.Delegates.GetShaderSourceARB) GetAddress("glGetShaderSourceARB", typeof(GL.Delegates.GetShaderSourceARB)); - GL.BindAttribLocationARB = (GL.Delegates.BindAttribLocationARB) GetAddress("glBindAttribLocationARB", typeof(GL.Delegates.BindAttribLocationARB)); - GL.GetActiveAttribARB = (GL.Delegates.GetActiveAttribARB) GetAddress("glGetActiveAttribARB", typeof(GL.Delegates.GetActiveAttribARB)); - GL.GetAttribLocationARB = (GL.Delegates.GetAttribLocationARB) GetAddress("glGetAttribLocationARB", typeof(GL.Delegates.GetAttribLocationARB)); - GL.DrawBuffersARB = (GL.Delegates.DrawBuffersARB) GetAddress("glDrawBuffersARB", typeof(GL.Delegates.DrawBuffersARB)); - GL.ClampColorARB = (GL.Delegates.ClampColorARB) GetAddress("glClampColorARB", typeof(GL.Delegates.ClampColorARB)); - GL.BlendColorEXT = (GL.Delegates.BlendColorEXT) GetAddress("glBlendColorEXT", typeof(GL.Delegates.BlendColorEXT)); - GL.PolygonOffsetEXT = (GL.Delegates.PolygonOffsetEXT) GetAddress("glPolygonOffsetEXT", typeof(GL.Delegates.PolygonOffsetEXT)); - GL.TexImage3DEXT = (GL.Delegates.TexImage3DEXT) GetAddress("glTexImage3DEXT", typeof(GL.Delegates.TexImage3DEXT)); - GL.TexSubImage3DEXT = (GL.Delegates.TexSubImage3DEXT) GetAddress("glTexSubImage3DEXT", typeof(GL.Delegates.TexSubImage3DEXT)); - GL.GetTexFilterFuncSGIS = (GL.Delegates.GetTexFilterFuncSGIS) GetAddress("glGetTexFilterFuncSGIS", typeof(GL.Delegates.GetTexFilterFuncSGIS)); - GL.TexFilterFuncSGIS = (GL.Delegates.TexFilterFuncSGIS) GetAddress("glTexFilterFuncSGIS", typeof(GL.Delegates.TexFilterFuncSGIS)); - GL.TexSubImage1DEXT = (GL.Delegates.TexSubImage1DEXT) GetAddress("glTexSubImage1DEXT", typeof(GL.Delegates.TexSubImage1DEXT)); - GL.TexSubImage2DEXT = (GL.Delegates.TexSubImage2DEXT) GetAddress("glTexSubImage2DEXT", typeof(GL.Delegates.TexSubImage2DEXT)); - GL.CopyTexImage1DEXT = (GL.Delegates.CopyTexImage1DEXT) GetAddress("glCopyTexImage1DEXT", typeof(GL.Delegates.CopyTexImage1DEXT)); - GL.CopyTexImage2DEXT = (GL.Delegates.CopyTexImage2DEXT) GetAddress("glCopyTexImage2DEXT", typeof(GL.Delegates.CopyTexImage2DEXT)); - GL.CopyTexSubImage1DEXT = (GL.Delegates.CopyTexSubImage1DEXT) GetAddress("glCopyTexSubImage1DEXT", typeof(GL.Delegates.CopyTexSubImage1DEXT)); - GL.CopyTexSubImage2DEXT = (GL.Delegates.CopyTexSubImage2DEXT) GetAddress("glCopyTexSubImage2DEXT", typeof(GL.Delegates.CopyTexSubImage2DEXT)); - GL.CopyTexSubImage3DEXT = (GL.Delegates.CopyTexSubImage3DEXT) GetAddress("glCopyTexSubImage3DEXT", typeof(GL.Delegates.CopyTexSubImage3DEXT)); - GL.GetHistogramEXT = (GL.Delegates.GetHistogramEXT) GetAddress("glGetHistogramEXT", typeof(GL.Delegates.GetHistogramEXT)); - GL.GetHistogramParameterfvEXT = (GL.Delegates.GetHistogramParameterfvEXT) GetAddress("glGetHistogramParameterfvEXT", typeof(GL.Delegates.GetHistogramParameterfvEXT)); - GL.GetHistogramParameterivEXT = (GL.Delegates.GetHistogramParameterivEXT) GetAddress("glGetHistogramParameterivEXT", typeof(GL.Delegates.GetHistogramParameterivEXT)); - GL.GetMinmaxEXT = (GL.Delegates.GetMinmaxEXT) GetAddress("glGetMinmaxEXT", typeof(GL.Delegates.GetMinmaxEXT)); - GL.GetMinmaxParameterfvEXT = (GL.Delegates.GetMinmaxParameterfvEXT) GetAddress("glGetMinmaxParameterfvEXT", typeof(GL.Delegates.GetMinmaxParameterfvEXT)); - GL.GetMinmaxParameterivEXT = (GL.Delegates.GetMinmaxParameterivEXT) GetAddress("glGetMinmaxParameterivEXT", typeof(GL.Delegates.GetMinmaxParameterivEXT)); - GL.HistogramEXT = (GL.Delegates.HistogramEXT) GetAddress("glHistogramEXT", typeof(GL.Delegates.HistogramEXT)); - GL.MinmaxEXT = (GL.Delegates.MinmaxEXT) GetAddress("glMinmaxEXT", typeof(GL.Delegates.MinmaxEXT)); - GL.ResetHistogramEXT = (GL.Delegates.ResetHistogramEXT) GetAddress("glResetHistogramEXT", typeof(GL.Delegates.ResetHistogramEXT)); - GL.ResetMinmaxEXT = (GL.Delegates.ResetMinmaxEXT) GetAddress("glResetMinmaxEXT", typeof(GL.Delegates.ResetMinmaxEXT)); - GL.ConvolutionFilter1DEXT = (GL.Delegates.ConvolutionFilter1DEXT) GetAddress("glConvolutionFilter1DEXT", typeof(GL.Delegates.ConvolutionFilter1DEXT)); - GL.ConvolutionFilter2DEXT = (GL.Delegates.ConvolutionFilter2DEXT) GetAddress("glConvolutionFilter2DEXT", typeof(GL.Delegates.ConvolutionFilter2DEXT)); - GL.ConvolutionParameterfEXT = (GL.Delegates.ConvolutionParameterfEXT) GetAddress("glConvolutionParameterfEXT", typeof(GL.Delegates.ConvolutionParameterfEXT)); - GL.ConvolutionParameterfvEXT = (GL.Delegates.ConvolutionParameterfvEXT) GetAddress("glConvolutionParameterfvEXT", typeof(GL.Delegates.ConvolutionParameterfvEXT)); - GL.ConvolutionParameteriEXT = (GL.Delegates.ConvolutionParameteriEXT) GetAddress("glConvolutionParameteriEXT", typeof(GL.Delegates.ConvolutionParameteriEXT)); - GL.ConvolutionParameterivEXT = (GL.Delegates.ConvolutionParameterivEXT) GetAddress("glConvolutionParameterivEXT", typeof(GL.Delegates.ConvolutionParameterivEXT)); - GL.CopyConvolutionFilter1DEXT = (GL.Delegates.CopyConvolutionFilter1DEXT) GetAddress("glCopyConvolutionFilter1DEXT", typeof(GL.Delegates.CopyConvolutionFilter1DEXT)); - GL.CopyConvolutionFilter2DEXT = (GL.Delegates.CopyConvolutionFilter2DEXT) GetAddress("glCopyConvolutionFilter2DEXT", typeof(GL.Delegates.CopyConvolutionFilter2DEXT)); - GL.GetConvolutionFilterEXT = (GL.Delegates.GetConvolutionFilterEXT) GetAddress("glGetConvolutionFilterEXT", typeof(GL.Delegates.GetConvolutionFilterEXT)); - GL.GetConvolutionParameterfvEXT = (GL.Delegates.GetConvolutionParameterfvEXT) GetAddress("glGetConvolutionParameterfvEXT", typeof(GL.Delegates.GetConvolutionParameterfvEXT)); - GL.GetConvolutionParameterivEXT = (GL.Delegates.GetConvolutionParameterivEXT) GetAddress("glGetConvolutionParameterivEXT", typeof(GL.Delegates.GetConvolutionParameterivEXT)); - GL.GetSeparableFilterEXT = (GL.Delegates.GetSeparableFilterEXT) GetAddress("glGetSeparableFilterEXT", typeof(GL.Delegates.GetSeparableFilterEXT)); - GL.SeparableFilter2DEXT = (GL.Delegates.SeparableFilter2DEXT) GetAddress("glSeparableFilter2DEXT", typeof(GL.Delegates.SeparableFilter2DEXT)); - GL.ColorTableSGI = (GL.Delegates.ColorTableSGI) GetAddress("glColorTableSGI", typeof(GL.Delegates.ColorTableSGI)); - GL.ColorTableParameterfvSGI = (GL.Delegates.ColorTableParameterfvSGI) GetAddress("glColorTableParameterfvSGI", typeof(GL.Delegates.ColorTableParameterfvSGI)); - GL.ColorTableParameterivSGI = (GL.Delegates.ColorTableParameterivSGI) GetAddress("glColorTableParameterivSGI", typeof(GL.Delegates.ColorTableParameterivSGI)); - GL.CopyColorTableSGI = (GL.Delegates.CopyColorTableSGI) GetAddress("glCopyColorTableSGI", typeof(GL.Delegates.CopyColorTableSGI)); - GL.GetColorTableSGI = (GL.Delegates.GetColorTableSGI) GetAddress("glGetColorTableSGI", typeof(GL.Delegates.GetColorTableSGI)); - GL.GetColorTableParameterfvSGI = (GL.Delegates.GetColorTableParameterfvSGI) GetAddress("glGetColorTableParameterfvSGI", typeof(GL.Delegates.GetColorTableParameterfvSGI)); - GL.GetColorTableParameterivSGI = (GL.Delegates.GetColorTableParameterivSGI) GetAddress("glGetColorTableParameterivSGI", typeof(GL.Delegates.GetColorTableParameterivSGI)); - GL.PixelTexGenSGIX = (GL.Delegates.PixelTexGenSGIX) GetAddress("glPixelTexGenSGIX", typeof(GL.Delegates.PixelTexGenSGIX)); - GL.PixelTexGenParameteriSGIS = (GL.Delegates.PixelTexGenParameteriSGIS) GetAddress("glPixelTexGenParameteriSGIS", typeof(GL.Delegates.PixelTexGenParameteriSGIS)); - GL.PixelTexGenParameterivSGIS = (GL.Delegates.PixelTexGenParameterivSGIS) GetAddress("glPixelTexGenParameterivSGIS", typeof(GL.Delegates.PixelTexGenParameterivSGIS)); - GL.PixelTexGenParameterfSGIS = (GL.Delegates.PixelTexGenParameterfSGIS) GetAddress("glPixelTexGenParameterfSGIS", typeof(GL.Delegates.PixelTexGenParameterfSGIS)); - GL.PixelTexGenParameterfvSGIS = (GL.Delegates.PixelTexGenParameterfvSGIS) GetAddress("glPixelTexGenParameterfvSGIS", typeof(GL.Delegates.PixelTexGenParameterfvSGIS)); - GL.GetPixelTexGenParameterivSGIS = (GL.Delegates.GetPixelTexGenParameterivSGIS) GetAddress("glGetPixelTexGenParameterivSGIS", typeof(GL.Delegates.GetPixelTexGenParameterivSGIS)); - GL.GetPixelTexGenParameterfvSGIS = (GL.Delegates.GetPixelTexGenParameterfvSGIS) GetAddress("glGetPixelTexGenParameterfvSGIS", typeof(GL.Delegates.GetPixelTexGenParameterfvSGIS)); - GL.TexImage4DSGIS = (GL.Delegates.TexImage4DSGIS) GetAddress("glTexImage4DSGIS", typeof(GL.Delegates.TexImage4DSGIS)); - GL.TexSubImage4DSGIS = (GL.Delegates.TexSubImage4DSGIS) GetAddress("glTexSubImage4DSGIS", typeof(GL.Delegates.TexSubImage4DSGIS)); - GL.AreTexturesResidentEXT = (GL.Delegates.AreTexturesResidentEXT) GetAddress("glAreTexturesResidentEXT", typeof(GL.Delegates.AreTexturesResidentEXT)); - GL.BindTextureEXT = (GL.Delegates.BindTextureEXT) GetAddress("glBindTextureEXT", typeof(GL.Delegates.BindTextureEXT)); - GL.DeleteTexturesEXT = (GL.Delegates.DeleteTexturesEXT) GetAddress("glDeleteTexturesEXT", typeof(GL.Delegates.DeleteTexturesEXT)); - GL.GenTexturesEXT = (GL.Delegates.GenTexturesEXT) GetAddress("glGenTexturesEXT", typeof(GL.Delegates.GenTexturesEXT)); - GL.IsTextureEXT = (GL.Delegates.IsTextureEXT) GetAddress("glIsTextureEXT", typeof(GL.Delegates.IsTextureEXT)); - GL.PrioritizeTexturesEXT = (GL.Delegates.PrioritizeTexturesEXT) GetAddress("glPrioritizeTexturesEXT", typeof(GL.Delegates.PrioritizeTexturesEXT)); - GL.DetailTexFuncSGIS = (GL.Delegates.DetailTexFuncSGIS) GetAddress("glDetailTexFuncSGIS", typeof(GL.Delegates.DetailTexFuncSGIS)); - GL.GetDetailTexFuncSGIS = (GL.Delegates.GetDetailTexFuncSGIS) GetAddress("glGetDetailTexFuncSGIS", typeof(GL.Delegates.GetDetailTexFuncSGIS)); - GL.SharpenTexFuncSGIS = (GL.Delegates.SharpenTexFuncSGIS) GetAddress("glSharpenTexFuncSGIS", typeof(GL.Delegates.SharpenTexFuncSGIS)); - GL.GetSharpenTexFuncSGIS = (GL.Delegates.GetSharpenTexFuncSGIS) GetAddress("glGetSharpenTexFuncSGIS", typeof(GL.Delegates.GetSharpenTexFuncSGIS)); - GL.SampleMaskSGIS = (GL.Delegates.SampleMaskSGIS) GetAddress("glSampleMaskSGIS", typeof(GL.Delegates.SampleMaskSGIS)); - GL.SamplePatternSGIS = (GL.Delegates.SamplePatternSGIS) GetAddress("glSamplePatternSGIS", typeof(GL.Delegates.SamplePatternSGIS)); - GL.ArrayElementEXT = (GL.Delegates.ArrayElementEXT) GetAddress("glArrayElementEXT", typeof(GL.Delegates.ArrayElementEXT)); - GL.ColorPointerEXT = (GL.Delegates.ColorPointerEXT) GetAddress("glColorPointerEXT", typeof(GL.Delegates.ColorPointerEXT)); - GL.DrawArraysEXT = (GL.Delegates.DrawArraysEXT) GetAddress("glDrawArraysEXT", typeof(GL.Delegates.DrawArraysEXT)); - GL.EdgeFlagPointerEXT = (GL.Delegates.EdgeFlagPointerEXT) GetAddress("glEdgeFlagPointerEXT", typeof(GL.Delegates.EdgeFlagPointerEXT)); - GL.GetPointervEXT = (GL.Delegates.GetPointervEXT) GetAddress("glGetPointervEXT", typeof(GL.Delegates.GetPointervEXT)); - GL.IndexPointerEXT = (GL.Delegates.IndexPointerEXT) GetAddress("glIndexPointerEXT", typeof(GL.Delegates.IndexPointerEXT)); - GL.NormalPointerEXT = (GL.Delegates.NormalPointerEXT) GetAddress("glNormalPointerEXT", typeof(GL.Delegates.NormalPointerEXT)); - GL.TexCoordPointerEXT = (GL.Delegates.TexCoordPointerEXT) GetAddress("glTexCoordPointerEXT", typeof(GL.Delegates.TexCoordPointerEXT)); - GL.VertexPointerEXT = (GL.Delegates.VertexPointerEXT) GetAddress("glVertexPointerEXT", typeof(GL.Delegates.VertexPointerEXT)); - GL.BlendEquationEXT = (GL.Delegates.BlendEquationEXT) GetAddress("glBlendEquationEXT", typeof(GL.Delegates.BlendEquationEXT)); - GL.SpriteParameterfSGIX = (GL.Delegates.SpriteParameterfSGIX) GetAddress("glSpriteParameterfSGIX", typeof(GL.Delegates.SpriteParameterfSGIX)); - GL.SpriteParameterfvSGIX = (GL.Delegates.SpriteParameterfvSGIX) GetAddress("glSpriteParameterfvSGIX", typeof(GL.Delegates.SpriteParameterfvSGIX)); - GL.SpriteParameteriSGIX = (GL.Delegates.SpriteParameteriSGIX) GetAddress("glSpriteParameteriSGIX", typeof(GL.Delegates.SpriteParameteriSGIX)); - GL.SpriteParameterivSGIX = (GL.Delegates.SpriteParameterivSGIX) GetAddress("glSpriteParameterivSGIX", typeof(GL.Delegates.SpriteParameterivSGIX)); - GL.PointParameterfEXT = (GL.Delegates.PointParameterfEXT) GetAddress("glPointParameterfEXT", typeof(GL.Delegates.PointParameterfEXT)); - GL.PointParameterfvEXT = (GL.Delegates.PointParameterfvEXT) GetAddress("glPointParameterfvEXT", typeof(GL.Delegates.PointParameterfvEXT)); - GL.PointParameterfSGIS = (GL.Delegates.PointParameterfSGIS) GetAddress("glPointParameterfSGIS", typeof(GL.Delegates.PointParameterfSGIS)); - GL.PointParameterfvSGIS = (GL.Delegates.PointParameterfvSGIS) GetAddress("glPointParameterfvSGIS", typeof(GL.Delegates.PointParameterfvSGIS)); - GL.GetInstrumentsSGIX = (GL.Delegates.GetInstrumentsSGIX) GetAddress("glGetInstrumentsSGIX", typeof(GL.Delegates.GetInstrumentsSGIX)); - GL.InstrumentsBufferSGIX = (GL.Delegates.InstrumentsBufferSGIX) GetAddress("glInstrumentsBufferSGIX", typeof(GL.Delegates.InstrumentsBufferSGIX)); - GL.PollInstrumentsSGIX = (GL.Delegates.PollInstrumentsSGIX) GetAddress("glPollInstrumentsSGIX", typeof(GL.Delegates.PollInstrumentsSGIX)); - GL.ReadInstrumentsSGIX = (GL.Delegates.ReadInstrumentsSGIX) GetAddress("glReadInstrumentsSGIX", typeof(GL.Delegates.ReadInstrumentsSGIX)); - GL.StartInstrumentsSGIX = (GL.Delegates.StartInstrumentsSGIX) GetAddress("glStartInstrumentsSGIX", typeof(GL.Delegates.StartInstrumentsSGIX)); - GL.StopInstrumentsSGIX = (GL.Delegates.StopInstrumentsSGIX) GetAddress("glStopInstrumentsSGIX", typeof(GL.Delegates.StopInstrumentsSGIX)); - GL.FrameZoomSGIX = (GL.Delegates.FrameZoomSGIX) GetAddress("glFrameZoomSGIX", typeof(GL.Delegates.FrameZoomSGIX)); - GL.TagSampleBufferSGIX = (GL.Delegates.TagSampleBufferSGIX) GetAddress("glTagSampleBufferSGIX", typeof(GL.Delegates.TagSampleBufferSGIX)); - GL.DeformationMap3dSGIX = (GL.Delegates.DeformationMap3dSGIX) GetAddress("glDeformationMap3dSGIX", typeof(GL.Delegates.DeformationMap3dSGIX)); - GL.DeformationMap3fSGIX = (GL.Delegates.DeformationMap3fSGIX) GetAddress("glDeformationMap3fSGIX", typeof(GL.Delegates.DeformationMap3fSGIX)); - GL.DeformSGIX = (GL.Delegates.DeformSGIX) GetAddress("glDeformSGIX", typeof(GL.Delegates.DeformSGIX)); - GL.LoadIdentityDeformationMapSGIX = (GL.Delegates.LoadIdentityDeformationMapSGIX) GetAddress("glLoadIdentityDeformationMapSGIX", typeof(GL.Delegates.LoadIdentityDeformationMapSGIX)); - GL.ReferencePlaneSGIX = (GL.Delegates.ReferencePlaneSGIX) GetAddress("glReferencePlaneSGIX", typeof(GL.Delegates.ReferencePlaneSGIX)); - GL.FlushRasterSGIX = (GL.Delegates.FlushRasterSGIX) GetAddress("glFlushRasterSGIX", typeof(GL.Delegates.FlushRasterSGIX)); - GL.FogFuncSGIS = (GL.Delegates.FogFuncSGIS) GetAddress("glFogFuncSGIS", typeof(GL.Delegates.FogFuncSGIS)); - GL.GetFogFuncSGIS = (GL.Delegates.GetFogFuncSGIS) GetAddress("glGetFogFuncSGIS", typeof(GL.Delegates.GetFogFuncSGIS)); - GL.ImageTransformParameteriHP = (GL.Delegates.ImageTransformParameteriHP) GetAddress("glImageTransformParameteriHP", typeof(GL.Delegates.ImageTransformParameteriHP)); - GL.ImageTransformParameterfHP = (GL.Delegates.ImageTransformParameterfHP) GetAddress("glImageTransformParameterfHP", typeof(GL.Delegates.ImageTransformParameterfHP)); - GL.ImageTransformParameterivHP = (GL.Delegates.ImageTransformParameterivHP) GetAddress("glImageTransformParameterivHP", typeof(GL.Delegates.ImageTransformParameterivHP)); - GL.ImageTransformParameterfvHP = (GL.Delegates.ImageTransformParameterfvHP) GetAddress("glImageTransformParameterfvHP", typeof(GL.Delegates.ImageTransformParameterfvHP)); - GL.GetImageTransformParameterivHP = (GL.Delegates.GetImageTransformParameterivHP) GetAddress("glGetImageTransformParameterivHP", typeof(GL.Delegates.GetImageTransformParameterivHP)); - GL.GetImageTransformParameterfvHP = (GL.Delegates.GetImageTransformParameterfvHP) GetAddress("glGetImageTransformParameterfvHP", typeof(GL.Delegates.GetImageTransformParameterfvHP)); - GL.ColorSubTableEXT = (GL.Delegates.ColorSubTableEXT) GetAddress("glColorSubTableEXT", typeof(GL.Delegates.ColorSubTableEXT)); - GL.CopyColorSubTableEXT = (GL.Delegates.CopyColorSubTableEXT) GetAddress("glCopyColorSubTableEXT", typeof(GL.Delegates.CopyColorSubTableEXT)); - GL.HintPGI = (GL.Delegates.HintPGI) GetAddress("glHintPGI", typeof(GL.Delegates.HintPGI)); - GL.ColorTableEXT = (GL.Delegates.ColorTableEXT) GetAddress("glColorTableEXT", typeof(GL.Delegates.ColorTableEXT)); - GL.GetColorTableEXT = (GL.Delegates.GetColorTableEXT) GetAddress("glGetColorTableEXT", typeof(GL.Delegates.GetColorTableEXT)); - GL.GetColorTableParameterivEXT = (GL.Delegates.GetColorTableParameterivEXT) GetAddress("glGetColorTableParameterivEXT", typeof(GL.Delegates.GetColorTableParameterivEXT)); - GL.GetColorTableParameterfvEXT = (GL.Delegates.GetColorTableParameterfvEXT) GetAddress("glGetColorTableParameterfvEXT", typeof(GL.Delegates.GetColorTableParameterfvEXT)); - GL.GetListParameterfvSGIX = (GL.Delegates.GetListParameterfvSGIX) GetAddress("glGetListParameterfvSGIX", typeof(GL.Delegates.GetListParameterfvSGIX)); - GL.GetListParameterivSGIX = (GL.Delegates.GetListParameterivSGIX) GetAddress("glGetListParameterivSGIX", typeof(GL.Delegates.GetListParameterivSGIX)); - GL.ListParameterfSGIX = (GL.Delegates.ListParameterfSGIX) GetAddress("glListParameterfSGIX", typeof(GL.Delegates.ListParameterfSGIX)); - GL.ListParameterfvSGIX = (GL.Delegates.ListParameterfvSGIX) GetAddress("glListParameterfvSGIX", typeof(GL.Delegates.ListParameterfvSGIX)); - GL.ListParameteriSGIX = (GL.Delegates.ListParameteriSGIX) GetAddress("glListParameteriSGIX", typeof(GL.Delegates.ListParameteriSGIX)); - GL.ListParameterivSGIX = (GL.Delegates.ListParameterivSGIX) GetAddress("glListParameterivSGIX", typeof(GL.Delegates.ListParameterivSGIX)); - GL.IndexMaterialEXT = (GL.Delegates.IndexMaterialEXT) GetAddress("glIndexMaterialEXT", typeof(GL.Delegates.IndexMaterialEXT)); - GL.IndexFuncEXT = (GL.Delegates.IndexFuncEXT) GetAddress("glIndexFuncEXT", typeof(GL.Delegates.IndexFuncEXT)); - GL.LockArraysEXT = (GL.Delegates.LockArraysEXT) GetAddress("glLockArraysEXT", typeof(GL.Delegates.LockArraysEXT)); - GL.UnlockArraysEXT = (GL.Delegates.UnlockArraysEXT) GetAddress("glUnlockArraysEXT", typeof(GL.Delegates.UnlockArraysEXT)); - GL.CullParameterdvEXT = (GL.Delegates.CullParameterdvEXT) GetAddress("glCullParameterdvEXT", typeof(GL.Delegates.CullParameterdvEXT)); - GL.CullParameterfvEXT = (GL.Delegates.CullParameterfvEXT) GetAddress("glCullParameterfvEXT", typeof(GL.Delegates.CullParameterfvEXT)); - GL.FragmentColorMaterialSGIX = (GL.Delegates.FragmentColorMaterialSGIX) GetAddress("glFragmentColorMaterialSGIX", typeof(GL.Delegates.FragmentColorMaterialSGIX)); - GL.FragmentLightfSGIX = (GL.Delegates.FragmentLightfSGIX) GetAddress("glFragmentLightfSGIX", typeof(GL.Delegates.FragmentLightfSGIX)); - GL.FragmentLightfvSGIX = (GL.Delegates.FragmentLightfvSGIX) GetAddress("glFragmentLightfvSGIX", typeof(GL.Delegates.FragmentLightfvSGIX)); - GL.FragmentLightiSGIX = (GL.Delegates.FragmentLightiSGIX) GetAddress("glFragmentLightiSGIX", typeof(GL.Delegates.FragmentLightiSGIX)); - GL.FragmentLightivSGIX = (GL.Delegates.FragmentLightivSGIX) GetAddress("glFragmentLightivSGIX", typeof(GL.Delegates.FragmentLightivSGIX)); - GL.FragmentLightModelfSGIX = (GL.Delegates.FragmentLightModelfSGIX) GetAddress("glFragmentLightModelfSGIX", typeof(GL.Delegates.FragmentLightModelfSGIX)); - GL.FragmentLightModelfvSGIX = (GL.Delegates.FragmentLightModelfvSGIX) GetAddress("glFragmentLightModelfvSGIX", typeof(GL.Delegates.FragmentLightModelfvSGIX)); - GL.FragmentLightModeliSGIX = (GL.Delegates.FragmentLightModeliSGIX) GetAddress("glFragmentLightModeliSGIX", typeof(GL.Delegates.FragmentLightModeliSGIX)); - GL.FragmentLightModelivSGIX = (GL.Delegates.FragmentLightModelivSGIX) GetAddress("glFragmentLightModelivSGIX", typeof(GL.Delegates.FragmentLightModelivSGIX)); - GL.FragmentMaterialfSGIX = (GL.Delegates.FragmentMaterialfSGIX) GetAddress("glFragmentMaterialfSGIX", typeof(GL.Delegates.FragmentMaterialfSGIX)); - GL.FragmentMaterialfvSGIX = (GL.Delegates.FragmentMaterialfvSGIX) GetAddress("glFragmentMaterialfvSGIX", typeof(GL.Delegates.FragmentMaterialfvSGIX)); - GL.FragmentMaterialiSGIX = (GL.Delegates.FragmentMaterialiSGIX) GetAddress("glFragmentMaterialiSGIX", typeof(GL.Delegates.FragmentMaterialiSGIX)); - GL.FragmentMaterialivSGIX = (GL.Delegates.FragmentMaterialivSGIX) GetAddress("glFragmentMaterialivSGIX", typeof(GL.Delegates.FragmentMaterialivSGIX)); - GL.GetFragmentLightfvSGIX = (GL.Delegates.GetFragmentLightfvSGIX) GetAddress("glGetFragmentLightfvSGIX", typeof(GL.Delegates.GetFragmentLightfvSGIX)); - GL.GetFragmentLightivSGIX = (GL.Delegates.GetFragmentLightivSGIX) GetAddress("glGetFragmentLightivSGIX", typeof(GL.Delegates.GetFragmentLightivSGIX)); - GL.GetFragmentMaterialfvSGIX = (GL.Delegates.GetFragmentMaterialfvSGIX) GetAddress("glGetFragmentMaterialfvSGIX", typeof(GL.Delegates.GetFragmentMaterialfvSGIX)); - GL.GetFragmentMaterialivSGIX = (GL.Delegates.GetFragmentMaterialivSGIX) GetAddress("glGetFragmentMaterialivSGIX", typeof(GL.Delegates.GetFragmentMaterialivSGIX)); - GL.LightEnviSGIX = (GL.Delegates.LightEnviSGIX) GetAddress("glLightEnviSGIX", typeof(GL.Delegates.LightEnviSGIX)); - GL.DrawRangeElementsEXT = (GL.Delegates.DrawRangeElementsEXT) GetAddress("glDrawRangeElementsEXT", typeof(GL.Delegates.DrawRangeElementsEXT)); - GL.ApplyTextureEXT = (GL.Delegates.ApplyTextureEXT) GetAddress("glApplyTextureEXT", typeof(GL.Delegates.ApplyTextureEXT)); - GL.TextureLightEXT = (GL.Delegates.TextureLightEXT) GetAddress("glTextureLightEXT", typeof(GL.Delegates.TextureLightEXT)); - GL.TextureMaterialEXT = (GL.Delegates.TextureMaterialEXT) GetAddress("glTextureMaterialEXT", typeof(GL.Delegates.TextureMaterialEXT)); - GL.AsyncMarkerSGIX = (GL.Delegates.AsyncMarkerSGIX) GetAddress("glAsyncMarkerSGIX", typeof(GL.Delegates.AsyncMarkerSGIX)); - GL.FinishAsyncSGIX = (GL.Delegates.FinishAsyncSGIX) GetAddress("glFinishAsyncSGIX", typeof(GL.Delegates.FinishAsyncSGIX)); - GL.PollAsyncSGIX = (GL.Delegates.PollAsyncSGIX) GetAddress("glPollAsyncSGIX", typeof(GL.Delegates.PollAsyncSGIX)); - GL.GenAsyncMarkersSGIX = (GL.Delegates.GenAsyncMarkersSGIX) GetAddress("glGenAsyncMarkersSGIX", typeof(GL.Delegates.GenAsyncMarkersSGIX)); - GL.DeleteAsyncMarkersSGIX = (GL.Delegates.DeleteAsyncMarkersSGIX) GetAddress("glDeleteAsyncMarkersSGIX", typeof(GL.Delegates.DeleteAsyncMarkersSGIX)); - GL.IsAsyncMarkerSGIX = (GL.Delegates.IsAsyncMarkerSGIX) GetAddress("glIsAsyncMarkerSGIX", typeof(GL.Delegates.IsAsyncMarkerSGIX)); - GL.VertexPointervINTEL = (GL.Delegates.VertexPointervINTEL) GetAddress("glVertexPointervINTEL", typeof(GL.Delegates.VertexPointervINTEL)); - GL.NormalPointervINTEL = (GL.Delegates.NormalPointervINTEL) GetAddress("glNormalPointervINTEL", typeof(GL.Delegates.NormalPointervINTEL)); - GL.ColorPointervINTEL = (GL.Delegates.ColorPointervINTEL) GetAddress("glColorPointervINTEL", typeof(GL.Delegates.ColorPointervINTEL)); - GL.TexCoordPointervINTEL = (GL.Delegates.TexCoordPointervINTEL) GetAddress("glTexCoordPointervINTEL", typeof(GL.Delegates.TexCoordPointervINTEL)); - GL.PixelTransformParameteriEXT = (GL.Delegates.PixelTransformParameteriEXT) GetAddress("glPixelTransformParameteriEXT", typeof(GL.Delegates.PixelTransformParameteriEXT)); - GL.PixelTransformParameterfEXT = (GL.Delegates.PixelTransformParameterfEXT) GetAddress("glPixelTransformParameterfEXT", typeof(GL.Delegates.PixelTransformParameterfEXT)); - GL.PixelTransformParameterivEXT = (GL.Delegates.PixelTransformParameterivEXT) GetAddress("glPixelTransformParameterivEXT", typeof(GL.Delegates.PixelTransformParameterivEXT)); - GL.PixelTransformParameterfvEXT = (GL.Delegates.PixelTransformParameterfvEXT) GetAddress("glPixelTransformParameterfvEXT", typeof(GL.Delegates.PixelTransformParameterfvEXT)); - GL.SecondaryColor3bEXT = (GL.Delegates.SecondaryColor3bEXT) GetAddress("glSecondaryColor3bEXT", typeof(GL.Delegates.SecondaryColor3bEXT)); - GL.SecondaryColor3bvEXT = (GL.Delegates.SecondaryColor3bvEXT) GetAddress("glSecondaryColor3bvEXT", typeof(GL.Delegates.SecondaryColor3bvEXT)); - GL.SecondaryColor3dEXT = (GL.Delegates.SecondaryColor3dEXT) GetAddress("glSecondaryColor3dEXT", typeof(GL.Delegates.SecondaryColor3dEXT)); - GL.SecondaryColor3dvEXT = (GL.Delegates.SecondaryColor3dvEXT) GetAddress("glSecondaryColor3dvEXT", typeof(GL.Delegates.SecondaryColor3dvEXT)); - GL.SecondaryColor3fEXT = (GL.Delegates.SecondaryColor3fEXT) GetAddress("glSecondaryColor3fEXT", typeof(GL.Delegates.SecondaryColor3fEXT)); - GL.SecondaryColor3fvEXT = (GL.Delegates.SecondaryColor3fvEXT) GetAddress("glSecondaryColor3fvEXT", typeof(GL.Delegates.SecondaryColor3fvEXT)); - GL.SecondaryColor3iEXT = (GL.Delegates.SecondaryColor3iEXT) GetAddress("glSecondaryColor3iEXT", typeof(GL.Delegates.SecondaryColor3iEXT)); - GL.SecondaryColor3ivEXT = (GL.Delegates.SecondaryColor3ivEXT) GetAddress("glSecondaryColor3ivEXT", typeof(GL.Delegates.SecondaryColor3ivEXT)); - GL.SecondaryColor3sEXT = (GL.Delegates.SecondaryColor3sEXT) GetAddress("glSecondaryColor3sEXT", typeof(GL.Delegates.SecondaryColor3sEXT)); - GL.SecondaryColor3svEXT = (GL.Delegates.SecondaryColor3svEXT) GetAddress("glSecondaryColor3svEXT", typeof(GL.Delegates.SecondaryColor3svEXT)); - GL.SecondaryColor3ubEXT = (GL.Delegates.SecondaryColor3ubEXT) GetAddress("glSecondaryColor3ubEXT", typeof(GL.Delegates.SecondaryColor3ubEXT)); - GL.SecondaryColor3ubvEXT = (GL.Delegates.SecondaryColor3ubvEXT) GetAddress("glSecondaryColor3ubvEXT", typeof(GL.Delegates.SecondaryColor3ubvEXT)); - GL.SecondaryColor3uiEXT = (GL.Delegates.SecondaryColor3uiEXT) GetAddress("glSecondaryColor3uiEXT", typeof(GL.Delegates.SecondaryColor3uiEXT)); - GL.SecondaryColor3uivEXT = (GL.Delegates.SecondaryColor3uivEXT) GetAddress("glSecondaryColor3uivEXT", typeof(GL.Delegates.SecondaryColor3uivEXT)); - GL.SecondaryColor3usEXT = (GL.Delegates.SecondaryColor3usEXT) GetAddress("glSecondaryColor3usEXT", typeof(GL.Delegates.SecondaryColor3usEXT)); - GL.SecondaryColor3usvEXT = (GL.Delegates.SecondaryColor3usvEXT) GetAddress("glSecondaryColor3usvEXT", typeof(GL.Delegates.SecondaryColor3usvEXT)); - GL.SecondaryColorPointerEXT = (GL.Delegates.SecondaryColorPointerEXT) GetAddress("glSecondaryColorPointerEXT", typeof(GL.Delegates.SecondaryColorPointerEXT)); - GL.TextureNormalEXT = (GL.Delegates.TextureNormalEXT) GetAddress("glTextureNormalEXT", typeof(GL.Delegates.TextureNormalEXT)); - GL.MultiDrawArraysEXT = (GL.Delegates.MultiDrawArraysEXT) GetAddress("glMultiDrawArraysEXT", typeof(GL.Delegates.MultiDrawArraysEXT)); - GL.MultiDrawElementsEXT = (GL.Delegates.MultiDrawElementsEXT) GetAddress("glMultiDrawElementsEXT", typeof(GL.Delegates.MultiDrawElementsEXT)); - GL.FogCoordfEXT = (GL.Delegates.FogCoordfEXT) GetAddress("glFogCoordfEXT", typeof(GL.Delegates.FogCoordfEXT)); - GL.FogCoordfvEXT = (GL.Delegates.FogCoordfvEXT) GetAddress("glFogCoordfvEXT", typeof(GL.Delegates.FogCoordfvEXT)); - GL.FogCoorddEXT = (GL.Delegates.FogCoorddEXT) GetAddress("glFogCoorddEXT", typeof(GL.Delegates.FogCoorddEXT)); - GL.FogCoorddvEXT = (GL.Delegates.FogCoorddvEXT) GetAddress("glFogCoorddvEXT", typeof(GL.Delegates.FogCoorddvEXT)); - GL.FogCoordPointerEXT = (GL.Delegates.FogCoordPointerEXT) GetAddress("glFogCoordPointerEXT", typeof(GL.Delegates.FogCoordPointerEXT)); - GL.Tangent3bEXT = (GL.Delegates.Tangent3bEXT) GetAddress("glTangent3bEXT", typeof(GL.Delegates.Tangent3bEXT)); - GL.Tangent3bvEXT = (GL.Delegates.Tangent3bvEXT) GetAddress("glTangent3bvEXT", typeof(GL.Delegates.Tangent3bvEXT)); - GL.Tangent3dEXT = (GL.Delegates.Tangent3dEXT) GetAddress("glTangent3dEXT", typeof(GL.Delegates.Tangent3dEXT)); - GL.Tangent3dvEXT = (GL.Delegates.Tangent3dvEXT) GetAddress("glTangent3dvEXT", typeof(GL.Delegates.Tangent3dvEXT)); - GL.Tangent3fEXT = (GL.Delegates.Tangent3fEXT) GetAddress("glTangent3fEXT", typeof(GL.Delegates.Tangent3fEXT)); - GL.Tangent3fvEXT = (GL.Delegates.Tangent3fvEXT) GetAddress("glTangent3fvEXT", typeof(GL.Delegates.Tangent3fvEXT)); - GL.Tangent3iEXT = (GL.Delegates.Tangent3iEXT) GetAddress("glTangent3iEXT", typeof(GL.Delegates.Tangent3iEXT)); - GL.Tangent3ivEXT = (GL.Delegates.Tangent3ivEXT) GetAddress("glTangent3ivEXT", typeof(GL.Delegates.Tangent3ivEXT)); - GL.Tangent3sEXT = (GL.Delegates.Tangent3sEXT) GetAddress("glTangent3sEXT", typeof(GL.Delegates.Tangent3sEXT)); - GL.Tangent3svEXT = (GL.Delegates.Tangent3svEXT) GetAddress("glTangent3svEXT", typeof(GL.Delegates.Tangent3svEXT)); - GL.Binormal3bEXT = (GL.Delegates.Binormal3bEXT) GetAddress("glBinormal3bEXT", typeof(GL.Delegates.Binormal3bEXT)); - GL.Binormal3bvEXT = (GL.Delegates.Binormal3bvEXT) GetAddress("glBinormal3bvEXT", typeof(GL.Delegates.Binormal3bvEXT)); - GL.Binormal3dEXT = (GL.Delegates.Binormal3dEXT) GetAddress("glBinormal3dEXT", typeof(GL.Delegates.Binormal3dEXT)); - GL.Binormal3dvEXT = (GL.Delegates.Binormal3dvEXT) GetAddress("glBinormal3dvEXT", typeof(GL.Delegates.Binormal3dvEXT)); - GL.Binormal3fEXT = (GL.Delegates.Binormal3fEXT) GetAddress("glBinormal3fEXT", typeof(GL.Delegates.Binormal3fEXT)); - GL.Binormal3fvEXT = (GL.Delegates.Binormal3fvEXT) GetAddress("glBinormal3fvEXT", typeof(GL.Delegates.Binormal3fvEXT)); - GL.Binormal3iEXT = (GL.Delegates.Binormal3iEXT) GetAddress("glBinormal3iEXT", typeof(GL.Delegates.Binormal3iEXT)); - GL.Binormal3ivEXT = (GL.Delegates.Binormal3ivEXT) GetAddress("glBinormal3ivEXT", typeof(GL.Delegates.Binormal3ivEXT)); - GL.Binormal3sEXT = (GL.Delegates.Binormal3sEXT) GetAddress("glBinormal3sEXT", typeof(GL.Delegates.Binormal3sEXT)); - GL.Binormal3svEXT = (GL.Delegates.Binormal3svEXT) GetAddress("glBinormal3svEXT", typeof(GL.Delegates.Binormal3svEXT)); - GL.TangentPointerEXT = (GL.Delegates.TangentPointerEXT) GetAddress("glTangentPointerEXT", typeof(GL.Delegates.TangentPointerEXT)); - GL.BinormalPointerEXT = (GL.Delegates.BinormalPointerEXT) GetAddress("glBinormalPointerEXT", typeof(GL.Delegates.BinormalPointerEXT)); - GL.FinishTextureSUNX = (GL.Delegates.FinishTextureSUNX) GetAddress("glFinishTextureSUNX", typeof(GL.Delegates.FinishTextureSUNX)); - GL.GlobalAlphaFactorbSUN = (GL.Delegates.GlobalAlphaFactorbSUN) GetAddress("glGlobalAlphaFactorbSUN", typeof(GL.Delegates.GlobalAlphaFactorbSUN)); - GL.GlobalAlphaFactorsSUN = (GL.Delegates.GlobalAlphaFactorsSUN) GetAddress("glGlobalAlphaFactorsSUN", typeof(GL.Delegates.GlobalAlphaFactorsSUN)); - GL.GlobalAlphaFactoriSUN = (GL.Delegates.GlobalAlphaFactoriSUN) GetAddress("glGlobalAlphaFactoriSUN", typeof(GL.Delegates.GlobalAlphaFactoriSUN)); - GL.GlobalAlphaFactorfSUN = (GL.Delegates.GlobalAlphaFactorfSUN) GetAddress("glGlobalAlphaFactorfSUN", typeof(GL.Delegates.GlobalAlphaFactorfSUN)); - GL.GlobalAlphaFactordSUN = (GL.Delegates.GlobalAlphaFactordSUN) GetAddress("glGlobalAlphaFactordSUN", typeof(GL.Delegates.GlobalAlphaFactordSUN)); - GL.GlobalAlphaFactorubSUN = (GL.Delegates.GlobalAlphaFactorubSUN) GetAddress("glGlobalAlphaFactorubSUN", typeof(GL.Delegates.GlobalAlphaFactorubSUN)); - GL.GlobalAlphaFactorusSUN = (GL.Delegates.GlobalAlphaFactorusSUN) GetAddress("glGlobalAlphaFactorusSUN", typeof(GL.Delegates.GlobalAlphaFactorusSUN)); - GL.GlobalAlphaFactoruiSUN = (GL.Delegates.GlobalAlphaFactoruiSUN) GetAddress("glGlobalAlphaFactoruiSUN", typeof(GL.Delegates.GlobalAlphaFactoruiSUN)); - GL.ReplacementCodeuiSUN = (GL.Delegates.ReplacementCodeuiSUN) GetAddress("glReplacementCodeuiSUN", typeof(GL.Delegates.ReplacementCodeuiSUN)); - GL.ReplacementCodeusSUN = (GL.Delegates.ReplacementCodeusSUN) GetAddress("glReplacementCodeusSUN", typeof(GL.Delegates.ReplacementCodeusSUN)); - GL.ReplacementCodeubSUN = (GL.Delegates.ReplacementCodeubSUN) GetAddress("glReplacementCodeubSUN", typeof(GL.Delegates.ReplacementCodeubSUN)); - GL.ReplacementCodeuivSUN = (GL.Delegates.ReplacementCodeuivSUN) GetAddress("glReplacementCodeuivSUN", typeof(GL.Delegates.ReplacementCodeuivSUN)); - GL.ReplacementCodeusvSUN = (GL.Delegates.ReplacementCodeusvSUN) GetAddress("glReplacementCodeusvSUN", typeof(GL.Delegates.ReplacementCodeusvSUN)); - GL.ReplacementCodeubvSUN = (GL.Delegates.ReplacementCodeubvSUN) GetAddress("glReplacementCodeubvSUN", typeof(GL.Delegates.ReplacementCodeubvSUN)); - GL.ReplacementCodePointerSUN = (GL.Delegates.ReplacementCodePointerSUN) GetAddress("glReplacementCodePointerSUN", typeof(GL.Delegates.ReplacementCodePointerSUN)); - GL.Color4ubVertex2fSUN = (GL.Delegates.Color4ubVertex2fSUN) GetAddress("glColor4ubVertex2fSUN", typeof(GL.Delegates.Color4ubVertex2fSUN)); - GL.Color4ubVertex2fvSUN = (GL.Delegates.Color4ubVertex2fvSUN) GetAddress("glColor4ubVertex2fvSUN", typeof(GL.Delegates.Color4ubVertex2fvSUN)); - GL.Color4ubVertex3fSUN = (GL.Delegates.Color4ubVertex3fSUN) GetAddress("glColor4ubVertex3fSUN", typeof(GL.Delegates.Color4ubVertex3fSUN)); - GL.Color4ubVertex3fvSUN = (GL.Delegates.Color4ubVertex3fvSUN) GetAddress("glColor4ubVertex3fvSUN", typeof(GL.Delegates.Color4ubVertex3fvSUN)); - GL.Color3fVertex3fSUN = (GL.Delegates.Color3fVertex3fSUN) GetAddress("glColor3fVertex3fSUN", typeof(GL.Delegates.Color3fVertex3fSUN)); - GL.Color3fVertex3fvSUN = (GL.Delegates.Color3fVertex3fvSUN) GetAddress("glColor3fVertex3fvSUN", typeof(GL.Delegates.Color3fVertex3fvSUN)); - GL.Normal3fVertex3fSUN = (GL.Delegates.Normal3fVertex3fSUN) GetAddress("glNormal3fVertex3fSUN", typeof(GL.Delegates.Normal3fVertex3fSUN)); - GL.Normal3fVertex3fvSUN = (GL.Delegates.Normal3fVertex3fvSUN) GetAddress("glNormal3fVertex3fvSUN", typeof(GL.Delegates.Normal3fVertex3fvSUN)); - GL.Color4fNormal3fVertex3fSUN = (GL.Delegates.Color4fNormal3fVertex3fSUN) GetAddress("glColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fSUN)); - GL.Color4fNormal3fVertex3fvSUN = (GL.Delegates.Color4fNormal3fVertex3fvSUN) GetAddress("glColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.Color4fNormal3fVertex3fvSUN)); - GL.TexCoord2fVertex3fSUN = (GL.Delegates.TexCoord2fVertex3fSUN) GetAddress("glTexCoord2fVertex3fSUN", typeof(GL.Delegates.TexCoord2fVertex3fSUN)); - GL.TexCoord2fVertex3fvSUN = (GL.Delegates.TexCoord2fVertex3fvSUN) GetAddress("glTexCoord2fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fVertex3fvSUN)); - GL.TexCoord4fVertex4fSUN = (GL.Delegates.TexCoord4fVertex4fSUN) GetAddress("glTexCoord4fVertex4fSUN", typeof(GL.Delegates.TexCoord4fVertex4fSUN)); - GL.TexCoord4fVertex4fvSUN = (GL.Delegates.TexCoord4fVertex4fvSUN) GetAddress("glTexCoord4fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fVertex4fvSUN)); - GL.TexCoord2fColor4ubVertex3fSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fSUN) GetAddress("glTexCoord2fColor4ubVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fSUN)); - GL.TexCoord2fColor4ubVertex3fvSUN = (GL.Delegates.TexCoord2fColor4ubVertex3fvSUN) GetAddress("glTexCoord2fColor4ubVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4ubVertex3fvSUN)); - GL.TexCoord2fColor3fVertex3fSUN = (GL.Delegates.TexCoord2fColor3fVertex3fSUN) GetAddress("glTexCoord2fColor3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fSUN)); - GL.TexCoord2fColor3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor3fVertex3fvSUN) GetAddress("glTexCoord2fColor3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor3fVertex3fvSUN)); - GL.TexCoord2fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fSUN) GetAddress("glTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fSUN)); - GL.TexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fNormal3fVertex3fvSUN) GetAddress("glTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fNormal3fVertex3fvSUN)); - GL.TexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN) GetAddress("glTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fSUN)); - GL.TexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN) GetAddress("glTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.TexCoord2fColor4fNormal3fVertex3fvSUN)); - GL.TexCoord4fColor4fNormal3fVertex4fSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN) GetAddress("glTexCoord4fColor4fNormal3fVertex4fSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fSUN)); - GL.TexCoord4fColor4fNormal3fVertex4fvSUN = (GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN) GetAddress("glTexCoord4fColor4fNormal3fVertex4fvSUN", typeof(GL.Delegates.TexCoord4fColor4fNormal3fVertex4fvSUN)); - GL.ReplacementCodeuiVertex3fSUN = (GL.Delegates.ReplacementCodeuiVertex3fSUN) GetAddress("glReplacementCodeuiVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fSUN)); - GL.ReplacementCodeuiVertex3fvSUN = (GL.Delegates.ReplacementCodeuiVertex3fvSUN) GetAddress("glReplacementCodeuiVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiVertex3fvSUN)); - GL.ReplacementCodeuiColor4ubVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN) GetAddress("glReplacementCodeuiColor4ubVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fSUN)); - GL.ReplacementCodeuiColor4ubVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN) GetAddress("glReplacementCodeuiColor4ubVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4ubVertex3fvSUN)); - GL.ReplacementCodeuiColor3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN) GetAddress("glReplacementCodeuiColor3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fSUN)); - GL.ReplacementCodeuiColor3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN) GetAddress("glReplacementCodeuiColor3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor3fVertex3fvSUN)); - GL.ReplacementCodeuiNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fSUN)); - GL.ReplacementCodeuiNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiColor4fNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)); - GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)); - GL.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) GetAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(GL.Delegates.ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)); - GL.BlendFuncSeparateEXT = (GL.Delegates.BlendFuncSeparateEXT) GetAddress("glBlendFuncSeparateEXT", typeof(GL.Delegates.BlendFuncSeparateEXT)); - GL.BlendFuncSeparateINGR = (GL.Delegates.BlendFuncSeparateINGR) GetAddress("glBlendFuncSeparateINGR", typeof(GL.Delegates.BlendFuncSeparateINGR)); - GL.VertexWeightfEXT = (GL.Delegates.VertexWeightfEXT) GetAddress("glVertexWeightfEXT", typeof(GL.Delegates.VertexWeightfEXT)); - GL.VertexWeightfvEXT = (GL.Delegates.VertexWeightfvEXT) GetAddress("glVertexWeightfvEXT", typeof(GL.Delegates.VertexWeightfvEXT)); - GL.VertexWeightPointerEXT = (GL.Delegates.VertexWeightPointerEXT) GetAddress("glVertexWeightPointerEXT", typeof(GL.Delegates.VertexWeightPointerEXT)); - GL.FlushVertexArrayRangeNV = (GL.Delegates.FlushVertexArrayRangeNV) GetAddress("glFlushVertexArrayRangeNV", typeof(GL.Delegates.FlushVertexArrayRangeNV)); - GL.VertexArrayRangeNV = (GL.Delegates.VertexArrayRangeNV) GetAddress("glVertexArrayRangeNV", typeof(GL.Delegates.VertexArrayRangeNV)); - GL.CombinerParameterfvNV = (GL.Delegates.CombinerParameterfvNV) GetAddress("glCombinerParameterfvNV", typeof(GL.Delegates.CombinerParameterfvNV)); - GL.CombinerParameterfNV = (GL.Delegates.CombinerParameterfNV) GetAddress("glCombinerParameterfNV", typeof(GL.Delegates.CombinerParameterfNV)); - GL.CombinerParameterivNV = (GL.Delegates.CombinerParameterivNV) GetAddress("glCombinerParameterivNV", typeof(GL.Delegates.CombinerParameterivNV)); - GL.CombinerParameteriNV = (GL.Delegates.CombinerParameteriNV) GetAddress("glCombinerParameteriNV", typeof(GL.Delegates.CombinerParameteriNV)); - GL.CombinerInputNV = (GL.Delegates.CombinerInputNV) GetAddress("glCombinerInputNV", typeof(GL.Delegates.CombinerInputNV)); - GL.CombinerOutputNV = (GL.Delegates.CombinerOutputNV) GetAddress("glCombinerOutputNV", typeof(GL.Delegates.CombinerOutputNV)); - GL.FinalCombinerInputNV = (GL.Delegates.FinalCombinerInputNV) GetAddress("glFinalCombinerInputNV", typeof(GL.Delegates.FinalCombinerInputNV)); - GL.GetCombinerInputParameterfvNV = (GL.Delegates.GetCombinerInputParameterfvNV) GetAddress("glGetCombinerInputParameterfvNV", typeof(GL.Delegates.GetCombinerInputParameterfvNV)); - GL.GetCombinerInputParameterivNV = (GL.Delegates.GetCombinerInputParameterivNV) GetAddress("glGetCombinerInputParameterivNV", typeof(GL.Delegates.GetCombinerInputParameterivNV)); - GL.GetCombinerOutputParameterfvNV = (GL.Delegates.GetCombinerOutputParameterfvNV) GetAddress("glGetCombinerOutputParameterfvNV", typeof(GL.Delegates.GetCombinerOutputParameterfvNV)); - GL.GetCombinerOutputParameterivNV = (GL.Delegates.GetCombinerOutputParameterivNV) GetAddress("glGetCombinerOutputParameterivNV", typeof(GL.Delegates.GetCombinerOutputParameterivNV)); - GL.GetFinalCombinerInputParameterfvNV = (GL.Delegates.GetFinalCombinerInputParameterfvNV) GetAddress("glGetFinalCombinerInputParameterfvNV", typeof(GL.Delegates.GetFinalCombinerInputParameterfvNV)); - GL.GetFinalCombinerInputParameterivNV = (GL.Delegates.GetFinalCombinerInputParameterivNV) GetAddress("glGetFinalCombinerInputParameterivNV", typeof(GL.Delegates.GetFinalCombinerInputParameterivNV)); - GL.ResizeBuffersMESA = (GL.Delegates.ResizeBuffersMESA) GetAddress("glResizeBuffersMESA", typeof(GL.Delegates.ResizeBuffersMESA)); - GL.WindowPos2dMESA = (GL.Delegates.WindowPos2dMESA) GetAddress("glWindowPos2dMESA", typeof(GL.Delegates.WindowPos2dMESA)); - GL.WindowPos2dvMESA = (GL.Delegates.WindowPos2dvMESA) GetAddress("glWindowPos2dvMESA", typeof(GL.Delegates.WindowPos2dvMESA)); - GL.WindowPos2fMESA = (GL.Delegates.WindowPos2fMESA) GetAddress("glWindowPos2fMESA", typeof(GL.Delegates.WindowPos2fMESA)); - GL.WindowPos2fvMESA = (GL.Delegates.WindowPos2fvMESA) GetAddress("glWindowPos2fvMESA", typeof(GL.Delegates.WindowPos2fvMESA)); - GL.WindowPos2iMESA = (GL.Delegates.WindowPos2iMESA) GetAddress("glWindowPos2iMESA", typeof(GL.Delegates.WindowPos2iMESA)); - GL.WindowPos2ivMESA = (GL.Delegates.WindowPos2ivMESA) GetAddress("glWindowPos2ivMESA", typeof(GL.Delegates.WindowPos2ivMESA)); - GL.WindowPos2sMESA = (GL.Delegates.WindowPos2sMESA) GetAddress("glWindowPos2sMESA", typeof(GL.Delegates.WindowPos2sMESA)); - GL.WindowPos2svMESA = (GL.Delegates.WindowPos2svMESA) GetAddress("glWindowPos2svMESA", typeof(GL.Delegates.WindowPos2svMESA)); - GL.WindowPos3dMESA = (GL.Delegates.WindowPos3dMESA) GetAddress("glWindowPos3dMESA", typeof(GL.Delegates.WindowPos3dMESA)); - GL.WindowPos3dvMESA = (GL.Delegates.WindowPos3dvMESA) GetAddress("glWindowPos3dvMESA", typeof(GL.Delegates.WindowPos3dvMESA)); - GL.WindowPos3fMESA = (GL.Delegates.WindowPos3fMESA) GetAddress("glWindowPos3fMESA", typeof(GL.Delegates.WindowPos3fMESA)); - GL.WindowPos3fvMESA = (GL.Delegates.WindowPos3fvMESA) GetAddress("glWindowPos3fvMESA", typeof(GL.Delegates.WindowPos3fvMESA)); - GL.WindowPos3iMESA = (GL.Delegates.WindowPos3iMESA) GetAddress("glWindowPos3iMESA", typeof(GL.Delegates.WindowPos3iMESA)); - GL.WindowPos3ivMESA = (GL.Delegates.WindowPos3ivMESA) GetAddress("glWindowPos3ivMESA", typeof(GL.Delegates.WindowPos3ivMESA)); - GL.WindowPos3sMESA = (GL.Delegates.WindowPos3sMESA) GetAddress("glWindowPos3sMESA", typeof(GL.Delegates.WindowPos3sMESA)); - GL.WindowPos3svMESA = (GL.Delegates.WindowPos3svMESA) GetAddress("glWindowPos3svMESA", typeof(GL.Delegates.WindowPos3svMESA)); - GL.WindowPos4dMESA = (GL.Delegates.WindowPos4dMESA) GetAddress("glWindowPos4dMESA", typeof(GL.Delegates.WindowPos4dMESA)); - GL.WindowPos4dvMESA = (GL.Delegates.WindowPos4dvMESA) GetAddress("glWindowPos4dvMESA", typeof(GL.Delegates.WindowPos4dvMESA)); - GL.WindowPos4fMESA = (GL.Delegates.WindowPos4fMESA) GetAddress("glWindowPos4fMESA", typeof(GL.Delegates.WindowPos4fMESA)); - GL.WindowPos4fvMESA = (GL.Delegates.WindowPos4fvMESA) GetAddress("glWindowPos4fvMESA", typeof(GL.Delegates.WindowPos4fvMESA)); - GL.WindowPos4iMESA = (GL.Delegates.WindowPos4iMESA) GetAddress("glWindowPos4iMESA", typeof(GL.Delegates.WindowPos4iMESA)); - GL.WindowPos4ivMESA = (GL.Delegates.WindowPos4ivMESA) GetAddress("glWindowPos4ivMESA", typeof(GL.Delegates.WindowPos4ivMESA)); - GL.WindowPos4sMESA = (GL.Delegates.WindowPos4sMESA) GetAddress("glWindowPos4sMESA", typeof(GL.Delegates.WindowPos4sMESA)); - GL.WindowPos4svMESA = (GL.Delegates.WindowPos4svMESA) GetAddress("glWindowPos4svMESA", typeof(GL.Delegates.WindowPos4svMESA)); - GL.MultiModeDrawArraysIBM = (GL.Delegates.MultiModeDrawArraysIBM) GetAddress("glMultiModeDrawArraysIBM", typeof(GL.Delegates.MultiModeDrawArraysIBM)); - GL.MultiModeDrawElementsIBM = (GL.Delegates.MultiModeDrawElementsIBM) GetAddress("glMultiModeDrawElementsIBM", typeof(GL.Delegates.MultiModeDrawElementsIBM)); - GL.ColorPointerListIBM = (GL.Delegates.ColorPointerListIBM) GetAddress("glColorPointerListIBM", typeof(GL.Delegates.ColorPointerListIBM)); - GL.SecondaryColorPointerListIBM = (GL.Delegates.SecondaryColorPointerListIBM) GetAddress("glSecondaryColorPointerListIBM", typeof(GL.Delegates.SecondaryColorPointerListIBM)); - GL.EdgeFlagPointerListIBM = (GL.Delegates.EdgeFlagPointerListIBM) GetAddress("glEdgeFlagPointerListIBM", typeof(GL.Delegates.EdgeFlagPointerListIBM)); - GL.FogCoordPointerListIBM = (GL.Delegates.FogCoordPointerListIBM) GetAddress("glFogCoordPointerListIBM", typeof(GL.Delegates.FogCoordPointerListIBM)); - GL.IndexPointerListIBM = (GL.Delegates.IndexPointerListIBM) GetAddress("glIndexPointerListIBM", typeof(GL.Delegates.IndexPointerListIBM)); - GL.NormalPointerListIBM = (GL.Delegates.NormalPointerListIBM) GetAddress("glNormalPointerListIBM", typeof(GL.Delegates.NormalPointerListIBM)); - GL.TexCoordPointerListIBM = (GL.Delegates.TexCoordPointerListIBM) GetAddress("glTexCoordPointerListIBM", typeof(GL.Delegates.TexCoordPointerListIBM)); - GL.VertexPointerListIBM = (GL.Delegates.VertexPointerListIBM) GetAddress("glVertexPointerListIBM", typeof(GL.Delegates.VertexPointerListIBM)); - GL.TbufferMask3DFX = (GL.Delegates.TbufferMask3DFX) GetAddress("glTbufferMask3DFX", typeof(GL.Delegates.TbufferMask3DFX)); - GL.SampleMaskEXT = (GL.Delegates.SampleMaskEXT) GetAddress("glSampleMaskEXT", typeof(GL.Delegates.SampleMaskEXT)); - GL.SamplePatternEXT = (GL.Delegates.SamplePatternEXT) GetAddress("glSamplePatternEXT", typeof(GL.Delegates.SamplePatternEXT)); - GL.TextureColorMaskSGIS = (GL.Delegates.TextureColorMaskSGIS) GetAddress("glTextureColorMaskSGIS", typeof(GL.Delegates.TextureColorMaskSGIS)); - GL.IglooInterfaceSGIX = (GL.Delegates.IglooInterfaceSGIX) GetAddress("glIglooInterfaceSGIX", typeof(GL.Delegates.IglooInterfaceSGIX)); - GL.DeleteFencesNV = (GL.Delegates.DeleteFencesNV) GetAddress("glDeleteFencesNV", typeof(GL.Delegates.DeleteFencesNV)); - GL.GenFencesNV = (GL.Delegates.GenFencesNV) GetAddress("glGenFencesNV", typeof(GL.Delegates.GenFencesNV)); - GL.IsFenceNV = (GL.Delegates.IsFenceNV) GetAddress("glIsFenceNV", typeof(GL.Delegates.IsFenceNV)); - GL.TestFenceNV = (GL.Delegates.TestFenceNV) GetAddress("glTestFenceNV", typeof(GL.Delegates.TestFenceNV)); - GL.GetFenceivNV = (GL.Delegates.GetFenceivNV) GetAddress("glGetFenceivNV", typeof(GL.Delegates.GetFenceivNV)); - GL.FinishFenceNV = (GL.Delegates.FinishFenceNV) GetAddress("glFinishFenceNV", typeof(GL.Delegates.FinishFenceNV)); - GL.SetFenceNV = (GL.Delegates.SetFenceNV) GetAddress("glSetFenceNV", typeof(GL.Delegates.SetFenceNV)); - GL.MapControlPointsNV = (GL.Delegates.MapControlPointsNV) GetAddress("glMapControlPointsNV", typeof(GL.Delegates.MapControlPointsNV)); - GL.MapParameterivNV = (GL.Delegates.MapParameterivNV) GetAddress("glMapParameterivNV", typeof(GL.Delegates.MapParameterivNV)); - GL.MapParameterfvNV = (GL.Delegates.MapParameterfvNV) GetAddress("glMapParameterfvNV", typeof(GL.Delegates.MapParameterfvNV)); - GL.GetMapControlPointsNV = (GL.Delegates.GetMapControlPointsNV) GetAddress("glGetMapControlPointsNV", typeof(GL.Delegates.GetMapControlPointsNV)); - GL.GetMapParameterivNV = (GL.Delegates.GetMapParameterivNV) GetAddress("glGetMapParameterivNV", typeof(GL.Delegates.GetMapParameterivNV)); - GL.GetMapParameterfvNV = (GL.Delegates.GetMapParameterfvNV) GetAddress("glGetMapParameterfvNV", typeof(GL.Delegates.GetMapParameterfvNV)); - GL.GetMapAttribParameterivNV = (GL.Delegates.GetMapAttribParameterivNV) GetAddress("glGetMapAttribParameterivNV", typeof(GL.Delegates.GetMapAttribParameterivNV)); - GL.GetMapAttribParameterfvNV = (GL.Delegates.GetMapAttribParameterfvNV) GetAddress("glGetMapAttribParameterfvNV", typeof(GL.Delegates.GetMapAttribParameterfvNV)); - GL.EvalMapsNV = (GL.Delegates.EvalMapsNV) GetAddress("glEvalMapsNV", typeof(GL.Delegates.EvalMapsNV)); - GL.CombinerStageParameterfvNV = (GL.Delegates.CombinerStageParameterfvNV) GetAddress("glCombinerStageParameterfvNV", typeof(GL.Delegates.CombinerStageParameterfvNV)); - GL.GetCombinerStageParameterfvNV = (GL.Delegates.GetCombinerStageParameterfvNV) GetAddress("glGetCombinerStageParameterfvNV", typeof(GL.Delegates.GetCombinerStageParameterfvNV)); - GL.AreProgramsResidentNV = (GL.Delegates.AreProgramsResidentNV) GetAddress("glAreProgramsResidentNV", typeof(GL.Delegates.AreProgramsResidentNV)); - GL.BindProgramNV = (GL.Delegates.BindProgramNV) GetAddress("glBindProgramNV", typeof(GL.Delegates.BindProgramNV)); - GL.DeleteProgramsNV = (GL.Delegates.DeleteProgramsNV) GetAddress("glDeleteProgramsNV", typeof(GL.Delegates.DeleteProgramsNV)); - GL.ExecuteProgramNV = (GL.Delegates.ExecuteProgramNV) GetAddress("glExecuteProgramNV", typeof(GL.Delegates.ExecuteProgramNV)); - GL.GenProgramsNV = (GL.Delegates.GenProgramsNV) GetAddress("glGenProgramsNV", typeof(GL.Delegates.GenProgramsNV)); - GL.GetProgramParameterdvNV = (GL.Delegates.GetProgramParameterdvNV) GetAddress("glGetProgramParameterdvNV", typeof(GL.Delegates.GetProgramParameterdvNV)); - GL.GetProgramParameterfvNV = (GL.Delegates.GetProgramParameterfvNV) GetAddress("glGetProgramParameterfvNV", typeof(GL.Delegates.GetProgramParameterfvNV)); - GL.GetProgramivNV = (GL.Delegates.GetProgramivNV) GetAddress("glGetProgramivNV", typeof(GL.Delegates.GetProgramivNV)); - GL.GetProgramStringNV = (GL.Delegates.GetProgramStringNV) GetAddress("glGetProgramStringNV", typeof(GL.Delegates.GetProgramStringNV)); - GL.GetTrackMatrixivNV = (GL.Delegates.GetTrackMatrixivNV) GetAddress("glGetTrackMatrixivNV", typeof(GL.Delegates.GetTrackMatrixivNV)); - GL.GetVertexAttribdvNV = (GL.Delegates.GetVertexAttribdvNV) GetAddress("glGetVertexAttribdvNV", typeof(GL.Delegates.GetVertexAttribdvNV)); - GL.GetVertexAttribfvNV = (GL.Delegates.GetVertexAttribfvNV) GetAddress("glGetVertexAttribfvNV", typeof(GL.Delegates.GetVertexAttribfvNV)); - GL.GetVertexAttribivNV = (GL.Delegates.GetVertexAttribivNV) GetAddress("glGetVertexAttribivNV", typeof(GL.Delegates.GetVertexAttribivNV)); - GL.GetVertexAttribPointervNV = (GL.Delegates.GetVertexAttribPointervNV) GetAddress("glGetVertexAttribPointervNV", typeof(GL.Delegates.GetVertexAttribPointervNV)); - GL.IsProgramNV = (GL.Delegates.IsProgramNV) GetAddress("glIsProgramNV", typeof(GL.Delegates.IsProgramNV)); - GL.LoadProgramNV = (GL.Delegates.LoadProgramNV) GetAddress("glLoadProgramNV", typeof(GL.Delegates.LoadProgramNV)); - GL.ProgramParameter4dNV = (GL.Delegates.ProgramParameter4dNV) GetAddress("glProgramParameter4dNV", typeof(GL.Delegates.ProgramParameter4dNV)); - GL.ProgramParameter4dvNV = (GL.Delegates.ProgramParameter4dvNV) GetAddress("glProgramParameter4dvNV", typeof(GL.Delegates.ProgramParameter4dvNV)); - GL.ProgramParameter4fNV = (GL.Delegates.ProgramParameter4fNV) GetAddress("glProgramParameter4fNV", typeof(GL.Delegates.ProgramParameter4fNV)); - GL.ProgramParameter4fvNV = (GL.Delegates.ProgramParameter4fvNV) GetAddress("glProgramParameter4fvNV", typeof(GL.Delegates.ProgramParameter4fvNV)); - GL.ProgramParameters4dvNV = (GL.Delegates.ProgramParameters4dvNV) GetAddress("glProgramParameters4dvNV", typeof(GL.Delegates.ProgramParameters4dvNV)); - GL.ProgramParameters4fvNV = (GL.Delegates.ProgramParameters4fvNV) GetAddress("glProgramParameters4fvNV", typeof(GL.Delegates.ProgramParameters4fvNV)); - GL.RequestResidentProgramsNV = (GL.Delegates.RequestResidentProgramsNV) GetAddress("glRequestResidentProgramsNV", typeof(GL.Delegates.RequestResidentProgramsNV)); - GL.TrackMatrixNV = (GL.Delegates.TrackMatrixNV) GetAddress("glTrackMatrixNV", typeof(GL.Delegates.TrackMatrixNV)); - GL.VertexAttribPointerNV = (GL.Delegates.VertexAttribPointerNV) GetAddress("glVertexAttribPointerNV", typeof(GL.Delegates.VertexAttribPointerNV)); - GL.VertexAttrib1dNV = (GL.Delegates.VertexAttrib1dNV) GetAddress("glVertexAttrib1dNV", typeof(GL.Delegates.VertexAttrib1dNV)); - GL.VertexAttrib1dvNV = (GL.Delegates.VertexAttrib1dvNV) GetAddress("glVertexAttrib1dvNV", typeof(GL.Delegates.VertexAttrib1dvNV)); - GL.VertexAttrib1fNV = (GL.Delegates.VertexAttrib1fNV) GetAddress("glVertexAttrib1fNV", typeof(GL.Delegates.VertexAttrib1fNV)); - GL.VertexAttrib1fvNV = (GL.Delegates.VertexAttrib1fvNV) GetAddress("glVertexAttrib1fvNV", typeof(GL.Delegates.VertexAttrib1fvNV)); - GL.VertexAttrib1sNV = (GL.Delegates.VertexAttrib1sNV) GetAddress("glVertexAttrib1sNV", typeof(GL.Delegates.VertexAttrib1sNV)); - GL.VertexAttrib1svNV = (GL.Delegates.VertexAttrib1svNV) GetAddress("glVertexAttrib1svNV", typeof(GL.Delegates.VertexAttrib1svNV)); - GL.VertexAttrib2dNV = (GL.Delegates.VertexAttrib2dNV) GetAddress("glVertexAttrib2dNV", typeof(GL.Delegates.VertexAttrib2dNV)); - GL.VertexAttrib2dvNV = (GL.Delegates.VertexAttrib2dvNV) GetAddress("glVertexAttrib2dvNV", typeof(GL.Delegates.VertexAttrib2dvNV)); - GL.VertexAttrib2fNV = (GL.Delegates.VertexAttrib2fNV) GetAddress("glVertexAttrib2fNV", typeof(GL.Delegates.VertexAttrib2fNV)); - GL.VertexAttrib2fvNV = (GL.Delegates.VertexAttrib2fvNV) GetAddress("glVertexAttrib2fvNV", typeof(GL.Delegates.VertexAttrib2fvNV)); - GL.VertexAttrib2sNV = (GL.Delegates.VertexAttrib2sNV) GetAddress("glVertexAttrib2sNV", typeof(GL.Delegates.VertexAttrib2sNV)); - GL.VertexAttrib2svNV = (GL.Delegates.VertexAttrib2svNV) GetAddress("glVertexAttrib2svNV", typeof(GL.Delegates.VertexAttrib2svNV)); - GL.VertexAttrib3dNV = (GL.Delegates.VertexAttrib3dNV) GetAddress("glVertexAttrib3dNV", typeof(GL.Delegates.VertexAttrib3dNV)); - GL.VertexAttrib3dvNV = (GL.Delegates.VertexAttrib3dvNV) GetAddress("glVertexAttrib3dvNV", typeof(GL.Delegates.VertexAttrib3dvNV)); - GL.VertexAttrib3fNV = (GL.Delegates.VertexAttrib3fNV) GetAddress("glVertexAttrib3fNV", typeof(GL.Delegates.VertexAttrib3fNV)); - GL.VertexAttrib3fvNV = (GL.Delegates.VertexAttrib3fvNV) GetAddress("glVertexAttrib3fvNV", typeof(GL.Delegates.VertexAttrib3fvNV)); - GL.VertexAttrib3sNV = (GL.Delegates.VertexAttrib3sNV) GetAddress("glVertexAttrib3sNV", typeof(GL.Delegates.VertexAttrib3sNV)); - GL.VertexAttrib3svNV = (GL.Delegates.VertexAttrib3svNV) GetAddress("glVertexAttrib3svNV", typeof(GL.Delegates.VertexAttrib3svNV)); - GL.VertexAttrib4dNV = (GL.Delegates.VertexAttrib4dNV) GetAddress("glVertexAttrib4dNV", typeof(GL.Delegates.VertexAttrib4dNV)); - GL.VertexAttrib4dvNV = (GL.Delegates.VertexAttrib4dvNV) GetAddress("glVertexAttrib4dvNV", typeof(GL.Delegates.VertexAttrib4dvNV)); - GL.VertexAttrib4fNV = (GL.Delegates.VertexAttrib4fNV) GetAddress("glVertexAttrib4fNV", typeof(GL.Delegates.VertexAttrib4fNV)); - GL.VertexAttrib4fvNV = (GL.Delegates.VertexAttrib4fvNV) GetAddress("glVertexAttrib4fvNV", typeof(GL.Delegates.VertexAttrib4fvNV)); - GL.VertexAttrib4sNV = (GL.Delegates.VertexAttrib4sNV) GetAddress("glVertexAttrib4sNV", typeof(GL.Delegates.VertexAttrib4sNV)); - GL.VertexAttrib4svNV = (GL.Delegates.VertexAttrib4svNV) GetAddress("glVertexAttrib4svNV", typeof(GL.Delegates.VertexAttrib4svNV)); - GL.VertexAttrib4ubNV = (GL.Delegates.VertexAttrib4ubNV) GetAddress("glVertexAttrib4ubNV", typeof(GL.Delegates.VertexAttrib4ubNV)); - GL.VertexAttrib4ubvNV = (GL.Delegates.VertexAttrib4ubvNV) GetAddress("glVertexAttrib4ubvNV", typeof(GL.Delegates.VertexAttrib4ubvNV)); - GL.VertexAttribs1dvNV = (GL.Delegates.VertexAttribs1dvNV) GetAddress("glVertexAttribs1dvNV", typeof(GL.Delegates.VertexAttribs1dvNV)); - GL.VertexAttribs1fvNV = (GL.Delegates.VertexAttribs1fvNV) GetAddress("glVertexAttribs1fvNV", typeof(GL.Delegates.VertexAttribs1fvNV)); - GL.VertexAttribs1svNV = (GL.Delegates.VertexAttribs1svNV) GetAddress("glVertexAttribs1svNV", typeof(GL.Delegates.VertexAttribs1svNV)); - GL.VertexAttribs2dvNV = (GL.Delegates.VertexAttribs2dvNV) GetAddress("glVertexAttribs2dvNV", typeof(GL.Delegates.VertexAttribs2dvNV)); - GL.VertexAttribs2fvNV = (GL.Delegates.VertexAttribs2fvNV) GetAddress("glVertexAttribs2fvNV", typeof(GL.Delegates.VertexAttribs2fvNV)); - GL.VertexAttribs2svNV = (GL.Delegates.VertexAttribs2svNV) GetAddress("glVertexAttribs2svNV", typeof(GL.Delegates.VertexAttribs2svNV)); - GL.VertexAttribs3dvNV = (GL.Delegates.VertexAttribs3dvNV) GetAddress("glVertexAttribs3dvNV", typeof(GL.Delegates.VertexAttribs3dvNV)); - GL.VertexAttribs3fvNV = (GL.Delegates.VertexAttribs3fvNV) GetAddress("glVertexAttribs3fvNV", typeof(GL.Delegates.VertexAttribs3fvNV)); - GL.VertexAttribs3svNV = (GL.Delegates.VertexAttribs3svNV) GetAddress("glVertexAttribs3svNV", typeof(GL.Delegates.VertexAttribs3svNV)); - GL.VertexAttribs4dvNV = (GL.Delegates.VertexAttribs4dvNV) GetAddress("glVertexAttribs4dvNV", typeof(GL.Delegates.VertexAttribs4dvNV)); - GL.VertexAttribs4fvNV = (GL.Delegates.VertexAttribs4fvNV) GetAddress("glVertexAttribs4fvNV", typeof(GL.Delegates.VertexAttribs4fvNV)); - GL.VertexAttribs4svNV = (GL.Delegates.VertexAttribs4svNV) GetAddress("glVertexAttribs4svNV", typeof(GL.Delegates.VertexAttribs4svNV)); - GL.VertexAttribs4ubvNV = (GL.Delegates.VertexAttribs4ubvNV) GetAddress("glVertexAttribs4ubvNV", typeof(GL.Delegates.VertexAttribs4ubvNV)); - GL.TexBumpParameterivATI = (GL.Delegates.TexBumpParameterivATI) GetAddress("glTexBumpParameterivATI", typeof(GL.Delegates.TexBumpParameterivATI)); - GL.TexBumpParameterfvATI = (GL.Delegates.TexBumpParameterfvATI) GetAddress("glTexBumpParameterfvATI", typeof(GL.Delegates.TexBumpParameterfvATI)); - GL.GetTexBumpParameterivATI = (GL.Delegates.GetTexBumpParameterivATI) GetAddress("glGetTexBumpParameterivATI", typeof(GL.Delegates.GetTexBumpParameterivATI)); - GL.GetTexBumpParameterfvATI = (GL.Delegates.GetTexBumpParameterfvATI) GetAddress("glGetTexBumpParameterfvATI", typeof(GL.Delegates.GetTexBumpParameterfvATI)); - GL.GenFragmentShadersATI = (GL.Delegates.GenFragmentShadersATI) GetAddress("glGenFragmentShadersATI", typeof(GL.Delegates.GenFragmentShadersATI)); - GL.BindFragmentShaderATI = (GL.Delegates.BindFragmentShaderATI) GetAddress("glBindFragmentShaderATI", typeof(GL.Delegates.BindFragmentShaderATI)); - GL.DeleteFragmentShaderATI = (GL.Delegates.DeleteFragmentShaderATI) GetAddress("glDeleteFragmentShaderATI", typeof(GL.Delegates.DeleteFragmentShaderATI)); - GL.BeginFragmentShaderATI = (GL.Delegates.BeginFragmentShaderATI) GetAddress("glBeginFragmentShaderATI", typeof(GL.Delegates.BeginFragmentShaderATI)); - GL.EndFragmentShaderATI = (GL.Delegates.EndFragmentShaderATI) GetAddress("glEndFragmentShaderATI", typeof(GL.Delegates.EndFragmentShaderATI)); - GL.PassTexCoordATI = (GL.Delegates.PassTexCoordATI) GetAddress("glPassTexCoordATI", typeof(GL.Delegates.PassTexCoordATI)); - GL.SampleMapATI = (GL.Delegates.SampleMapATI) GetAddress("glSampleMapATI", typeof(GL.Delegates.SampleMapATI)); - GL.ColorFragmentOp1ATI = (GL.Delegates.ColorFragmentOp1ATI) GetAddress("glColorFragmentOp1ATI", typeof(GL.Delegates.ColorFragmentOp1ATI)); - GL.ColorFragmentOp2ATI = (GL.Delegates.ColorFragmentOp2ATI) GetAddress("glColorFragmentOp2ATI", typeof(GL.Delegates.ColorFragmentOp2ATI)); - GL.ColorFragmentOp3ATI = (GL.Delegates.ColorFragmentOp3ATI) GetAddress("glColorFragmentOp3ATI", typeof(GL.Delegates.ColorFragmentOp3ATI)); - GL.AlphaFragmentOp1ATI = (GL.Delegates.AlphaFragmentOp1ATI) GetAddress("glAlphaFragmentOp1ATI", typeof(GL.Delegates.AlphaFragmentOp1ATI)); - GL.AlphaFragmentOp2ATI = (GL.Delegates.AlphaFragmentOp2ATI) GetAddress("glAlphaFragmentOp2ATI", typeof(GL.Delegates.AlphaFragmentOp2ATI)); - GL.AlphaFragmentOp3ATI = (GL.Delegates.AlphaFragmentOp3ATI) GetAddress("glAlphaFragmentOp3ATI", typeof(GL.Delegates.AlphaFragmentOp3ATI)); - GL.SetFragmentShaderConstantATI = (GL.Delegates.SetFragmentShaderConstantATI) GetAddress("glSetFragmentShaderConstantATI", typeof(GL.Delegates.SetFragmentShaderConstantATI)); - GL.PNTrianglesiATI = (GL.Delegates.PNTrianglesiATI) GetAddress("glPNTrianglesiATI", typeof(GL.Delegates.PNTrianglesiATI)); - GL.PNTrianglesfATI = (GL.Delegates.PNTrianglesfATI) GetAddress("glPNTrianglesfATI", typeof(GL.Delegates.PNTrianglesfATI)); - GL.NewObjectBufferATI = (GL.Delegates.NewObjectBufferATI) GetAddress("glNewObjectBufferATI", typeof(GL.Delegates.NewObjectBufferATI)); - GL.IsObjectBufferATI = (GL.Delegates.IsObjectBufferATI) GetAddress("glIsObjectBufferATI", typeof(GL.Delegates.IsObjectBufferATI)); - GL.UpdateObjectBufferATI = (GL.Delegates.UpdateObjectBufferATI) GetAddress("glUpdateObjectBufferATI", typeof(GL.Delegates.UpdateObjectBufferATI)); - GL.GetObjectBufferfvATI = (GL.Delegates.GetObjectBufferfvATI) GetAddress("glGetObjectBufferfvATI", typeof(GL.Delegates.GetObjectBufferfvATI)); - GL.GetObjectBufferivATI = (GL.Delegates.GetObjectBufferivATI) GetAddress("glGetObjectBufferivATI", typeof(GL.Delegates.GetObjectBufferivATI)); - GL.FreeObjectBufferATI = (GL.Delegates.FreeObjectBufferATI) GetAddress("glFreeObjectBufferATI", typeof(GL.Delegates.FreeObjectBufferATI)); - GL.ArrayObjectATI = (GL.Delegates.ArrayObjectATI) GetAddress("glArrayObjectATI", typeof(GL.Delegates.ArrayObjectATI)); - GL.GetArrayObjectfvATI = (GL.Delegates.GetArrayObjectfvATI) GetAddress("glGetArrayObjectfvATI", typeof(GL.Delegates.GetArrayObjectfvATI)); - GL.GetArrayObjectivATI = (GL.Delegates.GetArrayObjectivATI) GetAddress("glGetArrayObjectivATI", typeof(GL.Delegates.GetArrayObjectivATI)); - GL.VariantArrayObjectATI = (GL.Delegates.VariantArrayObjectATI) GetAddress("glVariantArrayObjectATI", typeof(GL.Delegates.VariantArrayObjectATI)); - GL.GetVariantArrayObjectfvATI = (GL.Delegates.GetVariantArrayObjectfvATI) GetAddress("glGetVariantArrayObjectfvATI", typeof(GL.Delegates.GetVariantArrayObjectfvATI)); - GL.GetVariantArrayObjectivATI = (GL.Delegates.GetVariantArrayObjectivATI) GetAddress("glGetVariantArrayObjectivATI", typeof(GL.Delegates.GetVariantArrayObjectivATI)); - GL.BeginVertexShaderEXT = (GL.Delegates.BeginVertexShaderEXT) GetAddress("glBeginVertexShaderEXT", typeof(GL.Delegates.BeginVertexShaderEXT)); - GL.EndVertexShaderEXT = (GL.Delegates.EndVertexShaderEXT) GetAddress("glEndVertexShaderEXT", typeof(GL.Delegates.EndVertexShaderEXT)); - GL.BindVertexShaderEXT = (GL.Delegates.BindVertexShaderEXT) GetAddress("glBindVertexShaderEXT", typeof(GL.Delegates.BindVertexShaderEXT)); - GL.GenVertexShadersEXT = (GL.Delegates.GenVertexShadersEXT) GetAddress("glGenVertexShadersEXT", typeof(GL.Delegates.GenVertexShadersEXT)); - GL.DeleteVertexShaderEXT = (GL.Delegates.DeleteVertexShaderEXT) GetAddress("glDeleteVertexShaderEXT", typeof(GL.Delegates.DeleteVertexShaderEXT)); - GL.ShaderOp1EXT = (GL.Delegates.ShaderOp1EXT) GetAddress("glShaderOp1EXT", typeof(GL.Delegates.ShaderOp1EXT)); - GL.ShaderOp2EXT = (GL.Delegates.ShaderOp2EXT) GetAddress("glShaderOp2EXT", typeof(GL.Delegates.ShaderOp2EXT)); - GL.ShaderOp3EXT = (GL.Delegates.ShaderOp3EXT) GetAddress("glShaderOp3EXT", typeof(GL.Delegates.ShaderOp3EXT)); - GL.SwizzleEXT = (GL.Delegates.SwizzleEXT) GetAddress("glSwizzleEXT", typeof(GL.Delegates.SwizzleEXT)); - GL.WriteMaskEXT = (GL.Delegates.WriteMaskEXT) GetAddress("glWriteMaskEXT", typeof(GL.Delegates.WriteMaskEXT)); - GL.InsertComponentEXT = (GL.Delegates.InsertComponentEXT) GetAddress("glInsertComponentEXT", typeof(GL.Delegates.InsertComponentEXT)); - GL.ExtractComponentEXT = (GL.Delegates.ExtractComponentEXT) GetAddress("glExtractComponentEXT", typeof(GL.Delegates.ExtractComponentEXT)); - GL.GenSymbolsEXT = (GL.Delegates.GenSymbolsEXT) GetAddress("glGenSymbolsEXT", typeof(GL.Delegates.GenSymbolsEXT)); - GL.SetInvariantEXT = (GL.Delegates.SetInvariantEXT) GetAddress("glSetInvariantEXT", typeof(GL.Delegates.SetInvariantEXT)); - GL.SetLocalConstantEXT = (GL.Delegates.SetLocalConstantEXT) GetAddress("glSetLocalConstantEXT", typeof(GL.Delegates.SetLocalConstantEXT)); - GL.VariantbvEXT = (GL.Delegates.VariantbvEXT) GetAddress("glVariantbvEXT", typeof(GL.Delegates.VariantbvEXT)); - GL.VariantsvEXT = (GL.Delegates.VariantsvEXT) GetAddress("glVariantsvEXT", typeof(GL.Delegates.VariantsvEXT)); - GL.VariantivEXT = (GL.Delegates.VariantivEXT) GetAddress("glVariantivEXT", typeof(GL.Delegates.VariantivEXT)); - GL.VariantfvEXT = (GL.Delegates.VariantfvEXT) GetAddress("glVariantfvEXT", typeof(GL.Delegates.VariantfvEXT)); - GL.VariantdvEXT = (GL.Delegates.VariantdvEXT) GetAddress("glVariantdvEXT", typeof(GL.Delegates.VariantdvEXT)); - GL.VariantubvEXT = (GL.Delegates.VariantubvEXT) GetAddress("glVariantubvEXT", typeof(GL.Delegates.VariantubvEXT)); - GL.VariantusvEXT = (GL.Delegates.VariantusvEXT) GetAddress("glVariantusvEXT", typeof(GL.Delegates.VariantusvEXT)); - GL.VariantuivEXT = (GL.Delegates.VariantuivEXT) GetAddress("glVariantuivEXT", typeof(GL.Delegates.VariantuivEXT)); - GL.VariantPointerEXT = (GL.Delegates.VariantPointerEXT) GetAddress("glVariantPointerEXT", typeof(GL.Delegates.VariantPointerEXT)); - GL.EnableVariantClientStateEXT = (GL.Delegates.EnableVariantClientStateEXT) GetAddress("glEnableVariantClientStateEXT", typeof(GL.Delegates.EnableVariantClientStateEXT)); - GL.DisableVariantClientStateEXT = (GL.Delegates.DisableVariantClientStateEXT) GetAddress("glDisableVariantClientStateEXT", typeof(GL.Delegates.DisableVariantClientStateEXT)); - GL.BindLightParameterEXT = (GL.Delegates.BindLightParameterEXT) GetAddress("glBindLightParameterEXT", typeof(GL.Delegates.BindLightParameterEXT)); - GL.BindMaterialParameterEXT = (GL.Delegates.BindMaterialParameterEXT) GetAddress("glBindMaterialParameterEXT", typeof(GL.Delegates.BindMaterialParameterEXT)); - GL.BindTexGenParameterEXT = (GL.Delegates.BindTexGenParameterEXT) GetAddress("glBindTexGenParameterEXT", typeof(GL.Delegates.BindTexGenParameterEXT)); - GL.BindTextureUnitParameterEXT = (GL.Delegates.BindTextureUnitParameterEXT) GetAddress("glBindTextureUnitParameterEXT", typeof(GL.Delegates.BindTextureUnitParameterEXT)); - GL.BindParameterEXT = (GL.Delegates.BindParameterEXT) GetAddress("glBindParameterEXT", typeof(GL.Delegates.BindParameterEXT)); - GL.IsVariantEnabledEXT = (GL.Delegates.IsVariantEnabledEXT) GetAddress("glIsVariantEnabledEXT", typeof(GL.Delegates.IsVariantEnabledEXT)); - GL.GetVariantBooleanvEXT = (GL.Delegates.GetVariantBooleanvEXT) GetAddress("glGetVariantBooleanvEXT", typeof(GL.Delegates.GetVariantBooleanvEXT)); - GL.GetVariantIntegervEXT = (GL.Delegates.GetVariantIntegervEXT) GetAddress("glGetVariantIntegervEXT", typeof(GL.Delegates.GetVariantIntegervEXT)); - GL.GetVariantFloatvEXT = (GL.Delegates.GetVariantFloatvEXT) GetAddress("glGetVariantFloatvEXT", typeof(GL.Delegates.GetVariantFloatvEXT)); - GL.GetVariantPointervEXT = (GL.Delegates.GetVariantPointervEXT) GetAddress("glGetVariantPointervEXT", typeof(GL.Delegates.GetVariantPointervEXT)); - GL.GetInvariantBooleanvEXT = (GL.Delegates.GetInvariantBooleanvEXT) GetAddress("glGetInvariantBooleanvEXT", typeof(GL.Delegates.GetInvariantBooleanvEXT)); - GL.GetInvariantIntegervEXT = (GL.Delegates.GetInvariantIntegervEXT) GetAddress("glGetInvariantIntegervEXT", typeof(GL.Delegates.GetInvariantIntegervEXT)); - GL.GetInvariantFloatvEXT = (GL.Delegates.GetInvariantFloatvEXT) GetAddress("glGetInvariantFloatvEXT", typeof(GL.Delegates.GetInvariantFloatvEXT)); - GL.GetLocalConstantBooleanvEXT = (GL.Delegates.GetLocalConstantBooleanvEXT) GetAddress("glGetLocalConstantBooleanvEXT", typeof(GL.Delegates.GetLocalConstantBooleanvEXT)); - GL.GetLocalConstantIntegervEXT = (GL.Delegates.GetLocalConstantIntegervEXT) GetAddress("glGetLocalConstantIntegervEXT", typeof(GL.Delegates.GetLocalConstantIntegervEXT)); - GL.GetLocalConstantFloatvEXT = (GL.Delegates.GetLocalConstantFloatvEXT) GetAddress("glGetLocalConstantFloatvEXT", typeof(GL.Delegates.GetLocalConstantFloatvEXT)); - GL.VertexStream1sATI = (GL.Delegates.VertexStream1sATI) GetAddress("glVertexStream1sATI", typeof(GL.Delegates.VertexStream1sATI)); - GL.VertexStream1svATI = (GL.Delegates.VertexStream1svATI) GetAddress("glVertexStream1svATI", typeof(GL.Delegates.VertexStream1svATI)); - GL.VertexStream1iATI = (GL.Delegates.VertexStream1iATI) GetAddress("glVertexStream1iATI", typeof(GL.Delegates.VertexStream1iATI)); - GL.VertexStream1ivATI = (GL.Delegates.VertexStream1ivATI) GetAddress("glVertexStream1ivATI", typeof(GL.Delegates.VertexStream1ivATI)); - GL.VertexStream1fATI = (GL.Delegates.VertexStream1fATI) GetAddress("glVertexStream1fATI", typeof(GL.Delegates.VertexStream1fATI)); - GL.VertexStream1fvATI = (GL.Delegates.VertexStream1fvATI) GetAddress("glVertexStream1fvATI", typeof(GL.Delegates.VertexStream1fvATI)); - GL.VertexStream1dATI = (GL.Delegates.VertexStream1dATI) GetAddress("glVertexStream1dATI", typeof(GL.Delegates.VertexStream1dATI)); - GL.VertexStream1dvATI = (GL.Delegates.VertexStream1dvATI) GetAddress("glVertexStream1dvATI", typeof(GL.Delegates.VertexStream1dvATI)); - GL.VertexStream2sATI = (GL.Delegates.VertexStream2sATI) GetAddress("glVertexStream2sATI", typeof(GL.Delegates.VertexStream2sATI)); - GL.VertexStream2svATI = (GL.Delegates.VertexStream2svATI) GetAddress("glVertexStream2svATI", typeof(GL.Delegates.VertexStream2svATI)); - GL.VertexStream2iATI = (GL.Delegates.VertexStream2iATI) GetAddress("glVertexStream2iATI", typeof(GL.Delegates.VertexStream2iATI)); - GL.VertexStream2ivATI = (GL.Delegates.VertexStream2ivATI) GetAddress("glVertexStream2ivATI", typeof(GL.Delegates.VertexStream2ivATI)); - GL.VertexStream2fATI = (GL.Delegates.VertexStream2fATI) GetAddress("glVertexStream2fATI", typeof(GL.Delegates.VertexStream2fATI)); - GL.VertexStream2fvATI = (GL.Delegates.VertexStream2fvATI) GetAddress("glVertexStream2fvATI", typeof(GL.Delegates.VertexStream2fvATI)); - GL.VertexStream2dATI = (GL.Delegates.VertexStream2dATI) GetAddress("glVertexStream2dATI", typeof(GL.Delegates.VertexStream2dATI)); - GL.VertexStream2dvATI = (GL.Delegates.VertexStream2dvATI) GetAddress("glVertexStream2dvATI", typeof(GL.Delegates.VertexStream2dvATI)); - GL.VertexStream3sATI = (GL.Delegates.VertexStream3sATI) GetAddress("glVertexStream3sATI", typeof(GL.Delegates.VertexStream3sATI)); - GL.VertexStream3svATI = (GL.Delegates.VertexStream3svATI) GetAddress("glVertexStream3svATI", typeof(GL.Delegates.VertexStream3svATI)); - GL.VertexStream3iATI = (GL.Delegates.VertexStream3iATI) GetAddress("glVertexStream3iATI", typeof(GL.Delegates.VertexStream3iATI)); - GL.VertexStream3ivATI = (GL.Delegates.VertexStream3ivATI) GetAddress("glVertexStream3ivATI", typeof(GL.Delegates.VertexStream3ivATI)); - GL.VertexStream3fATI = (GL.Delegates.VertexStream3fATI) GetAddress("glVertexStream3fATI", typeof(GL.Delegates.VertexStream3fATI)); - GL.VertexStream3fvATI = (GL.Delegates.VertexStream3fvATI) GetAddress("glVertexStream3fvATI", typeof(GL.Delegates.VertexStream3fvATI)); - GL.VertexStream3dATI = (GL.Delegates.VertexStream3dATI) GetAddress("glVertexStream3dATI", typeof(GL.Delegates.VertexStream3dATI)); - GL.VertexStream3dvATI = (GL.Delegates.VertexStream3dvATI) GetAddress("glVertexStream3dvATI", typeof(GL.Delegates.VertexStream3dvATI)); - GL.VertexStream4sATI = (GL.Delegates.VertexStream4sATI) GetAddress("glVertexStream4sATI", typeof(GL.Delegates.VertexStream4sATI)); - GL.VertexStream4svATI = (GL.Delegates.VertexStream4svATI) GetAddress("glVertexStream4svATI", typeof(GL.Delegates.VertexStream4svATI)); - GL.VertexStream4iATI = (GL.Delegates.VertexStream4iATI) GetAddress("glVertexStream4iATI", typeof(GL.Delegates.VertexStream4iATI)); - GL.VertexStream4ivATI = (GL.Delegates.VertexStream4ivATI) GetAddress("glVertexStream4ivATI", typeof(GL.Delegates.VertexStream4ivATI)); - GL.VertexStream4fATI = (GL.Delegates.VertexStream4fATI) GetAddress("glVertexStream4fATI", typeof(GL.Delegates.VertexStream4fATI)); - GL.VertexStream4fvATI = (GL.Delegates.VertexStream4fvATI) GetAddress("glVertexStream4fvATI", typeof(GL.Delegates.VertexStream4fvATI)); - GL.VertexStream4dATI = (GL.Delegates.VertexStream4dATI) GetAddress("glVertexStream4dATI", typeof(GL.Delegates.VertexStream4dATI)); - GL.VertexStream4dvATI = (GL.Delegates.VertexStream4dvATI) GetAddress("glVertexStream4dvATI", typeof(GL.Delegates.VertexStream4dvATI)); - GL.NormalStream3bATI = (GL.Delegates.NormalStream3bATI) GetAddress("glNormalStream3bATI", typeof(GL.Delegates.NormalStream3bATI)); - GL.NormalStream3bvATI = (GL.Delegates.NormalStream3bvATI) GetAddress("glNormalStream3bvATI", typeof(GL.Delegates.NormalStream3bvATI)); - GL.NormalStream3sATI = (GL.Delegates.NormalStream3sATI) GetAddress("glNormalStream3sATI", typeof(GL.Delegates.NormalStream3sATI)); - GL.NormalStream3svATI = (GL.Delegates.NormalStream3svATI) GetAddress("glNormalStream3svATI", typeof(GL.Delegates.NormalStream3svATI)); - GL.NormalStream3iATI = (GL.Delegates.NormalStream3iATI) GetAddress("glNormalStream3iATI", typeof(GL.Delegates.NormalStream3iATI)); - GL.NormalStream3ivATI = (GL.Delegates.NormalStream3ivATI) GetAddress("glNormalStream3ivATI", typeof(GL.Delegates.NormalStream3ivATI)); - GL.NormalStream3fATI = (GL.Delegates.NormalStream3fATI) GetAddress("glNormalStream3fATI", typeof(GL.Delegates.NormalStream3fATI)); - GL.NormalStream3fvATI = (GL.Delegates.NormalStream3fvATI) GetAddress("glNormalStream3fvATI", typeof(GL.Delegates.NormalStream3fvATI)); - GL.NormalStream3dATI = (GL.Delegates.NormalStream3dATI) GetAddress("glNormalStream3dATI", typeof(GL.Delegates.NormalStream3dATI)); - GL.NormalStream3dvATI = (GL.Delegates.NormalStream3dvATI) GetAddress("glNormalStream3dvATI", typeof(GL.Delegates.NormalStream3dvATI)); - GL.ClientActiveVertexStreamATI = (GL.Delegates.ClientActiveVertexStreamATI) GetAddress("glClientActiveVertexStreamATI", typeof(GL.Delegates.ClientActiveVertexStreamATI)); - GL.VertexBlendEnviATI = (GL.Delegates.VertexBlendEnviATI) GetAddress("glVertexBlendEnviATI", typeof(GL.Delegates.VertexBlendEnviATI)); - GL.VertexBlendEnvfATI = (GL.Delegates.VertexBlendEnvfATI) GetAddress("glVertexBlendEnvfATI", typeof(GL.Delegates.VertexBlendEnvfATI)); - GL.ElementPointerATI = (GL.Delegates.ElementPointerATI) GetAddress("glElementPointerATI", typeof(GL.Delegates.ElementPointerATI)); - GL.DrawElementArrayATI = (GL.Delegates.DrawElementArrayATI) GetAddress("glDrawElementArrayATI", typeof(GL.Delegates.DrawElementArrayATI)); - GL.DrawRangeElementArrayATI = (GL.Delegates.DrawRangeElementArrayATI) GetAddress("glDrawRangeElementArrayATI", typeof(GL.Delegates.DrawRangeElementArrayATI)); - GL.DrawMeshArraysSUN = (GL.Delegates.DrawMeshArraysSUN) GetAddress("glDrawMeshArraysSUN", typeof(GL.Delegates.DrawMeshArraysSUN)); - GL.GenOcclusionQueriesNV = (GL.Delegates.GenOcclusionQueriesNV) GetAddress("glGenOcclusionQueriesNV", typeof(GL.Delegates.GenOcclusionQueriesNV)); - GL.DeleteOcclusionQueriesNV = (GL.Delegates.DeleteOcclusionQueriesNV) GetAddress("glDeleteOcclusionQueriesNV", typeof(GL.Delegates.DeleteOcclusionQueriesNV)); - GL.IsOcclusionQueryNV = (GL.Delegates.IsOcclusionQueryNV) GetAddress("glIsOcclusionQueryNV", typeof(GL.Delegates.IsOcclusionQueryNV)); - GL.BeginOcclusionQueryNV = (GL.Delegates.BeginOcclusionQueryNV) GetAddress("glBeginOcclusionQueryNV", typeof(GL.Delegates.BeginOcclusionQueryNV)); - GL.EndOcclusionQueryNV = (GL.Delegates.EndOcclusionQueryNV) GetAddress("glEndOcclusionQueryNV", typeof(GL.Delegates.EndOcclusionQueryNV)); - GL.GetOcclusionQueryivNV = (GL.Delegates.GetOcclusionQueryivNV) GetAddress("glGetOcclusionQueryivNV", typeof(GL.Delegates.GetOcclusionQueryivNV)); - GL.GetOcclusionQueryuivNV = (GL.Delegates.GetOcclusionQueryuivNV) GetAddress("glGetOcclusionQueryuivNV", typeof(GL.Delegates.GetOcclusionQueryuivNV)); - GL.PointParameteriNV = (GL.Delegates.PointParameteriNV) GetAddress("glPointParameteriNV", typeof(GL.Delegates.PointParameteriNV)); - GL.PointParameterivNV = (GL.Delegates.PointParameterivNV) GetAddress("glPointParameterivNV", typeof(GL.Delegates.PointParameterivNV)); - GL.ActiveStencilFaceEXT = (GL.Delegates.ActiveStencilFaceEXT) GetAddress("glActiveStencilFaceEXT", typeof(GL.Delegates.ActiveStencilFaceEXT)); - GL.ElementPointerAPPLE = (GL.Delegates.ElementPointerAPPLE) GetAddress("glElementPointerAPPLE", typeof(GL.Delegates.ElementPointerAPPLE)); - GL.DrawElementArrayAPPLE = (GL.Delegates.DrawElementArrayAPPLE) GetAddress("glDrawElementArrayAPPLE", typeof(GL.Delegates.DrawElementArrayAPPLE)); - GL.DrawRangeElementArrayAPPLE = (GL.Delegates.DrawRangeElementArrayAPPLE) GetAddress("glDrawRangeElementArrayAPPLE", typeof(GL.Delegates.DrawRangeElementArrayAPPLE)); - GL.MultiDrawElementArrayAPPLE = (GL.Delegates.MultiDrawElementArrayAPPLE) GetAddress("glMultiDrawElementArrayAPPLE", typeof(GL.Delegates.MultiDrawElementArrayAPPLE)); - GL.MultiDrawRangeElementArrayAPPLE = (GL.Delegates.MultiDrawRangeElementArrayAPPLE) GetAddress("glMultiDrawRangeElementArrayAPPLE", typeof(GL.Delegates.MultiDrawRangeElementArrayAPPLE)); - GL.GenFencesAPPLE = (GL.Delegates.GenFencesAPPLE) GetAddress("glGenFencesAPPLE", typeof(GL.Delegates.GenFencesAPPLE)); - GL.DeleteFencesAPPLE = (GL.Delegates.DeleteFencesAPPLE) GetAddress("glDeleteFencesAPPLE", typeof(GL.Delegates.DeleteFencesAPPLE)); - GL.SetFenceAPPLE = (GL.Delegates.SetFenceAPPLE) GetAddress("glSetFenceAPPLE", typeof(GL.Delegates.SetFenceAPPLE)); - GL.IsFenceAPPLE = (GL.Delegates.IsFenceAPPLE) GetAddress("glIsFenceAPPLE", typeof(GL.Delegates.IsFenceAPPLE)); - GL.TestFenceAPPLE = (GL.Delegates.TestFenceAPPLE) GetAddress("glTestFenceAPPLE", typeof(GL.Delegates.TestFenceAPPLE)); - GL.FinishFenceAPPLE = (GL.Delegates.FinishFenceAPPLE) GetAddress("glFinishFenceAPPLE", typeof(GL.Delegates.FinishFenceAPPLE)); - GL.TestObjectAPPLE = (GL.Delegates.TestObjectAPPLE) GetAddress("glTestObjectAPPLE", typeof(GL.Delegates.TestObjectAPPLE)); - GL.FinishObjectAPPLE = (GL.Delegates.FinishObjectAPPLE) GetAddress("glFinishObjectAPPLE", typeof(GL.Delegates.FinishObjectAPPLE)); - GL.BindVertexArrayAPPLE = (GL.Delegates.BindVertexArrayAPPLE) GetAddress("glBindVertexArrayAPPLE", typeof(GL.Delegates.BindVertexArrayAPPLE)); - GL.DeleteVertexArraysAPPLE = (GL.Delegates.DeleteVertexArraysAPPLE) GetAddress("glDeleteVertexArraysAPPLE", typeof(GL.Delegates.DeleteVertexArraysAPPLE)); - GL.GenVertexArraysAPPLE = (GL.Delegates.GenVertexArraysAPPLE) GetAddress("glGenVertexArraysAPPLE", typeof(GL.Delegates.GenVertexArraysAPPLE)); - GL.IsVertexArrayAPPLE = (GL.Delegates.IsVertexArrayAPPLE) GetAddress("glIsVertexArrayAPPLE", typeof(GL.Delegates.IsVertexArrayAPPLE)); - GL.VertexArrayRangeAPPLE = (GL.Delegates.VertexArrayRangeAPPLE) GetAddress("glVertexArrayRangeAPPLE", typeof(GL.Delegates.VertexArrayRangeAPPLE)); - GL.FlushVertexArrayRangeAPPLE = (GL.Delegates.FlushVertexArrayRangeAPPLE) GetAddress("glFlushVertexArrayRangeAPPLE", typeof(GL.Delegates.FlushVertexArrayRangeAPPLE)); - GL.VertexArrayParameteriAPPLE = (GL.Delegates.VertexArrayParameteriAPPLE) GetAddress("glVertexArrayParameteriAPPLE", typeof(GL.Delegates.VertexArrayParameteriAPPLE)); - GL.DrawBuffersATI = (GL.Delegates.DrawBuffersATI) GetAddress("glDrawBuffersATI", typeof(GL.Delegates.DrawBuffersATI)); - GL.ProgramNamedParameter4fNV = (GL.Delegates.ProgramNamedParameter4fNV) GetAddress("glProgramNamedParameter4fNV", typeof(GL.Delegates.ProgramNamedParameter4fNV)); - GL.ProgramNamedParameter4dNV = (GL.Delegates.ProgramNamedParameter4dNV) GetAddress("glProgramNamedParameter4dNV", typeof(GL.Delegates.ProgramNamedParameter4dNV)); - GL.ProgramNamedParameter4fvNV = (GL.Delegates.ProgramNamedParameter4fvNV) GetAddress("glProgramNamedParameter4fvNV", typeof(GL.Delegates.ProgramNamedParameter4fvNV)); - GL.ProgramNamedParameter4dvNV = (GL.Delegates.ProgramNamedParameter4dvNV) GetAddress("glProgramNamedParameter4dvNV", typeof(GL.Delegates.ProgramNamedParameter4dvNV)); - GL.GetProgramNamedParameterfvNV = (GL.Delegates.GetProgramNamedParameterfvNV) GetAddress("glGetProgramNamedParameterfvNV", typeof(GL.Delegates.GetProgramNamedParameterfvNV)); - GL.GetProgramNamedParameterdvNV = (GL.Delegates.GetProgramNamedParameterdvNV) GetAddress("glGetProgramNamedParameterdvNV", typeof(GL.Delegates.GetProgramNamedParameterdvNV)); - GL.Vertex2hNV = (GL.Delegates.Vertex2hNV) GetAddress("glVertex2hNV", typeof(GL.Delegates.Vertex2hNV)); - GL.Vertex2hvNV = (GL.Delegates.Vertex2hvNV) GetAddress("glVertex2hvNV", typeof(GL.Delegates.Vertex2hvNV)); - GL.Vertex3hNV = (GL.Delegates.Vertex3hNV) GetAddress("glVertex3hNV", typeof(GL.Delegates.Vertex3hNV)); - GL.Vertex3hvNV = (GL.Delegates.Vertex3hvNV) GetAddress("glVertex3hvNV", typeof(GL.Delegates.Vertex3hvNV)); - GL.Vertex4hNV = (GL.Delegates.Vertex4hNV) GetAddress("glVertex4hNV", typeof(GL.Delegates.Vertex4hNV)); - GL.Vertex4hvNV = (GL.Delegates.Vertex4hvNV) GetAddress("glVertex4hvNV", typeof(GL.Delegates.Vertex4hvNV)); - GL.Normal3hNV = (GL.Delegates.Normal3hNV) GetAddress("glNormal3hNV", typeof(GL.Delegates.Normal3hNV)); - GL.Normal3hvNV = (GL.Delegates.Normal3hvNV) GetAddress("glNormal3hvNV", typeof(GL.Delegates.Normal3hvNV)); - GL.Color3hNV = (GL.Delegates.Color3hNV) GetAddress("glColor3hNV", typeof(GL.Delegates.Color3hNV)); - GL.Color3hvNV = (GL.Delegates.Color3hvNV) GetAddress("glColor3hvNV", typeof(GL.Delegates.Color3hvNV)); - GL.Color4hNV = (GL.Delegates.Color4hNV) GetAddress("glColor4hNV", typeof(GL.Delegates.Color4hNV)); - GL.Color4hvNV = (GL.Delegates.Color4hvNV) GetAddress("glColor4hvNV", typeof(GL.Delegates.Color4hvNV)); - GL.TexCoord1hNV = (GL.Delegates.TexCoord1hNV) GetAddress("glTexCoord1hNV", typeof(GL.Delegates.TexCoord1hNV)); - GL.TexCoord1hvNV = (GL.Delegates.TexCoord1hvNV) GetAddress("glTexCoord1hvNV", typeof(GL.Delegates.TexCoord1hvNV)); - GL.TexCoord2hNV = (GL.Delegates.TexCoord2hNV) GetAddress("glTexCoord2hNV", typeof(GL.Delegates.TexCoord2hNV)); - GL.TexCoord2hvNV = (GL.Delegates.TexCoord2hvNV) GetAddress("glTexCoord2hvNV", typeof(GL.Delegates.TexCoord2hvNV)); - GL.TexCoord3hNV = (GL.Delegates.TexCoord3hNV) GetAddress("glTexCoord3hNV", typeof(GL.Delegates.TexCoord3hNV)); - GL.TexCoord3hvNV = (GL.Delegates.TexCoord3hvNV) GetAddress("glTexCoord3hvNV", typeof(GL.Delegates.TexCoord3hvNV)); - GL.TexCoord4hNV = (GL.Delegates.TexCoord4hNV) GetAddress("glTexCoord4hNV", typeof(GL.Delegates.TexCoord4hNV)); - GL.TexCoord4hvNV = (GL.Delegates.TexCoord4hvNV) GetAddress("glTexCoord4hvNV", typeof(GL.Delegates.TexCoord4hvNV)); - GL.MultiTexCoord1hNV = (GL.Delegates.MultiTexCoord1hNV) GetAddress("glMultiTexCoord1hNV", typeof(GL.Delegates.MultiTexCoord1hNV)); - GL.MultiTexCoord1hvNV = (GL.Delegates.MultiTexCoord1hvNV) GetAddress("glMultiTexCoord1hvNV", typeof(GL.Delegates.MultiTexCoord1hvNV)); - GL.MultiTexCoord2hNV = (GL.Delegates.MultiTexCoord2hNV) GetAddress("glMultiTexCoord2hNV", typeof(GL.Delegates.MultiTexCoord2hNV)); - GL.MultiTexCoord2hvNV = (GL.Delegates.MultiTexCoord2hvNV) GetAddress("glMultiTexCoord2hvNV", typeof(GL.Delegates.MultiTexCoord2hvNV)); - GL.MultiTexCoord3hNV = (GL.Delegates.MultiTexCoord3hNV) GetAddress("glMultiTexCoord3hNV", typeof(GL.Delegates.MultiTexCoord3hNV)); - GL.MultiTexCoord3hvNV = (GL.Delegates.MultiTexCoord3hvNV) GetAddress("glMultiTexCoord3hvNV", typeof(GL.Delegates.MultiTexCoord3hvNV)); - GL.MultiTexCoord4hNV = (GL.Delegates.MultiTexCoord4hNV) GetAddress("glMultiTexCoord4hNV", typeof(GL.Delegates.MultiTexCoord4hNV)); - GL.MultiTexCoord4hvNV = (GL.Delegates.MultiTexCoord4hvNV) GetAddress("glMultiTexCoord4hvNV", typeof(GL.Delegates.MultiTexCoord4hvNV)); - GL.FogCoordhNV = (GL.Delegates.FogCoordhNV) GetAddress("glFogCoordhNV", typeof(GL.Delegates.FogCoordhNV)); - GL.FogCoordhvNV = (GL.Delegates.FogCoordhvNV) GetAddress("glFogCoordhvNV", typeof(GL.Delegates.FogCoordhvNV)); - GL.SecondaryColor3hNV = (GL.Delegates.SecondaryColor3hNV) GetAddress("glSecondaryColor3hNV", typeof(GL.Delegates.SecondaryColor3hNV)); - GL.SecondaryColor3hvNV = (GL.Delegates.SecondaryColor3hvNV) GetAddress("glSecondaryColor3hvNV", typeof(GL.Delegates.SecondaryColor3hvNV)); - GL.VertexWeighthNV = (GL.Delegates.VertexWeighthNV) GetAddress("glVertexWeighthNV", typeof(GL.Delegates.VertexWeighthNV)); - GL.VertexWeighthvNV = (GL.Delegates.VertexWeighthvNV) GetAddress("glVertexWeighthvNV", typeof(GL.Delegates.VertexWeighthvNV)); - GL.VertexAttrib1hNV = (GL.Delegates.VertexAttrib1hNV) GetAddress("glVertexAttrib1hNV", typeof(GL.Delegates.VertexAttrib1hNV)); - GL.VertexAttrib1hvNV = (GL.Delegates.VertexAttrib1hvNV) GetAddress("glVertexAttrib1hvNV", typeof(GL.Delegates.VertexAttrib1hvNV)); - GL.VertexAttrib2hNV = (GL.Delegates.VertexAttrib2hNV) GetAddress("glVertexAttrib2hNV", typeof(GL.Delegates.VertexAttrib2hNV)); - GL.VertexAttrib2hvNV = (GL.Delegates.VertexAttrib2hvNV) GetAddress("glVertexAttrib2hvNV", typeof(GL.Delegates.VertexAttrib2hvNV)); - GL.VertexAttrib3hNV = (GL.Delegates.VertexAttrib3hNV) GetAddress("glVertexAttrib3hNV", typeof(GL.Delegates.VertexAttrib3hNV)); - GL.VertexAttrib3hvNV = (GL.Delegates.VertexAttrib3hvNV) GetAddress("glVertexAttrib3hvNV", typeof(GL.Delegates.VertexAttrib3hvNV)); - GL.VertexAttrib4hNV = (GL.Delegates.VertexAttrib4hNV) GetAddress("glVertexAttrib4hNV", typeof(GL.Delegates.VertexAttrib4hNV)); - GL.VertexAttrib4hvNV = (GL.Delegates.VertexAttrib4hvNV) GetAddress("glVertexAttrib4hvNV", typeof(GL.Delegates.VertexAttrib4hvNV)); - GL.VertexAttribs1hvNV = (GL.Delegates.VertexAttribs1hvNV) GetAddress("glVertexAttribs1hvNV", typeof(GL.Delegates.VertexAttribs1hvNV)); - GL.VertexAttribs2hvNV = (GL.Delegates.VertexAttribs2hvNV) GetAddress("glVertexAttribs2hvNV", typeof(GL.Delegates.VertexAttribs2hvNV)); - GL.VertexAttribs3hvNV = (GL.Delegates.VertexAttribs3hvNV) GetAddress("glVertexAttribs3hvNV", typeof(GL.Delegates.VertexAttribs3hvNV)); - GL.VertexAttribs4hvNV = (GL.Delegates.VertexAttribs4hvNV) GetAddress("glVertexAttribs4hvNV", typeof(GL.Delegates.VertexAttribs4hvNV)); - GL.PixelDataRangeNV = (GL.Delegates.PixelDataRangeNV) GetAddress("glPixelDataRangeNV", typeof(GL.Delegates.PixelDataRangeNV)); - GL.FlushPixelDataRangeNV = (GL.Delegates.FlushPixelDataRangeNV) GetAddress("glFlushPixelDataRangeNV", typeof(GL.Delegates.FlushPixelDataRangeNV)); - GL.PrimitiveRestartNV = (GL.Delegates.PrimitiveRestartNV) GetAddress("glPrimitiveRestartNV", typeof(GL.Delegates.PrimitiveRestartNV)); - GL.PrimitiveRestartIndexNV = (GL.Delegates.PrimitiveRestartIndexNV) GetAddress("glPrimitiveRestartIndexNV", typeof(GL.Delegates.PrimitiveRestartIndexNV)); - GL.MapObjectBufferATI_ = (GL.Delegates.MapObjectBufferATI_) GetAddress("glMapObjectBufferATI_", typeof(GL.Delegates.MapObjectBufferATI_)); - GL.UnmapObjectBufferATI = (GL.Delegates.UnmapObjectBufferATI) GetAddress("glUnmapObjectBufferATI", typeof(GL.Delegates.UnmapObjectBufferATI)); - GL.StencilOpSeparateATI = (GL.Delegates.StencilOpSeparateATI) GetAddress("glStencilOpSeparateATI", typeof(GL.Delegates.StencilOpSeparateATI)); - GL.StencilFuncSeparateATI = (GL.Delegates.StencilFuncSeparateATI) GetAddress("glStencilFuncSeparateATI", typeof(GL.Delegates.StencilFuncSeparateATI)); - GL.VertexAttribArrayObjectATI = (GL.Delegates.VertexAttribArrayObjectATI) GetAddress("glVertexAttribArrayObjectATI", typeof(GL.Delegates.VertexAttribArrayObjectATI)); - GL.GetVertexAttribArrayObjectfvATI = (GL.Delegates.GetVertexAttribArrayObjectfvATI) GetAddress("glGetVertexAttribArrayObjectfvATI", typeof(GL.Delegates.GetVertexAttribArrayObjectfvATI)); - GL.GetVertexAttribArrayObjectivATI = (GL.Delegates.GetVertexAttribArrayObjectivATI) GetAddress("glGetVertexAttribArrayObjectivATI", typeof(GL.Delegates.GetVertexAttribArrayObjectivATI)); - GL.DepthBoundsEXT = (GL.Delegates.DepthBoundsEXT) GetAddress("glDepthBoundsEXT", typeof(GL.Delegates.DepthBoundsEXT)); - GL.BlendEquationSeparateEXT = (GL.Delegates.BlendEquationSeparateEXT) GetAddress("glBlendEquationSeparateEXT", typeof(GL.Delegates.BlendEquationSeparateEXT)); - GL.IsRenderbufferEXT = (GL.Delegates.IsRenderbufferEXT) GetAddress("glIsRenderbufferEXT", typeof(GL.Delegates.IsRenderbufferEXT)); - GL.BindRenderbufferEXT = (GL.Delegates.BindRenderbufferEXT) GetAddress("glBindRenderbufferEXT", typeof(GL.Delegates.BindRenderbufferEXT)); - GL.DeleteRenderbuffersEXT = (GL.Delegates.DeleteRenderbuffersEXT) GetAddress("glDeleteRenderbuffersEXT", typeof(GL.Delegates.DeleteRenderbuffersEXT)); - GL.GenRenderbuffersEXT = (GL.Delegates.GenRenderbuffersEXT) GetAddress("glGenRenderbuffersEXT", typeof(GL.Delegates.GenRenderbuffersEXT)); - GL.RenderbufferStorageEXT = (GL.Delegates.RenderbufferStorageEXT) GetAddress("glRenderbufferStorageEXT", typeof(GL.Delegates.RenderbufferStorageEXT)); - GL.GetRenderbufferParameterivEXT = (GL.Delegates.GetRenderbufferParameterivEXT) GetAddress("glGetRenderbufferParameterivEXT", typeof(GL.Delegates.GetRenderbufferParameterivEXT)); - GL.IsFramebufferEXT = (GL.Delegates.IsFramebufferEXT) GetAddress("glIsFramebufferEXT", typeof(GL.Delegates.IsFramebufferEXT)); - GL.BindFramebufferEXT = (GL.Delegates.BindFramebufferEXT) GetAddress("glBindFramebufferEXT", typeof(GL.Delegates.BindFramebufferEXT)); - GL.DeleteFramebuffersEXT = (GL.Delegates.DeleteFramebuffersEXT) GetAddress("glDeleteFramebuffersEXT", typeof(GL.Delegates.DeleteFramebuffersEXT)); - GL.GenFramebuffersEXT = (GL.Delegates.GenFramebuffersEXT) GetAddress("glGenFramebuffersEXT", typeof(GL.Delegates.GenFramebuffersEXT)); - GL.CheckFramebufferStatusEXT = (GL.Delegates.CheckFramebufferStatusEXT) GetAddress("glCheckFramebufferStatusEXT", typeof(GL.Delegates.CheckFramebufferStatusEXT)); - GL.FramebufferTexture1DEXT = (GL.Delegates.FramebufferTexture1DEXT) GetAddress("glFramebufferTexture1DEXT", typeof(GL.Delegates.FramebufferTexture1DEXT)); - GL.FramebufferTexture2DEXT = (GL.Delegates.FramebufferTexture2DEXT) GetAddress("glFramebufferTexture2DEXT", typeof(GL.Delegates.FramebufferTexture2DEXT)); - GL.FramebufferTexture3DEXT = (GL.Delegates.FramebufferTexture3DEXT) GetAddress("glFramebufferTexture3DEXT", typeof(GL.Delegates.FramebufferTexture3DEXT)); - GL.FramebufferRenderbufferEXT = (GL.Delegates.FramebufferRenderbufferEXT) GetAddress("glFramebufferRenderbufferEXT", typeof(GL.Delegates.FramebufferRenderbufferEXT)); - GL.GetFramebufferAttachmentParameterivEXT = (GL.Delegates.GetFramebufferAttachmentParameterivEXT) GetAddress("glGetFramebufferAttachmentParameterivEXT", typeof(GL.Delegates.GetFramebufferAttachmentParameterivEXT)); - GL.GenerateMipmapEXT = (GL.Delegates.GenerateMipmapEXT) GetAddress("glGenerateMipmapEXT", typeof(GL.Delegates.GenerateMipmapEXT)); - GL.StringMarkerGREMEDY = (GL.Delegates.StringMarkerGREMEDY) GetAddress("glStringMarkerGREMEDY", typeof(GL.Delegates.StringMarkerGREMEDY)); - CoreLoaded = true; - } - #endregion } } + diff --git a/Source/OpenGL/OpenGL/Contexts/Context.cs b/Source/OpenGL/OpenGL/Contexts/Context.cs index 96b6a9d2..f0ae1080 100644 --- a/Source/OpenGL/OpenGL/Contexts/Context.cs +++ b/Source/OpenGL/OpenGL/Contexts/Context.cs @@ -19,8 +19,7 @@ namespace OpenTK.OpenGL public abstract System.Delegate GetAddress(string function_string, Type function_type); public abstract void MakeCurrent(); - public abstract void Load(); - public abstract void LoadExtensions(); + //public abstract void LoadExtensions(); public abstract void Dispose(); diff --git a/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs b/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs index 95ce4862..3177fa48 100644 --- a/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs +++ b/Source/OpenGL/OpenGL/Contexts/WindowsContext.cs @@ -97,8 +97,8 @@ namespace OpenTK.OpenGL.Platform Load(); - if (load_extensions) - LoadExtensions(); + //if (load_extensions) + // LoadExtensions(); } public override void SwapBuffers() diff --git a/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs b/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs index 323f1596..92de4396 100644 --- a/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs +++ b/Source/OpenGL/OpenGL/Contexts/WindowsVistaContext.cs @@ -97,8 +97,8 @@ namespace OpenTK.OpenGL.Platform Load(); - if (load_extensions) - LoadExtensions(); + //if (load_extensions) + // LoadExtensions(); } public override void SwapBuffers() diff --git a/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj b/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj index 4ab4790e..c7233e69 100644 --- a/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj +++ b/Source/OpenGL/OpenGL/OpenTK.OpenGL.csproj @@ -42,13 +42,12 @@ - - - - + + + diff --git a/Source/OpenGL/OpenGL/Properties/AssemblyInfo.cs b/Source/OpenGL/OpenGL/Properties/AssemblyInfo.cs index 3ee35090..39200ae2 100644 --- a/Source/OpenGL/OpenGL/Properties/AssemblyInfo.cs +++ b/Source/OpenGL/OpenGL/Properties/AssemblyInfo.cs @@ -5,12 +5,12 @@ using System.Runtime.InteropServices; // General Information about an assembly is controlled through the following // set of attributes. Change these attribute values to modify the information // associated with an assembly. -[assembly: AssemblyTitle("OpenGL")] -[assembly: AssemblyDescription("")] +[assembly: AssemblyTitle("OpenGL assembly")] +[assembly: AssemblyDescription("Provides bindings to the OpenGL functions.")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("OpenGL")] -[assembly: AssemblyCopyright("Copyright © 2006")] +[assembly: AssemblyCopyright("Copyright © 2006 Stefanos Apostolopoulos")] [assembly: AssemblyTrademark("")] [assembly: AssemblyCulture("")] @@ -31,5 +31,5 @@ using System.Runtime.InteropServices; // // You can specify all the values or you can default the Revision and Build Numbers // by using the '*' as shown below: -[assembly: AssemblyVersion("0.3.1.0")] -[assembly: AssemblyFileVersion("0.3.1.0")] +[assembly: AssemblyVersion("0.3.1.1")] +[assembly: AssemblyFileVersion("0.3.1.1")] diff --git a/Specifications/cs_types.txt b/Specifications/cs_types.txt new file mode 100644 index 00000000..2a452c8b --- /dev/null +++ b/Specifications/cs_types.txt @@ -0,0 +1,29 @@ +# ARB and NV types (these should come before normal types to guard against double translation). +GLsizeiptrARB, IntPtr +GLintptrARB, IntPtr +GLhandleARB, Int32 #UInt32 +GLhalfARB, Int16 #UInt16 +GLhalfNV, Int16 #UInt16 +GLcharARB, Char + +# Normal types. +GLsizeiptr, IntPtr +GLintptr, IntPtr +GLenum, Int32 +GLboolean, Boolean +GLbitfield, Int32 #UInt32 +# GLvoid*, IntPtr +# GLvoid, void +GLchar, Char +GLbyte, SByte +GLshort, Int16 +GLint, Int32 +GLubyte, SByte +GLushort, Int16 #UInt16 +GLuint, Int32 #UInt32 +GLsizei, Int32 +GLfloat, Single +GLclampf, Single +GLdouble, Double +GLclampd, Double +GLstring, String \ No newline at end of file diff --git a/Specifications/gl_types.txt b/Specifications/gl_types.txt new file mode 100644 index 00000000..2df0c3bc --- /dev/null +++ b/Specifications/gl_types.txt @@ -0,0 +1,282 @@ +AccumOp,*,*, GLenum,*,* +AlphaFunction,*,*, GLenum,*,* +AttribMask,*,*, GLbitfield,*,* +BeginMode,*,*, GLenum,*,* +BinormalPointerTypeEXT,*,*, GLenum,*,* +BlendEquationMode,*,*, GLenum,*,* +BlendEquationModeEXT,*,*, GLenum,*,* +BlendFuncSeparateParameterEXT,*,*, GLenum,*,* +BlendingFactorDest,*,*, GLenum,*,* +BlendingFactorSrc,*,*, GLenum,*,* +Boolean,*,*, GLboolean,*,* +BooleanPointer,*,*, GLboolean*,*,* +Char,*,*, GLchar,*,* +CharPointer,*,*, GLchar*,*,* +CheckedFloat32,*,*, GLfloat,*,* +CheckedInt32,*,*, GLint,*,* +ClampColorTargetARB,*,*, GLenum,*,* +ClampColorModeARB,*,*, GLenum,*,* +ClampedColorF,*,*, GLclampf,*,* +ClampedFloat32,*,*, GLclampf,*,* +ClampedFloat64,*,*, GLclampd,*,* +ClampedStencilValue,*,*, GLint,*,* +ClearBufferMask,*,*, GLbitfield,*,* +ClientAttribMask,*,*, GLbitfield,*,* +ClipPlaneName,*,*, GLenum,*,* +ColorB,*,*, GLbyte,*,* +ColorD,*,*, GLdouble,*,* +ColorF,*,*, GLfloat,*,* +ColorI,*,*, GLint,*,* +ColorIndexValueD,*,*, GLdouble,*,* +ColorIndexValueF,*,*, GLfloat,*,* +ColorIndexValueI,*,*, GLint,*,* +ColorIndexValueS,*,*, GLshort,*,* +ColorIndexValueUB,*,*, GLubyte,*,* +ColorMaterialParameter,*,*, GLenum,*,* +ColorPointerType,*,*, GLenum,*,* +ColorS,*,*, GLshort,*,* +ColorTableParameterPName,*,*, GLenum,*,* +ColorTableParameterPNameSGI,*,*, GLenum,*,* +ColorTableTarget,*,*, GLenum,*,* +ColorTableTargetSGI,*,*, GLenum,*,* +ColorUB,*,*, GLubyte,*,* +ColorUI,*,*, GLuint,*,* +ColorUS,*,*, GLushort,*,* +CombinerBiasNV,*,*, GLenum,*,* +CombinerComponentUsageNV,*,*, GLenum,*,* +CombinerMappingNV,*,*, GLenum,*,* +CombinerParameterNV,*,*, GLenum,*,* +CombinerPortionNV,*,*, GLenum,*,* +CombinerRegisterNV,*,*, GLenum,*,* +CombinerScaleNV,*,*, GLenum,*,* +CombinerStageNV,*,*, GLenum,*,* +CombinerVariableNV,*,*, GLenum,*,* +CompressedTextureARB,*,*, GLvoid,*,* +ControlPointNV,*,*, GLvoid,*,* +ControlPointTypeNV,*,*, GLenum,*,* +ConvolutionParameter,*,*, GLenum,*,* +ConvolutionParameterEXT,*,*, GLenum,*,* +ConvolutionTarget,*,*, GLenum,*,* +ConvolutionTargetEXT,*,*, GLenum,*,* +CoordD,*,*, GLdouble,*,* +CoordF,*,*, GLfloat,*,* +CoordI,*,*, GLint,*,* +CoordS,*,*, GLshort,*,* +CullFaceMode,*,*, GLenum,*,* +CullParameterEXT,*,*, GLenum,*,* +DepthFunction,*,*, GLenum,*,* +DrawBufferMode,*,*, GLenum,*,* +DrawElementsType,*,*, GLenum,*,* +ElementPointerTypeATI,*,*, GLenum,*,* +EnableCap,*,*, GLenum,*,* +ErrorCode,*,*, GLenum,*,* +EvalMapsModeNV,*,*, GLenum,*,* +EvalTargetNV,*,*, GLenum,*,* +FeedbackElement,*,*, GLfloat,*,* +FeedbackType,*,*, GLenum,*,* +FenceNV,*,*, GLuint,*,* +FenceConditionNV,*,*, GLenum,*,* +FenceParameterNameNV,*,*, GLenum,*,* +FfdMaskSGIX,*,*, GLbitfield,*,* +FfdTargetSGIX,*,*, GLenum,*,* +Float32,*,*, GLfloat,*,* +Float32Pointer,*,*, GLfloat*,*,* +Float64,*,*, GLdouble,*,* +Float64Pointer,*,*, GLdouble*,*,* +FogParameter,*,*, GLenum,*,* +FogPointerTypeEXT,*,*, GLenum,*,* +FogPointerTypeIBM,*,*, GLenum,*,* +FragmentLightModelParameterSGIX,*,*,GLenum,*,* +FragmentLightNameSGIX,*,*, GLenum,*,* +FragmentLightParameterSGIX,*,*, GLenum,*,* +FrontFaceDirection,*,*, GLenum,*,* +FunctionPointer,*,*, _GLfuncptr,*,* +GetColorTableParameterPName,*,*, GLenum,*,* +GetColorTableParameterPNameSGI,*,*, GLenum,*,* +GetConvolutionParameterPName,*,*, GLenum,*,* +GetHistogramParameterPName,*,*, GLenum,*,* +GetHistogramParameterPNameEXT,*,*, GLenum,*,* +GetMapQuery,*,*, GLenum,*,* +GetMinmaxParameterPName,*,*, GLenum,*,* +GetMinmaxParameterPNameEXT,*,*, GLenum,*,* +GetPName,*,*, GLenum,*,* +GetPointervPName,*,*, GLenum,*,* +GetTextureParameter,*,*, GLenum,*,* +HintMode,*,*, GLenum,*,* +HintTarget,*,*, GLenum,*,* +HintTargetPGI,*,*, GLenum,*,* +HistogramTarget,*,*, GLenum,*,* +HistogramTargetEXT,*,*, GLenum,*,* +IglooFunctionSelectSGIX,*,*, GLenum,*,* +IglooParameterSGIX,*,*, GLvoid,*,* +ImageTransformPNameHP,*,*, GLenum,*,* +ImageTransformTargetHP,*,*, GLenum,*,* +IndexFunctionEXT,*,*, GLenum,*,* +IndexMaterialParameterEXT,*,*, GLenum,*,* +IndexPointerType,*,*, GLenum,*,* +Int16,*,*, GLshort,*,* +Int32,*,*, GLint,*,* +Int8,*,*, GLbyte,*,* +InterleavedArrayFormat,*,*, GLenum,*,* +LightEnvParameterSGIX,*,*, GLenum,*,* +LightModelParameter,*,*, GLenum,*,* +LightName,*,*, GLenum,*,* +LightParameter,*,*, GLenum,*,* +LightTextureModeEXT,*,*, GLenum,*,* +LightTexturePNameEXT,*,*, GLenum,*,* +LineStipple,*,*, GLushort,*,* +List,*,*, GLuint,*,* +ListMode,*,*, GLenum,*,* +ListNameType,*,*, GLenum,*,* +ListParameterName,*,*, GLenum,*,* +LogicOp,*,*, GLenum,*,* +MapAttribParameterNV,*,*, GLenum,*,* +MapParameterNV,*,*, GLenum,*,* +MapTarget,*,*, GLenum,*,* +MapTargetNV,*,*, GLenum,*,* +MapTypeNV,*,*, GLenum,*,* +MaskedColorIndexValueF,*,*, GLfloat,*,* +MaskedColorIndexValueI,*,*, GLuint,*,* +MaskedStencilValue,*,*, GLuint,*,* +MaterialFace,*,*, GLenum,*,* +MaterialParameter,*,*, GLenum,*,* +MatrixIndexPointerTypeARB,*,*, GLenum,*,* +MatrixMode,*,*, GLenum,*,* +MatrixTransformNV,*,*, GLenum,*,* +MeshMode1,*,*, GLenum,*,* +MeshMode2,*,*, GLenum,*,* +MinmaxTarget,*,*, GLenum,*,* +MinmaxTargetEXT,*,*, GLenum,*,* +NormalPointerType,*,*, GLenum,*,* +NurbsCallback,*,*, GLenum,*,* +NurbsObj,*,*, GLUnurbs*,*,* +NurbsProperty,*,*, GLenum,*,* +NurbsTrim,*,*, GLenum,*,* +OcclusionQueryParameterNameNV,*,*, GLenum,*,* +PixelCopyType,*,*, GLenum,*,* +PixelFormat,*,*, GLenum,*,* +PixelInternalFormat,*,*, GLenum,*,* +PixelMap,*,*, GLenum,*,* +PixelStoreParameter,*,*, GLenum,*,* +PixelTexGenModeSGIX,*,*, GLenum,*,* +PixelTexGenParameterNameSGIS,*,*, GLenum,*,* +PixelTransferParameter,*,*, GLenum,*,* +PixelTransformPNameEXT,*,*, GLenum,*,* +PixelTransformTargetEXT,*,*, GLenum,*,* +PixelType,*,*, GLenum,*,* +PointParameterNameARB,*,*, GLenum,*,* +PolygonMode,*,*, GLenum,*,* +ProgramNV,*,*, GLuint,*,* +ProgramCharacterNV,*,*, GLubyte,*,* +ProgramParameterNV,*,*, GLenum,*,* +QuadricCallback,*,*, GLenum,*,* +QuadricDrawStyle,*,*, GLenum,*,* +QuadricNormal,*,*, GLenum,*,* +QuadricObj,*,*, GLUquadric*,*,* +QuadricOrientation,*,*, GLenum,*,* +ReadBufferMode,*,*, GLenum,*,* +RenderingMode,*,*, GLenum,*,* +ReplacementCodeSUN,*,*, GLuint,*,* +ReplacementCodeTypeSUN,*,*, GLenum,*,* +SamplePassARB,*,*, GLenum,*,* +SamplePatternEXT,*,*, GLenum,*,* +SamplePatternSGIS,*,*, GLenum,*,* +SecondaryColorPointerTypeIBM,*,*, GLenum,*,* +SelectName,*,*, GLuint,*,* +SeparableTarget,*,*, GLenum,*,* +SeparableTargetEXT,*,*, GLenum,*,* +ShadingModel,*,*, GLenum,*,* +SizeI,*,*, GLsizei,*,* +SpriteParameterNameSGIX,*,*, GLenum,*,* +StencilFunction,*,*, GLenum,*,* +StencilFaceDirection,*,*, GLenum,*,* +StencilOp,*,*, GLenum,*,* +StencilValue,*,*, GLint,*,* +String,*,*, GLstring,*,* +StringName,*,*, GLenum,*,* +TangentPointerTypeEXT,*,*, GLenum,*,* +TessCallback,*,*, GLenum,*,* +TessContour,*,*, GLenum,*,* +TessProperty,*,*, GLenum,*,* +TesselatorObj,*,*, GLUtesselator*,*,* +TexCoordPointerType,*,*, GLenum,*,* +Texture,*,*, GLuint,*,* +TextureComponentCount,*,*, GLint,*,* +TextureCoordName,*,*, GLenum,*,* +TextureEnvParameter,*,*, GLenum,*,* +TextureEnvTarget,*,*, GLenum,*,* +TextureFilterSGIS,*,*, GLenum,*,* +TextureGenParameter,*,*, GLenum,*,* +TextureNormalModeEXT,*,*, GLenum,*,* +TextureParameterName,*,*, GLenum,*,* +TextureTarget,*,*, GLenum,*,* +TextureUnit,*,*, GLenum,*,* +UInt16,*,*, GLushort,*,* +UInt32,*,*, GLuint,*,* +UInt8,*,*, GLubyte,*,* +VertexAttribEnumNV,*,*, GLenum,*,* +VertexAttribPointerTypeNV,*,*, GLenum,*,* +VertexPointerType,*,*, GLenum,*,* +VertexWeightPointerTypeEXT,*,*, GLenum,*,* +Void,*,*, GLvoid,*,* +VoidPointer,*,*, GLvoid*,*,* +ConstVoidPointer,*,*, GLvoid* const,*,* +WeightPointerTypeARB,*,*, GLenum,*,* +WinCoord,*,*, GLint,*,* +void,*,*, *,*,* +ArrayObjectPNameATI,*,*, GLenum,*,* +ArrayObjectUsageATI,*,*, GLenum,*,*, +ConstFloat32,*,*, GLfloat,*,* +ConstInt32,*,*, GLint,*,* +ConstUInt32,*,*, GLuint,*,* +ConstVoid,*,*, GLvoid,*,* +DataTypeEXT,*,*, GLenum,*,* +FragmentOpATI,*,*, GLenum,*,* +GetTexBumpParameterATI,*,*, GLenum,*,* +GetVariantValueEXT,*,*, GLenum,*,* +ParameterRangeEXT,*,*, GLenum,*,* +PreserveModeATI,*,*, GLenum,*,* +ProgramFormatARB,*,*, GLenum,*,* +ProgramTargetARB,*,*, GLenum,*,* +ProgramPropertyARB,*,*, GLenum,*,* +ProgramStringPropertyARB,*,*, GLenum,*,* +ScalarType,*,*, GLenum,*,* +SwizzleOpATI,*,*, GLenum,*,* +TexBumpParameterATI,*,*, GLenum,*,* +VariantCapEXT,*,*, GLenum,*,* +VertexAttribPointerPropertyARB,*,*, GLenum,*,* +VertexAttribPointerTypeARB,*,*, GLenum,*,* +VertexAttribPropertyARB,*,*, GLenum,*,* +VertexShaderCoordOutEXT,*,*, GLenum,*,* +VertexShaderOpEXT,*,*, GLenum,*,* +VertexShaderParameterEXT,*,*, GLenum,*,* +VertexShaderStorageTypeEXT,*,*, GLenum,*,* +VertexShaderTextureUnitParameter,*,*, GLenum,*,* +VertexShaderWriteMaskEXT,*,*, GLenum,*,* +VertexStreamATI,*,*, GLenum,*,* +PNTrianglesPNameATI,*,*, GLenum,*,* +# ARB_vertex_buffer_object types and core equivalents for new types +VertexBufferOffset,*,*, GLintptr,*,* +VertexBufferSize,*,*, GLsizeiptr,*,* +VertexBufferAccessARB,*,*, GLenum,*,* +VertexBufferOffsetARB,*,*, GLintptrARB,*,* +VertexBufferPNameARB,*,*, GLenum,*,* +VertexBufferPointerNameARB,*,*, GLenum,*,* +VertexBufferSizeARB,*,*, GLsizeiptrARB,*,* +VertexBufferTargetARB,*,*, GLenum,*,* +VertexBufferUsageARB,*,*, GLenum,*,* +# APPLE_fence +ObjectTypeAPPLE,*,*, GLenum,*,* +# APPLE_vertex_array_range +VertexArrayPNameAPPLE,*,*, GLenum,*,* +# ATI_draw_buffers +DrawBufferModeATI,*,*, GLenum,*,* +# NV_half +Half16NV,*,*, GLhalfNV,*,* +# NV_pixel_data_range +PixelDataRangeTargetNV,*,*, GLenum,*,* +# Generic types for as-yet-unspecified enums +GLenum,*,*, GLenum,*,* +handleARB,*,*, GLhandleARB,*,* +charARB,*,*, GLcharARB,*,* +charPointerARB,*,*, GLcharARB*,*,* diff --git a/Todo.txt b/Todo.txt new file mode 100644 index 00000000..8f05ca6b --- /dev/null +++ b/Todo.txt @@ -0,0 +1,13 @@ +Todo: ++ Add more examples (e.g. the GLSL example I wrote, some of kanato's examples etc). ++ Change the hierarchy of the WindowsContext and WindowsVistaContext classes. The should have a common ancestor who manages the windows creation (it should be the same for both). ++ Add more constructors to the WindowsContext classes. This probably needs updating of the WinAPI assembly. ++ Add X11Context constructors. ++ Find out what is needed for the MacOS platform (how to do function loading and window management without X11). ++ Add full bindings to Glu, Wgl, Glx and Agl. ++ Add the Math module. ++ Research and add the Input module. ++ Review and add the timer module. ++ Review and add the OpenAL module. ++ Add projects for MonoDevelop. ++ See if using Nant for building is a good idea. \ No newline at end of file diff --git a/changelog.txt b/changelog.txt new file mode 100644 index 00000000..0686e410 --- /dev/null +++ b/changelog.txt @@ -0,0 +1,5 @@ +OpenTK 0.3.0 -> 0.3.1 ++ Updated the binding generator to version 0.7.4, based on the work done for Tao. ++ Updated the Context load functions. Now Context loads all functions are extensions, and the derived classes override this behavior as needed. ++ Changed the uint array used in the DisplayLists example to an int array. ++ Added the changelog! :) \ No newline at end of file