diff --git a/Build/Build.exe b/Build/Build.exe
new file mode 100644
index 00000000..d2ec398a
Binary files /dev/null and b/Build/Build.exe differ
diff --git a/Build/Instructions.txt b/Build/Instructions.txt
new file mode 100644
index 00000000..ab2551cb
--- /dev/null
+++ b/Build/Instructions.txt
@@ -0,0 +1,22 @@
+How to build OpenTK:
+
+1) Install nant from (http://nant.sourceforge.net/)
+2) Navigate to the Build folder and execute Build.exe:
+ 2a) Under Linux/Mac OS X, type 'mono Build.exe mono' or 'mono Build.exe mono debug' for the release/debug versions of the library.
+ 2b) Under Windows type 'build net' (or 'build net debug').
+3) The binaries (library, examples) are placed in the Binaries/Release folder.
+
+
+There are other parameters you can pass to Build.exe. A brief list:
+
+net - build using the .Net framework.
+mono - build using Mono.
+debug - build the debug version (e.g. 'build net debug').
+
+clean - delete intermediate object files and projects (reclaim some space, the binaries are not touched).
+distclean - delete intermediate and final object files (reclaim all space used during compilation).
+svnclean - delete '.svn' folders. Useful if you checked out from svn, useless if you downloaded a file release.
+
+vs2005 - create project files for Visual Studio 2005.
+monodev - create project files for MonoDevelop.
+sharpdev - as above, for SharpDevelop.
\ No newline at end of file
diff --git a/Build/Prebuild.exe b/Build/Prebuild.exe
new file mode 100644
index 00000000..6cbb6031
Binary files /dev/null and b/Build/Prebuild.exe differ
diff --git a/Build/Prebuild.xml b/Build/Prebuild.xml
new file mode 100644
index 00000000..2c5f1a9a
--- /dev/null
+++ b/Build/Prebuild.xml
@@ -0,0 +1,133 @@
+
+
+
+
+
+
+
+ DEBUG;TRACE;
+ false
+
+ true
+
+
+
+
+
+ TRACE;
+ true
+
+ false
+
+
+
+
+ ../Documentation/Todo.txt
+ ../Documentation/Release.txt
+ ../Documentation/Changelog.txt
+ ../Documentation/License.txt
+ ./Instructions.txt
+ Prebuild.xml
+
+
+
+
+
+
+ ../../Binaries/Debug/Exe
+
+
+
+
+
+ ../../Binaries/Release/Exe
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ../../Binaries/Debug/Exe
+
+
+
+
+
+ ../../Binaries/Release/Exe
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ../../Binaries/Debug/Libraries
+
+
+
+
+
+
+ ../../Binaries/Release/Libraries
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ ../../Binaries/Debug/Examples
+
+
+
+
+
+ ../../Binaries/Release/Examples
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Documentation/Changelog.txt b/Documentation/Changelog.txt
new file mode 100644
index 00000000..58608b2e
--- /dev/null
+++ b/Documentation/Changelog.txt
@@ -0,0 +1,125 @@
+OpenTK 0.3.7 -> 0.3.8
+
++ OpenTK.Build
+ + Improved console output.
+ + Added support for debug target.
+ + Better handling of wrong targets.
+
+- Removed OpenTK.Framework
+
++ OpenTK.GameWindow (new)
+ + Creates render window through system calls.
+ + Interface suited for games.
+ + Resize event support.
+ + Error handling.
+ - No keyboard input yet.
+
++ OpenTK.Platform
+ + Numerous additions, bugfixes in OpenTK.Platform.Windows, OpenTK.Platform.X11.
+ + Changed the class and namespace names.
+ + Added IGLContext, IGLControl, IGameWindow, INativeWindow, IResizable interfaces.
+ + Added class GLContext : IGLContext. Platform specific implementations in WinGLContext and X11GLContext.
+ + Added class GLControl : IGLControl. Platform specific implementations in WinGLControl and X11GLControl.
+ + Added classes WinGLNative, X11GLNative : INativeWindow.
+ + Added visual studio design support for GLControl.
+
+
+OpenTK 0.3.6 -> 0.3.7
+
++ OpenTK.Build
+ + Added new, (more) cross-platform build system, written on C#. This takes the place of the scripts and batch files used to compile OpenTK up till now.
+ + Removed all build scripts.
+
++ OpenTK.Framework
+ + Now builds under Linux.
+
++ OpenTK.OpenGL.Bind
+ + Synced with Tao.GlBindGen beta 2.1.3.6
+ + Enabled ref/out overloads.
+ + Added GLenum, which contains all opengl enumerants (useful for 'polymorphic' opengl functions).
+
++ OpenTK.OpenGL
+ + ref/out overloads and GLenum (see above).
+ + Fixed extension loading under Mac OS X.
+ + Improved compatibility with 64bit platforms.
+
+
+OpenTK 0.3.5 -> 0.3.6
+
++ OpenTK.OpenGL.Bind
+ + Synced with Tao.GlBindGen codebase.
+ + Uses CodeDOM internally for code generation.
+ + Updated to latest specs (which include shader model 4).
+
++ OpenTK.OpenGL (Low level)
+ + All OpenGL extensions are now generated (up to shader model 4).
+ + Decorated imports and delegates with the SuppressUnmanagedCodeSecurity attribute. Major speed improvements in CPU-bound applications.
+ + More robust and faster static initialisation for the GL class.
+ + Updated GLHelper.cs, with methods to obtain or reload OpenGL entry points, as well as query for supported extensions.
+ + Got rid of "object" overloads for typed arrays.
+ + All known bugs are now fixed.
+
++ OpenTK.OpenGL (High level)
+ + Added the DisplayList class.
+
++ OpenTK.Examples.OpenGL
+ + Added the Basic.DisplayLists example.
+
+
+
+OpenTK 0.3.4 -> 0.3.5
++ Thanks to Erik Ylvisaker's hard work, OpenTK now works under both Windows and X11.
+ + The GLContext class now contains all needed code for mode switching.
+ + The Framework class structure has been updated. Less code is duplicated between GLContext and Framework now.
+ + Three new examples have been added: OpenGL.Basic.Lesson01 (equivalent to OpenGL.GLSL.Lesson01 without the shaders), OpenGL.Basic.QueryDisplayModes which shows a list of all available display modes, and OpenGL.Basic.NoFramework which shows how to use OpenGL Contexts directly (without relying on the framework).
+ + New bindings for X and the XF86 extension.
++ New build system based on Prebuild and NAnt (similar to the one used in Tao or Mono.XNA).
++ Updates to the OpenTK.OpenGL.DisplayMode and ColorDepth classes.
++ More XML documentation blocks added to functions and classes.
++ Major update to OpenTK.OpenGL.Bind (see that changelog for more info).
+ + Revamped GL class (it is self contained now).
+ + Revamped GLContext class (it is no longer bound to the GL class initialisation).
+ + Cleaner code, new functions, comments and many new wrappers.
+ + Updated the spec files for opengl 2.1.
+ + Added the new 64 bit types to the typemaps (gl.tm and csharp.tm)
++ The bugs in the specs are still there:
+ + SGIX_icc_texture is still commented out, while enums use it.
+ + LightProperty is still used by constants (the correct enum is LightParameter).
+ + I think I should contact someone at the Khronos group about these. For the time being I worked around them, by adding a special case for LightProperty in the translator, and adding the SGIX enum to the missing parameters.
+ + See also: http://www.haskell.org/HOpenGL/spec_bugs.html (lots of useful information on that site).
++ Directory structure updates.
+ + Now every project has its own documentation.
+ + The spec files for OpenGL now reside in the Source/OpenTK/OpenGL directory.
++ Minor updates to the wgl bindings (int -> IntPtr).
++ Tested the binding generator with the glx specs (the reader and the enum writer work ok, the trnaslator and the other writers will need updating).
++ Renamed the GLForm to Framework.
+ + The Framework now resides in its own project directory.
+
+
+OpenTK 0.3.3 -> 0.3.4
++ Corrected the crash error in Release mode (it was caused by trying to Marshal the System.Windows.Forms.Message struct to PeekMessage - adding my own Message struct corrected the issue).
++ Corrected the call to glShaderSource GLSL.Lesson01. Now the correct number is passed to the count parameter, while the null parameter was changed to IntPtr.Zero (Mono now no longers fails in this call).
++ Updated the GLSL.Lesson01 example to use GetShaderInfoLog on compilation failure.
++ OpenTK.OpenGL.Bind 0.7.5.1 -> 0.7.5.2 (see Bind changelog for more information)
++ Full Mono support under windows.
+
+
+OpenTK 0.3.2 -> 0.3.3
++ OpenTK.OpenGL.Bind 0.7.5 -> 0.7.5.1 (see Bind changelog for more information)
++ Added the GLForm class which sets the base for cross-platform screen, context and keyboard handling.
++ Can now change between fullscreen and windowed modes.
++ Temporarily removed all examples except for GLSL.Lesson01, which has been updated to use the new GLForm class.
+
+
+OpenTK 0.3.1 -> 0.3.2
++ OpenTK.OpenGL.Glu: Eliminated the temporary IntPtr variable in the GetString and ErrorString functions.
++ Specifications.cs_types.txt: Changed types in order to be CLS compliant.
++ OpenTK.OpenGL.Bind 0.7.4 -> 0.7.5
++ Added the GLSL.Lesson01 example.
+
+
+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
diff --git a/Documentation/License.txt b/Documentation/License.txt
new file mode 100644
index 00000000..8c15766e
--- /dev/null
+++ b/Documentation/License.txt
@@ -0,0 +1,9 @@
+The MIT License
+
+Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/Documentation/Release.txt b/Documentation/Release.txt
new file mode 100644
index 00000000..6cf1abb4
--- /dev/null
+++ b/Documentation/Release.txt
@@ -0,0 +1,24 @@
+================================================================================
+
+OpenTK 0.3.8 WIP alpha Release notes
+
+IMPORTANT: This release is intended for testing and experimentation only. Use at your own risk!
+
+--------------------------------------------------------------------------------
+
+Highlights:
+
+ * Improved interface for GLContext, GLControl. Unfortunately, projects using 0.3.7 (or previous version of OpenTK) will not compile without changes.
+ * GLControls can be added in the VS designer.
+ * GameWindow class, a simple, no-nonsense windowing toolkit for games (incomplete).
+ * Numerous bugfixes and additions in OpenTK.Platform.Windows and OpenTK.Platform.X11
+
+--------------------------------------------------------------------------------
+
+For support, bug reports, feature requests and flames, visit the OpenTK site: http://opentk.sourceforge.net/
+
+The latest version is always available at http://sourceforge.net/projects/opentk
+
+Living on the edge? 'svn co https://opentk.svn.sourceforge.net/svnroot/opentk/trunk opentk'
+
+================================================================================
diff --git a/Documentation/Todo.txt b/Documentation/Todo.txt
new file mode 100644
index 00000000..5cc99f69
--- /dev/null
+++ b/Documentation/Todo.txt
@@ -0,0 +1,46 @@
+Generic Todos:
++ Correctly implement disposable pattern in all relevant classes (WIP as of 0.3.8).
++ Investigate startup lag.
+
+
+OpenTK.OpenGL todos:
+* Change the GCHandle method of pinning to 'fixed'. The behaviour is different: fixed guarantees pinning of the whole object.
+* Different classes for each extension category (ARB.Foo, instead of FooARB).
++ Inline XML documentation.
++ Add complete Wgl, Glx, Agl and Glu bindings.
++ Get rid of the "object" overloads in favour of generics.
+
+
+OpenTK.Platform:
+* GLContext class:
+ + Add more constructors.
+ + Add native support for the MacOS X platform (now goes through X).
+* GLControl class:
+ + Improve the interface. Add more constructors.
+* GameWindow class:
+ + Add input support.
+
+
+OpenTK.Input todos:
+* Make Key class non-static. Static means all GameWindows share the same input!
+* Complete the Key class.
+* Implement mouse input.
++ Implement other input devices.
+
+
+OpenTK.Timing todos:
++ Start implementing the Timer module.
+
+
+Examples:
++ Add comments were needed.
++ Add more Tutorials and WinForms examples.
+
+
+OpenTK.Math todos:
++ Start implementing the Math module.
+
+
+OpenTK.OpenAL todos:
++ Start researching the OpenAL module.
++ Take a look at the OpenALDotNet wrapper.
\ No newline at end of file
diff --git a/Source/Bind/Documentation/changelog.txt b/Source/Bind/Documentation/changelog.txt
new file mode 100644
index 00000000..9d80336e
--- /dev/null
+++ b/Source/Bind/Documentation/changelog.txt
@@ -0,0 +1,53 @@
+OpenTK.OpenGL.Bind 0.9.3
+
+0.7.7 -> 0.9.3
++ Synced code with Tao.GlBindGen
++ Re-enabled extensions
++ Updated specs
++ Now uses CodeDOM for code generation
++ Imports and delegates are decorated with the SupressUnmanagedCodeSecurity attribute for call overhead reduction
++ Several bugs have been fixed
+
+
+0.7.6 -> 0.7.7
++ Several bugfixes regarding bugs from the latest (0.7.6) code synchronisation between Tao.GlBindGen and OpenTK.OpenGL.Bind
++ Split the Enums, Core OpenGL and Extension OpenGL functions into different files. This speeds up the Visual Studio IDE a lot.
++ The Extension functions have been removed from the OpenTK.OpenGL.GL class. They will be added back on a later version, probably as OpenTK.OpenGL.GL.Extensions. No need to clatter up the code API with thousands of mostly useless extensions.
+ + Applications load much faster now.
++ Killed the Context class generation. It added a lot of complexity for little gain (what, cleaner OOP internal structure? Oh, please!) This move frees up the Context classes which can now be updated without dragging around several thousand function initialisations.
+ + OpenTK.OpenGL.GL is self-contained now. Delegates are initialised statically, calling the platform specific *GetAddress functions where needed (they are contained in the GL class, too - but not auto-generated).
++ Revamped the WriteSpecs class. Its methods are now completely modular (enum, core and extension writers have been split).
+ + This still needs some refactoring to reduce code copy-paste and allow for future wgl / glx binding generation.
+
+
+0.7.5.2 -> 0.7.6
++ Added NeedWrapper and WrapperType properties to each parameter (needed for more fine grained control on wrapper generation).
++ Added Function, Parameter, ParameterCollection (deep) copy constructors. This allows simpler code in many places (since we can now create new Functions without fear of affecting the old ones, for example).
++ Merged the ParameterCollection.cs with Parameter.cs
++ Added the FunctionBody class which contains the contents of a function as a list of strings. It is mainly intended for wrappers (allows cleaner code, too).
++ The wrapper generation now happens in TranlateSpecs.cs instead of WriteSpecs.cs. (Translations and generations should only happen during the translation phase, not while reading or writing. Allow for cleaner code).
++ Revamped the wrapper generator code. Now it handles correctly the cases where a function has more than one parameter that needs wrapping (i.e. it generates all permutations correctly). This is handled by recursively generating the needed permutations (it was a hell to implement).
++ Added some comments (many more to follow).
++ Removed some commented-out regions and some obsolete functions.
+
+
+0.7.5.1 -> 0.7.5.2
++ Added translation for out char[] parameters (they are treated as StringBuilders, as specified in MSDN).
++ Added System.Text using directive.
+
+
+0.7.5 -> 0.7.5.1
++ Added license information to the generated bindings.
++ Changed the name of the main Context class to GLContext (Context is used in the BCL).
+
+
+0.7.4 -> 0.7.5
++ Added wrappers for all functions that accept arrays. Permitted parameters for these are: an array of the original type (e.g. float[]), an IntPtr (if you manage memory yourself), or any blittable type (e.g. float[,,]). No type checking is done in the last case, so be careful!
++ Updated the wrappers for all functions that accept or return void pointers. Permitted parameters for these are: an IntPtr or any blittable type (type checking is turned off, so be extra careful!)
++ Aliased the GLbool type to int. It is hacky, but the examples bundled with Tao rely on this...
++ Added a wrapper for glLineStipple. Now you can pass an int to it, but only the last 16 bits will be used for the stipple (as per the function specification). This was the only way to avoid aliasing the parameter to ushort (non-CLS compatible) or having the user write unchecked((short)0x....) every time he used the function.
++ Added the WrapperType enum. Every function has a Property that indicates the wrapper it will need. This cleans up the WriteWrappers function somewhat.
++ Added the PreviousType property to the Function class. This is used when generating wrappers for functions with type-checked arrays (e.g. float[] arrays etc).
++ Corrected some type aliases in cs_types.txt
++ Added the missing wrappers for glReadPixels! (this falls in the out void array).
++ A missing enum now defaults to Enum.[Function category] (a new property was added to the Function class and the SpecReader.ReadFunctions function was modified). I should test this to see if it works ok.
\ No newline at end of file
diff --git a/Source/Bind/Documentation/todo.txt b/Source/Bind/Documentation/todo.txt
new file mode 100644
index 00000000..2ea24472
--- /dev/null
+++ b/Source/Bind/Documentation/todo.txt
@@ -0,0 +1,11 @@
+OpenTK.OpenGL.Bind 0.9.4 todos:
+
+Major:
++ Change the output of extensions from GL.BlahARB to GL.ARB.Blah
++ Use generics instead of object overloads.
++ Add ref overloads for arrays
+
+Minor:
++ Clean up the reader.
++ Add more settings to Settings.cs (the name of the files to read).
++ Comment the code.
diff --git a/Source/Bind/Main.cs b/Source/Bind/Main.cs
new file mode 100644
index 00000000..9b6ebb3b
--- /dev/null
+++ b/Source/Bind/Main.cs
@@ -0,0 +1,128 @@
+#region License
+/*
+MIT License
+Copyright ©2003-2006 Tao Framework Team
+http://www.taoframework.com
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#endregion License
+
+using System;
+using System.Text;
+using System.IO;
+using System.Security;
+using System.Security.Permissions;
+using System.Threading;
+using System.Collections.Generic;
+using System.CodeDom;
+
+namespace OpenTK.OpenGL.Bind
+{
+ static class MainClass
+ {
+ static void Main(string[] arguments)
+ {
+ Console.WriteLine("OpenGL binding generator {0} for OpenTK.",
+ System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString());
+ Console.WriteLine("For comments, bugs and suggestions visit http://opentk.sourceforge.net");
+ //Console.WriteLine(" - the OpenTK team ;-)");
+ Console.WriteLine();
+
+ #region Handle Arguments
+
+ try
+ {
+ foreach (string a in arguments)
+ {
+ if (a.StartsWith("--") || a.StartsWith("-") || a.StartsWith("/"))
+ {
+ string[] b = a.Split(new char[] { '-', '/', ':', '=' }, StringSplitOptions.RemoveEmptyEntries);
+ switch (b[0])
+ {
+ case "?":
+ case "help":
+ Console.WriteLine("Help not implemented yet.");
+ return;
+ case "in":
+ case "input":
+ Settings.InputPath = b[1];
+ break;
+ case "out":
+ case "Properties.Bind.Default.OutputPath":
+ Settings.OutputPath = b[1];
+ break;
+ case "class":
+ Settings.GLClass = b[1];
+ break;
+ default:
+ throw new ArgumentException("Argument " + a + " not recognized. Use the '/?' switch for help.");
+ }
+ }
+ }
+ }
+ catch (NullReferenceException e)
+ {
+ Console.WriteLine("Argument error ({0}). Please use the '/?' switch for help.", e.ToString());
+ return;
+ }
+ catch (ArgumentException e)
+ {
+ Console.WriteLine("Argument error ({0}). Please use the '/?' switch for help.", e.ToString());
+ return;
+ }
+
+ #endregion
+
+ try
+ {
+ long ticks = System.DateTime.Now.Ticks;
+
+ List functions;
+ List delegates;
+ CodeTypeDeclarationCollection enums;
+ CodeTypeDeclarationCollection enums2;
+
+ delegates = SpecReader.ReadFunctionSpecs("gl.spec");
+ SpecReader.ReadEnumSpecs("enum.spec", out enums);
+ SpecReader.ReadEnumSpecs("enumext.spec", out enums2);
+ enums = SpecTranslator.Merge(enums, enums2);
+ enums = SpecTranslator.TranslateEnums(enums);
+
+ functions = SpecTranslator.TranslateDelegates(delegates, enums);
+
+ // Generate the code
+ SpecWriter.Generate(delegates, functions, enums);
+
+ ticks = System.DateTime.Now.Ticks - ticks;
+
+ Console.WriteLine("Bindings generated in {0} seconds.", ticks / (double)10000000.0);
+ Console.WriteLine();
+ Console.WriteLine("Press enter to continue...");
+ Console.ReadLine();
+ }
+ 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.");
+ }
+ }
+ }
+}
diff --git a/Source/Bind/Properties/AssemblyInfo.cs b/Source/Bind/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..6c4765cd
--- /dev/null
+++ b/Source/Bind/Properties/AssemblyInfo.cs
@@ -0,0 +1,33 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+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 binding generator")]
+[assembly: AssemblyDescription("Generates OpenGL bindings for C# from the C OpenGL headers")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("OpenTK.OpenGL.Bind")]
+[assembly: AssemblyCopyright("Copyright © 2006-2007 Stefanos Apostolopoulos")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("0d681958-ca78-4a67-b71c-ff8755488e23")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+[assembly: AssemblyVersion("0.9.1.0")]
+[assembly: AssemblyFileVersion("0.9.1.0")]
diff --git a/Source/Bind/Properties/Bind.settings b/Source/Bind/Properties/Bind.settings
new file mode 100644
index 00000000..7dff31cf
--- /dev/null
+++ b/Source/Bind/Properties/Bind.settings
@@ -0,0 +1,30 @@
+
+
+
+
+
+ GL
+
+
+ OpenTK.OpenGL
+
+
+ ..\..\Source\OpenGL\OpenGL\Bindings
+
+
+ ..\..\Specifications
+
+
+ Platform
+
+
+ Imports
+
+
+ Enums
+
+
+ Context
+
+
+
\ No newline at end of file
diff --git a/Source/Bind/Properties/app.config b/Source/Bind/Properties/app.config
new file mode 100644
index 00000000..2ecf0fd1
--- /dev/null
+++ b/Source/Bind/Properties/app.config
@@ -0,0 +1,96 @@
+
+
+
+
+
+
+
+
+
+
+
+
+ GL
+
+
+ OpenTK.OpenGL
+
+
+ ..\..\Source\OpenGL\OpenGL\Bindings
+
+
+ ..\..\Specifications
+
+
+ Platform
+
+
+ Imports
+
+
+ Enums
+
+
+ Context
+
+
+
+
+ GL
+
+
+ OpenTK.OpenGL
+
+
+ ..\..\Source\OpenTK\OpenGL\Bindings
+
+
+ ..\..\..\Input
+
+
+ Platform
+
+
+ Imports
+
+
+ ..\..\Specifications
+
+
+ Enums
+
+
+ Context
+
+
+
+
+ GL
+
+
+ OpenTK.OpenGL
+
+
+ ..\..\Source\OpenTK\OpenGL\Bindings
+
+
+ ..\..\..\Input
+
+
+ Platform
+
+
+ Imports
+
+
+ ..\..\Specifications
+
+
+ Enums
+
+
+ Context
+
+
+
+
\ No newline at end of file
diff --git a/Source/Bind/Settings.cs b/Source/Bind/Settings.cs
new file mode 100644
index 00000000..3e0f0c0f
--- /dev/null
+++ b/Source/Bind/Settings.cs
@@ -0,0 +1,24 @@
+#region License
+//Copyright (c) 2006 Stefanos Apostolopoulos
+//See license.txt for license info
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.OpenGL.Bind
+{
+ static class Settings
+ {
+ public static string InputPath = "..\\..\\..\\Source\\OpenGL\\Specifications";
+ public static string OutputPath = "..\\..\\..\\Source\\OpenGL\\OpenGL\\Bindings";
+ public static string OutputNamespace = "OpenTK.OpenGL";
+ public static string GLClass = "GL";
+ public static string WglClass = "Wgl";
+ public static string GlxClass = "Glx";
+ public static string GluClass = "Glu";
+
+ public static string GLFunctionPrepend = String.Empty;
+ }
+}
diff --git a/Source/Bind/SpecReader.cs b/Source/Bind/SpecReader.cs
new file mode 100644
index 00000000..76680c0a
--- /dev/null
+++ b/Source/Bind/SpecReader.cs
@@ -0,0 +1,433 @@
+#region --- License ---
+/*
+MIT License
+Copyright ©2006-2007 Tao Framework Team
+http://www.taoframework.com
+Copyright ©2005-2007 OpenTK
+http://sourceforge.net/projects/opentk
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#endregion License
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.CodeDom;
+
+#endregion
+
+namespace OpenTK.OpenGL.Bind
+{
+ static class SpecReader
+ {
+ #region internal static string FilePath
+ internal static string FilePath
+ {
+ get
+ {
+ string filePath = Path.Combine("..", "..");
+ string fileDirectory = Settings.InputPath;
+ string fileName = "gl.spec";
+
+ if (File.Exists(fileName))
+ {
+ filePath = "";
+ fileDirectory = "";
+ }
+ else if (File.Exists(Path.Combine(fileDirectory, fileName)))
+ {
+ filePath = "";
+ }
+ return Path.Combine(filePath, fileDirectory);
+ }
+ }
+ #endregion
+
+ #region private static StreamReader OpenSpecFile(string file)
+ private static StreamReader OpenSpecFile(string file)
+ {
+ string path = Path.Combine(FilePath, 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;
+ }
+
+ return sr;
+ }
+ #endregion
+
+ #region private static bool IsExtension(string function_name)
+ private static bool IsExtension(string function_name)
+ {
+ return (function_name.EndsWith("ARB") ||
+ function_name.EndsWith("EXT") ||
+ function_name.EndsWith("ATI") ||
+ function_name.EndsWith("NV") ||
+ function_name.EndsWith("SUN") ||
+ function_name.EndsWith("SUNX") ||
+ function_name.EndsWith("SGI") ||
+ function_name.EndsWith("SGIS") ||
+ function_name.EndsWith("SGIX") ||
+ function_name.EndsWith("MESA") ||
+ function_name.EndsWith("3DFX") ||
+ function_name.EndsWith("IBM") ||
+ function_name.EndsWith("GREMEDY") ||
+ function_name.EndsWith("HP") ||
+ function_name.EndsWith("INTEL") ||
+ function_name.EndsWith("PGI") ||
+ function_name.EndsWith("INGR") ||
+ function_name.EndsWith("APPLE") ||
+ function_name.EndsWith("OML") ||
+ function_name.EndsWith("I3D"));
+ }
+ #endregion
+
+ #region private static string NextValidLine(StreamReader sr)
+ private static string NextValidLine(StreamReader sr)
+ {
+ string line;
+
+ do
+ {
+ if (sr.EndOfStream)
+ return null;
+
+ 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;
+
+ return line;
+ }
+ while (true);
+ }
+ #endregion
+
+ #region public static void ReadFunctionSpecs(string file, out List delegates, out List functions)
+ public static List ReadFunctionSpecs(string file)
+ {
+ StreamReader sr = OpenSpecFile(file);
+ Console.WriteLine("Reading function specs from file: {0}", file);
+
+ List delegates = new List();
+
+ do
+ {
+ string line = NextValidLine(sr);
+ if (String.IsNullOrEmpty(line))
+ break;
+
+ // Get next OpenGL function
+ while (line.Contains("(") && !sr.EndOfStream)
+ {
+ CodeTypeDelegate d = new CodeTypeDelegate();
+ d.Attributes = MemberAttributes.Static;
+ d.CustomAttributes.Add(new CodeAttributeDeclaration("System.Security.SuppressUnmanagedCodeSecurity"));
+
+ // Get function name:
+ d.Name = line.Split(SpecTranslator.Separators, StringSplitOptions.RemoveEmptyEntries)[0];
+ if (IsExtension(d.Name))
+ {
+ d.UserData.Add("Extension", true);
+ }
+ else
+ {
+ d.UserData.Add("Extension", false);
+ }
+
+ //d.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, d.Name));
+ //d.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, d.Name));
+
+ // Get function parameters and return value:
+ do
+ {
+ line = sr.ReadLine();
+ List words = new List(
+ line.Replace('\t', ' ').Split(SpecTranslator.Separators, StringSplitOptions.RemoveEmptyEntries));
+
+ if (words.Count == 0)
+ break;
+
+ // Identify line:
+ switch (words[0])
+ {
+ case "return": // Line denotes return value
+ CodeTypeReference tr = new CodeTypeReference(
+ words[1]
+ );
+
+ //if (tr.BaseType == "GLvoid")
+ // tr.BaseType = "System.Void";
+
+ d.ReturnType = tr;
+ break;
+
+ case "param": // Line denotes parameter
+ CodeParameterDeclarationExpression p =
+ new CodeParameterDeclarationExpression();
+ p.Name = words[1];
+ p.Type = new CodeTypeReference(words[2]);
+ p.Direction = words[3] == "in" ? FieldDirection.In : FieldDirection.Out;
+ if (words[3] != "in")
+ p.CustomAttributes.Add(new CodeAttributeDeclaration("In, Out"));
+ p.Type.ArrayRank = words[4] == "array" ? 1 : 0;
+
+ d.Parameters.Add(p);
+ break;
+
+ /* version directive is not used. GetTexParameterIivEXT and GetTexParameterIuivEXT define two(!) versions (why?)
+ case "version": // Line denotes function version (i.e. 1.0, 1.2, 1.5)
+ d.UserData.Add("version", words[1]);
+ break;
+ */
+
+ case "category":
+ d.UserData.Add("Category", words[1]);
+ break;
+ }
+ }
+ while (!sr.EndOfStream);
+
+ delegates.Add(d);
+ }
+ }
+ while (!sr.EndOfStream);
+
+ return delegates;
+ }
+
+ #endregion
+
+ #region public static void ReadEnumSpecs(string file, out List enums)
+ public static void ReadEnumSpecs(string file, out CodeTypeDeclarationCollection enums)
+ {
+ enums = new CodeTypeDeclarationCollection();
+ // comple_enum contains all opengl enumerants.
+ CodeTypeDeclaration complete_enum = new CodeTypeDeclaration();
+ complete_enum.IsEnum = true;
+ complete_enum.Name = "GLenum";
+
+ StreamReader sr = OpenSpecFile(file);
+ Console.WriteLine("Reading constant specs from file: {0}", file);
+
+ do
+ {
+ string line = NextValidLine(sr);
+ if (String.IsNullOrEmpty(line))
+ break;
+
+ line = line.Replace('\t', ' ');
+
+ // We just encountered the start of a new enumerant:
+ while (!String.IsNullOrEmpty(line) && line.Contains("enum"))
+ {
+ string[] words = line.Split(SpecTranslator.Separators, StringSplitOptions.RemoveEmptyEntries);
+ if (words.Length == 0)
+ continue;
+
+ // Declare a new enumerant
+ CodeTypeDeclaration e = new CodeTypeDeclaration();
+ e.IsEnum = true;
+ e.Name = SpecTranslator.GetTranslatedEnum(words[0]);
+ //d.Attributes = MemberAttributes.Const | MemberAttributes.Public;
+
+ // And fill in the values for this enumerant
+ do
+ {
+ line = NextValidLine(sr);
+
+ if (String.IsNullOrEmpty(line) || line.StartsWith("#"))
+ continue;
+
+ if (line.Contains("enum:") || sr.EndOfStream)
+ break;
+
+ line = line.Replace('\t', ' ');
+ words = line.Split(SpecTranslator.Separators, StringSplitOptions.RemoveEmptyEntries);
+
+ if (words.Length == 0)
+ continue;
+
+ // If we reach this point, we have found a new value for the current enumerant
+ CodeMemberField c = new CodeMemberField();
+ if (line.Contains("="))
+ {
+ c.Name = SpecTranslator.GetTranslatedEnum(words[0]);
+
+ uint number;
+ if (UInt32.TryParse(words[2].Replace("0x", String.Empty), System.Globalization.NumberStyles.AllowHexSpecifier, null, out number))
+ {
+ if (number > 0x7FFFFFFF)
+ {
+ words[2] = "unchecked((Int32)" + words[2] + ")";
+ }
+ }
+ else if (words[2].StartsWith("GL_"))
+ {
+ words[2] = words[2].Substring(3);
+ }
+
+ //c.InitExpression = new CodeFieldReferenceExpression(null, words[2]);
+ //c.UserData.Add("InitExpression", " = " + words[2]);
+ c.UserData.Add("ObjectReference", null);
+ c.UserData.Add("FieldReference", words[2]);
+ }
+ else if (words[0] == "use")
+ {
+ c.Name = SpecTranslator.GetTranslatedEnum(words[2]);
+
+ //c.InitExpression = new CodeFieldReferenceExpression(new CodeSnippetExpression(words[1]), SpecTranslator.GetTranslatedEnum(words[2]));
+ //c.UserData.Add("InitExpression", " = " + words[1] + "." + SpecTranslator.GetTranslatedEnum(words[2]));
+ c.UserData.Add("ObjectReference", words[1]);
+ c.UserData.Add("FieldReference", words[2]);
+ }
+
+ //if (!String.IsNullOrEmpty(c.Name) && !e.Members.Contains.Contains(c))
+ SpecTranslator.Merge(e.Members, c);
+
+ // Insert the current constant in the list of all constants.
+ SpecTranslator.Merge(complete_enum.Members, c);
+ }
+ while (!sr.EndOfStream);
+
+ // At this point, the complete value list for the current enumerant has been read, so add this
+ // enumerant to the list.
+ e.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "public enum " + e.Name));
+ e.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "public enum " + e.Name));
+
+ // (disabled) Hack - discard Boolean enum, it fsucks up the fragile translation code ahead.
+ //if (!e.Name.Contains("Bool"))
+ SpecTranslator.Merge(enums, e);
+ }
+ SpecTranslator.Merge(enums, complete_enum);
+ }
+ while (!sr.EndOfStream);
+ }
+
+ #endregion
+
+ #region public static bool ListContainsConstant(List enums, CodeMemberField c)
+ public static bool ListContainsConstant(List constants, CodeMemberField c)
+ {
+ foreach (CodeMemberField d in constants)
+ if (d.Name == c.Name)
+ return true;
+ return false;
+ }
+ #endregion
+
+ #region public static Dictionary ReadTypeMap(string file)
+ public static Dictionary ReadTypeMap(string file)
+ {
+ Dictionary map =
+ new Dictionary();
+
+ string path = Path.Combine(FilePath, 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(words[0], new CodeTypeReference(String.Empty));
+ }
+ else if (words[0] == "VoidPointer")
+ { // Special case for "VoidPointer" -> "GLvoid*"
+ map.Add(words[0], new CodeTypeReference("System.Object"));
+ }
+ else if (words[0] == "CharPointer" || words[0] == "charPointerARB")
+ {
+ map.Add(words[0], new CodeTypeReference("System.String"));
+ }
+ else if (words[0].Contains("Pointer"))
+ {
+ map.Add(words[0], new CodeTypeReference(words[1], 1));
+ }
+ //else if (words[1].Contains("Boolean"))
+ //{
+ // // Do not add this to the typemap!
+ //}
+ /*else if (words[1] == "GLenum")
+ {
+ // Do not throw away the type to generic GLenum. We want type checking!
+ }*/
+ else
+ {
+ map.Add(words[0], new CodeTypeReference(words[1]));
+ }
+ }
+ while (!sr.EndOfStream);
+
+ return map;
+ }
+ #endregion
+ }
+}
diff --git a/Source/Bind/SpecTranslator.cs b/Source/Bind/SpecTranslator.cs
new file mode 100644
index 00000000..c13e49d9
--- /dev/null
+++ b/Source/Bind/SpecTranslator.cs
@@ -0,0 +1,937 @@
+#region --- License ---
+/*
+MIT License
+Copyright ©2006-2007 Tao Framework Team
+http://www.taoframework.com
+Copyright ©2005-2007 OpenTK
+http://sourceforge.net/projects/opentk
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#endregion License
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Collections;
+using System.CodeDom;
+
+#endregion
+
+namespace OpenTK.OpenGL.Bind
+{
+ #region WrapperTypes enum
+
+ public enum WrapperTypes
+ {
+ ///
+ /// No wrapper needed.
+ ///
+ None,
+ ///
+ /// Function takes bool parameter - C uses Int for bools, so we have to marshal.
+ ///
+ BoolParameter,
+ ///
+ /// Function takes generic parameters - add ref/out generic and generic overloads.
+ ///
+ GenericParameter,
+ ///
+ /// Function takes arrays as parameters - add ref/out and ([Out]) array overloads.
+ ///
+ ArrayParameter,
+ ///
+ /// Function with bitmask parameters. Bitmask parameters map to UInt, but since we can only use signed
+ /// types (for CLS compliance), we must add the unchecked keyword.
+ /// Usually found in bitmasks
+ ///
+ UncheckedParameter,
+ ///
+ /// Function that takes (in/ref/out) a naked pointer as a parameter - we pass an IntPtr.
+ ///
+ PointerParameter,
+ ///
+ /// Function returns string - needs manual marshalling through IntPtr to prevent the managed GC
+ /// from freeing memory allocated on the unmanaged side (e.g. glGetString).
+ ///
+ StringReturnValue,
+ ///
+ /// Function returns a void pointer - maps to IntPtr, and the user has to manually marshal the type.
+ ///
+ GenericReturnValue,
+ ///
+ /// Function returns a typed pointer - we have to copy the data to an array to protect it from the GC.
+ ///
+ ArrayReturnValue
+ }
+
+ #endregion
+
+ static class SpecTranslator
+ {
+ #region static SpecTranslator()
+ // Do not remove! - forces BeforeFieldInit to false.
+ static SpecTranslator()
+ {
+ }
+ #endregion
+
+ #region Fields and Properties
+ public static char[] Separators = { ' ', '\n', ',', '(', ')', ';', '#' };
+
+ #region GL types dictionary
+
+ private static Dictionary _gl_types = SpecReader.ReadTypeMap("gl.tm");
+
+ public static Dictionary GLTypes
+ {
+ get { return SpecTranslator._gl_types; }
+ set { SpecTranslator._gl_types = value; }
+ }
+
+ #endregion
+
+ #region CS types dictionary
+
+ private static Dictionary _cs_types = SpecReader.ReadTypeMap("csharp.tm");
+
+ public static Dictionary CSTypes
+ {
+ get { return SpecTranslator._cs_types; }
+ set { SpecTranslator._cs_types = value; }
+ }
+
+ #endregion
+
+ #region GLX types dictionary
+
+ private static Dictionary _glx_types;
+
+ public static Dictionary GLXTypes
+ {
+ get { return _glx_types; }
+ set { _glx_types = value; }
+ }
+
+ #endregion
+
+ #region WGL types dictionary
+
+ private static Dictionary _wgl_types;
+
+ public static Dictionary WGLTypes
+ {
+ get { return _wgl_types; }
+ set { _wgl_types = value; }
+ }
+
+ #endregion
+ #endregion
+
+ #region public static List TranslateDelegates(List delegates, CodeTypeDeclarationCollection enums)
+ public static List TranslateDelegates(List delegates, CodeTypeDeclarationCollection enums)
+ {
+ List functions = new List();
+ foreach (CodeTypeDelegate d in delegates)
+ {
+ TranslateReturnValue(d);
+ TranslateParameters(d, enums);
+ functions.AddRange(CreateWrappers(d));
+ }
+
+ return functions;
+ }
+ #endregion
+
+ #region private static void TranslateReturnValue(CodeTypeDelegate d)
+ private static void TranslateReturnValue(CodeTypeDelegate d)
+ {
+ CodeTypeReference s;
+
+ if (d.ReturnType.BaseType == "void")
+ d.ReturnType.BaseType = "System.Void";
+
+ if (GLTypes.TryGetValue(d.ReturnType.BaseType, out s))
+ d.ReturnType = s;
+
+ if (d.ReturnType.BaseType == "GLstring")
+ {
+ d.ReturnType = new CodeTypeReference("IntPtr");
+ d.ReturnType.UserData.Add("Wrapper", WrapperTypes.StringReturnValue);
+ }
+
+ if (d.ReturnType.BaseType.ToLower().Contains("object"))
+ {
+ d.ReturnType.BaseType = "IntPtr";
+ d.ReturnType.UserData.Add("Wrapper", WrapperTypes.GenericReturnValue);
+ d.ReturnType.ArrayRank = 0;
+ }
+
+ if (d.ReturnType.BaseType == "GLenum")
+ {
+ d.ReturnType.BaseType = "Enums.GLenum";
+ }
+
+ if (d.ReturnType.UserData.Contains("Wrapper"))
+ {
+ d.UserData.Add("Wrapper", null);
+ }
+ }
+ #endregion
+
+ #region private static void TranslateParameters(CodeTypeDelegate d)
+ private static void TranslateParameters(CodeTypeDelegate d, CodeTypeDeclarationCollection enums)
+ {
+ CodeTypeReference s;
+
+ if (d.Name == "CreateShader")
+ {
+ }
+
+ // Translate each parameter of the function while checking for needed wrappers:
+ foreach (CodeParameterDeclarationExpression p in d.Parameters)
+ {
+ if (Search(enums, p.Type.BaseType) && p.Type.BaseType != "GLenum")
+ {
+ // If there is a specific enumerant entry for this parameter, then take this.
+ p.Type.BaseType = "Enums." + p.Type.BaseType;
+ }
+ else if (GLTypes.TryGetValue(p.Type.BaseType, out s))
+ {
+ if (s.BaseType == "GLenum" && d.UserData.Contains("Category"))
+ {
+ // If there isn't, try to see if any of the generic enumerants
+ // (category: VERSION_1_1 etc) match the needed name.
+ bool found = false;
+ foreach (CodeTypeDeclaration enumerant in enums)
+ {
+ if (enumerant.Name == (string)d.UserData["Category"])
+ {
+ p.Type.BaseType = "Enums." + (string)d.UserData["Category"];
+ found = true;
+ break;
+ }
+ }
+
+ // If none match, then fall back to the global enum list.
+ if (!found)
+ {
+ p.Type.BaseType = "Enums.GLenum";
+ }
+ }
+ else
+ {
+ p.Type.BaseType = s.BaseType;
+ }
+ }
+
+ if (p.Type.ArrayRank == 0 && p.Type.BaseType.ToLower().Contains("enums."))
+ {
+ // Do nothing
+ }
+ else if (p.Type.ArrayRank > 0 && p.Type.BaseType.Contains("char") ||
+ p.Type.ArrayRank == 0 && p.Type.BaseType.ToLower().Contains("string"))
+ {
+ // GLchar[] parameters should become (in) string or (out) StringBuilder
+ if (p.Direction == FieldDirection.Out || p.Direction == FieldDirection.Ref)
+ p.Type = new CodeTypeReference("System.Text.StringBuilder");
+ else
+ p.Type = new CodeTypeReference("System.String");
+ }
+ else if (p.Type.ArrayRank > 0 && p.Type.BaseType.ToLower().Contains("string"))
+ {
+ // string parameters do not need special wrappers. We add this here
+ // to simplify the next if-statements.
+ // p.Type.ArrayRank = 0;
+ }
+ else if (p.Type.ArrayRank > 0)
+ {
+ // All other array parameters need wrappers (around IntPtr).
+ if (p.Type.BaseType.Contains("void") || p.Type.BaseType.Contains("Void"))
+ {
+ p.UserData.Add("Wrapper", WrapperTypes.GenericParameter);
+ }
+ else if (p.Type.BaseType.Contains("IntPtr"))
+ {
+ //p.UserData.Add("Wrapper", WrapperTypes.PointerParameter);
+ }
+ else
+ {
+ p.UserData.Add("Wrapper", WrapperTypes.ArrayParameter);
+ p.UserData.Add("OriginalType", new string(p.Type.BaseType.ToCharArray()));
+ }
+
+ // We do not want an array of IntPtrs (IntPtr[]) - it is the IntPtr that points to the array.
+ p.Type = new CodeTypeReference();
+ p.Type.BaseType = "System.IntPtr";
+ p.Type.ArrayRank = 0;
+ p.UserData.Add("Flow", p.Direction);
+ // The same wrapper works for either in or out parameters.
+ //p.CustomAttributes.Add(new CodeAttributeDeclaration("In, Out"));
+ }
+ else if (p.Type.BaseType.Contains("ushort") && d.Name.Contains("LineStipple"))
+ {
+ // glLineStipple needs wrapper to allow large unsigned mask values.
+ p.UserData.Add("Wrapper", WrapperTypes.UncheckedParameter);
+ }
+
+
+ if (p.Type.BaseType.ToLower().Contains("boolean"))
+ {
+ p.Type.BaseType = "System.Boolean";
+ //p.UserData.Add("Wrapper", WrapperTypes.BoolParameter);
+ p.CustomAttributes.Add(
+ new CodeAttributeDeclaration(
+ "MarshalAs",
+ new CodeAttributeArgument(new CodeSnippetExpression("UnmanagedType.Bool"))
+ )
+ );
+ }
+
+ if (p.UserData.Contains("Wrapper") && !d.UserData.Contains("Wrapper"))
+ {
+ // If there is at least 1 parameter that needs wrappers, mark the funcction for wrapping.
+ d.UserData.Add("Wrapper", null);
+ }
+
+ //p.Direction = FieldDirection.In;
+ }
+ }
+ #endregion
+
+ #region private static bool Search(CodeTypeDeclarationCollection enums, string name)
+
+ private static bool Search(CodeTypeDeclarationCollection enums, string name)
+ {
+ foreach (CodeTypeDeclaration enumerant in enums)
+ {
+ if (enumerant.Name == name)
+ {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ #endregion
+
+ #region private static List CreateWrappers(CodeTypeDelegate d)
+ private static List CreateWrappers(CodeTypeDelegate d)
+ {
+ List wrappers = new List();
+ CodeMemberMethod f = new CodeMemberMethod();
+
+ // Check if a wrapper is needed:
+ if (!d.UserData.Contains("Wrapper"))
+ {
+ // If not, add just add a function that calls the delegate.
+ f = CreatePrototype(d);
+
+ if (!f.ReturnType.BaseType.Contains("Void"))
+ f.Statements.Add(new CodeMethodReturnStatement(GenerateInvokeExpression(f)));
+ else
+ f.Statements.Add(GenerateInvokeExpression(f));
+
+ wrappers.Add(f);
+ }
+ else
+ {
+ // We have to add wrappers for all possible WrapperTypes.
+
+ // First, check if the return type needs wrapping:
+ if (d.ReturnType.UserData.Contains("Wrapper"))
+ {
+ switch ((WrapperTypes)d.ReturnType.UserData["Wrapper"])
+ {
+ // If the function returns a string (glGetString) we must manually marshal it
+ // using Marshal.PtrToStringXXX. Otherwise, the GC will try to free the memory
+ // used by the string, resulting in corruption (the memory belongs to the
+ // unmanaged boundary).
+ case WrapperTypes.StringReturnValue:
+ f = CreatePrototype(d);
+ f.ReturnType = new CodeTypeReference("System.String");
+
+ f.Statements.Add(
+ new CodeMethodReturnStatement(
+ new CodeMethodInvokeExpression(
+ new CodeTypeReferenceExpression("Marshal"),
+ "PtrToStringAnsi",
+ new CodeExpression[] { GenerateInvokeExpression(f) }
+ )
+ )
+ );
+
+ wrappers.Add(f);
+ break;
+
+ // If the function returns a void* (GenericReturnValue), we'll have to return an IntPtr.
+ // The user will unfortunately need to marshal this IntPtr to a data type manually.
+ case WrapperTypes.GenericReturnValue:
+ f = CreatePrototype(d);
+
+ if (!f.ReturnType.BaseType.Contains("Void"))
+ f.Statements.Add(new CodeMethodReturnStatement(GenerateInvokeExpression(f)));
+ else
+ f.Statements.Add(GenerateInvokeExpression(f));
+
+ wrappers.Add(f);
+ break;
+ }
+ }
+
+ if (d.Name.Contains("LineStipple"))
+ {
+ // glLineStipple accepts a GLushort bitfield. Since GLushort is mapped to Int16, not UInt16
+ // (for CLS compliance), we'll have to add the unchecked keyword.
+ f = CreatePrototype(d);
+
+ CodeSnippetExpression e =
+ new CodeSnippetExpression("Delegates.glLineStipple(factor, unchecked((GLushort)pattern))");
+ f.Statements.Add(e);
+
+ wrappers.Add(f);
+ }
+
+ WrapPointersMonsterFunctionMK2(String.IsNullOrEmpty(f.Name) ? CreatePrototype(d) : f, wrappers);
+ }
+
+ return wrappers;
+ }
+ #endregion
+
+ #region private static void WrapPointersMonsterFunctionMK2(CodeTypeDelegate d, List wrappers)
+ // This function needs some heavy refactoring. I'm ashamed I ever wrote it, but it works...
+ // What it does is this: it adds to the wrapper list all possible wrapper permutations
+ // for functions that have more than one IntPtr parameter. Example:
+ // "void Delegates.f(IntPtr p, IntPtr q)" where p and q are pointers to void arrays needs the following wrappers:
+ // "void f(IntPtr p, IntPtr q)"
+ // "void f(IntPtr p, object q)"
+ // "void f(object p, IntPtr q)"
+ // "void f(object p, object q)"
+ private static int count = 0;
+ private static void WrapPointersMonsterFunctionMK2(CodeMemberMethod f, List wrappers)
+ {
+ if (count == 0)
+ {
+ bool functionContainsIntPtrParameters = false;
+ // Check if there are any IntPtr parameters (we may have come here from a ReturnType wrapper
+ // such as glGetString, which contains no IntPtr parameters)
+ foreach (CodeParameterDeclarationExpression p in f.Parameters)
+ {
+ if (p.Type.BaseType.Contains("IntPtr"))
+ {
+ functionContainsIntPtrParameters = true;
+ break;
+ }
+ }
+
+ if (functionContainsIntPtrParameters)
+ {
+ wrappers.Add(IntPtrToIntPtr(f));
+ }
+ else
+ {
+ return;
+ }
+ }
+
+ if (count >= 0 && count < f.Parameters.Count)
+ {
+ if (f.Parameters[count].UserData.Contains("Wrapper"))
+ {
+ //++count;
+ //WrapPointersMonsterFunctionMK2(d, wrappers);
+ //--count;
+
+ if ((WrapperTypes)f.Parameters[count].UserData["Wrapper"] == WrapperTypes.ArrayParameter)
+ {
+ ++count;
+ WrapPointersMonsterFunctionMK2(f, wrappers);
+ --count;
+
+ CodeMemberMethod w = IntPtrToArray(f, count);
+ wrappers.Add(w);
+
+ ++count;
+ WrapPointersMonsterFunctionMK2(w, wrappers);
+ --count;
+
+ w = IntPtrToReference(f, count);
+ wrappers.Add(w);
+
+ ++count;
+ WrapPointersMonsterFunctionMK2(w, wrappers);
+ --count;
+ }
+ else if ((WrapperTypes)f.Parameters[count].UserData["Wrapper"] == WrapperTypes.GenericParameter)
+ {
+ ++count;
+ WrapPointersMonsterFunctionMK2(f, wrappers);
+ --count;
+
+ CodeMemberMethod w = IntPtrToObject(f, count);
+ wrappers.Add(w);
+
+ ++count;
+ WrapPointersMonsterFunctionMK2(w, wrappers);
+ --count;
+ }
+ }
+ else
+ {
+ ++count;
+ WrapPointersMonsterFunctionMK2(f, wrappers);
+ --count;
+ }
+ }
+ }
+
+ #endregion
+
+ #region private static CodeMemberMethod IntPtrToIntPtr(CodeMemberMethod f)
+ private static CodeMemberMethod IntPtrToIntPtr(CodeMemberMethod f)
+ {
+ CodeMemberMethod w = CreatePrototype(f);
+ if (!w.ReturnType.BaseType.Contains("Void"))
+ {
+ w.Statements.Add(new CodeMethodReturnStatement(GenerateInvokeExpression(w)));
+ }
+ else
+ {
+ w.Statements.Add(GenerateInvokeExpression(w));
+ }
+ return w;
+ }
+ #endregion
+
+ #region private static CodeMemberMethod IntPtrToObject(CodeMemberMethod f, int index)
+ private static CodeMemberMethod IntPtrToObject(CodeMemberMethod f, int index)
+ {
+ CodeMemberMethod w = CreatePrototype(f);
+
+ CodeParameterDeclarationExpression newp = new CodeParameterDeclarationExpression();
+ newp.Name = f.Parameters[index].Name;
+ newp.Type = new CodeTypeReference("System.Object");
+ //if (newp.Flow == Parameter.FlowDirection.Out)
+ // newp.Flow = Parameter.FlowDirection.Undefined;
+ w.Parameters[index] = newp;
+
+ // In the function body we should pin all objects in memory before calling the
+ // low-level function.
+ w.Statements.AddRange(GenerateInvokeExpressionWithPins(w));
+
+ return w;
+ }
+ #endregion
+
+ #region private static CodeMemberMethod IntPtrToArray(CodeMemberMethod f, int index)
+ // IntPtr -> GL[...] wrapper.
+ private static CodeMemberMethod IntPtrToArray(CodeMemberMethod f, int index)
+ {
+ CodeMemberMethod w = CreatePrototype(f);
+
+ // Search and replace IntPtr parameters with the known parameter types:
+ CodeParameterDeclarationExpression newp = new CodeParameterDeclarationExpression();
+ newp.Name = f.Parameters[index].Name;
+ newp.Type.BaseType = (string)f.Parameters[index].UserData["OriginalType"];
+ newp.Type.ArrayRank = 1;
+ w.Parameters[index] = newp;
+
+ // In the function body we should pin all objects in memory before calling the
+ // low-level function.
+ w.Statements.AddRange(GenerateInvokeExpressionWithPins(w));
+
+ return w;
+ }
+ #endregion
+
+ #region private static CodeMemberMethod IntPtrToReference(CodeMemberMethod f, int index)
+ ///
+ /// Obtain an IntPtr to the reference passed by the user.
+ ///
+ ///
+ ///
+ ///
+ private static CodeMemberMethod IntPtrToReference(CodeMemberMethod f, int index)
+ {
+ CodeMemberMethod w = CreatePrototype(f);
+
+ // Search and replace IntPtr parameters with the known parameter types:
+ CodeParameterDeclarationExpression newp = new CodeParameterDeclarationExpression();
+ newp.Name = f.Parameters[index].Name;
+ newp.Type.BaseType = (string)f.Parameters[index].UserData["OriginalType"];
+ if (f.Parameters[index].UserData.Contains("Flow") &&
+ (FieldDirection)f.Parameters[index].UserData["Flow"] == FieldDirection.Out)
+ newp.Direction = FieldDirection.Out;
+ else
+ newp.Direction = FieldDirection.Ref;
+ w.Parameters[index] = newp;
+
+ // In the function body we should pin all objects in memory before calling the
+ // low-level function.
+ w.Statements.AddRange(GenerateInvokeExpressionWithPins(w));
+
+ return w;
+ }
+ #endregion
+
+ #region private static CodeMemberMethod CreatePrototype(CodeTypeDelegate d)
+ private static CodeMemberMethod CreatePrototype(CodeTypeDelegate d)
+ {
+ CodeMemberMethod f = new CodeMemberMethod();
+
+ f.Name = Settings.GLFunctionPrepend + d.Name;
+ f.Parameters.AddRange(d.Parameters);
+ f.ReturnType = d.ReturnType;
+ f.Attributes = MemberAttributes.Static | MemberAttributes.Public;
+
+ //f.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, f.Name));
+ //f.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, f.Name));
+
+ /*f.Comments.Add(new CodeCommentStatement("", true));
+ f.Comments.Add(new CodeCommentStatement(" ", true));
+ f.Comments.Add(new CodeCommentStatement("", true));*/
+
+ return f;
+ }
+ #endregion
+
+ #region private static CodeMemberMethod CreatePrototype(CodeMemberMethod d)
+ private static CodeMemberMethod CreatePrototype(CodeMemberMethod d)
+ {
+ CodeMemberMethod f = new CodeMemberMethod();
+
+ f.Name = d.Name;
+ f.Parameters.AddRange(d.Parameters);
+ f.ReturnType = d.ReturnType;
+ f.Attributes = MemberAttributes.Static | MemberAttributes.Public;
+
+ //f.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, f.Name));
+ //f.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, f.Name));
+
+ foreach (object key in d.UserData.Keys)
+ {
+ f.UserData.Add(key, d.UserData[key]);
+ }
+
+ /*f.Comments.Add(new CodeCommentStatement("", true));
+ f.Comments.Add(new CodeCommentStatement(" ", true));
+ f.Comments.Add(new CodeCommentStatement("", true));*/
+
+ return f;
+ }
+ #endregion
+
+ #region private static CodeExpression GenerateInvokeExpression(CodeMemberMethod f)
+ private static CodeExpression GenerateInvokeExpression(CodeMemberMethod f)
+ {
+ CodeVariableReferenceExpression[] parameters = new CodeVariableReferenceExpression[f.Parameters.Count];
+ int i = 0;
+ foreach (CodeParameterDeclarationExpression p in f.Parameters)
+ {
+ parameters[i++] = new CodeVariableReferenceExpression(p.Name);
+ }
+
+ return new CodeMethodInvokeExpression(
+ new CodeTypeReferenceExpression("Delegates"),
+ "gl" + f.Name,
+ parameters
+ );
+ }
+ #endregion
+
+ #region private static CodeStatementCollection GenerateInvokeExpressionWithPins(CodeMemberMethod f)
+ private static CodeStatementCollection GenerateInvokeExpressionWithPins(CodeMemberMethod f)
+ {
+ CodeVariableReferenceExpression[] parameters = new CodeVariableReferenceExpression[f.Parameters.Count];
+ CodeTryCatchFinallyStatement m = new CodeTryCatchFinallyStatement();
+ CodeStatementCollection statements = new CodeStatementCollection();
+
+ int h = 0;
+ int i = 0;
+ foreach (CodeParameterDeclarationExpression p in f.Parameters)
+ {
+ // Do manual marshalling for objects and arrays, but not strings.
+ if (p.Type.BaseType == "object" || p.Type.BaseType == "System.Object" ||
+ (p.Type.ArrayRank > 0 && !p.Type.BaseType.ToLower().Contains("string")) ||
+ ((p.Direction == FieldDirection.Ref || p.Direction == FieldDirection.Out) &&
+ !p.Type.BaseType.ToLower().Contains("string")))
+ {
+ if (p.Direction == FieldDirection.Out)
+ {
+ statements.Add(
+ new CodeAssignStatement(
+ new CodeVariableReferenceExpression(p.Name),
+ new CodeSnippetExpression("default(" + p.Type.BaseType + ")")
+ )
+ );
+ }
+
+ // Pin the object and store the resulting GCHandle to h0, h1, ...
+ CodeVariableDeclarationStatement s = new CodeVariableDeclarationStatement();
+ s.Type = new CodeTypeReference("GCHandle");
+ s.Name = "h" + h;
+ s.InitExpression =
+ new CodeMethodInvokeExpression(
+ new CodeTypeReferenceExpression("GCHandle"),
+ "Alloc",
+ new CodeTypeReferenceExpression[] {
+ new CodeTypeReferenceExpression(p.Name),
+ new CodeTypeReferenceExpression("GCHandleType.Pinned")
+ }
+ );
+ statements.Add(s);
+
+ // Free the object using the h0, h1, ... variables
+ m.FinallyStatements.Add(
+ new CodeMethodInvokeExpression(
+ new CodeTypeReferenceExpression("h" + h),
+ "Free"
+ )
+ );
+
+ // Add the h(n) variable to the list of parameters
+ parameters[i] = new CodeVariableReferenceExpression("h" + h + ".AddrOfPinnedObject()");
+
+ // Add an assignment statement: "variable_name = (variable_type)h(n).Target" for out parameters.
+ if (p.Direction == FieldDirection.Out)
+ {
+ m.TryStatements.Add(
+ new CodeAssignStatement(
+ new CodeVariableReferenceExpression(p.Name),
+ new CodeSnippetExpression("(" + p.Type.BaseType + ")h" + h + ".Target")
+ )
+ );
+ }
+
+ h++;
+ }
+ else
+ {
+ // Add the normal paramater to the parameter list
+ parameters[i] = new CodeVariableReferenceExpression(p.Name);
+ }
+ i++;
+ }
+
+ if (f.ReturnType.BaseType.Contains("Void"))
+ {
+ m.TryStatements.Insert(0,
+ new CodeExpressionStatement(
+ new CodeMethodInvokeExpression(
+ new CodeTypeReferenceExpression("Delegates"),
+ "gl" + f.Name,
+ parameters
+ )
+ )
+ );
+ }
+ else
+ {
+ m.TryStatements.Insert(0, new CodeVariableDeclarationStatement(f.ReturnType, "retval"));
+ m.TryStatements.Insert(1,
+ new CodeAssignStatement(
+ new CodeVariableReferenceExpression("retval"),
+ new CodeMethodInvokeExpression(
+ new CodeTypeReferenceExpression("Delegates"),
+ "gl" + f.Name,
+ parameters
+ )
+ )
+ );
+
+ m.TryStatements.Add(
+ new CodeMethodReturnStatement(new CodeVariableReferenceExpression("retval"))
+ );
+ }
+
+ statements.Add(m);
+
+ return statements;
+ }
+ #endregion
+
+ #region public static CodeTypeDeclarationCollection Merge(CodeTypeDeclarationCollection list1, CodeTypeDeclarationCollection list2)
+ public static CodeTypeDeclarationCollection Merge(CodeTypeDeclarationCollection list1, CodeTypeDeclarationCollection list2)
+ {
+ foreach (CodeTypeDeclaration d in list2)
+ {
+ Merge(list1, d);
+ }
+
+ return list1;
+ }
+ #endregion
+
+ #region public static CodeTypeDeclarationCollection Merge(CodeTypeDeclarationCollection list, CodeTypeDeclaration item)
+ public static CodeTypeDeclarationCollection Merge(CodeTypeDeclarationCollection list, CodeTypeDeclaration item)
+ {
+ bool t_exists = false;
+ foreach (CodeTypeDeclaration d in list)
+ {
+ if (d.Name == item.Name)
+ {
+ t_exists = true;
+ foreach (CodeTypeMember m in item.Members)
+ {
+ Merge(d.Members, m);
+ }
+ }
+ }
+
+ if (!t_exists)
+ {
+ list.Add(item);
+ }
+
+ return list;
+ }
+ #endregion
+
+ #region public static CodeTypeMemberCollection Merge(CodeTypeMemberCollection list, CodeTypeMember item)
+ public static CodeTypeMemberCollection Merge(CodeTypeMemberCollection list, CodeTypeMember item)
+ {
+ bool t_exists = false;
+ foreach (CodeTypeMember d in list)
+ {
+ if (d.Name == item.Name)
+ {
+ t_exists = true;
+ }
+ }
+
+ if (!t_exists)
+ {
+ list.Add(item);
+ }
+
+ return list;
+ }
+ #endregion
+
+ #region public static CodeTypeDeclarationCollection TranslateEnums(CodeTypeDeclarationCollection enums)
+ public static CodeTypeDeclarationCollection TranslateEnums(CodeTypeDeclarationCollection enums)
+ {
+ // Add missing enums.
+ {
+ CodeTypeDeclaration e = new CodeTypeDeclaration("SGIX_icc_texture");
+ e.IsEnum = true;
+ CodeMemberField c;
+ c = new CodeMemberField(); c.Name = "RGB_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8460"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "RGBA_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8461"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "ALPHA_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8462"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "LUMINANCE_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8463"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "INTENSITY_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8464"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "LUMINANCE_ALPHA_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8465"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "R5_G6_B5_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8466"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "R5_G6_B5_A8_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8467"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "ALPHA16_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8468"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "LUMINANCE16_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x8469"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "INTENSITY16_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x846A"); e.Members.Add(c);
+ c = new CodeMemberField(); c.Name = "LUMINANCE16_ALPHA8_ICC_SGIX"; c.InitExpression = new CodeFieldReferenceExpression(null, "0x846B"); e.Members.Add(c);
+
+ enums.Add(e);
+ }
+
+ // Translate enums.
+ foreach (CodeTypeDeclaration e in enums)
+ {
+ if (Char.IsDigit(e.Name[0]))
+ e.Name = e.Name.Insert(0, "_");
+
+ if (e.Name == "Boolean")
+ continue;
+
+ foreach (CodeMemberField c in e.Members)
+ {
+ // Prepend an '_' if the first letter is a number (e.g. 4_BYTES -> _4_BYTES)
+ if (Char.IsDigit(c.Name[0]))
+ c.Name = c.Name.Insert(0, "_");
+
+ if (c.UserData["FieldReference"] == null)
+ continue;
+
+ c.UserData["ObjectReference"] = GetTranslatedEnum((string)c.UserData["ObjectReference"]);
+ c.UserData["FieldReference"] = GetTranslatedEnum((string)c.UserData["FieldReference"]);
+
+ // There are cases when a value is not a number but an aliased constant, with no enum specified.
+ // In this case try searching all enums for the correct constant to alias (stupid opengl specs).
+ if (c.UserData["ObjectReference"] == null &&
+ !((string)c.UserData["FieldReference"]).StartsWith("0x") &&
+ !Char.IsDigit(((string)c.UserData["FieldReference"])[0]))
+ {
+ if (((string)c.UserData["FieldReference"]).StartsWith("GL_"))
+ c.UserData["FieldReference"] = ((string)c.UserData["FieldReference"]).Substring(3);
+
+ foreach (CodeTypeDeclaration enumerant in enums)
+ {
+ foreach (CodeTypeMember member in enumerant.Members)
+ {
+ if (member.Name == (string)c.UserData["FieldReference"] ||
+ member.Name == ((string)c.UserData["FieldReference"]).TrimStart('_'))
+ {
+ c.UserData["ObjectReference"] = enumerant.Name;
+ }
+ }
+ }
+ }
+
+ c.InitExpression =
+ new CodeFieldReferenceExpression(
+ c.UserData["ObjectReference"] == null ? null : new CodeSnippetExpression((string)c.UserData["ObjectReference"]),
+ (string)c.UserData["FieldReference"]
+ );
+ }
+ }
+
+ return enums;
+ }
+ #endregion
+
+ #region public static string GetTranslatedEnum(string name)
+ public static string GetTranslatedEnum(string name)
+ {
+ int useless;
+
+ if (String.IsNullOrEmpty(name))
+ return null;
+
+ // Check if the name starts with a number, and prepend a "_" if yes.
+ if (!name.StartsWith("0x") &&
+ !Int32.TryParse(name, out useless) &&
+ Char.IsDigit(name[0]))
+ {
+ return name.Insert(0, "_");
+ }
+
+ if (name == "LightProperty")
+ {
+ return "LightParameter";
+ }
+
+ return name;
+ }
+ #endregion
+ }
+}
diff --git a/Source/Bind/SpecWriter.cs b/Source/Bind/SpecWriter.cs
new file mode 100644
index 00000000..d330463b
--- /dev/null
+++ b/Source/Bind/SpecWriter.cs
@@ -0,0 +1,350 @@
+#region --- License ---
+/*
+MIT License
+Copyright ©2006-2007 Tao Framework Team
+http://www.taoframework.com
+Copyright ©2005-2007 OpenTK
+http://sourceforge.net/projects/opentk
+
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+#endregion License
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.CodeDom;
+
+#endregion
+
+namespace OpenTK.OpenGL.Bind
+{
+ static class SpecWriter
+ {
+ #region internal class CodeTypeNameComparer : Comparer where T : CodeTypeMember
+ internal class CodeTypeNameComparer : Comparer where T : CodeTypeMember
+ {
+ public override int Compare(T x, T y)
+ {
+ return x.Name.CompareTo(y.Name);
+ }
+ }
+ #endregion
+
+ #region Generate
+
+ public static void Generate(
+ List delegates,
+ List functions,
+ CodeTypeDeclarationCollection enums
+ )
+ {
+ if (!Directory.Exists(Settings.OutputPath))
+ Directory.CreateDirectory(Settings.OutputPath);
+
+ CodeNamespace ns = new CodeNamespace(Settings.OutputNamespace);
+
+ ns.Imports.Add(new CodeNamespaceImport("System"));
+ ns.Imports.Add(new CodeNamespaceImport("System.Runtime.InteropServices"));
+ ns.Imports.Add(new CodeNamespaceImport("System.Text"));
+ //ns.Imports.Add(new CodeNamespaceImport(Settings.OutputNamespace + ".Enums"));
+
+ foreach (string key in SpecTranslator.CSTypes.Keys)
+ {
+ ns.Imports.Add(new CodeNamespaceImport(key + " = System." + SpecTranslator.CSTypes[key].BaseType));
+ }
+
+ functions.Sort(new CodeTypeNameComparer());
+ delegates.Sort(new CodeTypeNameComparer());
+
+
+ ns.Types.Add(GenerateGLClass(functions));
+ ns.Types.Add(GenerateDelegatesClass(delegates));
+ ns.Types.Add(GenerateImportsClass(delegates));
+
+ CodeCompileUnit cu = new CodeCompileUnit();
+
+ cu.StartDirectives.Add(new CodeDirective());
+ cu.Namespaces.Add(ns);
+
+ using (StreamWriter sw = new StreamWriter(Path.Combine(Settings.OutputPath, Settings.GLClass + ".cs"), false))
+ {
+ Console.WriteLine("Writing {0} class", Settings.OutputNamespace + "." + Settings.GLClass);
+
+ Microsoft.CSharp.CSharpCodeProvider cs = new Microsoft.CSharp.CSharpCodeProvider();
+ System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
+ options.BracingStyle = "C";
+ options.BlankLinesBetweenMembers = false;
+ options.VerbatimOrder = true;
+
+ cs.GenerateCodeFromCompileUnit(cu, sw, options);
+
+ sw.Flush();
+ }
+
+ ns.Name = Settings.OutputNamespace + ".Enums";
+ ns.Imports.Clear();
+ ns.Imports.Add(new CodeNamespaceImport("System"));
+ ns.Types.Clear();
+ //enums.Sort(new CodeTypeNameComparer());
+ //CodeTypeDeclaration d = new CodeTypeDeclaration("Enums");
+ //d.IsStruct = true;
+ //d.Members.AddRange(enums);
+ //ns.Types.Add(d);
+ ns.Types.AddRange(enums);
+
+ using (StreamWriter sw = new StreamWriter(Path.Combine(Settings.OutputPath, Settings.GLClass + "enums.cs"), false))
+ {
+ Console.WriteLine("Writing {0} enums", Settings.OutputNamespace + "." + Settings.GLClass);
+
+ Microsoft.CSharp.CSharpCodeProvider cs = new Microsoft.CSharp.CSharpCodeProvider();
+ System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
+ options.BracingStyle = "C";
+ options.BlankLinesBetweenMembers = false;
+ options.VerbatimOrder = true;
+
+ cs.GenerateCodeFromCompileUnit(cu, sw, options);
+
+ sw.Flush();
+ }
+ }
+
+ #endregion
+
+ #region private static CodeTypeDeclaration GenerateGLClass(List functions, List enums)
+ private static CodeTypeDeclaration GenerateGLClass(List functions)
+ {
+ CodeTypeDeclaration gl_class = new CodeTypeDeclaration(Settings.GLClass);
+ gl_class.IsClass = true;
+ gl_class.IsPartial = true;
+ gl_class.TypeAttributes = System.Reflection.TypeAttributes.Public;
+
+ gl_class.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "GL class"));
+ gl_class.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "GL class"));
+
+ gl_class.Members.Add(new CodeSnippetTypeMember(" #pragma warning disable 1591"));
+
+ gl_class.Members.Add(new CodeSnippetTypeMember(
+@"
+ #region Private Constants
+
+ #region string GL_NATIVE_LIBRARY
+ ///
+ /// Specifies OpenGl's native library archive.
+ ///
+ ///
+ /// Specifies opengl32.dll everywhere; will be mapped via .config for mono.
+ ///
+ internal const string GL_NATIVE_LIBRARY = ""opengl32.dll"";
+ #endregion string GL_NATIVE_LIBRARY
+
+ #endregion Private Constants
+"));
+ /*
+ if (constants.Count > 0)
+ {
+ constants[0].StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "OpenGL constants"));
+ constants[constants.Count - 1].EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "OpenGL constants"));
+ }
+ gl_class.Members.AddRange(constants.ToArray());
+ */
+ if (functions.Count > 0)
+ {
+ functions[0].StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, "OpenGL functions"));
+ functions[functions.Count - 1].EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, "OpenGL functions"));
+ }
+ gl_class.Members.AddRange(functions.ToArray());
+
+ return gl_class;
+ }
+ #endregion
+
+ #region private static CodeTypeDeclaration GenerateDelegatesClass(List delegates)
+ private static CodeTypeDeclaration GenerateDelegatesClass(List delegates)
+ {
+ CodeTypeDeclaration delegate_class = new CodeTypeDeclaration("Delegates");
+ delegate_class.TypeAttributes = System.Reflection.TypeAttributes.NotPublic;
+
+ CodeStatementCollection statements = new CodeStatementCollection();
+
+ foreach (CodeTypeDelegate d in delegates)
+ {
+ // Hack - turn FieldDirection.Out parameters to FieldDirection.In. The parameter flow
+ // is handle by the [In, Out()] parameter attribute.
+ foreach (CodeParameterDeclarationExpression p in d.Parameters)
+ {
+ p.Direction = FieldDirection.In;
+ }
+ delegate_class.Members.Add(d);
+
+ CodeMemberField m = new CodeMemberField();
+ m.Name = "gl" + d.Name;
+ m.Type = new CodeTypeReference(d.Name);
+ m.Attributes = MemberAttributes.Public | MemberAttributes.Static;
+
+ //m.InitExpression =
+ //new CodeCastExpression(
+ // "Delegates." + d.Name,
+ // new CodeMethodInvokeExpression(
+ // new CodeMethodReferenceExpression(
+ // new CodeTypeReferenceExpression(Properties.Bind.Default.OutputClass),
+ // "GetDelegateForExtensionMethod"
+ // ),
+ // new CodeExpression[] {
+ // new CodeSnippetExpression("\"gl" + d.Name + "\""),
+ // new CodeTypeOfExpression("Delegates." + d.Name)
+ // }
+ // )
+ //);
+
+ // Hack - generate inline initialisers in the form:
+ // public static Accum glAccum = GetDelegate[...] ?? new Accum(Imports.Accum);
+ CodeSnippetExpression expr = new CodeSnippetExpression();
+ //expr.Value = "public static " + d.Name + " gl" + d.Name + " = ";
+ expr.Value +=
+ "((" + d.Name + ")(" + Settings.GLClass +".GetDelegateForExtensionMethod(\"" + "gl" + d.Name + "\", typeof(" + d.Name + "))))";
+ if (d.UserData.Contains("Extension") && !(bool)d.UserData["Extension"])
+ {
+ expr.Value += " ?? ";
+ expr.Value += "new " + d.Name + "(Imports." + d.Name + ")";
+ }
+
+ m.InitExpression = expr;
+ delegate_class.Members.Add(m);
+
+ /*
+ if (!(bool)d.UserData["Extension"])
+ {
+ statements.Add(
+ new CodeSnippetExpression(
+ "Delegates.gl" + d.Name + " = Delegates.gl" + d.Name + " ?? new Delegates." + d.Name + "(Imports." + d.Name + ")"
+ )
+ );
+ }
+ */
+ }
+
+ // Disable BeforeFieldInit attribute and initialize OpenGL core.
+ CodeTypeConstructor con = new CodeTypeConstructor();
+ //con.Statements.AddRange(statements);
+ delegate_class.Members.Add(con);
+
+ delegate_class.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, delegate_class.Name));
+ delegate_class.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, delegate_class.Name));
+
+ return delegate_class;
+ }
+ #endregion
+
+ #region private static CodeTypeDeclaration GenerateImportsClass(List delegates)
+ private static CodeTypeDeclaration GenerateImportsClass(List delegates)
+ {
+ CodeTypeDeclaration import_class = new CodeTypeDeclaration("Imports");
+ import_class.TypeAttributes = System.Reflection.TypeAttributes.NotPublic;
+ import_class.Members.Add(new CodeTypeConstructor());
+
+ foreach (CodeTypeDelegate d in delegates)
+ {
+ if (!(bool)d.UserData["Extension"])
+ {
+ CodeMemberMethodImport m = new CodeMemberMethodImport();
+
+ m.Name = d.Name;
+ m.CustomAttributes.Add(new CodeAttributeDeclaration("System.Security.SuppressUnmanagedCodeSecurity()"));
+ m.CustomAttributes.Add(
+ new CodeAttributeDeclaration(
+ "DllImport(" + Settings.GLClass + ".GL_NATIVE_LIBRARY, EntryPoint = \"" + "gl" + m.Name + "\", ExactSpelling = true)"
+ )
+ );
+ m.Parameters.AddRange(d.Parameters);
+ m.ReturnType = d.ReturnType;
+
+ import_class.Members.Add(new CodeSnippetTypeMember(m.Text));
+
+ }
+ }
+
+ import_class.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, import_class.Name));
+ import_class.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, import_class.Name));
+
+ return import_class;
+ }
+ #endregion
+ }
+
+ #region class CodeMemberMethodImport : CodeMemberMethod
+ ///
+ /// A hack to create the C# code for a DllImported function;
+ /// CodeDom does not directly support static extern methods.
+ ///
+ class CodeMemberMethodImport : CodeMemberMethod
+ {
+ public string Text
+ {
+ get
+ {
+ string s;
+ //m.Attributes = MemberAttributes.Static | MemberAttributes.Public;
+ s = " #region " + this.Name + Environment.NewLine;
+ s += " [System.Security.SuppressUnmanagedCodeSecurity()]" + Environment.NewLine;
+ s += " [DllImport(" + Settings.GLClass + ".GL_NATIVE_LIBRARY, EntryPoint = \"" + "gl" + this.Name + "\", ExactSpelling = true)]" + Environment.NewLine;
+ s += " public extern static ";
+ if (this.ReturnType.BaseType == "System.Void")
+ {
+ s += "void";
+ }
+ else
+ {
+ s += this.ReturnType.BaseType;
+ }
+
+ s += " " + this.Name + "(";
+ foreach (CodeParameterDeclarationExpression p in this.Parameters)
+ {
+ s += p.Type.BaseType;
+ if (p.Type.ArrayRank > 0)
+ s += "[]";
+ s += " ";
+ if (p.Name == "base")
+ s += "@base";
+ else if (p.Name == "params")
+ s += "@params";
+ else if (p.Name == "string")
+ s += "@string";
+ else if (p.Name == "ref")
+ s += "@ref";
+ else
+ s += p.Name;
+ s += ", ";
+ }
+ s = s.TrimEnd(',', ' ') + ");" + Environment.NewLine;
+ s += " #endregion" + Environment.NewLine;
+
+ return s;
+ }
+ }
+ }
+ #endregion
+}
diff --git a/Source/Bind/Specifications/csharp.tm b/Source/Bind/Specifications/csharp.tm
new file mode 100644
index 00000000..88ac6d15
--- /dev/null
+++ b/Source/Bind/Specifications/csharp.tm
@@ -0,0 +1,35 @@
+# Normal types.
+GLsizei, Int32
+GLsizeiptr, IntPtr
+GLintptr, IntPtr
+# GLenum, Int32
+GLboolean, Boolean #Int32 #Boolean
+GLbitfield, Int32 #UInt32
+# GLvoid*, IntPtr
+GLvoid, Object
+GLchar, Char
+GLbyte, Byte #SByte
+GLubyte, Byte
+GLshort, Int16
+GLushort, Int16 #UInt16
+GLint, Int32
+GLuint, Int32 #UInt32
+GLfloat, Single
+GLclampf, Single
+GLdouble, Double
+GLclampd, Double
+GLstring, String
+
+# ARB and NV types.
+GLsizeiptrARB, IntPtr
+GLintptrARB, IntPtr
+GLhandleARB, Int32 #UInt32
+GLhalfARB, Int16 #UInt16
+GLhalfNV, Int16 #UInt16
+GLcharARB, Char
+
+# 64 bit types (introduced in 2.1)
+GLint64EXT, Int64
+GLuint64EXT, Int64
+GLint64, Int64
+GLuint64, Int64
diff --git a/Source/Bind/Specifications/enum.spec b/Source/Bind/Specifications/enum.spec
new file mode 100644
index 00000000..6069fe44
--- /dev/null
+++ b/Source/Bind/Specifications/enum.spec
@@ -0,0 +1,5868 @@
+# This is the OpenGL and OpenGL ES enumerant registry.
+#
+# It is an extremely important file. Do not mess with it unless
+# you know what you're doing and have permission to do so.
+#
+###############################################################################
+#
+# Before modifying this file, read the following:
+#
+# ONLY the Khronos API Registrar (Jon Leech, jon 'at' alumni.caltech.edu)
+# may allocate new enumerants outside the 'experimental' range described
+# below. Any modifications to this file not performed by the Registrar
+# are incompatible with the OpenGL API. The master copy of the registry,
+# showing up-to-date enumerant allocations, is maintained in the
+# OpenGL registry at
+#
+# http://www.opengl.org/registry/
+#
+# The following guidelines are thus only for reference purposes
+# (unless you're the Registrar)
+#
+# Enumerant values for extensions CANNOT be chosen arbitrarily, since
+# the enumerant value space is shared by all GL implementations. It is
+# therefore imperative that the procedures described in this file be
+# followed carefully when allocating extension enum values.
+#
+# - Use tabs, not spaces.
+#
+# - When adding enum values for a new extension, use existing extensions
+# as a guide.
+#
+# - When a vendor has committed to releasing a new extension and needs to
+# allocate enum values for that extension, the vendor may request that the
+# ARB allocate a previously unallocated block of 16 enum values, in the
+# range 0x8000-0xFFFF, for the vendor's exclusive use.
+#
+# - The vendor that introduces an extension will allocate enum values for
+# it as if it is a single-vendor extension, even if it is a multi-vendor
+# (EXT) extension.
+#
+# - The file enum.spec is primarily a reference. The file enumext.spec
+# contains enumerants for all OpenGL 1.2 and OpenGL extensions in a form
+# used to generate .
+#
+# - If a vendor hasn't yet released an extension, just add a comment to
+# enum.spec that contains the name of the extension and the range of enum
+# values used by the extension. When the vendor releases the extension,
+# put the actual enum assignments in enum.spec and enumext.spec.
+#
+# - Allocate all of the enum values for an extension in a single contiguous
+# block.
+#
+# - If an extension is experimental, allocate temporary enum values in the
+# range 0x6000-0x8000 during development work. When the vendor commits to
+# releasing the extension, allocate permanent enum values (see below).
+# There are two reasons for this policy:
+#
+# 1. It is desirable to keep extension enum values tightly packed and to
+# make all of the enum values for an extension be contiguous. This is
+# possible only if permanent enum values for a new extension are not
+# allocated until the extension spec is stable and the number of new
+# enum values needed by the extension has therefore stopped changing.
+#
+# 2. OpenGL ARB policy is that a vendor may allocate a new block of 16
+# extension enum values only if it has committed to releasing an
+# extension that will use values in that block.
+#
+# - To allocate a new block of permanent enum values for an extension, do the
+# following:
+#
+# 1. Start at the top of enum.spec and choose the first future_use
+# range that is not allocated to another vendor and is large enough
+# to contain the new block. This will almost certainly be the
+# 'Any_vendor_future_use' range near the end of enum.spec. This
+# process helps keep allocated enum values tightly packed into
+# the start of the 0x8000-0xFFFF range.
+#
+# 2. Allocate a block of enum values at the start of this range. If
+# the enum definitions are going into enumfuture.spec, add a comment
+# to enum.spec that contains the name of the extension and the range
+# of values in the new block. Use existing extensions as a guide.
+#
+# 3. Add the size of the block you just allocated to the start of the
+# chosen future_use range. If you have allocated the entire range,
+# eliminate its future_use entry.
+#
+# 4. Note that there are historical enum allocations above 0xFFFF, but
+# no new allocations will be made there in the forseeable future.
+#
+###############################################################################
+
+Extensions define:
+ VERSION_1_1 = 1
+ VERSION_1_2 = 1
+ VERSION_1_3 = 1
+ VERSION_1_4 = 1
+ VERSION_1_5 = 1
+ ARB_imaging = 1
+ EXT_abgr = 1
+ EXT_blend_color = 1
+ EXT_blend_logic_op = 1
+ EXT_blend_minmax = 1
+ EXT_blend_subtract = 1
+ EXT_cmyka = 1
+ EXT_convolution = 1
+ EXT_copy_texture = 1
+ EXT_histogram = 1
+ EXT_packed_pixels = 1
+ EXT_point_parameters = 1
+ EXT_polygon_offset = 1
+ EXT_rescale_normal = 1
+ EXT_shared_texture_palette = 1
+ EXT_subtexture = 1
+ EXT_texture = 1
+ EXT_texture3D = 1
+ EXT_texture_object = 1
+ EXT_vertex_array = 1
+ SGIS_detail_texture = 1
+ SGIS_fog_function = 1
+ SGIS_generate_mipmap = 1
+ SGIS_multisample = 1
+ SGIS_pixel_texture = 1
+ SGIS_point_line_texgen = 1
+ SGIS_point_parameters = 1
+ SGIS_sharpen_texture = 1
+ SGIS_texture4D = 1
+ SGIS_texture_border_clamp = 1
+ SGIS_texture_edge_clamp = 1
+ SGIS_texture_filter4 = 1
+ SGIS_texture_lod = 1
+ SGIS_texture_select = 1
+ SGIX_async = 1
+ SGIX_async_histogram = 1
+ SGIX_async_pixel = 1
+ SGIX_blend_alpha_minmax = 1
+ SGIX_calligraphic_fragment = 1
+ SGIX_clipmap = 1
+ SGIX_convolution_accuracy = 1
+ SGIX_depth_texture = 1
+ SGIX_flush_raster = 1
+ SGIX_fog_offset = 1
+ SGIX_fragment_lighting = 1
+ SGIX_framezoom = 1
+ SGIX_icc_texture = 1
+ SGIX_impact_pixel_texture = 1
+ SGIX_instruments = 1
+ SGIX_interlace = 1
+ SGIX_ir_instrument1 = 1
+ SGIX_list_priority = 1
+ SGIX_pixel_texture = 1
+ SGIX_pixel_tiles = 1
+ SGIX_polynomial_ffd = 1
+ SGIX_reference_plane = 1
+ SGIX_resample = 1
+ SGIX_scalebias_hint = 1
+ SGIX_shadow = 1
+ SGIX_shadow_ambient = 1
+ SGIX_sprite = 1
+ SGIX_subsample = 1
+ SGIX_tag_sample_buffer = 1
+ SGIX_texture_add_env = 1
+ SGIX_texture_coordinate_clamp = 1
+ SGIX_texture_lod_bias = 1
+ SGIX_texture_multi_buffer = 1
+ SGIX_texture_scale_bias = 1
+ SGIX_vertex_preclip = 1
+ SGIX_ycrcb = 1
+ SGI_color_matrix = 1
+ SGI_color_table = 1
+ SGI_texture_color_table = 1
+
+###############################################################################
+
+AttribMask enum:
+ CURRENT_BIT = 0x00000001
+ POINT_BIT = 0x00000002
+ LINE_BIT = 0x00000004
+ POLYGON_BIT = 0x00000008
+ POLYGON_STIPPLE_BIT = 0x00000010
+ PIXEL_MODE_BIT = 0x00000020
+ LIGHTING_BIT = 0x00000040
+ FOG_BIT = 0x00000080
+ DEPTH_BUFFER_BIT = 0x00000100
+ ACCUM_BUFFER_BIT = 0x00000200
+ STENCIL_BUFFER_BIT = 0x00000400
+ VIEWPORT_BIT = 0x00000800
+ TRANSFORM_BIT = 0x00001000
+ ENABLE_BIT = 0x00002000
+ COLOR_BUFFER_BIT = 0x00004000
+ HINT_BIT = 0x00008000
+ EVAL_BIT = 0x00010000
+ LIST_BIT = 0x00020000
+ TEXTURE_BIT = 0x00040000
+ SCISSOR_BIT = 0x00080000
+ ALL_ATTRIB_BITS = 0xFFFFFFFF
+#??? ALL_ATTRIB_BITS mask value changed to all-1s in OpenGL 1.3 - this affects covgl.
+# use ARB_multisample MULTISAMPLE_BIT_ARB
+# use EXT_multisample MULTISAMPLE_BIT_EXT
+# use 3DFX_multisample MULTISAMPLE_BIT_3DFX
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# ARB_multisample enum:
+# MULTISAMPLE_BIT = 0x20000000
+# MULTISAMPLE_BIT_ARB = 0x20000000
+
+# EXT_multisample enum:
+# MULTISAMPLE_BIT_EXT = 0x20000000
+
+# 3DFX_multisample enum:
+# MULTISAMPLE_BIT_3DFX = 0x20000000
+
+###############################################################################
+
+ClearBufferMask enum:
+ use AttribMask COLOR_BUFFER_BIT
+ use AttribMask ACCUM_BUFFER_BIT
+ use AttribMask STENCIL_BUFFER_BIT
+ use AttribMask DEPTH_BUFFER_BIT
+
+###############################################################################
+
+ClientAttribMask enum:
+ CLIENT_PIXEL_STORE_BIT = 0x00000001
+ CLIENT_VERTEX_ARRAY_BIT = 0x00000002
+ CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF
+
+###############################################################################
+
+Boolean enum:
+ FALSE = 0
+ TRUE = 1
+
+###############################################################################
+
+BeginMode enum:
+ POINTS = 0x0000
+ LINES = 0x0001
+ LINE_LOOP = 0x0002
+ LINE_STRIP = 0x0003
+ TRIANGLES = 0x0004
+ TRIANGLE_STRIP = 0x0005
+ TRIANGLE_FAN = 0x0006
+ QUADS = 0x0007
+ QUAD_STRIP = 0x0008
+ POLYGON = 0x0009
+# NV_geometry_program4 enum: (additional; see below)
+# LINES_ADJACENCY_EXT = 0x000A
+# LINE_STRIP_ADJACENCY_EXT = 0x000B
+# TRIANGLES_ADJACENCY_EXT = 0x000C
+# TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D
+
+###############################################################################
+
+AccumOp enum:
+ ACCUM = 0x0100
+ LOAD = 0x0101
+ RETURN = 0x0102
+ MULT = 0x0103
+ ADD = 0x0104
+
+###############################################################################
+
+AlphaFunction enum:
+ NEVER = 0x0200
+ LESS = 0x0201
+ EQUAL = 0x0202
+ LEQUAL = 0x0203
+ GREATER = 0x0204
+ NOTEQUAL = 0x0205
+ GEQUAL = 0x0206
+ ALWAYS = 0x0207
+
+###############################################################################
+
+BlendingFactorDest enum:
+ ZERO = 0
+ ONE = 1
+ SRC_COLOR = 0x0300
+ ONE_MINUS_SRC_COLOR = 0x0301
+ SRC_ALPHA = 0x0302
+ ONE_MINUS_SRC_ALPHA = 0x0303
+ DST_ALPHA = 0x0304
+ ONE_MINUS_DST_ALPHA = 0x0305
+ use EXT_blend_color CONSTANT_COLOR_EXT
+ use EXT_blend_color ONE_MINUS_CONSTANT_COLOR_EXT
+ use EXT_blend_color CONSTANT_ALPHA_EXT
+ use EXT_blend_color ONE_MINUS_CONSTANT_ALPHA_EXT
+
+###############################################################################
+
+BlendingFactorSrc enum:
+ use BlendingFactorDest ZERO
+ use BlendingFactorDest ONE
+ DST_COLOR = 0x0306
+ ONE_MINUS_DST_COLOR = 0x0307
+ SRC_ALPHA_SATURATE = 0x0308
+ use BlendingFactorDest SRC_ALPHA
+ use BlendingFactorDest ONE_MINUS_SRC_ALPHA
+ use BlendingFactorDest DST_ALPHA
+ use BlendingFactorDest ONE_MINUS_DST_ALPHA
+ use EXT_blend_color CONSTANT_COLOR_EXT
+ use EXT_blend_color ONE_MINUS_CONSTANT_COLOR_EXT
+ use EXT_blend_color CONSTANT_ALPHA_EXT
+ use EXT_blend_color ONE_MINUS_CONSTANT_ALPHA_EXT
+
+###############################################################################
+
+BlendEquationModeEXT enum:
+ use GetPName LOGIC_OP
+ use EXT_blend_minmax FUNC_ADD_EXT
+ use EXT_blend_minmax MIN_EXT
+ use EXT_blend_minmax MAX_EXT
+ use EXT_blend_subtract FUNC_SUBTRACT_EXT
+ use EXT_blend_subtract FUNC_REVERSE_SUBTRACT_EXT
+ use SGIX_blend_alpha_minmax ALPHA_MIN_SGIX
+ use SGIX_blend_alpha_minmax ALPHA_MAX_SGIX
+
+###############################################################################
+
+ColorMaterialFace enum:
+ use DrawBufferMode FRONT
+ use DrawBufferMode BACK
+ use DrawBufferMode FRONT_AND_BACK
+
+###############################################################################
+
+ColorMaterialParameter enum:
+ use LightParameter AMBIENT
+ use LightParameter DIFFUSE
+ use LightParameter SPECULAR
+ use MaterialParameter EMISSION
+ use MaterialParameter AMBIENT_AND_DIFFUSE
+
+###############################################################################
+
+ColorPointerType enum:
+ use DataType BYTE
+ use DataType UNSIGNED_BYTE
+ use DataType SHORT
+ use DataType UNSIGNED_SHORT
+ use DataType INT
+ use DataType UNSIGNED_INT
+ use DataType FLOAT
+ use DataType DOUBLE
+
+###############################################################################
+
+ColorTableParameterPNameSGI enum:
+ use SGI_color_table COLOR_TABLE_SCALE_SGI
+ use SGI_color_table COLOR_TABLE_BIAS_SGI
+
+###############################################################################
+
+ColorTableTargetSGI enum:
+ use SGI_color_table COLOR_TABLE_SGI
+ use SGI_color_table POST_CONVOLUTION_COLOR_TABLE_SGI
+ use SGI_color_table POST_COLOR_MATRIX_COLOR_TABLE_SGI
+ use SGI_color_table PROXY_COLOR_TABLE_SGI
+ use SGI_color_table PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI
+ use SGI_color_table PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI
+ use SGI_texture_color_table TEXTURE_COLOR_TABLE_SGI
+ use SGI_texture_color_table PROXY_TEXTURE_COLOR_TABLE_SGI
+
+###############################################################################
+
+ConvolutionBorderModeEXT enum:
+ use EXT_convolution REDUCE_EXT
+
+###############################################################################
+
+ConvolutionParameterEXT enum:
+ use EXT_convolution CONVOLUTION_BORDER_MODE_EXT
+ use EXT_convolution CONVOLUTION_FILTER_SCALE_EXT
+ use EXT_convolution CONVOLUTION_FILTER_BIAS_EXT
+
+###############################################################################
+
+ConvolutionTargetEXT enum:
+ use EXT_convolution CONVOLUTION_1D_EXT
+ use EXT_convolution CONVOLUTION_2D_EXT
+
+###############################################################################
+
+CullFaceMode enum:
+ use DrawBufferMode FRONT
+ use DrawBufferMode BACK
+ use DrawBufferMode FRONT_AND_BACK
+
+###############################################################################
+
+DepthFunction enum:
+ use AlphaFunction NEVER
+ use AlphaFunction LESS
+ use AlphaFunction EQUAL
+ use AlphaFunction LEQUAL
+ use AlphaFunction GREATER
+ use AlphaFunction NOTEQUAL
+ use AlphaFunction GEQUAL
+ use AlphaFunction ALWAYS
+
+###############################################################################
+
+DrawBufferMode enum:
+ NONE = 0
+ FRONT_LEFT = 0x0400
+ FRONT_RIGHT = 0x0401
+ BACK_LEFT = 0x0402
+ BACK_RIGHT = 0x0403
+ FRONT = 0x0404
+ BACK = 0x0405
+ LEFT = 0x0406
+ RIGHT = 0x0407
+ FRONT_AND_BACK = 0x0408
+ AUX0 = 0x0409
+ AUX1 = 0x040A
+ AUX2 = 0x040B
+ AUX3 = 0x040C
+
+###############################################################################
+
+EnableCap enum:
+ use GetPName FOG
+ use GetPName LIGHTING
+ use GetPName TEXTURE_1D
+ use GetPName TEXTURE_2D
+ use GetPName LINE_STIPPLE
+ use GetPName POLYGON_STIPPLE
+ use GetPName CULL_FACE
+ use GetPName ALPHA_TEST
+ use GetPName BLEND
+ use GetPName INDEX_LOGIC_OP
+ use GetPName COLOR_LOGIC_OP
+ use GetPName DITHER
+ use GetPName STENCIL_TEST
+ use GetPName DEPTH_TEST
+ use GetPName CLIP_PLANE0
+ use GetPName CLIP_PLANE1
+ use GetPName CLIP_PLANE2
+ use GetPName CLIP_PLANE3
+ use GetPName CLIP_PLANE4
+ use GetPName CLIP_PLANE5
+ use GetPName LIGHT0
+ use GetPName LIGHT1
+ use GetPName LIGHT2
+ use GetPName LIGHT3
+ use GetPName LIGHT4
+ use GetPName LIGHT5
+ use GetPName LIGHT6
+ use GetPName LIGHT7
+ use GetPName TEXTURE_GEN_S
+ use GetPName TEXTURE_GEN_T
+ use GetPName TEXTURE_GEN_R
+ use GetPName TEXTURE_GEN_Q
+ use GetPName MAP1_VERTEX_3
+ use GetPName MAP1_VERTEX_4
+ use GetPName MAP1_COLOR_4
+ use GetPName MAP1_INDEX
+ use GetPName MAP1_NORMAL
+ use GetPName MAP1_TEXTURE_COORD_1
+ use GetPName MAP1_TEXTURE_COORD_2
+ use GetPName MAP1_TEXTURE_COORD_3
+ use GetPName MAP1_TEXTURE_COORD_4
+ use GetPName MAP2_VERTEX_3
+ use GetPName MAP2_VERTEX_4
+ use GetPName MAP2_COLOR_4
+ use GetPName MAP2_INDEX
+ use GetPName MAP2_NORMAL
+ use GetPName MAP2_TEXTURE_COORD_1
+ use GetPName MAP2_TEXTURE_COORD_2
+ use GetPName MAP2_TEXTURE_COORD_3
+ use GetPName MAP2_TEXTURE_COORD_4
+ use GetPName POINT_SMOOTH
+ use GetPName LINE_SMOOTH
+ use GetPName POLYGON_SMOOTH
+ use GetPName SCISSOR_TEST
+ use GetPName COLOR_MATERIAL
+ use GetPName NORMALIZE
+ use GetPName AUTO_NORMAL
+ use GetPName POLYGON_OFFSET_POINT
+ use GetPName POLYGON_OFFSET_LINE
+ use GetPName POLYGON_OFFSET_FILL
+ use GetPName VERTEX_ARRAY
+ use GetPName NORMAL_ARRAY
+ use GetPName COLOR_ARRAY
+ use GetPName INDEX_ARRAY
+ use GetPName TEXTURE_COORD_ARRAY
+ use GetPName EDGE_FLAG_ARRAY
+ use EXT_convolution CONVOLUTION_1D_EXT
+ use EXT_convolution CONVOLUTION_2D_EXT
+ use EXT_convolution SEPARABLE_2D_EXT
+ use EXT_histogram HISTOGRAM_EXT
+ use EXT_histogram MINMAX_EXT
+ use EXT_rescale_normal RESCALE_NORMAL_EXT
+ use EXT_shared_texture_palette SHARED_TEXTURE_PALETTE_EXT
+ use EXT_texture3D TEXTURE_3D_EXT
+ use SGIS_multisample MULTISAMPLE_SGIS
+ use SGIS_multisample SAMPLE_ALPHA_TO_MASK_SGIS
+ use SGIS_multisample SAMPLE_ALPHA_TO_ONE_SGIS
+ use SGIS_multisample SAMPLE_MASK_SGIS
+ use SGIS_texture4D TEXTURE_4D_SGIS
+ use SGIX_async_histogram ASYNC_HISTOGRAM_SGIX
+ use SGIX_async_pixel ASYNC_TEX_IMAGE_SGIX
+ use SGIX_async_pixel ASYNC_DRAW_PIXELS_SGIX
+ use SGIX_async_pixel ASYNC_READ_PIXELS_SGIX
+ use SGIX_calligraphic_fragment CALLIGRAPHIC_FRAGMENT_SGIX
+ use SGIX_fog_offset FOG_OFFSET_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHTING_SGIX
+ use SGIX_fragment_lighting FRAGMENT_COLOR_MATERIAL_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT0_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT1_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT2_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT3_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT4_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT5_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT6_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT7_SGIX
+ use SGIX_framezoom FRAMEZOOM_SGIX
+ use SGIX_interlace INTERLACE_SGIX
+ use SGIX_ir_instrument1 IR_INSTRUMENT1_SGIX
+ use SGIX_pixel_texture PIXEL_TEX_GEN_SGIX
+ use SGIS_pixel_texture PIXEL_TEXTURE_SGIS
+ use SGIX_reference_plane REFERENCE_PLANE_SGIX
+ use SGIX_sprite SPRITE_SGIX
+ use SGI_color_table COLOR_TABLE_SGI
+ use SGI_color_table POST_CONVOLUTION_COLOR_TABLE_SGI
+ use SGI_color_table POST_COLOR_MATRIX_COLOR_TABLE_SGI
+ use SGI_texture_color_table TEXTURE_COLOR_TABLE_SGI
+
+###############################################################################
+
+ErrorCode enum:
+ NO_ERROR = 0
+ INVALID_ENUM = 0x0500
+ INVALID_VALUE = 0x0501
+ INVALID_OPERATION = 0x0502
+ STACK_OVERFLOW = 0x0503
+ STACK_UNDERFLOW = 0x0504
+ OUT_OF_MEMORY = 0x0505
+ use EXT_histogram TABLE_TOO_LARGE_EXT
+ use EXT_texture TEXTURE_TOO_LARGE_EXT
+
+# Additional error code
+# EXT_framebuffer_object enum:
+# INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506
+
+###############################################################################
+
+FeedbackType enum:
+ 2D = 0x0600
+ 3D = 0x0601
+ 3D_COLOR = 0x0602
+ 3D_COLOR_TEXTURE = 0x0603
+ 4D_COLOR_TEXTURE = 0x0604
+
+###############################################################################
+
+FeedBackToken enum:
+ PASS_THROUGH_TOKEN = 0x0700
+ POINT_TOKEN = 0x0701
+ LINE_TOKEN = 0x0702
+ POLYGON_TOKEN = 0x0703
+ BITMAP_TOKEN = 0x0704
+ DRAW_PIXEL_TOKEN = 0x0705
+ COPY_PIXEL_TOKEN = 0x0706
+ LINE_RESET_TOKEN = 0x0707
+
+###############################################################################
+
+FfdMaskSGIX enum:
+ TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001
+ GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002
+
+###############################################################################
+
+FfdTargetSGIX enum:
+ use SGIX_polynomial_ffd GEOMETRY_DEFORMATION_SGIX
+ use SGIX_polynomial_ffd TEXTURE_DEFORMATION_SGIX
+
+###############################################################################
+
+FogMode enum:
+ use TextureMagFilter LINEAR
+ EXP = 0x0800
+ EXP2 = 0x0801
+ use SGIS_fog_function FOG_FUNC_SGIS
+
+###############################################################################
+
+FogParameter enum:
+ use GetPName FOG_COLOR
+ use GetPName FOG_DENSITY
+ use GetPName FOG_END
+ use GetPName FOG_INDEX
+ use GetPName FOG_MODE
+ use GetPName FOG_START
+ use SGIX_fog_offset FOG_OFFSET_VALUE_SGIX
+
+###############################################################################
+
+FragmentLightModelParameterSGIX enum:
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX
+
+###############################################################################
+
+FrontFaceDirection enum:
+ CW = 0x0900
+ CCW = 0x0901
+
+###############################################################################
+
+GetColorTableParameterPNameSGI enum:
+ use SGI_color_table COLOR_TABLE_SCALE_SGI
+ use SGI_color_table COLOR_TABLE_BIAS_SGI
+ use SGI_color_table COLOR_TABLE_FORMAT_SGI
+ use SGI_color_table COLOR_TABLE_WIDTH_SGI
+ use SGI_color_table COLOR_TABLE_RED_SIZE_SGI
+ use SGI_color_table COLOR_TABLE_GREEN_SIZE_SGI
+ use SGI_color_table COLOR_TABLE_BLUE_SIZE_SGI
+ use SGI_color_table COLOR_TABLE_ALPHA_SIZE_SGI
+ use SGI_color_table COLOR_TABLE_LUMINANCE_SIZE_SGI
+ use SGI_color_table COLOR_TABLE_INTENSITY_SIZE_SGI
+
+###############################################################################
+
+GetConvolutionParameter enum:
+ use EXT_convolution CONVOLUTION_BORDER_MODE_EXT
+ use EXT_convolution CONVOLUTION_FILTER_SCALE_EXT
+ use EXT_convolution CONVOLUTION_FILTER_BIAS_EXT
+ use EXT_convolution CONVOLUTION_FORMAT_EXT
+ use EXT_convolution CONVOLUTION_WIDTH_EXT
+ use EXT_convolution CONVOLUTION_HEIGHT_EXT
+ use EXT_convolution MAX_CONVOLUTION_WIDTH_EXT
+ use EXT_convolution MAX_CONVOLUTION_HEIGHT_EXT
+
+###############################################################################
+
+GetHistogramParameterPNameEXT enum:
+ use EXT_histogram HISTOGRAM_WIDTH_EXT
+ use EXT_histogram HISTOGRAM_FORMAT_EXT
+ use EXT_histogram HISTOGRAM_RED_SIZE_EXT
+ use EXT_histogram HISTOGRAM_GREEN_SIZE_EXT
+ use EXT_histogram HISTOGRAM_BLUE_SIZE_EXT
+ use EXT_histogram HISTOGRAM_ALPHA_SIZE_EXT
+ use EXT_histogram HISTOGRAM_LUMINANCE_SIZE_EXT
+ use EXT_histogram HISTOGRAM_SINK_EXT
+
+###############################################################################
+
+GetMapQuery enum:
+ COEFF = 0x0A00
+ ORDER = 0x0A01
+ DOMAIN = 0x0A02
+
+###############################################################################
+
+GetMinmaxParameterPNameEXT enum:
+ use EXT_histogram MINMAX_FORMAT_EXT
+ use EXT_histogram MINMAX_SINK_EXT
+
+###############################################################################
+
+GetPixelMap enum:
+ PIXEL_MAP_I_TO_I = 0x0C70
+ PIXEL_MAP_S_TO_S = 0x0C71
+ PIXEL_MAP_I_TO_R = 0x0C72
+ PIXEL_MAP_I_TO_G = 0x0C73
+ PIXEL_MAP_I_TO_B = 0x0C74
+ PIXEL_MAP_I_TO_A = 0x0C75
+ PIXEL_MAP_R_TO_R = 0x0C76
+ PIXEL_MAP_G_TO_G = 0x0C77
+ PIXEL_MAP_B_TO_B = 0x0C78
+ PIXEL_MAP_A_TO_A = 0x0C79
+
+###############################################################################
+
+GetPointervPName enum:
+ VERTEX_ARRAY_POINTER = 0x808E
+ NORMAL_ARRAY_POINTER = 0x808F
+ COLOR_ARRAY_POINTER = 0x8090
+ INDEX_ARRAY_POINTER = 0x8091
+ TEXTURE_COORD_ARRAY_POINTER = 0x8092
+ EDGE_FLAG_ARRAY_POINTER = 0x8093
+ FEEDBACK_BUFFER_POINTER = 0x0DF0
+ SELECTION_BUFFER_POINTER = 0x0DF3
+ use SGIX_instruments INSTRUMENT_BUFFER_POINTER_SGIX
+
+###############################################################################
+
+# the columns after the comment symbol (#) indicate: number of params, type
+# (F - float, D - double, I - integer) for the returned values
+GetPName enum:
+ CURRENT_COLOR = 0x0B00 # 4 F
+ CURRENT_INDEX = 0x0B01 # 1 F
+ CURRENT_NORMAL = 0x0B02 # 3 F
+ CURRENT_TEXTURE_COORDS = 0x0B03 # 4 F
+ CURRENT_RASTER_COLOR = 0x0B04 # 4 F
+ CURRENT_RASTER_INDEX = 0x0B05 # 1 F
+ CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 # 4 F
+ CURRENT_RASTER_POSITION = 0x0B07 # 4 F
+ CURRENT_RASTER_POSITION_VALID = 0x0B08 # 1 I
+ CURRENT_RASTER_DISTANCE = 0x0B09 # 1 F
+
+ POINT_SMOOTH = 0x0B10 # 1 I
+ POINT_SIZE = 0x0B11 # 1 F
+ POINT_SIZE_RANGE = 0x0B12 # 2 F
+ POINT_SIZE_GRANULARITY = 0x0B13 # 1 F
+
+ LINE_SMOOTH = 0x0B20 # 1 I
+ LINE_WIDTH = 0x0B21 # 1 F
+ LINE_WIDTH_RANGE = 0x0B22 # 2 F
+ LINE_WIDTH_GRANULARITY = 0x0B23 # 1 F
+ LINE_STIPPLE = 0x0B24 # 1 I
+ LINE_STIPPLE_PATTERN = 0x0B25 # 1 I
+ LINE_STIPPLE_REPEAT = 0x0B26 # 1 I
+ use VERSION_1_2 SMOOTH_POINT_SIZE_RANGE
+ use VERSION_1_2 SMOOTH_POINT_SIZE_GRANULARITY
+ use VERSION_1_2 SMOOTH_LINE_WIDTH_RANGE
+ use VERSION_1_2 SMOOTH_LINE_WIDTH_GRANULARITY
+ use VERSION_1_2 ALIASED_POINT_SIZE_RANGE
+ use VERSION_1_2 ALIASED_LINE_WIDTH_RANGE
+
+ LIST_MODE = 0x0B30 # 1 I
+ MAX_LIST_NESTING = 0x0B31 # 1 I
+ LIST_BASE = 0x0B32 # 1 I
+ LIST_INDEX = 0x0B33 # 1 I
+
+ POLYGON_MODE = 0x0B40 # 2 I
+ POLYGON_SMOOTH = 0x0B41 # 1 I
+ POLYGON_STIPPLE = 0x0B42 # 1 I
+ EDGE_FLAG = 0x0B43 # 1 I
+ CULL_FACE = 0x0B44 # 1 I
+ CULL_FACE_MODE = 0x0B45 # 1 I
+ FRONT_FACE = 0x0B46 # 1 I
+
+ LIGHTING = 0x0B50 # 1 I
+ LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 # 1 I
+ LIGHT_MODEL_TWO_SIDE = 0x0B52 # 1 I
+ LIGHT_MODEL_AMBIENT = 0x0B53 # 4 F
+ SHADE_MODEL = 0x0B54 # 1 I
+ COLOR_MATERIAL_FACE = 0x0B55 # 1 I
+ COLOR_MATERIAL_PARAMETER = 0x0B56 # 1 I
+ COLOR_MATERIAL = 0x0B57 # 1 I
+
+ FOG = 0x0B60 # 1 I
+ FOG_INDEX = 0x0B61 # 1 I
+ FOG_DENSITY = 0x0B62 # 1 F
+ FOG_START = 0x0B63 # 1 F
+ FOG_END = 0x0B64 # 1 F
+ FOG_MODE = 0x0B65 # 1 I
+ FOG_COLOR = 0x0B66 # 4 F
+
+ DEPTH_RANGE = 0x0B70 # 2 F
+ DEPTH_TEST = 0x0B71 # 1 I
+ DEPTH_WRITEMASK = 0x0B72 # 1 I
+ DEPTH_CLEAR_VALUE = 0x0B73 # 1 F
+ DEPTH_FUNC = 0x0B74 # 1 I
+
+ ACCUM_CLEAR_VALUE = 0x0B80 # 4 F
+
+ STENCIL_TEST = 0x0B90 # 1 I
+ STENCIL_CLEAR_VALUE = 0x0B91 # 1 I
+ STENCIL_FUNC = 0x0B92 # 1 I
+ STENCIL_VALUE_MASK = 0x0B93 # 1 I
+ STENCIL_FAIL = 0x0B94 # 1 I
+ STENCIL_PASS_DEPTH_FAIL = 0x0B95 # 1 I
+ STENCIL_PASS_DEPTH_PASS = 0x0B96 # 1 I
+ STENCIL_REF = 0x0B97 # 1 I
+ STENCIL_WRITEMASK = 0x0B98 # 1 I
+
+ MATRIX_MODE = 0x0BA0 # 1 I
+ NORMALIZE = 0x0BA1 # 1 I
+ VIEWPORT = 0x0BA2 # 4 I
+ MODELVIEW_STACK_DEPTH = 0x0BA3 # 1 I
+ PROJECTION_STACK_DEPTH = 0x0BA4 # 1 I
+ TEXTURE_STACK_DEPTH = 0x0BA5 # 1 I
+ MODELVIEW_MATRIX = 0x0BA6 # 16 F
+ PROJECTION_MATRIX = 0x0BA7 # 16 F
+ TEXTURE_MATRIX = 0x0BA8 # 16 F
+
+ ATTRIB_STACK_DEPTH = 0x0BB0 # 1 I
+ CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 # 1 I
+
+ ALPHA_TEST = 0x0BC0 # 1 I
+ ALPHA_TEST_FUNC = 0x0BC1 # 1 I
+ ALPHA_TEST_REF = 0x0BC2 # 1 F
+
+ DITHER = 0x0BD0 # 1 I
+
+ BLEND_DST = 0x0BE0 # 1 I
+ BLEND_SRC = 0x0BE1 # 1 I
+ BLEND = 0x0BE2 # 1 I
+
+ LOGIC_OP_MODE = 0x0BF0 # 1 I
+ INDEX_LOGIC_OP = 0x0BF1 # 1 I
+ LOGIC_OP = 0x0BF1 # 1 I
+ COLOR_LOGIC_OP = 0x0BF2 # 1 I
+
+ AUX_BUFFERS = 0x0C00 # 1 I
+ DRAW_BUFFER = 0x0C01 # 1 I
+ READ_BUFFER = 0x0C02 # 1 I
+
+ SCISSOR_BOX = 0x0C10 # 4 I
+ SCISSOR_TEST = 0x0C11 # 1 I
+
+ INDEX_CLEAR_VALUE = 0x0C20 # 1 I
+ INDEX_WRITEMASK = 0x0C21 # 1 I
+ COLOR_CLEAR_VALUE = 0x0C22 # 4 F
+ COLOR_WRITEMASK = 0x0C23 # 4 I
+
+ INDEX_MODE = 0x0C30 # 1 I
+ RGBA_MODE = 0x0C31 # 1 I
+ DOUBLEBUFFER = 0x0C32 # 1 I
+ STEREO = 0x0C33 # 1 I
+
+ RENDER_MODE = 0x0C40 # 1 I
+
+ PERSPECTIVE_CORRECTION_HINT = 0x0C50 # 1 I
+ POINT_SMOOTH_HINT = 0x0C51 # 1 I
+ LINE_SMOOTH_HINT = 0x0C52 # 1 I
+ POLYGON_SMOOTH_HINT = 0x0C53 # 1 I
+ FOG_HINT = 0x0C54 # 1 I
+
+ TEXTURE_GEN_S = 0x0C60 # 1 I
+ TEXTURE_GEN_T = 0x0C61 # 1 I
+ TEXTURE_GEN_R = 0x0C62 # 1 I
+ TEXTURE_GEN_Q = 0x0C63 # 1 I
+
+ PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 # 1 I
+ PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 # 1 I
+ PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 # 1 I
+ PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 # 1 I
+ PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 # 1 I
+ PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 # 1 I
+ PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 # 1 I
+ PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 # 1 I
+ PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 # 1 I
+ PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 # 1 I
+
+ UNPACK_SWAP_BYTES = 0x0CF0 # 1 I
+ UNPACK_LSB_FIRST = 0x0CF1 # 1 I
+ UNPACK_ROW_LENGTH = 0x0CF2 # 1 I
+ UNPACK_SKIP_ROWS = 0x0CF3 # 1 I
+ UNPACK_SKIP_PIXELS = 0x0CF4 # 1 I
+ UNPACK_ALIGNMENT = 0x0CF5 # 1 I
+
+ PACK_SWAP_BYTES = 0x0D00 # 1 I
+ PACK_LSB_FIRST = 0x0D01 # 1 I
+ PACK_ROW_LENGTH = 0x0D02 # 1 I
+ PACK_SKIP_ROWS = 0x0D03 # 1 I
+ PACK_SKIP_PIXELS = 0x0D04 # 1 I
+ PACK_ALIGNMENT = 0x0D05 # 1 I
+
+ MAP_COLOR = 0x0D10 # 1 I
+ MAP_STENCIL = 0x0D11 # 1 I
+ INDEX_SHIFT = 0x0D12 # 1 I
+ INDEX_OFFSET = 0x0D13 # 1 I
+ RED_SCALE = 0x0D14 # 1 F
+ RED_BIAS = 0x0D15 # 1 F
+ ZOOM_X = 0x0D16 # 1 F
+ ZOOM_Y = 0x0D17 # 1 F
+ GREEN_SCALE = 0x0D18 # 1 F
+ GREEN_BIAS = 0x0D19 # 1 F
+ BLUE_SCALE = 0x0D1A # 1 F
+ BLUE_BIAS = 0x0D1B # 1 F
+ ALPHA_SCALE = 0x0D1C # 1 F
+ ALPHA_BIAS = 0x0D1D # 1 F
+ DEPTH_SCALE = 0x0D1E # 1 F
+ DEPTH_BIAS = 0x0D1F # 1 F
+
+ MAX_EVAL_ORDER = 0x0D30 # 1 I
+ MAX_LIGHTS = 0x0D31 # 1 I
+ MAX_CLIP_PLANES = 0x0D32 # 1 I
+ MAX_TEXTURE_SIZE = 0x0D33 # 1 I
+ MAX_PIXEL_MAP_TABLE = 0x0D34 # 1 I
+ MAX_ATTRIB_STACK_DEPTH = 0x0D35 # 1 I
+ MAX_MODELVIEW_STACK_DEPTH = 0x0D36 # 1 I
+ MAX_NAME_STACK_DEPTH = 0x0D37 # 1 I
+ MAX_PROJECTION_STACK_DEPTH = 0x0D38 # 1 I
+ MAX_TEXTURE_STACK_DEPTH = 0x0D39 # 1 I
+ MAX_VIEWPORT_DIMS = 0x0D3A # 2 F
+ MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B # 1 I
+
+ SUBPIXEL_BITS = 0x0D50 # 1 I
+ INDEX_BITS = 0x0D51 # 1 I
+ RED_BITS = 0x0D52 # 1 I
+ GREEN_BITS = 0x0D53 # 1 I
+ BLUE_BITS = 0x0D54 # 1 I
+ ALPHA_BITS = 0x0D55 # 1 I
+ DEPTH_BITS = 0x0D56 # 1 I
+ STENCIL_BITS = 0x0D57 # 1 I
+ ACCUM_RED_BITS = 0x0D58 # 1 I
+ ACCUM_GREEN_BITS = 0x0D59 # 1 I
+ ACCUM_BLUE_BITS = 0x0D5A # 1 I
+ ACCUM_ALPHA_BITS = 0x0D5B # 1 I
+
+ NAME_STACK_DEPTH = 0x0D70 # 1 I
+
+ AUTO_NORMAL = 0x0D80 # 1 I
+
+ MAP1_COLOR_4 = 0x0D90 # 1 I
+ MAP1_INDEX = 0x0D91 # 1 I
+ MAP1_NORMAL = 0x0D92 # 1 I
+ MAP1_TEXTURE_COORD_1 = 0x0D93 # 1 I
+ MAP1_TEXTURE_COORD_2 = 0x0D94 # 1 I
+ MAP1_TEXTURE_COORD_3 = 0x0D95 # 1 I
+ MAP1_TEXTURE_COORD_4 = 0x0D96 # 1 I
+ MAP1_VERTEX_3 = 0x0D97 # 1 I
+ MAP1_VERTEX_4 = 0x0D98 # 1 I
+
+ MAP2_COLOR_4 = 0x0DB0 # 1 I
+ MAP2_INDEX = 0x0DB1 # 1 I
+ MAP2_NORMAL = 0x0DB2 # 1 I
+ MAP2_TEXTURE_COORD_1 = 0x0DB3 # 1 I
+ MAP2_TEXTURE_COORD_2 = 0x0DB4 # 1 I
+ MAP2_TEXTURE_COORD_3 = 0x0DB5 # 1 I
+ MAP2_TEXTURE_COORD_4 = 0x0DB6 # 1 I
+ MAP2_VERTEX_3 = 0x0DB7 # 1 I
+ MAP2_VERTEX_4 = 0x0DB8 # 1 I
+
+ MAP1_GRID_DOMAIN = 0x0DD0 # 2 F
+ MAP1_GRID_SEGMENTS = 0x0DD1 # 1 I
+ MAP2_GRID_DOMAIN = 0x0DD2 # 4 F
+ MAP2_GRID_SEGMENTS = 0x0DD3 # 2 I
+
+ TEXTURE_1D = 0x0DE0 # 1 I
+ TEXTURE_2D = 0x0DE1 # 1 I
+
+ FEEDBACK_BUFFER_SIZE = 0x0DF1 # 1 I
+ FEEDBACK_BUFFER_TYPE = 0x0DF2 # 1 I
+
+ SELECTION_BUFFER_SIZE = 0x0DF4 # 1 I
+
+ POLYGON_OFFSET_UNITS = 0x2A00 # 1 F
+ POLYGON_OFFSET_POINT = 0x2A01 # 1 I
+ POLYGON_OFFSET_LINE = 0x2A02 # 1 I
+ POLYGON_OFFSET_FILL = 0x8037 # 1 I
+ POLYGON_OFFSET_FACTOR = 0x8038 # 1 F
+
+ TEXTURE_BINDING_1D = 0x8068 # 1 I
+ TEXTURE_BINDING_2D = 0x8069 # 1 I
+ TEXTURE_BINDING_3D = 0x806A # 1 I
+
+ VERTEX_ARRAY = 0x8074 # 1 I
+ NORMAL_ARRAY = 0x8075 # 1 I
+ COLOR_ARRAY = 0x8076 # 1 I
+ INDEX_ARRAY = 0x8077 # 1 I
+ TEXTURE_COORD_ARRAY = 0x8078 # 1 I
+ EDGE_FLAG_ARRAY = 0x8079 # 1 I
+
+ VERTEX_ARRAY_SIZE = 0x807A # 1 I
+ VERTEX_ARRAY_TYPE = 0x807B # 1 I
+ VERTEX_ARRAY_STRIDE = 0x807C # 1 I
+
+ NORMAL_ARRAY_TYPE = 0x807E # 1 I
+ NORMAL_ARRAY_STRIDE = 0x807F # 1 I
+
+ COLOR_ARRAY_SIZE = 0x8081 # 1 I
+ COLOR_ARRAY_TYPE = 0x8082 # 1 I
+ COLOR_ARRAY_STRIDE = 0x8083 # 1 I
+
+ INDEX_ARRAY_TYPE = 0x8085 # 1 I
+ INDEX_ARRAY_STRIDE = 0x8086 # 1 I
+
+ TEXTURE_COORD_ARRAY_SIZE = 0x8088 # 1 I
+ TEXTURE_COORD_ARRAY_TYPE = 0x8089 # 1 I
+ TEXTURE_COORD_ARRAY_STRIDE = 0x808A # 1 I
+
+ EDGE_FLAG_ARRAY_STRIDE = 0x808C # 1 I
+
+ use ClipPlaneName CLIP_PLANE0
+ use ClipPlaneName CLIP_PLANE1
+ use ClipPlaneName CLIP_PLANE2
+ use ClipPlaneName CLIP_PLANE3
+ use ClipPlaneName CLIP_PLANE4
+ use ClipPlaneName CLIP_PLANE5
+
+ use LightName LIGHT0
+ use LightName LIGHT1
+ use LightName LIGHT2
+ use LightName LIGHT3
+ use LightName LIGHT4
+ use LightName LIGHT5
+ use LightName LIGHT6
+ use LightName LIGHT7
+
+# use ARB_transpose_matrix TRANSPOSE_MODELVIEW_MATRIX_ARB
+# use ARB_transpose_matrix TRANSPOSE_PROJECTION_MATRIX_ARB
+# use ARB_transpose_matrix TRANSPOSE_TEXTURE_MATRIX_ARB
+# use ARB_transpose_matrix TRANSPOSE_COLOR_MATRIX_ARB
+
+ use VERSION_1_2 LIGHT_MODEL_COLOR_CONTROL
+
+ use EXT_blend_color BLEND_COLOR_EXT
+
+ use EXT_blend_minmax BLEND_EQUATION_EXT
+
+ use EXT_cmyka PACK_CMYK_HINT_EXT
+ use EXT_cmyka UNPACK_CMYK_HINT_EXT
+
+ use EXT_convolution CONVOLUTION_1D_EXT
+ use EXT_convolution CONVOLUTION_2D_EXT
+ use EXT_convolution SEPARABLE_2D_EXT
+ use EXT_convolution POST_CONVOLUTION_RED_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_GREEN_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_BLUE_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_ALPHA_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_RED_BIAS_EXT
+ use EXT_convolution POST_CONVOLUTION_GREEN_BIAS_EXT
+ use EXT_convolution POST_CONVOLUTION_BLUE_BIAS_EXT
+ use EXT_convolution POST_CONVOLUTION_ALPHA_BIAS_EXT
+
+ use EXT_histogram HISTOGRAM_EXT
+ use EXT_histogram MINMAX_EXT
+
+ use EXT_polygon_offset POLYGON_OFFSET_BIAS_EXT
+
+ use EXT_rescale_normal RESCALE_NORMAL_EXT
+
+ use EXT_shared_texture_palette SHARED_TEXTURE_PALETTE_EXT
+
+ use EXT_texture_object TEXTURE_3D_BINDING_EXT
+
+ use EXT_texture3D PACK_SKIP_IMAGES_EXT
+ use EXT_texture3D PACK_IMAGE_HEIGHT_EXT
+ use EXT_texture3D UNPACK_SKIP_IMAGES_EXT
+ use EXT_texture3D UNPACK_IMAGE_HEIGHT_EXT
+ use EXT_texture3D TEXTURE_3D_EXT
+ use EXT_texture3D MAX_3D_TEXTURE_SIZE_EXT
+
+ use EXT_vertex_array VERTEX_ARRAY_COUNT_EXT
+ use EXT_vertex_array NORMAL_ARRAY_COUNT_EXT
+ use EXT_vertex_array COLOR_ARRAY_COUNT_EXT
+ use EXT_vertex_array INDEX_ARRAY_COUNT_EXT
+ use EXT_vertex_array TEXTURE_COORD_ARRAY_COUNT_EXT
+ use EXT_vertex_array EDGE_FLAG_ARRAY_COUNT_EXT
+
+ use SGIS_detail_texture DETAIL_TEXTURE_2D_BINDING_SGIS
+
+ use SGIS_fog_function FOG_FUNC_POINTS_SGIS
+ use SGIS_fog_function MAX_FOG_FUNC_POINTS_SGIS
+
+ use SGIS_generate_mipmap GENERATE_MIPMAP_HINT_SGIS
+
+ use SGIS_multisample MULTISAMPLE_SGIS
+ use SGIS_multisample SAMPLE_ALPHA_TO_MASK_SGIS
+ use SGIS_multisample SAMPLE_ALPHA_TO_ONE_SGIS
+ use SGIS_multisample SAMPLE_MASK_SGIS
+ use SGIS_multisample SAMPLE_BUFFERS_SGIS
+ use SGIS_multisample SAMPLES_SGIS
+ use SGIS_multisample SAMPLE_MASK_VALUE_SGIS
+ use SGIS_multisample SAMPLE_MASK_INVERT_SGIS
+ use SGIS_multisample SAMPLE_PATTERN_SGIS
+
+ use SGIS_pixel_texture PIXEL_TEXTURE_SGIS
+
+ use SGIS_point_parameters POINT_SIZE_MIN_SGIS
+ use SGIS_point_parameters POINT_SIZE_MAX_SGIS
+ use SGIS_point_parameters POINT_FADE_THRESHOLD_SIZE_SGIS
+ use SGIS_point_parameters DISTANCE_ATTENUATION_SGIS
+
+ use SGIS_texture4D PACK_SKIP_VOLUMES_SGIS
+ use SGIS_texture4D PACK_IMAGE_DEPTH_SGIS
+ use SGIS_texture4D UNPACK_SKIP_VOLUMES_SGIS
+ use SGIS_texture4D UNPACK_IMAGE_DEPTH_SGIS
+ use SGIS_texture4D TEXTURE_4D_SGIS
+ use SGIS_texture4D MAX_4D_TEXTURE_SIZE_SGIS
+ use SGIS_texture4D TEXTURE_4D_BINDING_SGIS
+
+ use SGIX_async ASYNC_MARKER_SGIX
+
+ use SGIX_async_histogram ASYNC_HISTOGRAM_SGIX
+ use SGIX_async_histogram MAX_ASYNC_HISTOGRAM_SGIX
+
+ use SGIX_async_pixel ASYNC_TEX_IMAGE_SGIX
+ use SGIX_async_pixel ASYNC_DRAW_PIXELS_SGIX
+ use SGIX_async_pixel ASYNC_READ_PIXELS_SGIX
+ use SGIX_async_pixel MAX_ASYNC_TEX_IMAGE_SGIX
+ use SGIX_async_pixel MAX_ASYNC_DRAW_PIXELS_SGIX
+ use SGIX_async_pixel MAX_ASYNC_READ_PIXELS_SGIX
+
+ use SGIX_calligraphic_fragment CALLIGRAPHIC_FRAGMENT_SGIX
+
+ use SGIX_clipmap MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX
+ use SGIX_clipmap MAX_CLIPMAP_DEPTH_SGIX
+
+ use SGIX_convolution_accuracy CONVOLUTION_HINT_SGIX
+
+ use SGIX_fog_offset FOG_OFFSET_SGIX
+ use SGIX_fog_offset FOG_OFFSET_VALUE_SGIX
+
+ use SGIX_fragment_lighting FRAGMENT_LIGHTING_SGIX
+ use SGIX_fragment_lighting FRAGMENT_COLOR_MATERIAL_SGIX
+ use SGIX_fragment_lighting FRAGMENT_COLOR_MATERIAL_FACE_SGIX
+ use SGIX_fragment_lighting FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX
+ use SGIX_fragment_lighting MAX_FRAGMENT_LIGHTS_SGIX
+ use SGIX_fragment_lighting MAX_ACTIVE_LIGHTS_SGIX
+ use SGIX_fragment_lighting LIGHT_ENV_MODE_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT0_SGIX
+
+ use SGIX_framezoom FRAMEZOOM_SGIX
+ use SGIX_framezoom FRAMEZOOM_FACTOR_SGIX
+ use SGIX_framezoom MAX_FRAMEZOOM_FACTOR_SGIX
+
+ use SGIX_instruments INSTRUMENT_MEASUREMENTS_SGIX
+
+ use SGIX_interlace INTERLACE_SGIX
+
+ use SGIX_ir_instrument1 IR_INSTRUMENT1_SGIX
+
+ use SGIX_pixel_texture PIXEL_TEX_GEN_SGIX
+ use SGIX_pixel_texture PIXEL_TEX_GEN_MODE_SGIX
+
+ use SGIX_pixel_tiles PIXEL_TILE_BEST_ALIGNMENT_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_CACHE_INCREMENT_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_WIDTH_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_HEIGHT_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_GRID_WIDTH_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_GRID_HEIGHT_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_GRID_DEPTH_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_CACHE_SIZE_SGIX
+
+ use SGIX_polynomial_ffd DEFORMATIONS_MASK_SGIX
+
+ use SGIX_reference_plane REFERENCE_PLANE_EQUATION_SGIX
+ use SGIX_reference_plane REFERENCE_PLANE_SGIX
+
+ use SGIX_sprite SPRITE_SGIX
+ use SGIX_sprite SPRITE_MODE_SGIX
+ use SGIX_sprite SPRITE_AXIS_SGIX
+ use SGIX_sprite SPRITE_TRANSLATION_SGIX
+
+ use SGIX_subsample PACK_SUBSAMPLE_RATE_SGIX
+ use SGIX_subsample UNPACK_SUBSAMPLE_RATE_SGIX
+ use SGIX_resample PACK_RESAMPLE_SGIX
+ use SGIX_resample UNPACK_RESAMPLE_SGIX
+
+ use SGIX_texture_scale_bias POST_TEXTURE_FILTER_BIAS_RANGE_SGIX
+ use SGIX_texture_scale_bias POST_TEXTURE_FILTER_SCALE_RANGE_SGIX
+
+ use SGIX_vertex_preclip VERTEX_PRECLIP_SGIX
+ use SGIX_vertex_preclip VERTEX_PRECLIP_HINT_SGIX
+
+ use SGI_color_matrix COLOR_MATRIX_SGI
+ use SGI_color_matrix COLOR_MATRIX_STACK_DEPTH_SGI
+ use SGI_color_matrix MAX_COLOR_MATRIX_STACK_DEPTH_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_RED_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_GREEN_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_BLUE_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_ALPHA_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_RED_BIAS_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_GREEN_BIAS_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_BLUE_BIAS_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_ALPHA_BIAS_SGI
+
+ use SGI_color_table COLOR_TABLE_SGI
+ use SGI_color_table POST_CONVOLUTION_COLOR_TABLE_SGI
+ use SGI_color_table POST_COLOR_MATRIX_COLOR_TABLE_SGI
+
+ use SGI_texture_color_table TEXTURE_COLOR_TABLE_SGI
+
+###############################################################################
+
+GetTextureParameter enum:
+ use TextureParameterName TEXTURE_MAG_FILTER
+ use TextureParameterName TEXTURE_MIN_FILTER
+ use TextureParameterName TEXTURE_WRAP_S
+ use TextureParameterName TEXTURE_WRAP_T
+ TEXTURE_WIDTH = 0x1000
+ TEXTURE_HEIGHT = 0x1001
+ TEXTURE_INTERNAL_FORMAT = 0x1003
+ TEXTURE_COMPONENTS = 0x1003
+ TEXTURE_BORDER_COLOR = 0x1004
+ TEXTURE_BORDER = 0x1005
+ TEXTURE_RED_SIZE = 0x805C
+ TEXTURE_GREEN_SIZE = 0x805D
+ TEXTURE_BLUE_SIZE = 0x805E
+ TEXTURE_ALPHA_SIZE = 0x805F
+ TEXTURE_LUMINANCE_SIZE = 0x8060
+ TEXTURE_INTENSITY_SIZE = 0x8061
+ TEXTURE_PRIORITY = 0x8066
+ TEXTURE_RESIDENT = 0x8067
+ use EXT_texture3D TEXTURE_DEPTH_EXT
+ use EXT_texture3D TEXTURE_WRAP_R_EXT
+ use SGIS_detail_texture DETAIL_TEXTURE_LEVEL_SGIS
+ use SGIS_detail_texture DETAIL_TEXTURE_MODE_SGIS
+ use SGIS_detail_texture DETAIL_TEXTURE_FUNC_POINTS_SGIS
+ use SGIS_generate_mipmap GENERATE_MIPMAP_SGIS
+ use SGIS_sharpen_texture SHARPEN_TEXTURE_FUNC_POINTS_SGIS
+ use SGIS_texture_filter4 TEXTURE_FILTER4_SIZE_SGIS
+ use SGIS_texture_lod TEXTURE_MIN_LOD_SGIS
+ use SGIS_texture_lod TEXTURE_MAX_LOD_SGIS
+ use SGIS_texture_lod TEXTURE_BASE_LEVEL_SGIS
+ use SGIS_texture_lod TEXTURE_MAX_LEVEL_SGIS
+ use SGIS_texture_select DUAL_TEXTURE_SELECT_SGIS
+ use SGIS_texture_select QUAD_TEXTURE_SELECT_SGIS
+ use SGIS_texture4D TEXTURE_4DSIZE_SGIS
+ use SGIS_texture4D TEXTURE_WRAP_Q_SGIS
+ use SGIX_clipmap TEXTURE_CLIPMAP_CENTER_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_FRAME_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_OFFSET_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_LOD_OFFSET_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_DEPTH_SGIX
+ use SGIX_shadow TEXTURE_COMPARE_SGIX
+ use SGIX_shadow TEXTURE_COMPARE_OPERATOR_SGIX
+ use SGIX_shadow TEXTURE_LEQUAL_R_SGIX
+ use SGIX_shadow TEXTURE_GEQUAL_R_SGIX
+ use SGIX_shadow_ambient SHADOW_AMBIENT_SGIX
+ use SGIX_texture_coordinate_clamp TEXTURE_MAX_CLAMP_S_SGIX
+ use SGIX_texture_coordinate_clamp TEXTURE_MAX_CLAMP_T_SGIX
+ use SGIX_texture_coordinate_clamp TEXTURE_MAX_CLAMP_R_SGIX
+ use SGIX_texture_lod_bias TEXTURE_LOD_BIAS_S_SGIX
+ use SGIX_texture_lod_bias TEXTURE_LOD_BIAS_T_SGIX
+ use SGIX_texture_lod_bias TEXTURE_LOD_BIAS_R_SGIX
+ use SGIX_texture_scale_bias POST_TEXTURE_FILTER_BIAS_SGIX
+ use SGIX_texture_scale_bias POST_TEXTURE_FILTER_SCALE_SGIX
+
+###############################################################################
+
+HintMode enum:
+ DONT_CARE = 0x1100
+ FASTEST = 0x1101
+ NICEST = 0x1102
+
+###############################################################################
+
+HintTarget enum:
+ use GetPName PERSPECTIVE_CORRECTION_HINT
+ use GetPName POINT_SMOOTH_HINT
+ use GetPName LINE_SMOOTH_HINT
+ use GetPName POLYGON_SMOOTH_HINT
+ use GetPName FOG_HINT
+ use EXT_cmyka PACK_CMYK_HINT_EXT
+ use EXT_cmyka UNPACK_CMYK_HINT_EXT
+ use SGIS_generate_mipmap GENERATE_MIPMAP_HINT_SGIS
+ use SGIX_convolution_accuracy CONVOLUTION_HINT_SGIX
+ use SGIX_texture_multi_buffer TEXTURE_MULTI_BUFFER_HINT_SGIX
+ use SGIX_vertex_preclip VERTEX_PRECLIP_HINT_SGIX
+
+###############################################################################
+
+HistogramTargetEXT enum:
+ use EXT_histogram HISTOGRAM_EXT
+ use EXT_histogram PROXY_HISTOGRAM_EXT
+
+###############################################################################
+
+IndexPointerType enum:
+ use DataType SHORT
+ use DataType INT
+ use DataType FLOAT
+ use DataType DOUBLE
+
+###############################################################################
+
+LightEnvModeSGIX enum:
+ use StencilOp REPLACE
+ use TextureEnvMode MODULATE
+ use AccumOp ADD
+
+###############################################################################
+
+LightEnvParameterSGIX enum:
+ use SGIX_fragment_lighting LIGHT_ENV_MODE_SGIX
+
+###############################################################################
+
+LightModelColorControl enum:
+ use VERSION_1_2 SINGLE_COLOR
+ use VERSION_1_2 SEPARATE_SPECULAR_COLOR
+
+###############################################################################
+
+LightModelParameter enum:
+ use GetPName LIGHT_MODEL_AMBIENT
+ use GetPName LIGHT_MODEL_LOCAL_VIEWER
+ use GetPName LIGHT_MODEL_TWO_SIDE
+ use VERSION_1_2 LIGHT_MODEL_COLOR_CONTROL
+
+###############################################################################
+
+LightParameter enum:
+ AMBIENT = 0x1200
+ DIFFUSE = 0x1201
+ SPECULAR = 0x1202
+ POSITION = 0x1203
+ SPOT_DIRECTION = 0x1204
+ SPOT_EXPONENT = 0x1205
+ SPOT_CUTOFF = 0x1206
+ CONSTANT_ATTENUATION = 0x1207
+ LINEAR_ATTENUATION = 0x1208
+ QUADRATIC_ATTENUATION = 0x1209
+
+###############################################################################
+
+ListMode enum:
+ COMPILE = 0x1300
+ COMPILE_AND_EXECUTE = 0x1301
+
+###############################################################################
+
+DataType enum:
+ BYTE = 0x1400
+ UNSIGNED_BYTE = 0x1401
+ SHORT = 0x1402
+ UNSIGNED_SHORT = 0x1403
+ INT = 0x1404
+ UNSIGNED_INT = 0x1405
+ FLOAT = 0x1406
+ 2_BYTES = 0x1407
+ 3_BYTES = 0x1408
+ 4_BYTES = 0x1409
+ DOUBLE = 0x140A
+ DOUBLE_EXT = 0x140A
+
+# ARB_half_float_pixel enum:
+# NV_half_float enum:
+# HALF_FLOAT_ARB = 0x140B
+# HALF_FLOAT_NV = 0x140B
+
+# OES_fixed_point enum:
+# FIXED_OES = 0x140C
+
+###############################################################################
+
+ListNameType enum:
+ use DataType BYTE
+ use DataType UNSIGNED_BYTE
+ use DataType SHORT
+ use DataType UNSIGNED_SHORT
+ use DataType INT
+ use DataType UNSIGNED_INT
+ use DataType FLOAT
+ use DataType 2_BYTES
+ use DataType 3_BYTES
+ use DataType 4_BYTES
+
+###############################################################################
+
+ListParameterName enum:
+ use SGIX_list_priority LIST_PRIORITY_SGIX
+
+###############################################################################
+
+LogicOp enum:
+ CLEAR = 0x1500
+ AND = 0x1501
+ AND_REVERSE = 0x1502
+ COPY = 0x1503
+ AND_INVERTED = 0x1504
+ NOOP = 0x1505
+ XOR = 0x1506
+ OR = 0x1507
+ NOR = 0x1508
+ EQUIV = 0x1509
+ INVERT = 0x150A
+ OR_REVERSE = 0x150B
+ COPY_INVERTED = 0x150C
+ OR_INVERTED = 0x150D
+ NAND = 0x150E
+ SET = 0x150F
+
+###############################################################################
+
+MapTarget enum:
+ use GetPName MAP1_COLOR_4
+ use GetPName MAP1_INDEX
+ use GetPName MAP1_NORMAL
+ use GetPName MAP1_TEXTURE_COORD_1
+ use GetPName MAP1_TEXTURE_COORD_2
+ use GetPName MAP1_TEXTURE_COORD_3
+ use GetPName MAP1_TEXTURE_COORD_4
+ use GetPName MAP1_VERTEX_3
+ use GetPName MAP1_VERTEX_4
+ use GetPName MAP2_COLOR_4
+ use GetPName MAP2_INDEX
+ use GetPName MAP2_NORMAL
+ use GetPName MAP2_TEXTURE_COORD_1
+ use GetPName MAP2_TEXTURE_COORD_2
+ use GetPName MAP2_TEXTURE_COORD_3
+ use GetPName MAP2_TEXTURE_COORD_4
+ use GetPName MAP2_VERTEX_3
+ use GetPName MAP2_VERTEX_4
+ use SGIX_polynomial_ffd GEOMETRY_DEFORMATION_SGIX
+ use SGIX_polynomial_ffd TEXTURE_DEFORMATION_SGIX
+
+###############################################################################
+
+MaterialFace enum:
+ use DrawBufferMode FRONT
+ use DrawBufferMode BACK
+ use DrawBufferMode FRONT_AND_BACK
+
+
+###############################################################################
+
+MaterialParameter enum:
+ EMISSION = 0x1600
+ SHININESS = 0x1601
+ AMBIENT_AND_DIFFUSE = 0x1602
+ COLOR_INDEXES = 0x1603
+ use LightProperty AMBIENT
+ use LightProperty DIFFUSE
+ use LightProperty SPECULAR
+
+###############################################################################
+
+MatrixMode enum:
+ MODELVIEW = 0x1700
+ PROJECTION = 0x1701
+ TEXTURE = 0x1702
+
+###############################################################################
+
+MeshMode1 enum:
+ use PolygonMode POINT
+ use PolygonMode LINE
+
+###############################################################################
+
+MeshMode2 enum:
+ use PolygonMode POINT
+ use PolygonMode LINE
+ use PolygonMode FILL
+
+###############################################################################
+
+MinmaxTargetEXT enum:
+ use EXT_histogram MINMAX_EXT
+
+###############################################################################
+
+NormalPointerType enum:
+ use DataType BYTE
+ use DataType SHORT
+ use DataType INT
+ use DataType FLOAT
+ use DataType DOUBLE
+
+###############################################################################
+
+PixelCopyType enum:
+ COLOR = 0x1800
+ DEPTH = 0x1801
+ STENCIL = 0x1802
+
+###############################################################################
+
+PixelFormat enum:
+ COLOR_INDEX = 0x1900
+ STENCIL_INDEX = 0x1901
+ DEPTH_COMPONENT = 0x1902
+ RED = 0x1903
+ GREEN = 0x1904
+ BLUE = 0x1905
+ ALPHA = 0x1906
+ RGB = 0x1907
+ RGBA = 0x1908
+ LUMINANCE = 0x1909
+ LUMINANCE_ALPHA = 0x190A
+ use EXT_abgr ABGR_EXT
+ use EXT_cmyka CMYK_EXT
+ use EXT_cmyka CMYKA_EXT
+ use SGIX_icc_texture R5_G6_B5_ICC_SGIX
+ use SGIX_icc_texture R5_G6_B5_A8_ICC_SGIX
+ use SGIX_icc_texture ALPHA16_ICC_SGIX
+ use SGIX_icc_texture LUMINANCE16_ICC_SGIX
+ use SGIX_icc_texture LUMINANCE16_ALPHA8_ICC_SGIX
+ use SGIX_ycrcb YCRCB_422_SGIX
+ use SGIX_ycrcb YCRCB_444_SGIX
+
+###############################################################################
+
+PixelMap enum:
+ use GetPixelMap PIXEL_MAP_I_TO_I
+ use GetPixelMap PIXEL_MAP_S_TO_S
+ use GetPixelMap PIXEL_MAP_I_TO_R
+ use GetPixelMap PIXEL_MAP_I_TO_G
+ use GetPixelMap PIXEL_MAP_I_TO_B
+ use GetPixelMap PIXEL_MAP_I_TO_A
+ use GetPixelMap PIXEL_MAP_R_TO_R
+ use GetPixelMap PIXEL_MAP_G_TO_G
+ use GetPixelMap PIXEL_MAP_B_TO_B
+ use GetPixelMap PIXEL_MAP_A_TO_A
+
+###############################################################################
+
+PixelStoreParameter enum:
+ use GetPName UNPACK_SWAP_BYTES
+ use GetPName UNPACK_LSB_FIRST
+ use GetPName UNPACK_ROW_LENGTH
+ use GetPName UNPACK_SKIP_ROWS
+ use GetPName UNPACK_SKIP_PIXELS
+ use GetPName UNPACK_ALIGNMENT
+ use GetPName PACK_SWAP_BYTES
+ use GetPName PACK_LSB_FIRST
+ use GetPName PACK_ROW_LENGTH
+ use GetPName PACK_SKIP_ROWS
+ use GetPName PACK_SKIP_PIXELS
+ use GetPName PACK_ALIGNMENT
+ use EXT_texture3D PACK_SKIP_IMAGES_EXT
+ use EXT_texture3D PACK_IMAGE_HEIGHT_EXT
+ use EXT_texture3D UNPACK_SKIP_IMAGES_EXT
+ use EXT_texture3D UNPACK_IMAGE_HEIGHT_EXT
+ use SGIS_texture4D PACK_SKIP_VOLUMES_SGIS
+ use SGIS_texture4D PACK_IMAGE_DEPTH_SGIS
+ use SGIS_texture4D UNPACK_SKIP_VOLUMES_SGIS
+ use SGIS_texture4D UNPACK_IMAGE_DEPTH_SGIS
+ use SGIX_pixel_tiles PIXEL_TILE_WIDTH_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_HEIGHT_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_GRID_WIDTH_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_GRID_HEIGHT_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_GRID_DEPTH_SGIX
+ use SGIX_pixel_tiles PIXEL_TILE_CACHE_SIZE_SGIX
+ use SGIX_subsample PACK_SUBSAMPLE_RATE_SGIX
+ use SGIX_subsample UNPACK_SUBSAMPLE_RATE_SGIX
+ use SGIX_resample PACK_RESAMPLE_SGIX
+ use SGIX_resample UNPACK_RESAMPLE_SGIX
+
+###############################################################################
+
+PixelStoreResampleMode enum:
+ use SGIX_resample RESAMPLE_REPLICATE_SGIX
+ use SGIX_resample RESAMPLE_ZERO_FILL_SGIX
+ use SGIX_resample RESAMPLE_DECIMATE_SGIX
+
+###############################################################################
+
+PixelStoreSubsampleRate enum:
+ use SGIX_subsample PIXEL_SUBSAMPLE_4444_SGIX
+ use SGIX_subsample PIXEL_SUBSAMPLE_2424_SGIX
+ use SGIX_subsample PIXEL_SUBSAMPLE_4242_SGIX
+
+###############################################################################
+
+PixelTexGenMode enum:
+ use DrawBufferMode NONE
+ use PixelFormat RGB
+ use PixelFormat RGBA
+ use PixelFormat LUMINANCE
+ use PixelFormat LUMINANCE_ALPHA
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_ALPHA_MS_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_ALPHA_LS_SGIX
+
+###############################################################################
+
+PixelTexGenParameterNameSGIS enum:
+ use SGIS_pixel_texture PIXEL_FRAGMENT_RGB_SOURCE_SGIS
+ use SGIS_pixel_texture PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS
+
+###############################################################################
+
+PixelTransferParameter enum:
+ use GetPName MAP_COLOR
+ use GetPName MAP_STENCIL
+ use GetPName INDEX_SHIFT
+ use GetPName INDEX_OFFSET
+ use GetPName RED_SCALE
+ use GetPName RED_BIAS
+ use GetPName GREEN_SCALE
+ use GetPName GREEN_BIAS
+ use GetPName BLUE_SCALE
+ use GetPName BLUE_BIAS
+ use GetPName ALPHA_SCALE
+ use GetPName ALPHA_BIAS
+ use GetPName DEPTH_SCALE
+ use GetPName DEPTH_BIAS
+ use EXT_convolution POST_CONVOLUTION_RED_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_GREEN_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_BLUE_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_ALPHA_SCALE_EXT
+ use EXT_convolution POST_CONVOLUTION_RED_BIAS_EXT
+ use EXT_convolution POST_CONVOLUTION_GREEN_BIAS_EXT
+ use EXT_convolution POST_CONVOLUTION_BLUE_BIAS_EXT
+ use EXT_convolution POST_CONVOLUTION_ALPHA_BIAS_EXT
+ use SGI_color_matrix POST_COLOR_MATRIX_RED_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_GREEN_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_BLUE_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_ALPHA_SCALE_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_RED_BIAS_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_GREEN_BIAS_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_BLUE_BIAS_SGI
+ use SGI_color_matrix POST_COLOR_MATRIX_ALPHA_BIAS_SGI
+
+###############################################################################
+
+PixelType enum:
+ BITMAP = 0x1A00
+ use DataType BYTE
+ use DataType UNSIGNED_BYTE
+ use DataType SHORT
+ use DataType UNSIGNED_SHORT
+ use DataType INT
+ use DataType UNSIGNED_INT
+ use DataType FLOAT
+ use EXT_packed_pixels UNSIGNED_BYTE_3_3_2_EXT
+ use EXT_packed_pixels UNSIGNED_SHORT_4_4_4_4_EXT
+ use EXT_packed_pixels UNSIGNED_SHORT_5_5_5_1_EXT
+ use EXT_packed_pixels UNSIGNED_INT_8_8_8_8_EXT
+ use EXT_packed_pixels UNSIGNED_INT_10_10_10_2_EXT
+
+###############################################################################
+
+PointParameterNameSGIS enum:
+ use SGIS_point_parameters POINT_SIZE_MIN_SGIS
+ use SGIS_point_parameters POINT_SIZE_MAX_SGIS
+ use SGIS_point_parameters POINT_FADE_THRESHOLD_SIZE_SGIS
+ use SGIS_point_parameters DISTANCE_ATTENUATION_SGIS
+
+###############################################################################
+
+PolygonMode enum:
+ POINT = 0x1B00
+ LINE = 0x1B01
+ FILL = 0x1B02
+
+###############################################################################
+
+ReadBufferMode enum:
+ use DrawBufferMode FRONT_LEFT
+ use DrawBufferMode FRONT_RIGHT
+ use DrawBufferMode BACK_LEFT
+ use DrawBufferMode BACK_RIGHT
+ use DrawBufferMode FRONT
+ use DrawBufferMode BACK
+ use DrawBufferMode LEFT
+ use DrawBufferMode RIGHT
+ use DrawBufferMode AUX0
+ use DrawBufferMode AUX1
+ use DrawBufferMode AUX2
+ use DrawBufferMode AUX3
+
+###############################################################################
+
+RenderingMode enum:
+ RENDER = 0x1C00
+ FEEDBACK = 0x1C01
+ SELECT = 0x1C02
+
+###############################################################################
+
+SamplePatternSGIS enum:
+ use SGIS_multisample 1PASS_SGIS
+ use SGIS_multisample 2PASS_0_SGIS
+ use SGIS_multisample 2PASS_1_SGIS
+ use SGIS_multisample 4PASS_0_SGIS
+ use SGIS_multisample 4PASS_1_SGIS
+ use SGIS_multisample 4PASS_2_SGIS
+ use SGIS_multisample 4PASS_3_SGIS
+
+###############################################################################
+
+SeparableTargetEXT enum:
+ use EXT_convolution SEPARABLE_2D_EXT
+
+###############################################################################
+
+ShadingModel enum:
+ FLAT = 0x1D00
+ SMOOTH = 0x1D01
+
+###############################################################################
+
+StencilFunction enum:
+ use AlphaFunction NEVER
+ use AlphaFunction LESS
+ use AlphaFunction EQUAL
+ use AlphaFunction LEQUAL
+ use AlphaFunction GREATER
+ use AlphaFunction NOTEQUAL
+ use AlphaFunction GEQUAL
+ use AlphaFunction ALWAYS
+
+###############################################################################
+
+StencilOp enum:
+ use BlendingFactorDest ZERO
+ KEEP = 0x1E00
+ REPLACE = 0x1E01
+ INCR = 0x1E02
+ DECR = 0x1E03
+ use LogicOp INVERT
+
+###############################################################################
+
+StringName enum:
+ VENDOR = 0x1F00
+ RENDERER = 0x1F01
+ VERSION = 0x1F02
+ EXTENSIONS = 0x1F03
+
+###############################################################################
+
+TexCoordPointerType enum:
+ use DataType SHORT
+ use DataType INT
+ use DataType FLOAT
+ use DataType DOUBLE
+
+###############################################################################
+
+TextureCoordName enum:
+ S = 0x2000
+ T = 0x2001
+ R = 0x2002
+ Q = 0x2003
+
+###############################################################################
+
+TextureEnvMode enum:
+ MODULATE = 0x2100
+ DECAL = 0x2101
+ use GetPName BLEND
+ use EXT_texture REPLACE_EXT
+ use AccumOp ADD
+ use SGIX_texture_add_env TEXTURE_ENV_BIAS_SGIX
+
+###############################################################################
+
+TextureEnvParameter enum:
+ TEXTURE_ENV_MODE = 0x2200
+ TEXTURE_ENV_COLOR = 0x2201
+
+###############################################################################
+
+TextureEnvTarget enum:
+ TEXTURE_ENV = 0x2300
+
+###############################################################################
+
+TextureFilterFuncSGIS enum:
+ use SGIS_texture_filter4 FILTER4_SGIS
+
+###############################################################################
+
+TextureGenMode enum:
+ EYE_LINEAR = 0x2400
+ OBJECT_LINEAR = 0x2401
+ SPHERE_MAP = 0x2402
+ use SGIS_point_line_texgen EYE_DISTANCE_TO_POINT_SGIS
+ use SGIS_point_line_texgen OBJECT_DISTANCE_TO_POINT_SGIS
+ use SGIS_point_line_texgen EYE_DISTANCE_TO_LINE_SGIS
+ use SGIS_point_line_texgen OBJECT_DISTANCE_TO_LINE_SGIS
+
+###############################################################################
+
+TextureGenParameter enum:
+ TEXTURE_GEN_MODE = 0x2500
+ OBJECT_PLANE = 0x2501
+ EYE_PLANE = 0x2502
+ use SGIS_point_line_texgen EYE_POINT_SGIS
+ use SGIS_point_line_texgen OBJECT_POINT_SGIS
+ use SGIS_point_line_texgen EYE_LINE_SGIS
+ use SGIS_point_line_texgen OBJECT_LINE_SGIS
+
+###############################################################################
+
+TextureMagFilter enum:
+ NEAREST = 0x2600
+ LINEAR = 0x2601
+ use SGIS_detail_texture LINEAR_DETAIL_SGIS
+ use SGIS_detail_texture LINEAR_DETAIL_ALPHA_SGIS
+ use SGIS_detail_texture LINEAR_DETAIL_COLOR_SGIS
+ use SGIS_sharpen_texture LINEAR_SHARPEN_SGIS
+ use SGIS_sharpen_texture LINEAR_SHARPEN_ALPHA_SGIS
+ use SGIS_sharpen_texture LINEAR_SHARPEN_COLOR_SGIS
+ use SGIS_texture_filter4 FILTER4_SGIS
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_Q_CEILING_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_Q_ROUND_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_Q_FLOOR_SGIX
+
+###############################################################################
+
+TextureMinFilter enum:
+ use TextureMagFilter NEAREST
+ use TextureMagFilter LINEAR
+ NEAREST_MIPMAP_NEAREST = 0x2700
+ LINEAR_MIPMAP_NEAREST = 0x2701
+ NEAREST_MIPMAP_LINEAR = 0x2702
+ LINEAR_MIPMAP_LINEAR = 0x2703
+ use SGIS_texture_filter4 FILTER4_SGIS
+ use SGIX_clipmap LINEAR_CLIPMAP_LINEAR_SGIX
+ use SGIX_clipmap NEAREST_CLIPMAP_NEAREST_SGIX
+ use SGIX_clipmap NEAREST_CLIPMAP_LINEAR_SGIX
+ use SGIX_clipmap LINEAR_CLIPMAP_NEAREST_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_Q_CEILING_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_Q_ROUND_SGIX
+ use SGIX_impact_pixel_texture PIXEL_TEX_GEN_Q_FLOOR_SGIX
+
+###############################################################################
+
+TextureParameterName enum:
+ TEXTURE_MAG_FILTER = 0x2800
+ TEXTURE_MIN_FILTER = 0x2801
+ TEXTURE_WRAP_S = 0x2802
+ TEXTURE_WRAP_T = 0x2803
+ use GetTextureParameter TEXTURE_BORDER_COLOR
+ use GetTextureParameter TEXTURE_PRIORITY
+ use EXT_texture3D TEXTURE_WRAP_R_EXT
+ use SGIS_detail_texture DETAIL_TEXTURE_LEVEL_SGIS
+ use SGIS_detail_texture DETAIL_TEXTURE_MODE_SGIS
+ use SGIS_generate_mipmap GENERATE_MIPMAP_SGIS
+ use SGIS_texture_select DUAL_TEXTURE_SELECT_SGIS
+ use SGIS_texture_select QUAD_TEXTURE_SELECT_SGIS
+ use SGIS_texture4D TEXTURE_WRAP_Q_SGIS
+ use SGIX_clipmap TEXTURE_CLIPMAP_CENTER_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_FRAME_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_OFFSET_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_LOD_OFFSET_SGIX
+ use SGIX_clipmap TEXTURE_CLIPMAP_DEPTH_SGIX
+ use SGIX_shadow TEXTURE_COMPARE_SGIX
+ use SGIX_shadow TEXTURE_COMPARE_OPERATOR_SGIX
+ use SGIX_shadow_ambient SHADOW_AMBIENT_SGIX
+ use SGIX_texture_coordinate_clamp TEXTURE_MAX_CLAMP_S_SGIX
+ use SGIX_texture_coordinate_clamp TEXTURE_MAX_CLAMP_T_SGIX
+ use SGIX_texture_coordinate_clamp TEXTURE_MAX_CLAMP_R_SGIX
+ use SGIX_texture_lod_bias TEXTURE_LOD_BIAS_S_SGIX
+ use SGIX_texture_lod_bias TEXTURE_LOD_BIAS_T_SGIX
+ use SGIX_texture_lod_bias TEXTURE_LOD_BIAS_R_SGIX
+ use SGIX_texture_scale_bias POST_TEXTURE_FILTER_BIAS_SGIX
+ use SGIX_texture_scale_bias POST_TEXTURE_FILTER_SCALE_SGIX
+
+###############################################################################
+
+TextureTarget enum:
+ use GetPName TEXTURE_1D
+ use GetPName TEXTURE_2D
+ PROXY_TEXTURE_1D = 0x8063
+ PROXY_TEXTURE_2D = 0x8064
+ use EXT_texture3D TEXTURE_3D_EXT
+ use EXT_texture3D PROXY_TEXTURE_3D_EXT
+ use SGIS_detail_texture DETAIL_TEXTURE_2D_SGIS
+ use SGIS_texture4D TEXTURE_4D_SGIS
+ use SGIS_texture4D PROXY_TEXTURE_4D_SGIS
+ use SGIS_texture_lod TEXTURE_MIN_LOD_SGIS
+ use SGIS_texture_lod TEXTURE_MAX_LOD_SGIS
+ use SGIS_texture_lod TEXTURE_BASE_LEVEL_SGIS
+ use SGIS_texture_lod TEXTURE_MAX_LEVEL_SGIS
+
+###############################################################################
+
+TextureWrapMode enum:
+ CLAMP = 0x2900
+ REPEAT = 0x2901
+ use SGIS_texture_border_clamp CLAMP_TO_BORDER_SGIS
+ use SGIS_texture_edge_clamp CLAMP_TO_EDGE_SGIS
+
+###############################################################################
+
+PixelInternalFormat enum:
+ R3_G3_B2 = 0x2A10
+ ALPHA4 = 0x803B
+ ALPHA8 = 0x803C
+ ALPHA12 = 0x803D
+ ALPHA16 = 0x803E
+ LUMINANCE4 = 0x803F
+ LUMINANCE8 = 0x8040
+ LUMINANCE12 = 0x8041
+ LUMINANCE16 = 0x8042
+ LUMINANCE4_ALPHA4 = 0x8043
+ LUMINANCE6_ALPHA2 = 0x8044
+ LUMINANCE8_ALPHA8 = 0x8045
+ LUMINANCE12_ALPHA4 = 0x8046
+ LUMINANCE12_ALPHA12 = 0x8047
+ LUMINANCE16_ALPHA16 = 0x8048
+ INTENSITY = 0x8049
+ INTENSITY4 = 0x804A
+ INTENSITY8 = 0x804B
+ INTENSITY12 = 0x804C
+ INTENSITY16 = 0x804D
+ RGB4 = 0x804F
+ RGB5 = 0x8050
+ RGB8 = 0x8051
+ RGB10 = 0x8052
+ RGB12 = 0x8053
+ RGB16 = 0x8054
+ RGBA2 = 0x8055
+ RGBA4 = 0x8056
+ RGB5_A1 = 0x8057
+ RGBA8 = 0x8058
+ RGB10_A2 = 0x8059
+ RGBA12 = 0x805A
+ RGBA16 = 0x805B
+ use EXT_texture RGB2_EXT
+ use SGIS_texture_select DUAL_ALPHA4_SGIS
+ use SGIS_texture_select DUAL_ALPHA8_SGIS
+ use SGIS_texture_select DUAL_ALPHA12_SGIS
+ use SGIS_texture_select DUAL_ALPHA16_SGIS
+ use SGIS_texture_select DUAL_LUMINANCE4_SGIS
+ use SGIS_texture_select DUAL_LUMINANCE8_SGIS
+ use SGIS_texture_select DUAL_LUMINANCE12_SGIS
+ use SGIS_texture_select DUAL_LUMINANCE16_SGIS
+ use SGIS_texture_select DUAL_INTENSITY4_SGIS
+ use SGIS_texture_select DUAL_INTENSITY8_SGIS
+ use SGIS_texture_select DUAL_INTENSITY12_SGIS
+ use SGIS_texture_select DUAL_INTENSITY16_SGIS
+ use SGIS_texture_select DUAL_LUMINANCE_ALPHA4_SGIS
+ use SGIS_texture_select DUAL_LUMINANCE_ALPHA8_SGIS
+ use SGIS_texture_select QUAD_ALPHA4_SGIS
+ use SGIS_texture_select QUAD_ALPHA8_SGIS
+ use SGIS_texture_select QUAD_LUMINANCE4_SGIS
+ use SGIS_texture_select QUAD_LUMINANCE8_SGIS
+ use SGIS_texture_select QUAD_INTENSITY4_SGIS
+ use SGIS_texture_select QUAD_INTENSITY8_SGIS
+ use SGIX_depth_texture DEPTH_COMPONENT16_SGIX
+ use SGIX_depth_texture DEPTH_COMPONENT24_SGIX
+ use SGIX_depth_texture DEPTH_COMPONENT32_SGIX
+ use SGIX_icc_texture RGB_ICC_SGIX
+ use SGIX_icc_texture RGBA_ICC_SGIX
+ use SGIX_icc_texture ALPHA_ICC_SGIX
+ use SGIX_icc_texture LUMINANCE_ICC_SGIX
+ use SGIX_icc_texture INTENSITY_ICC_SGIX
+ use SGIX_icc_texture LUMINANCE_ALPHA_ICC_SGIX
+ use SGIX_icc_texture R5_G6_B5_ICC_SGIX
+ use SGIX_icc_texture R5_G6_B5_A8_ICC_SGIX
+ use SGIX_icc_texture ALPHA16_ICC_SGIX
+ use SGIX_icc_texture LUMINANCE16_ICC_SGIX
+ use SGIX_icc_texture INTENSITY16_ICC_SGIX
+ use SGIX_icc_texture LUMINANCE16_ALPHA8_ICC_SGIX
+
+###############################################################################
+
+InterleavedArrayFormat enum:
+ V2F = 0x2A20
+ V3F = 0x2A21
+ C4UB_V2F = 0x2A22
+ C4UB_V3F = 0x2A23
+ C3F_V3F = 0x2A24
+ N3F_V3F = 0x2A25
+ C4F_N3F_V3F = 0x2A26
+ T2F_V3F = 0x2A27
+ T4F_V4F = 0x2A28
+ T2F_C4UB_V3F = 0x2A29
+ T2F_C3F_V3F = 0x2A2A
+ T2F_N3F_V3F = 0x2A2B
+ T2F_C4F_N3F_V3F = 0x2A2C
+ T4F_C4F_N3F_V4F = 0x2A2D
+
+###############################################################################
+
+VertexPointerType enum:
+ use DataType SHORT
+ use DataType INT
+ use DataType FLOAT
+ use DataType DOUBLE
+
+###############################################################################
+
+# 0x3000 through 0x3FFF are reserved for clip planes
+ClipPlaneName enum:
+ CLIP_PLANE0 = 0x3000 # 1 I
+ CLIP_PLANE1 = 0x3001 # 1 I
+ CLIP_PLANE2 = 0x3002 # 1 I
+ CLIP_PLANE3 = 0x3003 # 1 I
+ CLIP_PLANE4 = 0x3004 # 1 I
+ CLIP_PLANE5 = 0x3005 # 1 I
+
+###############################################################################
+
+# 0x4000-0x4FFF are reserved for light numbers
+LightName enum:
+ LIGHT0 = 0x4000 # 1 I
+ LIGHT1 = 0x4001 # 1 I
+ LIGHT2 = 0x4002 # 1 I
+ LIGHT3 = 0x4003 # 1 I
+ LIGHT4 = 0x4004 # 1 I
+ LIGHT5 = 0x4005 # 1 I
+ LIGHT6 = 0x4006 # 1 I
+ LIGHT7 = 0x4007 # 1 I
+ use SGIX_fragment_lighting FRAGMENT_LIGHT0_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT1_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT2_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT3_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT4_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT5_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT6_SGIX
+ use SGIX_fragment_lighting FRAGMENT_LIGHT7_SGIX
+
+###############################################################################
+
+EXT_abgr enum:
+ ABGR_EXT = 0x8000
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_blend_color enum:
+ CONSTANT_COLOR = 0x8001
+ CONSTANT_COLOR_EXT = 0x8001
+ ONE_MINUS_CONSTANT_COLOR = 0x8002
+ ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002
+ CONSTANT_ALPHA = 0x8003
+ CONSTANT_ALPHA_EXT = 0x8003
+ ONE_MINUS_CONSTANT_ALPHA = 0x8004
+ ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004
+ BLEND_COLOR = 0x8005 # 4 F
+ BLEND_COLOR_EXT = 0x8005 # 4 F
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_blend_minmax enum:
+ FUNC_ADD = 0x8006
+ FUNC_ADD_EXT = 0x8006
+ MIN = 0x8007
+ MIN_EXT = 0x8007
+ MAX = 0x8008
+ MAX_EXT = 0x8008
+ BLEND_EQUATION = 0x8009 # 1 I
+ BLEND_EQUATION_EXT = 0x8009 # 1 I
+
+# VERSION_2_0 enum: (Promoted for OpenGL 2.0)
+# EXT_blend_equation_separate enum: (separate; see below)
+# BLEND_EQUATION_RGB = GL_BLEND_EQUATION # VERSION_2_0
+# BLEND_EQUATION_RGB_EXT = GL_BLEND_EQUATION
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_blend_subtract enum:
+ FUNC_SUBTRACT = 0x800A
+ FUNC_SUBTRACT_EXT = 0x800A
+ FUNC_REVERSE_SUBTRACT = 0x800B
+ FUNC_REVERSE_SUBTRACT_EXT = 0x800B
+
+###############################################################################
+
+EXT_cmyka enum:
+ CMYK_EXT = 0x800C
+ CMYKA_EXT = 0x800D
+ PACK_CMYK_HINT_EXT = 0x800E # 1 I
+ UNPACK_CMYK_HINT_EXT = 0x800F # 1 I
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_convolution enum:
+ CONVOLUTION_1D = 0x8010 # 1 I
+ CONVOLUTION_1D_EXT = 0x8010 # 1 I
+ CONVOLUTION_2D = 0x8011 # 1 I
+ CONVOLUTION_2D_EXT = 0x8011 # 1 I
+ SEPARABLE_2D = 0x8012 # 1 I
+ SEPARABLE_2D_EXT = 0x8012 # 1 I
+ CONVOLUTION_BORDER_MODE = 0x8013
+ CONVOLUTION_BORDER_MODE_EXT = 0x8013
+ CONVOLUTION_FILTER_SCALE = 0x8014
+ CONVOLUTION_FILTER_SCALE_EXT = 0x8014
+ CONVOLUTION_FILTER_BIAS = 0x8015
+ CONVOLUTION_FILTER_BIAS_EXT = 0x8015
+ REDUCE = 0x8016
+ REDUCE_EXT = 0x8016
+ CONVOLUTION_FORMAT = 0x8017
+ CONVOLUTION_FORMAT_EXT = 0x8017
+ CONVOLUTION_WIDTH = 0x8018
+ CONVOLUTION_WIDTH_EXT = 0x8018
+ CONVOLUTION_HEIGHT = 0x8019
+ CONVOLUTION_HEIGHT_EXT = 0x8019
+ MAX_CONVOLUTION_WIDTH = 0x801A
+ MAX_CONVOLUTION_WIDTH_EXT = 0x801A
+ MAX_CONVOLUTION_HEIGHT = 0x801B
+ MAX_CONVOLUTION_HEIGHT_EXT = 0x801B
+ POST_CONVOLUTION_RED_SCALE = 0x801C # 1 F
+ POST_CONVOLUTION_RED_SCALE_EXT = 0x801C # 1 F
+ POST_CONVOLUTION_GREEN_SCALE = 0x801D # 1 F
+ POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D # 1 F
+ POST_CONVOLUTION_BLUE_SCALE = 0x801E # 1 F
+ POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E # 1 F
+ POST_CONVOLUTION_ALPHA_SCALE = 0x801F # 1 F
+ POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F # 1 F
+ POST_CONVOLUTION_RED_BIAS = 0x8020 # 1 F
+ POST_CONVOLUTION_RED_BIAS_EXT = 0x8020 # 1 F
+ POST_CONVOLUTION_GREEN_BIAS = 0x8021 # 1 F
+ POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021 # 1 F
+ POST_CONVOLUTION_BLUE_BIAS = 0x8022 # 1 F
+ POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022 # 1 F
+ POST_CONVOLUTION_ALPHA_BIAS = 0x8023 # 1 F
+ POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023 # 1 F
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_histogram enum:
+ HISTOGRAM = 0x8024 # 1 I
+ HISTOGRAM_EXT = 0x8024 # 1 I
+ PROXY_HISTOGRAM = 0x8025
+ PROXY_HISTOGRAM_EXT = 0x8025
+ HISTOGRAM_WIDTH = 0x8026
+ HISTOGRAM_WIDTH_EXT = 0x8026
+ HISTOGRAM_FORMAT = 0x8027
+ HISTOGRAM_FORMAT_EXT = 0x8027
+ HISTOGRAM_RED_SIZE = 0x8028
+ HISTOGRAM_RED_SIZE_EXT = 0x8028
+ HISTOGRAM_GREEN_SIZE = 0x8029
+ HISTOGRAM_GREEN_SIZE_EXT = 0x8029
+ HISTOGRAM_BLUE_SIZE = 0x802A
+ HISTOGRAM_BLUE_SIZE_EXT = 0x802A
+ HISTOGRAM_ALPHA_SIZE = 0x802B
+ HISTOGRAM_ALPHA_SIZE_EXT = 0x802B
+ HISTOGRAM_LUMINANCE_SIZE = 0x802C
+ HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C
+ HISTOGRAM_SINK = 0x802D
+ HISTOGRAM_SINK_EXT = 0x802D
+ MINMAX = 0x802E # 1 I
+ MINMAX_EXT = 0x802E # 1 I
+ MINMAX_FORMAT = 0x802F
+ MINMAX_FORMAT_EXT = 0x802F
+ MINMAX_SINK = 0x8030
+ MINMAX_SINK_EXT = 0x8030
+ TABLE_TOO_LARGE = 0x8031
+ TABLE_TOO_LARGE_EXT = 0x8031
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_packed_pixels enum:
+ UNSIGNED_BYTE_3_3_2 = 0x8032
+ UNSIGNED_BYTE_3_3_2_EXT = 0x8032
+ UNSIGNED_SHORT_4_4_4_4 = 0x8033
+ UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033
+ UNSIGNED_SHORT_5_5_5_1 = 0x8034
+ UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034
+ UNSIGNED_INT_8_8_8_8 = 0x8035
+ UNSIGNED_INT_8_8_8_8_EXT = 0x8035
+ UNSIGNED_INT_10_10_10_2 = 0x8036
+ UNSIGNED_INT_10_10_10_2_EXT = 0x8036
+ UNSIGNED_BYTE_2_3_3_REV = 0x8362
+ UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362
+ UNSIGNED_SHORT_5_6_5 = 0x8363
+ UNSIGNED_SHORT_5_6_5_EXT = 0x8363
+ UNSIGNED_SHORT_5_6_5_REV = 0x8364
+ UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364
+ UNSIGNED_SHORT_4_4_4_4_REV = 0x8365
+ UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365
+ UNSIGNED_SHORT_1_5_5_5_REV = 0x8366
+ UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366
+ UNSIGNED_INT_8_8_8_8_REV = 0x8367
+ UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367
+ UNSIGNED_INT_2_10_10_10_REV = 0x8368
+ UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368
+
+###############################################################################
+
+EXT_polygon_offset enum:
+ POLYGON_OFFSET_EXT = 0x8037
+ POLYGON_OFFSET_FACTOR_EXT = 0x8038
+ POLYGON_OFFSET_BIAS_EXT = 0x8039 # 1 F
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_rescale_normal enum:
+ RESCALE_NORMAL = 0x803A # 1 I
+ RESCALE_NORMAL_EXT = 0x803A # 1 I
+
+###############################################################################
+
+EXT_texture enum:
+ ALPHA4_EXT = 0x803B
+ ALPHA8_EXT = 0x803C
+ ALPHA12_EXT = 0x803D
+ ALPHA16_EXT = 0x803E
+ LUMINANCE4_EXT = 0x803F
+ LUMINANCE8_EXT = 0x8040
+ LUMINANCE12_EXT = 0x8041
+ LUMINANCE16_EXT = 0x8042
+ LUMINANCE4_ALPHA4_EXT = 0x8043
+ LUMINANCE6_ALPHA2_EXT = 0x8044
+ LUMINANCE8_ALPHA8_EXT = 0x8045
+ LUMINANCE12_ALPHA4_EXT = 0x8046
+ LUMINANCE12_ALPHA12_EXT = 0x8047
+ LUMINANCE16_ALPHA16_EXT = 0x8048
+ INTENSITY_EXT = 0x8049
+ INTENSITY4_EXT = 0x804A
+ INTENSITY8_EXT = 0x804B
+ INTENSITY12_EXT = 0x804C
+ INTENSITY16_EXT = 0x804D
+ RGB2_EXT = 0x804E
+ RGB4_EXT = 0x804F
+ RGB5_EXT = 0x8050
+ RGB8_EXT = 0x8051
+ RGB10_EXT = 0x8052
+ RGB12_EXT = 0x8053
+ RGB16_EXT = 0x8054
+ RGBA2_EXT = 0x8055
+ RGBA4_EXT = 0x8056
+ RGB5_A1_EXT = 0x8057
+ RGBA8_EXT = 0x8058
+ RGB10_A2_EXT = 0x8059
+ RGBA12_EXT = 0x805A
+ RGBA16_EXT = 0x805B
+ TEXTURE_RED_SIZE_EXT = 0x805C
+ TEXTURE_GREEN_SIZE_EXT = 0x805D
+ TEXTURE_BLUE_SIZE_EXT = 0x805E
+ TEXTURE_ALPHA_SIZE_EXT = 0x805F
+ TEXTURE_LUMINANCE_SIZE_EXT = 0x8060
+ TEXTURE_INTENSITY_SIZE_EXT = 0x8061
+ REPLACE_EXT = 0x8062
+ PROXY_TEXTURE_1D_EXT = 0x8063
+ PROXY_TEXTURE_2D_EXT = 0x8064
+ TEXTURE_TOO_LARGE_EXT = 0x8065
+
+###############################################################################
+
+EXT_texture_object enum:
+ TEXTURE_PRIORITY_EXT = 0x8066
+ TEXTURE_RESIDENT_EXT = 0x8067
+ TEXTURE_1D_BINDING_EXT = 0x8068
+ TEXTURE_2D_BINDING_EXT = 0x8069
+ TEXTURE_3D_BINDING_EXT = 0x806A # 1 I
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_texture3D enum:
+ PACK_SKIP_IMAGES = 0x806B # 1 I
+ PACK_SKIP_IMAGES_EXT = 0x806B # 1 I
+ PACK_IMAGE_HEIGHT = 0x806C # 1 F
+ PACK_IMAGE_HEIGHT_EXT = 0x806C # 1 F
+ UNPACK_SKIP_IMAGES = 0x806D # 1 I
+ UNPACK_SKIP_IMAGES_EXT = 0x806D # 1 I
+ UNPACK_IMAGE_HEIGHT = 0x806E # 1 F
+ UNPACK_IMAGE_HEIGHT_EXT = 0x806E # 1 F
+ TEXTURE_3D = 0x806F # 1 I
+ TEXTURE_3D_EXT = 0x806F # 1 I
+ PROXY_TEXTURE_3D = 0x8070
+ PROXY_TEXTURE_3D_EXT = 0x8070
+ TEXTURE_DEPTH = 0x8071
+ TEXTURE_DEPTH_EXT = 0x8071
+ TEXTURE_WRAP_R = 0x8072
+ TEXTURE_WRAP_R_EXT = 0x8072
+ MAX_3D_TEXTURE_SIZE = 0x8073 # 1 I
+ MAX_3D_TEXTURE_SIZE_EXT = 0x8073 # 1 I
+
+###############################################################################
+
+EXT_vertex_array enum:
+ VERTEX_ARRAY_EXT = 0x8074
+ NORMAL_ARRAY_EXT = 0x8075
+ COLOR_ARRAY_EXT = 0x8076
+ INDEX_ARRAY_EXT = 0x8077
+ TEXTURE_COORD_ARRAY_EXT = 0x8078
+ EDGE_FLAG_ARRAY_EXT = 0x8079
+ VERTEX_ARRAY_SIZE_EXT = 0x807A
+ VERTEX_ARRAY_TYPE_EXT = 0x807B
+ VERTEX_ARRAY_STRIDE_EXT = 0x807C
+ VERTEX_ARRAY_COUNT_EXT = 0x807D # 1 I
+ NORMAL_ARRAY_TYPE_EXT = 0x807E
+ NORMAL_ARRAY_STRIDE_EXT = 0x807F
+ NORMAL_ARRAY_COUNT_EXT = 0x8080 # 1 I
+ COLOR_ARRAY_SIZE_EXT = 0x8081
+ COLOR_ARRAY_TYPE_EXT = 0x8082
+ COLOR_ARRAY_STRIDE_EXT = 0x8083
+ COLOR_ARRAY_COUNT_EXT = 0x8084 # 1 I
+ INDEX_ARRAY_TYPE_EXT = 0x8085
+ INDEX_ARRAY_STRIDE_EXT = 0x8086
+ INDEX_ARRAY_COUNT_EXT = 0x8087 # 1 I
+ TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088
+ TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089
+ TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A
+ TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B # 1 I
+ EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C
+ EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D # 1 I
+ VERTEX_ARRAY_POINTER_EXT = 0x808E
+ NORMAL_ARRAY_POINTER_EXT = 0x808F
+ COLOR_ARRAY_POINTER_EXT = 0x8090
+ INDEX_ARRAY_POINTER_EXT = 0x8091
+ TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092
+ EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093
+
+###############################################################################
+
+SGIX_interlace enum:
+ INTERLACE_SGIX = 0x8094 # 1 I
+
+###############################################################################
+
+SGIS_detail_texture enum:
+ DETAIL_TEXTURE_2D_SGIS = 0x8095
+ DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096 # 1 I
+ LINEAR_DETAIL_SGIS = 0x8097
+ LINEAR_DETAIL_ALPHA_SGIS = 0x8098
+ LINEAR_DETAIL_COLOR_SGIS = 0x8099
+ DETAIL_TEXTURE_LEVEL_SGIS = 0x809A
+ DETAIL_TEXTURE_MODE_SGIS = 0x809B
+ DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C
+
+###############################################################################
+
+# Reuses some SGIS_multisample values
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+ARB_multisample enum:
+ MULTISAMPLE = 0x809D
+ MULTISAMPLE_ARB = 0x809D
+ SAMPLE_ALPHA_TO_COVERAGE = 0x809E
+ SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E
+ SAMPLE_ALPHA_TO_ONE = 0x809F
+ SAMPLE_ALPHA_TO_ONE_ARB = 0x809F
+ SAMPLE_COVERAGE = 0x80A0
+ SAMPLE_COVERAGE_ARB = 0x80A0
+ SAMPLE_BUFFERS = 0x80A8 # 1 I
+ SAMPLE_BUFFERS_ARB = 0x80A8 # 1 I
+ SAMPLES = 0x80A9 # 1 I
+ SAMPLES_ARB = 0x80A9 # 1 I
+ SAMPLE_COVERAGE_VALUE = 0x80AA # 1 F
+ SAMPLE_COVERAGE_VALUE_ARB = 0x80AA # 1 F
+ SAMPLE_COVERAGE_INVERT = 0x80AB # 1 I
+ SAMPLE_COVERAGE_INVERT_ARB = 0x80AB # 1 I
+
+SGIS_multisample enum:
+ MULTISAMPLE_SGIS = 0x809D # 1 I
+ SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E # 1 I
+ SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F # 1 I
+ SAMPLE_MASK_SGIS = 0x80A0 # 1 I
+ 1PASS_SGIS = 0x80A1
+ 2PASS_0_SGIS = 0x80A2
+ 2PASS_1_SGIS = 0x80A3
+ 4PASS_0_SGIS = 0x80A4
+ 4PASS_1_SGIS = 0x80A5
+ 4PASS_2_SGIS = 0x80A6
+ 4PASS_3_SGIS = 0x80A7
+ SAMPLE_BUFFERS_SGIS = 0x80A8 # 1 I
+ SAMPLES_SGIS = 0x80A9 # 1 I
+ SAMPLE_MASK_VALUE_SGIS = 0x80AA # 1 F
+ SAMPLE_MASK_INVERT_SGIS = 0x80AB # 1 I
+ SAMPLE_PATTERN_SGIS = 0x80AC # 1 I
+
+# Reuses SGIS_multisample values.
+# EXT_multisample enum:
+# MULTISAMPLE_EXT = 0x809D
+# SAMPLE_ALPHA_TO_MASK_EXT = 0x809E
+# SAMPLE_ALPHA_TO_ONE_EXT = 0x809F
+# SAMPLE_MASK_EXT = 0x80A0
+# 1PASS_EXT = 0x80A1
+# 2PASS_0_EXT = 0x80A2
+# 2PASS_1_EXT = 0x80A3
+# 4PASS_0_EXT = 0x80A4
+# 4PASS_1_EXT = 0x80A5
+# 4PASS_2_EXT = 0x80A6
+# 4PASS_3_EXT = 0x80A7
+# SAMPLE_BUFFERS_EXT = 0x80A8 # 1 I
+# SAMPLES_EXT = 0x80A9 # 1 I
+# SAMPLE_MASK_VALUE_EXT = 0x80AA # 1 F
+# SAMPLE_MASK_INVERT_EXT = 0x80AB # 1 I
+# SAMPLE_PATTERN_EXT = 0x80AC # 1 I
+# MULTISAMPLE_BIT_EXT = 0x20000000
+
+###############################################################################
+
+SGIS_sharpen_texture enum:
+ LINEAR_SHARPEN_SGIS = 0x80AD
+ LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE
+ LINEAR_SHARPEN_COLOR_SGIS = 0x80AF
+ SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+SGI_color_matrix enum:
+ COLOR_MATRIX = 0x80B1 # 16 F
+ COLOR_MATRIX_SGI = 0x80B1 # 16 F
+ COLOR_MATRIX_STACK_DEPTH = 0x80B2 # 1 I
+ COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2 # 1 I
+ MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3 # 1 I
+ MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3 # 1 I
+ POST_COLOR_MATRIX_RED_SCALE = 0x80B4 # 1 F
+ POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4 # 1 F
+ POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5 # 1 F
+ POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5 # 1 F
+ POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6 # 1 F
+ POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6 # 1 F
+ POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7 # 1 F
+ POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7 # 1 F
+ POST_COLOR_MATRIX_RED_BIAS = 0x80B8 # 1 F
+ POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8 # 1 F
+ POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9 # 1 F
+ POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9 # 1 F
+ POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA # 1 F
+ POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA # 1 F
+ POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB # 1 F
+ POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB # 1 F
+
+###############################################################################
+
+SGI_texture_color_table enum:
+ TEXTURE_COLOR_TABLE_SGI = 0x80BC # 1 I
+ PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD
+
+###############################################################################
+
+SGIX_texture_add_env enum:
+ TEXTURE_ENV_BIAS_SGIX = 0x80BE
+
+###############################################################################
+
+SGIX_shadow_ambient enum:
+ SHADOW_AMBIENT_SGIX = 0x80BF
+
+###############################################################################
+
+# Intergraph/Intense3D/3Dlabs: 0x80C0-0x80CF
+
+# 3Dlabs_future_use: 0x80C0-0x80C7
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# EXT_blend_func_separate enum:
+# BLEND_DST_RGB = 0x80C8
+# BLEND_DST_RGB_EXT = 0x80C8
+# BLEND_SRC_RGB = 0x80C9
+# BLEND_SRC_RGB_EXT = 0x80C9
+# BLEND_DST_ALPHA = 0x80CA
+# BLEND_DST_ALPHA_EXT = 0x80CA
+# BLEND_SRC_ALPHA = 0x80CB
+# BLEND_SRC_ALPHA_EXT = 0x80CB
+
+# EXT_422_pixels enum:
+# 422_EXT = 0x80CC
+# 422_REV_EXT = 0x80CD
+# 422_AVERAGE_EXT = 0x80CE
+# 422_REV_AVERAGE_EXT = 0x80CF
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+SGI_color_table enum:
+ COLOR_TABLE = 0x80D0 # 1 I
+ COLOR_TABLE_SGI = 0x80D0 # 1 I
+ POST_CONVOLUTION_COLOR_TABLE = 0x80D1 # 1 I
+ POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1 # 1 I
+ POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2 # 1 I
+ POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2 # 1 I
+ PROXY_COLOR_TABLE = 0x80D3
+ PROXY_COLOR_TABLE_SGI = 0x80D3
+ PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4
+ PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5
+ COLOR_TABLE_SCALE = 0x80D6
+ COLOR_TABLE_SCALE_SGI = 0x80D6
+ COLOR_TABLE_BIAS = 0x80D7
+ COLOR_TABLE_BIAS_SGI = 0x80D7
+ COLOR_TABLE_FORMAT = 0x80D8
+ COLOR_TABLE_FORMAT_SGI = 0x80D8
+ COLOR_TABLE_WIDTH = 0x80D9
+ COLOR_TABLE_WIDTH_SGI = 0x80D9
+ COLOR_TABLE_RED_SIZE = 0x80DA
+ COLOR_TABLE_RED_SIZE_SGI = 0x80DA
+ COLOR_TABLE_GREEN_SIZE = 0x80DB
+ COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB
+ COLOR_TABLE_BLUE_SIZE = 0x80DC
+ COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC
+ COLOR_TABLE_ALPHA_SIZE = 0x80DD
+ COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD
+ COLOR_TABLE_LUMINANCE_SIZE = 0x80DE
+ COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE
+ COLOR_TABLE_INTENSITY_SIZE = 0x80DF
+ COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_bgra enum:
+ BGR = 0x80E0
+ BGR_EXT = 0x80E0
+ BGRA = 0x80E1
+ BGRA_EXT = 0x80E1
+
+###############################################################################
+
+# Microsoft: 0x80E2-0x80E7
+
+###############################################################################
+
+VERSION_1_2 enum:
+ MAX_ELEMENTS_VERTICES = 0x80E8
+ MAX_ELEMENTS_INDICES = 0x80E9
+
+###############################################################################
+
+# Microsoft: 0x80EA-0x810F
+
+###############################################################################
+
+SGIS_texture_select enum:
+ DUAL_ALPHA4_SGIS = 0x8110
+ DUAL_ALPHA8_SGIS = 0x8111
+ DUAL_ALPHA12_SGIS = 0x8112
+ DUAL_ALPHA16_SGIS = 0x8113
+ DUAL_LUMINANCE4_SGIS = 0x8114
+ DUAL_LUMINANCE8_SGIS = 0x8115
+ DUAL_LUMINANCE12_SGIS = 0x8116
+ DUAL_LUMINANCE16_SGIS = 0x8117
+ DUAL_INTENSITY4_SGIS = 0x8118
+ DUAL_INTENSITY8_SGIS = 0x8119
+ DUAL_INTENSITY12_SGIS = 0x811A
+ DUAL_INTENSITY16_SGIS = 0x811B
+ DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C
+ DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D
+ QUAD_ALPHA4_SGIS = 0x811E
+ QUAD_ALPHA8_SGIS = 0x811F
+ QUAD_LUMINANCE4_SGIS = 0x8120
+ QUAD_LUMINANCE8_SGIS = 0x8121
+ QUAD_INTENSITY4_SGIS = 0x8122
+ QUAD_INTENSITY8_SGIS = 0x8123
+ DUAL_TEXTURE_SELECT_SGIS = 0x8124
+ QUAD_TEXTURE_SELECT_SGIS = 0x8125
+
+###############################################################################
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# ARB_point_parameters enum:
+# EXT_point_parameters enum:
+SGIS_point_parameters enum:
+ POINT_SIZE_MIN = 0x8126 # 1 F
+ POINT_SIZE_MIN_ARB = 0x8126 # 1 F
+ POINT_SIZE_MIN_EXT = 0x8126 # 1 F
+ POINT_SIZE_MIN_SGIS = 0x8126 # 1 F
+ POINT_SIZE_MAX = 0x8127 # 1 F
+ POINT_SIZE_MAX_ARB = 0x8127 # 1 F
+ POINT_SIZE_MAX_EXT = 0x8127 # 1 F
+ POINT_SIZE_MAX_SGIS = 0x8127 # 1 F
+ POINT_FADE_THRESHOLD_SIZE = 0x8128 # 1 F
+ POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128 # 1 F
+ POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128 # 1 F
+ POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128 # 1 F
+ POINT_DISTANCE_ATTENUATION = 0x8129 # 3 F
+ POINT_DISTANCE_ATTENUATION_ARB = 0x8129 # 3 F
+ DISTANCE_ATTENUATION_EXT = 0x8129 # 3 F
+ DISTANCE_ATTENUATION_SGIS = 0x8129 # 3 F
+
+###############################################################################
+
+SGIS_fog_function enum:
+ FOG_FUNC_SGIS = 0x812A
+ FOG_FUNC_POINTS_SGIS = 0x812B # 1 I
+ MAX_FOG_FUNC_POINTS_SGIS = 0x812C # 1 I
+
+###############################################################################
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# ARB_texture_border_clamp enum:
+SGIS_texture_border_clamp enum:
+ CLAMP_TO_BORDER = 0x812D
+ CLAMP_TO_BORDER_ARB = 0x812D
+ CLAMP_TO_BORDER_SGIS = 0x812D
+
+###############################################################################
+
+SGIX_texture_multi_buffer enum:
+ TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+SGIS_texture_edge_clamp enum:
+ CLAMP_TO_EDGE = 0x812F
+ CLAMP_TO_EDGE_SGIS = 0x812F
+
+###############################################################################
+
+SGIS_texture4D enum:
+ PACK_SKIP_VOLUMES_SGIS = 0x8130 # 1 I
+ PACK_IMAGE_DEPTH_SGIS = 0x8131 # 1 I
+ UNPACK_SKIP_VOLUMES_SGIS = 0x8132 # 1 I
+ UNPACK_IMAGE_DEPTH_SGIS = 0x8133 # 1 I
+ TEXTURE_4D_SGIS = 0x8134 # 1 I
+ PROXY_TEXTURE_4D_SGIS = 0x8135
+ TEXTURE_4DSIZE_SGIS = 0x8136
+ TEXTURE_WRAP_Q_SGIS = 0x8137
+ MAX_4D_TEXTURE_SIZE_SGIS = 0x8138 # 1 I
+ TEXTURE_4D_BINDING_SGIS = 0x814F # 1 I
+
+###############################################################################
+
+SGIX_pixel_texture enum:
+ PIXEL_TEX_GEN_SGIX = 0x8139 # 1 I
+ PIXEL_TEX_GEN_MODE_SGIX = 0x832B # 1 I
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+SGIS_texture_lod enum:
+ TEXTURE_MIN_LOD = 0x813A
+ TEXTURE_MIN_LOD_SGIS = 0x813A
+ TEXTURE_MAX_LOD = 0x813B
+ TEXTURE_MAX_LOD_SGIS = 0x813B
+ TEXTURE_BASE_LEVEL = 0x813C
+ TEXTURE_BASE_LEVEL_SGIS = 0x813C
+ TEXTURE_MAX_LEVEL = 0x813D
+ TEXTURE_MAX_LEVEL_SGIS = 0x813D
+
+###############################################################################
+
+SGIX_pixel_tiles enum:
+ PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E # 1 I
+ PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F # 1 I
+ PIXEL_TILE_WIDTH_SGIX = 0x8140 # 1 I
+ PIXEL_TILE_HEIGHT_SGIX = 0x8141 # 1 I
+ PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142 # 1 I
+
+ PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143 # 1 I
+ PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144 # 1 I
+ PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145 # 1 I
+
+###############################################################################
+
+SGIS_texture_filter4 enum:
+ FILTER4_SGIS = 0x8146
+ TEXTURE_FILTER4_SIZE_SGIS = 0x8147
+
+###############################################################################
+
+SGIX_sprite enum:
+ SPRITE_SGIX = 0x8148 # 1 I
+ SPRITE_MODE_SGIX = 0x8149 # 1 I
+ SPRITE_AXIS_SGIX = 0x814A # 3 F
+ SPRITE_TRANSLATION_SGIX = 0x814B # 3 F
+ SPRITE_AXIAL_SGIX = 0x814C
+ SPRITE_OBJECT_ALIGNED_SGIX = 0x814D
+ SPRITE_EYE_ALIGNED_SGIX = 0x814E
+
+###############################################################################
+
+# SGIS_texture4D (additional; see above): 0x814F
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+# IGNORE_BORDER was *not* promoted into OpenGL 1.2
+HP_convolution_border_modes enum:
+ IGNORE_BORDER_HP = 0x8150
+ CONSTANT_BORDER = 0x8151
+ CONSTANT_BORDER_HP = 0x8151
+# WRAP_BORDER = 0x8152 # Not actually promoted?
+ REPLICATE_BORDER = 0x8153
+ REPLICATE_BORDER_HP = 0x8153
+ CONVOLUTION_BORDER_COLOR = 0x8154
+ CONVOLUTION_BORDER_COLOR_HP = 0x8154
+
+###############################################################################
+
+# HP: 0x8155-0x816F
+
+###############################################################################
+
+SGIX_clipmap enum:
+ LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170
+ TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171
+ TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172
+ TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173
+ TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174
+ TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175
+ TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176
+ MAX_CLIPMAP_DEPTH_SGIX = 0x8177 # 1 I
+ MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178 # 1 I
+ NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D
+ NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E
+ LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F
+
+###############################################################################
+
+SGIX_texture_scale_bias enum:
+ POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179
+ POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A
+ POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B # 2 F
+ POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C # 2 F
+
+###############################################################################
+
+SGIX_reference_plane enum:
+ REFERENCE_PLANE_SGIX = 0x817D # 1 I
+ REFERENCE_PLANE_EQUATION_SGIX = 0x817E # 4 F
+
+###############################################################################
+
+SGIX_ir_instrument1 enum:
+ IR_INSTRUMENT1_SGIX = 0x817F # 1 I
+
+###############################################################################
+
+SGIX_instruments enum:
+ INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180
+ INSTRUMENT_MEASUREMENTS_SGIX = 0x8181 # 1 I
+
+###############################################################################
+
+SGIX_list_priority enum:
+ LIST_PRIORITY_SGIX = 0x8182
+
+###############################################################################
+
+SGIX_calligraphic_fragment enum:
+ CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183 # 1 I
+
+###############################################################################
+
+SGIX_impact_pixel_texture enum:
+ PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184
+ PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185
+ PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186
+ PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187
+ PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188
+ PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189
+ PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A
+
+###############################################################################
+
+SGIX_framezoom enum:
+ FRAMEZOOM_SGIX = 0x818B # 1 I
+ FRAMEZOOM_FACTOR_SGIX = 0x818C # 1 I
+ MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D # 1 I
+
+###############################################################################
+
+SGIX_texture_lod_bias enum:
+ TEXTURE_LOD_BIAS_S_SGIX = 0x818E
+ TEXTURE_LOD_BIAS_T_SGIX = 0x818F
+ TEXTURE_LOD_BIAS_R_SGIX = 0x8190
+
+###############################################################################
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+SGIS_generate_mipmap enum:
+ GENERATE_MIPMAP = 0x8191
+ GENERATE_MIPMAP_SGIS = 0x8191
+ GENERATE_MIPMAP_HINT = 0x8192 # 1 I
+ GENERATE_MIPMAP_HINT_SGIS = 0x8192 # 1 I
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_spotlight_cutoff: 0x8193
+# SPOT_CUTOFF_DELTA_SGIX = 0x8193
+
+###############################################################################
+
+# SGIX_polynomial_ffd enum:
+ GEOMETRY_DEFORMATION_SGIX = 0x8194
+ TEXTURE_DEFORMATION_SGIX = 0x8195
+ DEFORMATIONS_MASK_SGIX = 0x8196 # 1 I
+ MAX_DEFORMATION_ORDER_SGIX = 0x8197
+
+###############################################################################
+
+SGIX_fog_offset enum:
+ FOG_OFFSET_SGIX = 0x8198 # 1 I
+ FOG_OFFSET_VALUE_SGIX = 0x8199 # 4 F
+
+###############################################################################
+
+SGIX_shadow enum:
+ TEXTURE_COMPARE_SGIX = 0x819A
+ TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B
+ TEXTURE_LEQUAL_R_SGIX = 0x819C
+ TEXTURE_GEQUAL_R_SGIX = 0x819D
+
+###############################################################################
+
+# SGI private extension, not in enumext.spec
+# SGIX_igloo_interface: 0x819E-0x81A4
+# IGLOO_FULLSCREEN_SGIX = 0x819E
+# IGLOO_VIEWPORT_OFFSET_SGIX = 0x819F
+# IGLOO_SWAPTMESH_SGIX = 0x81A0
+# IGLOO_COLORNORMAL_SGIX = 0x81A1
+# IGLOO_IRISGL_MODE_SGIX = 0x81A2
+# IGLOO_LMC_COLOR_SGIX = 0x81A3
+# IGLOO_TMESHMODE_SGIX = 0x81A4
+
+###############################################################################
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# ARB_depth_texture enum:
+SGIX_depth_texture enum:
+ DEPTH_COMPONENT16 = 0x81A5
+ DEPTH_COMPONENT16_SGIX = 0x81A5
+ DEPTH_COMPONENT24 = 0x81A6
+ DEPTH_COMPONENT24_SGIX = 0x81A6
+ DEPTH_COMPONENT32 = 0x81A7
+ DEPTH_COMPONENT32_SGIX = 0x81A7
+
+###############################################################################
+
+#EXT_compiled_vertex_array enum:
+# ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8
+# ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9
+
+###############################################################################
+
+#EXT_cull_vertex enum:
+# CULL_VERTEX_EXT = 0x81AA
+# CULL_VERTEX_EYE_POSITION_EXT = 0x81AB
+# CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC
+
+###############################################################################
+
+# Promoted from SGI?
+#EXT_index_array_formats enum:
+# IUI_V2F_EXT = 0x81AD
+# IUI_V3F_EXT = 0x81AE
+# IUI_N3F_V2F_EXT = 0x81AF
+# IUI_N3F_V3F_EXT = 0x81B0
+# T2F_IUI_V2F_EXT = 0x81B1
+# T2F_IUI_V3F_EXT = 0x81B2
+# T2F_IUI_N3F_V2F_EXT = 0x81B3
+# T2F_IUI_N3F_V3F_EXT = 0x81B4
+
+###############################################################################
+
+# Promoted from SGI?
+#EXT_index_func enum:
+# INDEX_TEST_EXT = 0x81B5
+# INDEX_TEST_FUNC_EXT = 0x81B6
+# INDEX_TEST_REF_EXT = 0x81B7
+
+###############################################################################
+
+# Promoted from SGI?
+#EXT_index_material enum:
+# INDEX_MATERIAL_EXT = 0x81B8
+# INDEX_MATERIAL_PARAMETER_EXT = 0x81B9
+# INDEX_MATERIAL_FACE_EXT = 0x81BA
+
+###############################################################################
+
+SGIX_ycrcb enum:
+ YCRCB_422_SGIX = 0x81BB
+ YCRCB_444_SGIX = 0x81BC
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGI_complex_type: 0x81BD-0x81C3
+# COMPLEX_UNSIGNED_BYTE_SGI = 0x81BD
+# COMPLEX_BYTE_SGI = 0x81BE
+# COMPLEX_UNSIGNED_SHORT_SGI = 0x81BF
+# COMPLEX_SHORT_SGI = 0x81C0
+# COMPLEX_UNSIGNED_INT_SGI = 0x81C1
+# COMPLEX_INT_SGI = 0x81C2
+# COMPLEX_FLOAT_SGI = 0x81C3
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGI_fft: 0x81C4-0x81CA
+# POST_TRANSFORM_RED_SCALE_SGI = ???? # 1 F
+# POST_TRANSFORM_GREEN_SCALE_SGI = ???? # 1 F
+# POST_TRANSFORM_BLUE_SCALE_SGI = ???? # 1 F
+# POST_TRANSFORM_ALPHA_SCALE_SGI = ???? # 1 F
+# POST_TRANSFORM_RED_BIAS_SGI = ???? # 1 F
+# POST_TRANSFORM_GREEN_BIAS_SGI = ???? # 1 F
+# POST_TRANSFORM_BLUE_BIAS_SGI = ???? # 1 F
+# POST_TRANSFORM_ALPHA_BIAS_SGI = ???? # 1 F
+# PIXEL_TRANSFORM_OPERATOR_SGI = 0x81C4 # 1 I
+# CONVOLUTION_SGI = 0x81C5
+# FFT_1D_SGI = 0x81C6
+# PIXEL_TRANSFORM_SGI = 0x81C7
+# MAX_FFT_WIDTH_SGI = 0x81C8
+# SORT_SGI = 0x81C9
+# TRANSPOSE_SGI = 0x81CA
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_nurbs_eval: 0x81CB-0x81CF
+# MAP1_VERTEX_3_NURBS_SGIX = 0x81CB # 1 I
+# MAP1_VERTEX_4_NURBS_SGIX = 0x81CC # 1 I
+# MAP1_INDEX_NURBS_SGIX = 0x81CD # 1 I
+# MAP1_COLOR_4_NURBS_SGIX = 0x81CE # 1 I
+# MAP1_NORMAL_NURBS_SGIX = 0x81CF # 1 I
+# MAP1_TEXTURE_COORD_1_NURBS_SGIX = 0x81E0 # 1 I
+# MAP1_TEXTURE_COORD_2_NURBS_SGIX = 0x81E1 # 1 I
+# MAP1_TEXTURE_COORD_3_NURBS_SGIX = 0x81E2 # 1 I
+# MAP1_TEXTURE_COORD_4_NURBS_SGIX = 0x81E3 # 1 I
+# MAP2_VERTEX_3_NURBS_SGIX = 0x81E4 # 1 I
+# MAP2_VERTEX_4_NURBS_SGIX = 0x81E5 # 1 I
+# MAP2_INDEX_NURBS_SGIX = 0x81E6 # 1 I
+# MAP2_COLOR_4_NURBS_SGIX = 0x81E7 # 1 I
+# MAP2_NORMAL_NURBS_SGIX = 0x81E8 # 1 I
+# MAP2_TEXTURE_COORD_1_NURBS_SGIX = 0x81E9 # 1 I
+# MAP2_TEXTURE_COORD_2_NURBS_SGIX = 0x81EA # 1 I
+# MAP2_TEXTURE_COORD_3_NURBS_SGIX = 0x81EB # 1 I
+# MAP2_TEXTURE_COORD_4_NURBS_SGIX = 0x81EC # 1 I
+# NURBS_KNOT_COUNT_SGIX = 0x81ED
+# NURBS_KNOT_VECTOR_SGIX = 0x81EE
+
+###############################################################################
+
+# Sun: 0x81D0-0x81DF
+
+# No extension spec, not in enumext.spec
+# SUNX_surface_hint enum:
+# SURFACE_SIZE_HINT_SUNX = 0x81D2
+# LARGE_SUNX = 0x81D3
+
+# SUNX_general_triangle_list enum:
+# RESTART_SUN = 0x0001
+# REPLACE_MIDDLE_SUN = 0x0002
+# REPLACE_OLDEST_SUN = 0x0003
+# WRAP_BORDER_SUN = 0x81D4
+# TRIANGLE_LIST_SUN = 0x81D7
+# REPLACEMENT_CODE_SUN = 0x81D8
+# REPLACEMENT_CODE_ARRAY_SUN = 0x85C0
+# REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1
+# REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2
+# REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3
+# R1UI_V3F_SUN = 0x85C4
+# R1UI_C4UB_V3F_SUN = 0x85C5
+# R1UI_C3F_V3F_SUN = 0x85C6
+# R1UI_N3F_V3F_SUN = 0x85C7
+# R1UI_C4F_N3F_V3F_SUN = 0x85C8
+# R1UI_T2F_V3F_SUN = 0x85C9
+# R1UI_T2F_N3F_V3F_SUN = 0x85CA
+# R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB
+
+# SUNX_constant_data enum:
+# UNPACK_CONSTANT_DATA_SUNX = 0x81D5
+# TEXTURE_CONSTANT_DATA_SUNX = 0x81D6
+
+# SUN_global_alpha enum:
+# GLOBAL_ALPHA_SUN = 0x81D9
+# GLOBAL_ALPHA_FACTOR_SUN = 0x81DA
+
+###############################################################################
+
+# SGIX_nurbs_eval (additional; see above): 0x81E0-0x81EE
+
+###############################################################################
+
+SGIS_texture_color_mask enum:
+ TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF
+
+###############################################################################
+
+SGIS_point_line_texgen enum:
+ EYE_DISTANCE_TO_POINT_SGIS = 0x81F0
+ OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1
+ EYE_DISTANCE_TO_LINE_SGIS = 0x81F2
+ OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3
+ EYE_POINT_SGIS = 0x81F4
+ OBJECT_POINT_SGIS = 0x81F5
+ EYE_LINE_SGIS = 0x81F6
+ OBJECT_LINE_SGIS = 0x81F7
+
+###############################################################################
+
+# VERSION_1_2 enum: (Promoted for OpenGL 1.2)
+EXT_separate_specular_color enum:
+ LIGHT_MODEL_COLOR_CONTROL = 0x81F8 # 1 I
+ LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8
+ SINGLE_COLOR = 0x81F9
+ SINGLE_COLOR_EXT = 0x81F9
+ SEPARATE_SPECULAR_COLOR = 0x81FA
+ SEPARATE_SPECULAR_COLOR_EXT = 0x81FA
+
+###############################################################################
+
+EXT_shared_texture_palette enum:
+ SHARED_TEXTURE_PALETTE_EXT = 0x81FB # 1 I
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_fog_scale: 0x81FC-0x81FD
+# FOG_SCALE_SGIX = 0x81FC # 1 I
+# FOG_SCALE_VALUE_SGIX = 0x81FD # 1 F
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_fog_blend: 0x81FE-0x81FF
+# FOG_BLEND_ALPHA_SGIX = 0x81FE # 1 I
+# FOG_BLEND_COLOR_SGIX = 0x81FF # 1 I
+
+###############################################################################
+
+# ATI: 0x8200-0x820F (released by Microsoft 2002/9/16)
+# ATI_text_fragment_shader enum:
+# TEXT_FRAGMENT_SHADER_ATI = 0x8200
+
+###############################################################################
+
+# Any_vendor_future_use: 0x8210-0x82AF (released by Microsoft 2002/9/16)
+
+###############################################################################
+
+# ADD: 0x82B0-0x830F
+
+###############################################################################
+
+# SGIX_depth_pass_instrument enum: 0x8310-0x8312
+# DEPTH_PASS_INSTRUMENT_SGIX = 0x8310
+# DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311
+# DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312
+
+###############################################################################
+
+# SGIX_fragments_instrument enum: 0x8313-0x8315
+# FRAGMENTS_INSTRUMENT_SGIX = 0x8313 # 1 I
+# FRAGMENTS_INSTRUMENT_COUNTERS_SGIX = 0x8314 # 1 I
+# FRAGMENTS_INSTRUMENT_MAX_SGIX = 0x8315 # 1 I
+
+###############################################################################
+
+SGIX_convolution_accuracy enum:
+ CONVOLUTION_HINT_SGIX = 0x8316 # 1 I
+
+###############################################################################
+
+# SGIX_color_matrix_accuracy: 0x8317
+
+###############################################################################
+
+# SGIX_ycrcba: 0x8318-0x8319
+# YCRCB_SGIX = 0x8318
+# YCRCBA_SGIX = 0x8319
+
+###############################################################################
+
+# SGIX_slim: 0x831A-0x831F
+# UNPACK_COMPRESSED_SIZE_SGIX = 0x831A
+# PACK_MAX_COMPRESSED_SIZE_SGIX = 0x831B
+# PACK_COMPRESSED_SIZE_SGIX = 0x831C
+# SLIM8U_SGIX = 0x831D
+# SLIM10U_SGIX = 0x831E
+# SLIM12S_SGIX = 0x831F
+
+###############################################################################
+
+SGIX_blend_alpha_minmax enum:
+ ALPHA_MIN_SGIX = 0x8320
+ ALPHA_MAX_SGIX = 0x8321
+
+###############################################################################
+
+# SGIX_scalebias_hint enum:
+# SCALEBIAS_HINT_SGIX = 0x8322
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_fog_layers: 0x8323-0x8328
+# FOG_TYPE_SGIX = 0x8323 # 1 I
+# UNIFORM_SGIX = 0x8324
+# LAYERED_SGIX = 0x8325
+# FOG_GROUND_PLANE_SGIX = 0x8326 # 4 F
+# FOG_LAYERS_POINTS_SGIX = 0x8327 # 1 I
+# MAX_FOG_LAYERS_POINTS_SGIX = 0x8328 # 1 I
+
+###############################################################################
+
+# SGIX_async enum:
+ ASYNC_MARKER_SGIX = 0x8329
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_texture_phase: 0x832A
+# PHASE_SGIX = 0x832A
+
+###############################################################################
+
+# SGIX_pixel_texture (additional; see above): 0x832B
+
+###############################################################################
+
+SGIX_async_histogram enum:
+ ASYNC_HISTOGRAM_SGIX = 0x832C
+ MAX_ASYNC_HISTOGRAM_SGIX = 0x832D
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_texture_mipmap_anisotropic: 0x832E-0x832F
+# TEXTURE_MIPMAP_ANISOTROPY_SGIX = 0x832E
+# MAX_MIPMAP_ANISOTROPY_SGIX = 0x832F # 1 I
+
+###############################################################################
+
+EXT_pixel_transform enum:
+ PIXEL_TRANSFORM_2D_EXT = 0x8330
+ PIXEL_MAG_FILTER_EXT = 0x8331
+ PIXEL_MIN_FILTER_EXT = 0x8332
+ PIXEL_CUBIC_WEIGHT_EXT = 0x8333
+ CUBIC_EXT = 0x8334
+ AVERAGE_EXT = 0x8335
+ PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336
+ MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337
+ PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338
+
+# SUN_future_use: 0x8339-0x833F
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_cube_map: 0x8340-0x8348
+# ENV_MAP_SGIX = 0x8340
+# CUBE_MAP_SGIX = 0x8341
+# CUBE_MAP_ZP_SGIX = 0x8342
+# CUBE_MAP_ZN_SGIX = 0x8343
+# CUBE_MAP_XN_SGIX = 0x8344
+# CUBE_MAP_XP_SGIX = 0x8345
+# CUBE_MAP_YN_SGIX = 0x8346
+# CUBE_MAP_YP_SGIX = 0x8347
+# CUBE_MAP_BINDING_SGIX = 0x8348 # 1 I
+
+###############################################################################
+
+# Unfortunately, there was a collision promoting to EXT from SGIX.
+# Use fog_coord's value of 0x8452 instead of the previously
+# assigned FRAGMENT_DEPTH_EXT = 0x834B.
+# EXT_light_texture: 0x8349-0x8352
+# FRAGMENT_MATERIAL_EXT = 0x8349
+# FRAGMENT_NORMAL_EXT = 0x834A
+# FRAGMENT_COLOR_EXT = 0x834C
+# ATTENUATION_EXT = 0x834D
+# SHADOW_ATTENUATION_EXT = 0x834E
+# TEXTURE_APPLICATION_MODE_EXT = 0x834F # 1 I
+# TEXTURE_LIGHT_EXT = 0x8350 # 1 I
+# TEXTURE_MATERIAL_FACE_EXT = 0x8351 # 1 I
+# TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352 # 1 I
+# use EXT_fog_coord FRAGMENT_DEPTH_EXT
+
+###############################################################################
+
+SGIS_pixel_texture enum:
+ PIXEL_TEXTURE_SGIS = 0x8353 # 1 I
+ PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354 # 1 I
+ PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355 # 1 I
+ PIXEL_GROUP_COLOR_SGIS = 0x8356 # 1 I
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_pixel_texture_bits: 0x8357-0x8359
+# COLOR_TO_TEXTURE_COORD_SGIX = 0x8357
+# COLOR_BIT_PATTERN_SGIX = 0x8358
+# COLOR_VALUE_SGIX = 0x8359
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_pixel_texture_lod: 0x835A
+# PIXEL_TEX_GEN_LAMBDA_SOURCE_SGIX = 0x835A
+
+###############################################################################
+
+# SGIX_line_quality_hint:
+# LINE_QUALITY_HINT_SGIX = 0x835B
+
+###############################################################################
+
+SGIX_async_pixel enum:
+ ASYNC_TEX_IMAGE_SGIX = 0x835C
+ ASYNC_DRAW_PIXELS_SGIX = 0x835D
+ ASYNC_READ_PIXELS_SGIX = 0x835E
+ MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F
+ MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360
+ MAX_ASYNC_READ_PIXELS_SGIX = 0x8361
+
+###############################################################################
+
+# EXT_packed_pixels (additional; see above): 0x8362-0x8368
+
+###############################################################################
+
+SGIX_texture_coordinate_clamp enum:
+ TEXTURE_MAX_CLAMP_S_SGIX = 0x8369
+ TEXTURE_MAX_CLAMP_T_SGIX = 0x836A
+ TEXTURE_MAX_CLAMP_R_SGIX = 0x836B
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_fog_texture: 0x836C-0x836E
+# FRAGMENT_FOG_SGIX = 0x836C
+# TEXTURE_FOG_SGIX = 0x836D # 1 I
+# FOG_PATCHY_FACTOR_SGIX = 0x836E
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_fog_factor_to_alpha: 0x836F
+ FOG_FACTOR_TO_ALPHA_SGIX = 0x836F
+
+###############################################################################
+
+# HP: 0x8370-0x837F
+# NOTE: IBM is using values in this range, because of a bobble
+# when Pat Brown left at the same time as I assigned them the
+# next range and their registry became inconsistent. Unknown
+# whether HP has any conflicts as they have never reported using
+# any values in this range.
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# ARB_texture_mirrored_repeat enum:
+# IBM_texture_mirrored_repeat enum:
+# MIRRORED_REPEAT = 0x8370
+# MIRRORED_REPEAT_ARB = 0x8370
+# MIRRORED_REPEAT_IBM = 0x8370
+
+###############################################################################
+
+# IBM: 0x8380-0x839F
+
+###############################################################################
+
+# S3: 0x83A0-0x83BF
+
+# Extension #276
+# S3_s3tc enum: 0x83A0-0x83A3
+# RGB_S3TC = 0x83A0
+# RGB4_S3TC = 0x83A1
+# RGBA_S3TC = 0x83A2
+# RGBA4_S3TC = 0x83A3
+
+# S3_future_use: 0x83A4-0x83BF
+
+###############################################################################
+
+# Obsolete extension, never to be put in enumext.spec
+# SGIS_multitexture: 0x83C0-0x83E5
+# SELECTED_TEXTURE_SGIS = 0x83C0 # 1 I
+# SELECTED_TEXTURE_COORD_SET_SGIS = 0x83C1 # 1 I
+# SELECTED_TEXTURE_TRANSFORM_SGIS = 0x83C2 # 1 I
+# MAX_TEXTURES_SGIS = 0x83C3 # 1 I
+# MAX_TEXTURE_COORD_SETS_SGIS = 0x83C4 # 1 I
+# TEXTURE_COORD_SET_INTERLEAVE_FACTOR_SGIS = 0x83C5 # 1 I
+# TEXTURE_ENV_COORD_SET_SGIS = 0x83C6
+# TEXTURE0_SGIS = 0x83C7
+# TEXTURE1_SGIS = 0x83C8
+# TEXTURE2_SGIS = 0x83C9
+# TEXTURE3_SGIS = 0x83CA
+#
+# SGIS_multitexture_future_use: 0x83CB-0x83E5
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_bali_g_instruments: 0x83E6-0x83E9
+# BALI_NUM_TRIS_CULLED_INSTRUMENT_SGIX = 0x83E6 # 1 I
+# BALI_NUM_PRIMS_CLIPPED_INSTRUMENT_SGIX = 0x83E7 # 1 I
+# BALI_NUM_PRIMS_REJECT_INSTRUMENT_SGIX = 0x83E8 # 1 I
+# BALI_NUM_PRIMS_CLIP_RESULT_INSTRUMENT_SGIX = 0x83E9 # 1 I
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_bali_r_instruments: 0x83EA-0x83EC
+# BALI_FRAGMENTS_GENERATED_INSTRUMENT_SGIX = 0x83EA # 1 I
+# BALI_DEPTH_PASS_INSTRUMENT_SGIX = 0x83EB # 1 I
+# BALI_R_CHIP_COUNT_SGIX = 0x83EC # 1 I
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_occlusion_instrument: 0x83ED
+# OCCLUSION_INSTRUMENT_SGIX = 0x83ED # 1 I
+
+###############################################################################
+
+SGIX_vertex_preclip enum:
+ VERTEX_PRECLIP_SGIX = 0x83EE
+ VERTEX_PRECLIP_HINT_SGIX = 0x83EF
+
+###############################################################################
+
+# INTEL: 0x83F0-0x83FF
+# Note that this block was reclaimed from NTP, who never shipped it,
+# and reassigned to Intel.
+
+EXT_texture_compression_s3tc enum:
+ COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0
+ COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1
+ COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2
+ COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3
+
+INTEL_parallel_arrays enum:
+ PARALLEL_ARRAYS_INTEL = 0x83F4
+ VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5
+ NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6
+ COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7
+ TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8
+
+# INTEL_future_use: 0x83F9-0x83FF
+
+###############################################################################
+
+SGIX_fragment_lighting enum:
+ FRAGMENT_LIGHTING_SGIX = 0x8400 # 1 I
+ FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401 # 1 I
+ FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402 # 1 I
+ FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403 # 1 I
+ MAX_FRAGMENT_LIGHTS_SGIX = 0x8404 # 1 I
+ MAX_ACTIVE_LIGHTS_SGIX = 0x8405 # 1 I
+ CURRENT_RASTER_NORMAL_SGIX = 0x8406 # 1 I
+ LIGHT_ENV_MODE_SGIX = 0x8407 # 1 I
+ FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408 # 1 I
+ FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409 # 1 I
+ FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A # 4 F
+ FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B # 1 I
+ FRAGMENT_LIGHT0_SGIX = 0x840C # 1 I
+ FRAGMENT_LIGHT1_SGIX = 0x840D
+ FRAGMENT_LIGHT2_SGIX = 0x840E
+ FRAGMENT_LIGHT3_SGIX = 0x840F
+ FRAGMENT_LIGHT4_SGIX = 0x8410
+ FRAGMENT_LIGHT5_SGIX = 0x8411
+ FRAGMENT_LIGHT6_SGIX = 0x8412
+ FRAGMENT_LIGHT7_SGIX = 0x8413
+
+# SGIX_fragment_lighting_future_use: 0x8414-0x842B
+
+###############################################################################
+
+SGIX_resample enum:
+ PACK_RESAMPLE_SGIX = 0x842C
+ UNPACK_RESAMPLE_SGIX = 0x842D
+ RESAMPLE_REPLICATE_SGIX = 0x842E
+ RESAMPLE_ZERO_FILL_SGIX = 0x842F
+ RESAMPLE_DECIMATE_SGIX = 0x8430
+
+# SGIX_resample_future_use: 0x8431-0x8435
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_fragment_lighting_space: 0x8436-0x8449
+# EYE_SPACE_SGIX = 0x8436
+# TANGENT_SPACE_SGIX = 0x8437
+# OBJECT_SPACE_SGIX = 0x8438
+# TANGENT_ARRAY_SGIX = 0x8439
+# BINORMAL_ARRAY_SGIX = 0x843A
+# CURRENT_TANGENT_SGIX = 0x843B # 3 F
+# CURRENT_BINORMAL_SGIX = 0x843C # 3 F
+# FRAGMENT_LIGHT_SPACE_SGIX = 0x843D # 1 I
+# TANGENT_ARRAY_TYPE_SGIX = 0x843E
+# TANGENT_ARRAY_STRIDE_SGIX = 0x843F
+# TANGENT_ARRAY_COUNT_SGIX = 0x8440
+# BINORMAL_ARRAY_TYPE_SGIX = 0x8441
+# BINORMAL_ARRAY_STRIDE_SGIX = 0x8442
+# BINORMAL_ARRAY_COUNT_SGIX = 0x8443
+# TANGENT_ARRAY_POINTER_SGIX = 0x8444
+# BINORMAL_ARRAY_POINTER_SGIX = 0x8445
+# MAP1_TANGENT_SGIX = 0x8446
+# MAP2_TANGENT_SGIX = 0x8447
+# MAP1_BINORMAL_SGIX = 0x8448
+# MAP2_BINORMAL_SGIX = 0x8449
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_bali_timer_instruments: 0x844A-0x844C
+# BALI_GEOM_TIMER_INSTRUMENT_SGIX = 0x844A # 1 I
+# BALI_RASTER_TIMER_INSTRUMENT_SGIX = 0x844B # 1 I
+# BALI_INSTRUMENT_TIME_UNIT_SGIX = 0x844C # 1 I
+
+###############################################################################
+
+# SGIX_clipmap (additional; see above): 0x844D-0x844F
+
+###############################################################################
+
+# SGI (actually brokered for Id Software): 0x8450-0x845F
+
+# VERSION_1_5 enum: (Consistent naming scheme for OpenGL 1.5)
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# EXT_fog_coord enum:
+# FOG_COORD_SRC = GL_FOG_COORDINATE_SOURCE
+# FOG_COORDINATE_SOURCE = 0x8450 # 1 I
+# FOG_COORDINATE_SOURCE_EXT = 0x8450 # 1 I
+# FOG_COORD = GL_FOG_COORDINATE
+# FOG_COORDINATE = 0x8451
+# FOG_COORDINATE_EXT = 0x8451
+# FRAGMENT_DEPTH = 0x8452
+# FRAGMENT_DEPTH_EXT = 0x8452
+# CURRENT_FOG_COORD = GL_CURRENT_FOG_COORDINATE
+# CURRENT_FOG_COORDINATE = 0x8453 # 1 F
+# CURRENT_FOG_COORDINATE_EXT = 0x8453 # 1 F
+# FOG_COORD_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE
+# FOG_COORDINATE_ARRAY_TYPE = 0x8454 # 1 I
+# FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454 # 1 I
+# FOG_COORD_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE
+# FOG_COORDINATE_ARRAY_STRIDE = 0x8455 # 1 I
+# FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455 # 1 I
+# FOG_COORD_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER
+# FOG_COORDINATE_ARRAY_POINTER = 0x8456
+# FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456
+# FOG_COORD_ARRAY = GL_FOG_COORDINATE_ARRAY
+# FOG_COORDINATE_ARRAY = 0x8457 # 1 I
+# FOG_COORDINATE_ARRAY_EXT = 0x8457 # 1 I
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# EXT_secondary_color enum:
+# ARB_vertex_program enum:
+# COLOR_SUM = 0x8458 # 1 I
+# COLOR_SUM_EXT = 0x8458 # 1 I
+# COLOR_SUM_ARB = 0x8458 # 1 I # ARB_vertex_program
+# CURRENT_SECONDARY_COLOR = 0x8459 # 3 F
+# CURRENT_SECONDARY_COLOR_EXT = 0x8459 # 3 F
+# SECONDARY_COLOR_ARRAY_SIZE = 0x845A # 1 I
+# SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A # 1 I
+# SECONDARY_COLOR_ARRAY_TYPE = 0x845B # 1 I
+# SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B # 1 I
+# SECONDARY_COLOR_ARRAY_STRIDE = 0x845C # 1 I
+# SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C # 1 I
+# SECONDARY_COLOR_ARRAY_POINTER = 0x845D
+# SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D
+# SECONDARY_COLOR_ARRAY = 0x845E # 1 I
+# SECONDARY_COLOR_ARRAY_EXT = 0x845E # 1 I
+
+# VERSION_2_1 enum:
+# CURRENT_RASTER_SECONDARY_COLOR = 0x845F
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_icc_texture enum:
+# RGB_ICC_SGIX = 0x8460
+# RGBA_ICC_SGIX = 0x8461
+# ALPHA_ICC_SGIX = 0x8462
+# LUMINANCE_ICC_SGIX = 0x8463
+# INTENSITY_ICC_SGIX = 0x8464
+# LUMINANCE_ALPHA_ICC_SGIX = 0x8465
+# R5_G6_B5_ICC_SGIX = 0x8466
+# R5_G6_B5_A8_ICC_SGIX = 0x8467
+# ALPHA16_ICC_SGIX = 0x8468
+# LUMINANCE16_ICC_SGIX = 0x8469
+# INTENSITY16_ICC_SGIX = 0x846A
+# LUMINANCE16_ALPHA8_ICC_SGIX = 0x846B
+
+###############################################################################
+
+# SGI_future_use: 0x846C
+
+###############################################################################
+
+# SMOOTH_* enums are new names for pre-1.2 enums.
+VERSION_1_2 enum:
+ SMOOTH_POINT_SIZE_RANGE = 0x0B12 # 2 F
+ SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 # 1 F
+ SMOOTH_LINE_WIDTH_RANGE = 0x0B22 # 2 F
+ SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 # 1 F
+ ALIASED_POINT_SIZE_RANGE = 0x846D # 2 F
+ ALIASED_LINE_WIDTH_RANGE = 0x846E # 2 F
+
+###############################################################################
+
+# SGI_future_use: 0x846F
+
+###############################################################################
+
+# ATI Technologies (vendor multitexture, spec not yet released): 0x8470-0x848F
+
+###############################################################################
+
+# REND (Rendition): 0x8490-0x849F
+
+# REND_screen_coordinates enum:
+# SCREEN_COORDINATES_REND = 0x8490
+# INVERTED_SCREEN_W_REND = 0x8491
+
+###############################################################################
+
+# ATI Technologies (vendor multitexture, spec not yet released): 0x84A0-84BF
+
+###############################################################################
+
+# ARB: 0x84C0-0x84EF
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# ARB_multitexture enum:
+# TEXTURE0 = 0x84C0
+# TEXTURE0_ARB = 0x84C0
+# TEXTURE1 = 0x84C1
+# TEXTURE1_ARB = 0x84C1
+# TEXTURE2 = 0x84C2
+# TEXTURE2_ARB = 0x84C2
+# TEXTURE3 = 0x84C3
+# TEXTURE3_ARB = 0x84C3
+# TEXTURE4 = 0x84C4
+# TEXTURE4_ARB = 0x84C4
+# TEXTURE5 = 0x84C5
+# TEXTURE5_ARB = 0x84C5
+# TEXTURE6 = 0x84C6
+# TEXTURE6_ARB = 0x84C6
+# TEXTURE7 = 0x84C7
+# TEXTURE7_ARB = 0x84C7
+# TEXTURE8 = 0x84C8
+# TEXTURE8_ARB = 0x84C8
+# TEXTURE9 = 0x84C9
+# TEXTURE9_ARB = 0x84C9
+# TEXTURE10 = 0x84CA
+# TEXTURE10_ARB = 0x84CA
+# TEXTURE11 = 0x84CB
+# TEXTURE11_ARB = 0x84CB
+# TEXTURE12 = 0x84CC
+# TEXTURE12_ARB = 0x84CC
+# TEXTURE13 = 0x84CD
+# TEXTURE13_ARB = 0x84CD
+# TEXTURE14 = 0x84CE
+# TEXTURE14_ARB = 0x84CE
+# TEXTURE15 = 0x84CF
+# TEXTURE15_ARB = 0x84CF
+# TEXTURE16 = 0x84D0
+# TEXTURE16_ARB = 0x84D0
+# TEXTURE17 = 0x84D1
+# TEXTURE17_ARB = 0x84D1
+# TEXTURE18 = 0x84D2
+# TEXTURE18_ARB = 0x84D2
+# TEXTURE19 = 0x84D3
+# TEXTURE19_ARB = 0x84D3
+# TEXTURE20 = 0x84D4
+# TEXTURE20_ARB = 0x84D4
+# TEXTURE21 = 0x84D5
+# TEXTURE21_ARB = 0x84D5
+# TEXTURE22 = 0x84D6
+# TEXTURE22_ARB = 0x84D6
+# TEXTURE23 = 0x84D7
+# TEXTURE23_ARB = 0x84D7
+# TEXTURE24 = 0x84D8
+# TEXTURE24_ARB = 0x84D8
+# TEXTURE25 = 0x84D9
+# TEXTURE25_ARB = 0x84D9
+# TEXTURE26 = 0x84DA
+# TEXTURE26_ARB = 0x84DA
+# TEXTURE27 = 0x84DB
+# TEXTURE27_ARB = 0x84DB
+# TEXTURE28 = 0x84DC
+# TEXTURE28_ARB = 0x84DC
+# TEXTURE29 = 0x84DD
+# TEXTURE29_ARB = 0x84DD
+# TEXTURE30 = 0x84DE
+# TEXTURE30_ARB = 0x84DE
+# TEXTURE31 = 0x84DF
+# TEXTURE31_ARB = 0x84DF
+# ACTIVE_TEXTURE = 0x84E0 # 1 I
+# ACTIVE_TEXTURE_ARB = 0x84E0 # 1 I
+# CLIENT_ACTIVE_TEXTURE = 0x84E1 # 1 I
+# CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1 # 1 I
+# MAX_TEXTURE_UNITS = 0x84E2 # 1 I
+# MAX_TEXTURE_UNITS_ARB = 0x84E2 # 1 I
+
+
+
+
+###############################################################################
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# ARB_transpose_matrix enum:
+# TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 # 16 F
+# TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3 # 16 F
+# TRANSPOSE_PROJECTION_MATRIX = 0x84E4 # 16 F
+# TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4 # 16 F
+# TRANSPOSE_TEXTURE_MATRIX = 0x84E5 # 16 F
+# TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5 # 16 F
+# TRANSPOSE_COLOR_MATRIX = 0x84E6 # 16 F
+# TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6 # 16 F
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# ARB_texture_env_combine enum:
+# SUBTRACT = 0x84E7
+# SUBTRACT_ARB = 0x84E7
+
+# EXT_framebuffer_object (additional; see below):
+# MAX_RENDERBUFFER_SIZE_EXT = 0x84E8
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# ARB_texture_compression enum:
+# COMPRESSED_ALPHA = 0x84E9
+# COMPRESSED_ALPHA_ARB = 0x84E9
+# COMPRESSED_LUMINANCE = 0x84EA
+# COMPRESSED_LUMINANCE_ARB = 0x84EA
+# COMPRESSED_LUMINANCE_ALPHA = 0x84EB
+# COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB
+# COMPRESSED_INTENSITY = 0x84EC
+# COMPRESSED_INTENSITY_ARB = 0x84EC
+# COMPRESSED_RGB = 0x84ED
+# COMPRESSED_RGB_ARB = 0x84ED
+# COMPRESSED_RGBA = 0x84EE
+# COMPRESSED_RGBA_ARB = 0x84EE
+# TEXTURE_COMPRESSION_HINT = 0x84EF
+# TEXTURE_COMPRESSION_HINT_ARB = 0x84EF
+# TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0
+# TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0
+# TEXTURE_COMPRESSED = 0x86A1
+# TEXTURE_COMPRESSED_ARB = 0x86A1
+# NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2
+# NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2
+# COMPRESSED_TEXTURE_FORMATS = 0x86A3
+# COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3
+
+###############################################################################
+
+# NVIDIA: 0x84F0-0x855F
+
+# NV_future_use: 0x84F0-0x84F1
+
+# NV_fence enum:
+# ALL_COMPLETED_NV = 0x84F2
+# FENCE_STATUS_NV = 0x84F3
+# FENCE_CONDITION_NV = 0x84F4
+
+# ARB_texture_rectangle enum:
+# NV_texture_rectangle enum:
+# TEXTURE_RECTANGLE_ARB = 0x84F5
+# TEXTURE_RECTANGLE_NV = 0x84F5
+# TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6
+# TEXTURE_BINDING_RECTANGLE_NV = 0x84F6
+# PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7
+# PROXY_TEXTURE_RECTANGLE_NV = 0x84F7
+# MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8
+# MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8
+
+# EXT_packed_depth_stencil enum:
+# NV_packed_depth_stencil enum:
+# DEPTH_STENCIL_EXT = 0x84F9
+# DEPTH_STENCIL_NV = 0x84F9
+# UNSIGNED_INT_24_8_EXT = 0x84FA
+# UNSIGNED_INT_24_8_NV = 0x84FA
+
+# NV_future_use: 0x84FB-0x84FC
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# EXT_texture_lod_bias enum:
+# MAX_TEXTURE_LOD_BIAS = 0x84FD
+# MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD
+
+# EXT_texture_filter_anisotropic enum:
+# TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE
+# MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# EXT_texture_lod_bias enum:
+# TEXTURE_FILTER_CONTROL = 0x8500
+# TEXTURE_FILTER_CONTROL_EXT = 0x8500
+# TEXTURE_LOD_BIAS = 0x8501
+# TEXTURE_LOD_BIAS_EXT = 0x8501
+
+# EXT_vertex_weighting enum:
+# MODELVIEW1_STACK_DEPTH_EXT = 0x8502
+
+# NV_texture_env_combine4 (additional; see below): 0x8503
+
+# NV_light_max_exponent enum:
+# MAX_SHININESS_NV = 0x8504
+# MAX_SPOT_EXPONENT_NV = 0x8505
+
+# EXT_vertex_weighting enum:
+# MODELVIEW_MATRIX1_EXT = 0x8506
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# EXT_stencil_wrap enum:
+# INCR_WRAP = 0x8507
+# INCR_WRAP_EXT = 0x8507
+# DECR_WRAP = 0x8508
+# DECR_WRAP_EXT = 0x8508
+
+# EXT_vertex_weighting enum:
+# VERTEX_WEIGHTING_EXT = 0x8509
+# MODELVIEW1_EXT = 0x850A
+# CURRENT_VERTEX_WEIGHT_EXT = 0x850B
+# VERTEX_WEIGHT_ARRAY_EXT = 0x850C
+# VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D
+# VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E
+# VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F
+# VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# Note: these are also exposed as NV and EXT, as well as ARB
+# NV_texgen_reflection enum:
+# EXT_texture_cube_map enum:
+# ARB_texture_cube_map enum:
+# NORMAL_MAP = 0x8511
+# NORMAL_MAP_ARB = 0x8511
+# REFLECTION_MAP = 0x8512
+# REFLECTION_MAP_ARB = 0x8512
+# TEXTURE_CUBE_MAP = 0x8513
+# TEXTURE_CUBE_MAP_ARB = 0x8513
+# TEXTURE_BINDING_CUBE_MAP = 0x8514
+# TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514
+# TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515
+# TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515
+# TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516
+# TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516
+# TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517
+# TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517
+# TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518
+# TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518
+# TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519
+# TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519
+# TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A
+# TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A
+# PROXY_TEXTURE_CUBE_MAP = 0x851B
+# PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B
+# MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C
+# MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C
+
+# NV_vertex_array_range enum:
+# VERTEX_ARRAY_RANGE_NV = 0x851D
+# VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E
+# VERTEX_ARRAY_RANGE_VALID_NV = 0x851F
+# MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520
+# VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521
+
+# @@@ How does this interact with NV_vertex_array_range?
+# APPLE_vertex_array_range enum:
+# VERTEX_ARRAY_RANGE_APPLE = 0x851D
+# VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E
+# VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F
+# VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521
+# STORAGE_CACHED_APPLE = 0x85BE
+# STORAGE_SHARED_APPLE = 0x85BF
+
+# NV_register_combiners enum:
+# REGISTER_COMBINERS_NV = 0x8522
+# VARIABLE_A_NV = 0x8523
+# VARIABLE_B_NV = 0x8524
+# VARIABLE_C_NV = 0x8525
+# VARIABLE_D_NV = 0x8526
+# VARIABLE_E_NV = 0x8527
+# VARIABLE_F_NV = 0x8528
+# VARIABLE_G_NV = 0x8529
+# CONSTANT_COLOR0_NV = 0x852A
+# CONSTANT_COLOR1_NV = 0x852B
+# PRIMARY_COLOR_NV = 0x852C
+# SECONDARY_COLOR_NV = 0x852D
+# SPARE0_NV = 0x852E
+# SPARE1_NV = 0x852F
+# DISCARD_NV = 0x8530
+# E_TIMES_F_NV = 0x8531
+# SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532
+# UNSIGNED_IDENTITY_NV = 0x8536
+# UNSIGNED_INVERT_NV = 0x8537
+# EXPAND_NORMAL_NV = 0x8538
+# EXPAND_NEGATE_NV = 0x8539
+# HALF_BIAS_NORMAL_NV = 0x853A
+# HALF_BIAS_NEGATE_NV = 0x853B
+# SIGNED_IDENTITY_NV = 0x853C
+# UNSIGNED_NEGATE_NV = 0x853D
+# SCALE_BY_TWO_NV = 0x853E
+# SCALE_BY_FOUR_NV = 0x853F
+# SCALE_BY_ONE_HALF_NV = 0x8540
+# BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541
+# COMBINER_INPUT_NV = 0x8542
+# COMBINER_MAPPING_NV = 0x8543
+# COMBINER_COMPONENT_USAGE_NV = 0x8544
+# COMBINER_AB_DOT_PRODUCT_NV = 0x8545
+# COMBINER_CD_DOT_PRODUCT_NV = 0x8546
+# COMBINER_MUX_SUM_NV = 0x8547
+# COMBINER_SCALE_NV = 0x8548
+# COMBINER_BIAS_NV = 0x8549
+# COMBINER_AB_OUTPUT_NV = 0x854A
+# COMBINER_CD_OUTPUT_NV = 0x854B
+# COMBINER_SUM_OUTPUT_NV = 0x854C
+# MAX_GENERAL_COMBINERS_NV = 0x854D
+# NUM_GENERAL_COMBINERS_NV = 0x854E
+# COLOR_SUM_CLAMP_NV = 0x854F
+# COMBINER0_NV = 0x8550
+# COMBINER1_NV = 0x8551
+# COMBINER2_NV = 0x8552
+# COMBINER3_NV = 0x8553
+# COMBINER4_NV = 0x8554
+# COMBINER5_NV = 0x8555
+# COMBINER6_NV = 0x8556
+# COMBINER7_NV = 0x8557
+
+# NV_vertex_array_range2:
+# VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533
+
+# NV_multisample_filter_hint:
+# MULTISAMPLE_FILTER_HINT_NV = 0x8534
+
+# NV_register_combiners2 enum:
+# PER_STAGE_CONSTANTS_NV = 0x8535
+
+# NV_register_combiners (additional; see above): 0x8536-0x8557
+
+# NV_primitive_restart enum:
+# PRIMITIVE_RESTART_NV = 0x8558
+# PRIMITIVE_RESTART_INDEX_NV = 0x8559
+
+# NV_fog_distance enum:
+# FOG_GEN_MODE_NV = 0x855A
+# EYE_RADIAL_NV = 0x855B
+# EYE_PLANE_ABSOLUTE_NV = 0x855C
+
+# NV_texgen_emboss enum:
+# EMBOSS_LIGHT_NV = 0x855D
+# EMBOSS_CONSTANT_NV = 0x855E
+# EMBOSS_MAP_NV = 0x855F
+
+###############################################################################
+
+# Intergraph/Intense3D/3Dlabs: 0x8560-0x856F
+
+# INGR_color_clamp enum:
+# RED_MIN_CLAMP_INGR = 0x8560
+# GREEN_MIN_CLAMP_INGR = 0x8561
+# BLUE_MIN_CLAMP_INGR = 0x8562
+# ALPHA_MIN_CLAMP_INGR = 0x8563
+# RED_MAX_CLAMP_INGR = 0x8564
+# GREEN_MAX_CLAMP_INGR = 0x8565
+# BLUE_MAX_CLAMP_INGR = 0x8566
+# ALPHA_MAX_CLAMP_INGR = 0x8567
+
+# INGR_interlace_read enum:
+# INTERLACE_READ_INGR = 0x8568
+
+# 3Dlabs_future_use: 0x8569-0x856F
+
+###############################################################################
+
+# ATI/NVIDIA: 0x8570-0x859F
+
+# VERSION_1_5 enum: (Consistent naming scheme for OpenGL 1.5)
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# EXT_texture_env_combine enum:
+# COMBINE = 0x8570
+# COMBINE_EXT = 0x8570
+# COMBINE_RGB = 0x8571
+# COMBINE_RGB_EXT = 0x8571
+# COMBINE_ALPHA = 0x8572
+# COMBINE_ALPHA_EXT = 0x8572
+# RGB_SCALE = 0x8573
+# RGB_SCALE_EXT = 0x8573
+# ADD_SIGNED = 0x8574
+# ADD_SIGNED_EXT = 0x8574
+# INTERPOLATE = 0x8575
+# INTERPOLATE_EXT = 0x8575
+# CONSTANT = 0x8576
+# CONSTANT_EXT = 0x8576
+# PRIMARY_COLOR = 0x8577
+# PRIMARY_COLOR_EXT = 0x8577
+# PREVIOUS = 0x8578
+# PREVIOUS_EXT = 0x8578
+# SRC0_RGB = GL_SOURCE0_RGB
+# SOURCE0_RGB = 0x8580
+# SOURCE0_RGB_EXT = 0x8580
+# SRC1_RGB = GL_SOURCE1_RGB
+# SOURCE1_RGB = 0x8581
+# SOURCE1_RGB_EXT = 0x8581
+# SRC2_RGB = GL_SOURCE2_RGB
+# SOURCE2_RGB = 0x8582
+# SOURCE2_RGB_EXT = 0x8582
+# SRC0_ALPHA = GL_SOURCE0_ALPHA
+# SOURCE0_ALPHA = 0x8588
+# SOURCE0_ALPHA_EXT = 0x8588
+# SRC1_ALPHA = GL_SOURCE1_ALPHA
+# SOURCE1_ALPHA = 0x8589
+# SOURCE1_ALPHA_EXT = 0x8589
+# SRC2_ALPHA = GL_SOURCE2_ALPHA
+# SOURCE2_ALPHA = 0x858A
+# SOURCE2_ALPHA_EXT = 0x858A
+# OPERAND0_RGB = 0x8590
+# OPERAND0_RGB_EXT = 0x8590
+# OPERAND1_RGB = 0x8591
+# OPERAND1_RGB_EXT = 0x8591
+# OPERAND2_RGB = 0x8592
+# OPERAND2_RGB_EXT = 0x8592
+# OPERAND0_ALPHA = 0x8598
+# OPERAND0_ALPHA_EXT = 0x8598
+# OPERAND1_ALPHA = 0x8599
+# OPERAND1_ALPHA_EXT = 0x8599
+# OPERAND2_ALPHA = 0x859A
+# OPERAND2_ALPHA_EXT = 0x859A
+
+# NV_texture_env_combine4 enum:
+# COMBINE4_NV = 0x8503
+# SOURCE3_RGB_NV = 0x8583
+# SOURCE3_ALPHA_NV = 0x858B
+# OPERAND3_RGB_NV = 0x8593
+# OPERAND3_ALPHA_NV = 0x859B
+
+# "Future use" => "additional combiner input/output enums" only
+# ATI/NVIDIA_future_use: 0x8584-0x8587
+# ATI/NVIDIA_future_use: 0x858C-0x858F
+# ATI/NVIDIA_future_use: 0x8594-0x8597
+# ATI/NVIDIA_future_use: 0x859C-0x859F
+
+###############################################################################
+
+SGIX_subsample enum:
+ PACK_SUBSAMPLE_RATE_SGIX = 0x85A0
+ UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1
+ PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2
+ PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3
+ PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIS_color_range: 0x85A5-0x85AD
+# EXTENDED_RANGE_SGIS = 0x85A5
+# MIN_RED_SGIS = 0x85A6
+# MAX_RED_SGIS = 0x85A7
+# MIN_GREEN_SGIS = 0x85A8
+# MAX_GREEN_SGIS = 0x85A9
+# MIN_BLUE_SGIS = 0x85AA
+# MAX_BLUE_SGIS = 0x85AB
+# MIN_ALPHA_SGIS = 0x85AC
+# MAX_ALPHA_SGIS = 0x85AD
+
+###############################################################################
+
+# EXT_texture_perturb_normal enum:
+# PERTURB_EXT = 0x85AE
+# TEXTURE_NORMAL_EXT = 0x85AF
+
+###############################################################################
+
+# Apple: 0x85B0-0x85BF
+
+# APPLE_specular_vector enum:
+# LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0
+
+# APPLE_transform_hint enum:
+# TRANSFORM_HINT_APPLE = 0x85B1
+
+# APPLE_client_storage enum:
+# UNPACK_CLIENT_STORAGE_APPLE = 0x85B2
+
+# APPLE_future_use: 0x85B3-0x85B4
+## From Jeremy 2006/10/18 (Bugzilla bug 632) - unknown extension name
+# BUFFER_OBJECT_APPLE = 0x85B3
+# STORAGE_CLIENT_APPLE = 0x85B4
+
+# APPLE_vertex_array_object enum:
+# VERTEX_ARRAY_BINDING_APPLE = 0x85B5
+
+# APPLE_future_use: 0x85B6-0x85B8
+## From Jeremy 2006/10/18 (Bugzilla bug 632) - unknown extension name
+# TEXTURE_MINIMIZE_STORAGE_APPLE = 0x85B6
+# TEXTURE_RANGE_LENGTH_APPLE = 0x85B7
+# TEXTURE_RANGE_POINTER_APPLE = 0x85B8
+
+# APPLE_ycbcr_422 enum:
+# YCBCR_422_APPLE = 0x85B9
+# UNSIGNED_SHORT_8_8_APPLE = 0x85BA
+# UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB
+
+# MESA_ycbcr_texture enum: (separate; see below)
+# UNSIGNED_SHORT_8_8_MESA = 0x85BA
+# UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB
+
+# APPLE_future_use: 0x85BC-0x85BD
+## From Jeremy 2006/10/18 (Bugzilla bug 632) - unknown extension name
+# TEXTURE_STORAGE_HINT_APPLE = 0x85BC
+# STORAGE_PRIVATE_APPLE = 0x85BD
+
+# APPLE_vertex_array_range (additional; see above): 0x85BE-0x85BF
+
+###############################################################################
+
+# Sun: 0x85C0-0x85CF
+
+# SUNX_general_triangle_list (additional; see above): 0x85C0-0x85CB
+
+# SUN_slice_accum: 0x85CC
+# SLICE_ACCUM_SUN = 0x85CC
+
+###############################################################################
+
+# Unknown extension name, not in enumext.spec
+# 3Dlabs/Autodesk: 0x85D0-0x85DF
+# FACET_NORMAL_AUTODESK = 0x85D0
+# FACET_NORMAL_ARRAY_AUTODESK = 0x85D1
+
+###############################################################################
+
+# Incomplete extension, not in enumext.spec
+# SGIX_texture_range: 0x85E0-0x85FB
+# RGB_SIGNED_SGIX = 0x85E0
+# RGBA_SIGNED_SGIX = 0x85E1
+# ALPHA_SIGNED_SGIX = 0x85E2
+# LUMINANCE_SIGNED_SGIX = 0x85E3
+# INTENSITY_SIGNED_SGIX = 0x85E4
+# LUMINANCE_ALPHA_SIGNED_SGIX = 0x85E5
+# RGB16_SIGNED_SGIX = 0x85E6
+# RGBA16_SIGNED_SGIX = 0x85E7
+# ALPHA16_SIGNED_SGIX = 0x85E8
+# LUMINANCE16_SIGNED_SGIX = 0x85E9
+# INTENSITY16_SIGNED_SGIX = 0x85EA
+# LUMINANCE16_ALPHA16_SIGNED_SGIX = 0x85EB
+# RGB_EXTENDED_RANGE_SGIX = 0x85EC
+# RGBA_EXTENDED_RANGE_SGIX = 0x85ED
+# ALPHA_EXTENDED_RANGE_SGIX = 0x85EE
+# LUMINANCE_EXTENDED_RANGE_SGIX = 0x85EF
+# INTENSITY_EXTENDED_RANGE_SGIX = 0x85F0
+# LUMINANCE_ALPHA_EXTENDED_RANGE_SGIX = 0x85F1
+# RGB16_EXTENDED_RANGE_SGIX = 0x85F2
+# RGBA16_EXTENDED_RANGE_SGIX = 0x85F3
+# ALPHA16_EXTENDED_RANGE_SGIX = 0x85F4
+# LUMINANCE16_EXTENDED_RANGE_SGIX = 0x85F5
+# INTENSITY16_EXTENDED_RANGE_SGIX = 0x85F6
+# LUMINANCE16_ALPHA16_EXTENDED_RANGE_SGIX = 0x85F7
+# MIN_LUMINANCE_SGIS = 0x85F8
+# MAX_LUMINANCE_SGIS = 0x85F9
+# MIN_INTENSITY_SGIS = 0x85FA
+# MAX_INTENSITY_SGIS = 0x85FB
+
+###############################################################################
+
+# SGI_future_use: 0x85FC-0x85FF
+
+###############################################################################
+
+# Sun: 0x8600-0x861F
+
+# SUN_mesh_array: 0x8614-0x8615
+# QUAD_MESH_SUN = 0x8614
+# TRIANGLE_MESH_SUN = 0x8615
+
+###############################################################################
+
+# NVIDIA: 0x8620-0x867F
+
+# NV_vertex_program enum:
+# VERTEX_PROGRAM_NV = 0x8620
+# VERTEX_STATE_PROGRAM_NV = 0x8621
+# ATTRIB_ARRAY_SIZE_NV = 0x8623
+# ATTRIB_ARRAY_STRIDE_NV = 0x8624
+# ATTRIB_ARRAY_TYPE_NV = 0x8625
+# CURRENT_ATTRIB_NV = 0x8626
+# PROGRAM_LENGTH_NV = 0x8627
+# PROGRAM_STRING_NV = 0x8628
+# MODELVIEW_PROJECTION_NV = 0x8629
+# IDENTITY_NV = 0x862A
+# INVERSE_NV = 0x862B
+# TRANSPOSE_NV = 0x862C
+# INVERSE_TRANSPOSE_NV = 0x862D
+# MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E
+# MAX_TRACK_MATRICES_NV = 0x862F
+# MATRIX0_NV = 0x8630
+# MATRIX1_NV = 0x8631
+# MATRIX2_NV = 0x8632
+# MATRIX3_NV = 0x8633
+# MATRIX4_NV = 0x8634
+# MATRIX5_NV = 0x8635
+# MATRIX6_NV = 0x8636
+# MATRIX7_NV = 0x8637
+# ##################
+# #
+# # Reserved:
+# #
+# # MATRIX8_NV = 0x8638
+# # MATRIX9_NV = 0x8639
+# # MATRIX10_NV = 0x863A
+# # MATRIX11_NV = 0x863B
+# # MATRIX12_NV = 0x863C
+# # MATRIX13_NV = 0x863D
+# # MATRIX14_NV = 0x863E
+# # MATRIX15_NV = 0x863F
+# #
+# ###################
+# CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640
+# CURRENT_MATRIX_NV = 0x8641
+# VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642
+# VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643
+# PROGRAM_PARAMETER_NV = 0x8644
+# ATTRIB_ARRAY_POINTER_NV = 0x8645
+# PROGRAM_TARGET_NV = 0x8646
+# PROGRAM_RESIDENT_NV = 0x8647
+# TRACK_MATRIX_NV = 0x8648
+# TRACK_MATRIX_TRANSFORM_NV = 0x8649
+# VERTEX_PROGRAM_BINDING_NV = 0x864A
+# PROGRAM_ERROR_POSITION_NV = 0x864B
+# VERTEX_ATTRIB_ARRAY0_NV = 0x8650
+# VERTEX_ATTRIB_ARRAY1_NV = 0x8651
+# VERTEX_ATTRIB_ARRAY2_NV = 0x8652
+# VERTEX_ATTRIB_ARRAY3_NV = 0x8653
+# VERTEX_ATTRIB_ARRAY4_NV = 0x8654
+# VERTEX_ATTRIB_ARRAY5_NV = 0x8655
+# VERTEX_ATTRIB_ARRAY6_NV = 0x8656
+# VERTEX_ATTRIB_ARRAY7_NV = 0x8657
+# VERTEX_ATTRIB_ARRAY8_NV = 0x8658
+# VERTEX_ATTRIB_ARRAY9_NV = 0x8659
+# VERTEX_ATTRIB_ARRAY10_NV = 0x865A
+# VERTEX_ATTRIB_ARRAY11_NV = 0x865B
+# VERTEX_ATTRIB_ARRAY12_NV = 0x865C
+# VERTEX_ATTRIB_ARRAY13_NV = 0x865D
+# VERTEX_ATTRIB_ARRAY14_NV = 0x865E
+# VERTEX_ATTRIB_ARRAY15_NV = 0x865F
+# MAP1_VERTEX_ATTRIB0_4_NV = 0x8660
+# MAP1_VERTEX_ATTRIB1_4_NV = 0x8661
+# MAP1_VERTEX_ATTRIB2_4_NV = 0x8662
+# MAP1_VERTEX_ATTRIB3_4_NV = 0x8663
+# MAP1_VERTEX_ATTRIB4_4_NV = 0x8664
+# MAP1_VERTEX_ATTRIB5_4_NV = 0x8665
+# MAP1_VERTEX_ATTRIB6_4_NV = 0x8666
+# MAP1_VERTEX_ATTRIB7_4_NV = 0x8667
+# MAP1_VERTEX_ATTRIB8_4_NV = 0x8668
+# MAP1_VERTEX_ATTRIB9_4_NV = 0x8669
+# MAP1_VERTEX_ATTRIB10_4_NV = 0x866A
+# MAP1_VERTEX_ATTRIB11_4_NV = 0x866B
+# MAP1_VERTEX_ATTRIB12_4_NV = 0x866C
+# MAP1_VERTEX_ATTRIB13_4_NV = 0x866D
+# MAP1_VERTEX_ATTRIB14_4_NV = 0x866E
+# MAP1_VERTEX_ATTRIB15_4_NV = 0x866F
+# MAP2_VERTEX_ATTRIB0_4_NV = 0x8670
+# MAP2_VERTEX_ATTRIB1_4_NV = 0x8671
+# MAP2_VERTEX_ATTRIB2_4_NV = 0x8672
+# MAP2_VERTEX_ATTRIB3_4_NV = 0x8673
+# MAP2_VERTEX_ATTRIB4_4_NV = 0x8674
+# MAP2_VERTEX_ATTRIB5_4_NV = 0x8675
+# MAP2_VERTEX_ATTRIB6_4_NV = 0x8676
+# MAP2_VERTEX_ATTRIB7_4_NV = 0x8677
+# MAP2_VERTEX_ATTRIB8_4_NV = 0x8678
+# MAP2_VERTEX_ATTRIB9_4_NV = 0x8679
+# MAP2_VERTEX_ATTRIB10_4_NV = 0x867A
+# MAP2_VERTEX_ATTRIB11_4_NV = 0x867B
+# MAP2_VERTEX_ATTRIB12_4_NV = 0x867C
+# MAP2_VERTEX_ATTRIB13_4_NV = 0x867D
+# MAP2_VERTEX_ATTRIB14_4_NV = 0x867E
+# MAP2_VERTEX_ATTRIB15_4_NV = 0x867F
+
+# NV_texture_shader (additional; see below): 0x864C-0x864E
+
+# NV_geometry_program4 enum: (additional; see below)
+# PROGRAM_POINT_SIZE_EXT = 0x8642
+
+# NV_depth_clamp enum:
+# DEPTH_CLAMP_NV = 0x864F
+
+# VERSION_2_0 enum: (Promoted from ARB_vertex_shader; only some values)
+# ARB_vertex_program enum: (additional; see above; reuses NV_vertex_program values)
+# ARB_fragment_program enum: (additional; only some values; see below)
+# (Unfortunately, PROGRAM_BINDING_ARB does accidentally reuse 0x8677)
+# VERTEX_PROGRAM_ARB = 0x8620
+# VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 # VERSION_2_0
+# VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622
+# VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 # VERSION_2_0
+# VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623
+# VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 # VERSION_2_0
+# VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624
+# VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 # VERSION_2_0
+# VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625
+# CURRENT_VERTEX_ATTRIB = 0x8626 # VERSION_2_0
+# CURRENT_VERTEX_ATTRIB_ARB = 0x8626
+# PROGRAM_LENGTH_ARB = 0x8627 # ARB_fragment_program
+# PROGRAM_STRING_ARB = 0x8628 # ARB_fragment_program
+# MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E # ARB_fragment_program
+# MAX_PROGRAM_MATRICES_ARB = 0x862F # ARB_fragment_program
+# CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640 # ARB_fragment_program
+# CURRENT_MATRIX_ARB = 0x8641 # ARB_fragment_program
+# VERTEX_PROGRAM_POINT_SIZE = 0x8642 # VERSION_2_0
+# VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642
+# VERTEX_PROGRAM_TWO_SIDE = 0x8643 # VERSION_2_0
+# VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643
+# VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 # VERSION_2_0
+# VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645
+# PROGRAM_ERROR_POSITION_ARB = 0x864B # ARB_fragment_program
+# PROGRAM_BINDING_ARB = 0x8677 # ARB_fragment_program
+
+###############################################################################
+
+# Pixelfusion: 0x8680-0x869F
+
+###############################################################################
+
+# ARB: 0x86A0-0x86AF
+
+# ARB_texture_compression/1.3 (additional; see above): 0x86A0-0x86A3
+
+# ARB_vertex_blend enum:
+# MAX_VERTEX_UNITS_ARB = 0x86A4
+# ACTIVE_VERTEX_UNITS_ARB = 0x86A5
+# WEIGHT_SUM_UNITY_ARB = 0x86A6
+# VERTEX_BLEND_ARB = 0x86A7
+# CURRENT_WEIGHT_ARB = 0x86A8
+# WEIGHT_ARRAY_TYPE_ARB = 0x86A9
+# WEIGHT_ARRAY_STRIDE_ARB = 0x86AA
+# WEIGHT_ARRAY_SIZE_ARB = 0x86AB
+# WEIGHT_ARRAY_POINTER_ARB = 0x86AC
+# WEIGHT_ARRAY_ARB = 0x86AD
+# Note: MODELVIEW0/1 are defined in other extensions, but not as ARB)
+# MODELVIEW0_ARB = 0x1700
+# MODELVIEW1_ARB = 0x850A
+# MODELVIEW2_ARB = 0x8722
+# MODELVIEW3_ARB = 0x8723
+# MODELVIEW4_ARB = 0x8724
+# MODELVIEW5_ARB = 0x8725
+# MODELVIEW6_ARB = 0x8726
+# MODELVIEW7_ARB = 0x8727
+# MODELVIEW8_ARB = 0x8728
+# MODELVIEW9_ARB = 0x8729
+# MODELVIEW10_ARB = 0x872A
+# MODELVIEW11_ARB = 0x872B
+# MODELVIEW12_ARB = 0x872C
+# MODELVIEW13_ARB = 0x872D
+# MODELVIEW14_ARB = 0x872E
+# MODELVIEW15_ARB = 0x872F
+# MODELVIEW16_ARB = 0x8730
+# MODELVIEW17_ARB = 0x8731
+# MODELVIEW18_ARB = 0x8732
+# MODELVIEW19_ARB = 0x8733
+# MODELVIEW20_ARB = 0x8734
+# MODELVIEW21_ARB = 0x8735
+# MODELVIEW22_ARB = 0x8736
+# MODELVIEW23_ARB = 0x8737
+# MODELVIEW24_ARB = 0x8738
+# MODELVIEW25_ARB = 0x8739
+# MODELVIEW26_ARB = 0x873A
+# MODELVIEW27_ARB = 0x873B
+# MODELVIEW28_ARB = 0x873C
+# MODELVIEW29_ARB = 0x873D
+# MODELVIEW30_ARB = 0x873E
+# MODELVIEW31_ARB = 0x873F
+
+# VERSION_1_3 enum: (Promoted for OpenGL 1.3)
+# ARB_texture_env_dot3
+# DOT3_RGB = 0x86AE
+# DOT3_RGB_ARB = 0x86AE
+# DOT3_RGBA = 0x86AF
+# DOT3_RGBA_ARB = 0x86AF
+
+###############################################################################
+
+# 3Dfx: 0x86B0-0x86BF
+
+# 3DFX_texture_compression_FXT1 enum:
+# COMPRESSED_RGB_FXT1_3DFX = 0x86B0
+# COMPRESSED_RGBA_FXT1_3DFX = 0x86B1
+
+# 3DFX_multisample enum:
+# MULTISAMPLE_3DFX = 0x86B2
+# SAMPLE_BUFFERS_3DFX = 0x86B3
+# SAMPLES_3DFX = 0x86B4
+# MULTISAMPLE_BIT_3DFX = 0x20000000
+
+###############################################################################
+
+# NVIDIA: 0x86C0-0x871F
+
+# NV_evaluators enum:
+# EVAL_2D_NV = 0x86C0
+# EVAL_TRIANGULAR_2D_NV = 0x86C1
+# MAP_TESSELLATION_NV = 0x86C2
+# MAP_ATTRIB_U_ORDER_NV = 0x86C3
+# MAP_ATTRIB_V_ORDER_NV = 0x86C4
+# EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5
+# EVAL_VERTEX_ATRRIB0_NV = 0x86C6
+# EVAL_VERTEX_ATRRIB1_NV = 0x86C7
+# EVAL_VERTEX_ATRRIB2_NV = 0x86C8
+# EVAL_VERTEX_ATRRIB3_NV = 0x86C9
+# EVAL_VERTEX_ATRRIB4_NV = 0x86CA
+# EVAL_VERTEX_ATRRIB5_NV = 0x86CB
+# EVAL_VERTEX_ATRRIB6_NV = 0x86CC
+# EVAL_VERTEX_ATRRIB7_NV = 0x86CD
+# EVAL_VERTEX_ATRRIB8_NV = 0x86CE
+# EVAL_VERTEX_ATRRIB9_NV = 0x86CF
+# EVAL_VERTEX_ATRRIB10_NV = 0x86D0
+# EVAL_VERTEX_ATRRIB11_NV = 0x86D1
+# EVAL_VERTEX_ATRRIB12_NV = 0x86D2
+# EVAL_VERTEX_ATRRIB13_NV = 0x86D3
+# EVAL_VERTEX_ATRRIB14_NV = 0x86D4
+# EVAL_VERTEX_ATRRIB15_NV = 0x86D5
+# MAX_MAP_TESSELLATION_NV = 0x86D6
+# MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7
+
+# NV_future_use: 0x86D8
+
+# NV_texture_shader enum:
+# OFFSET_TEXTURE_RECTANGLE_NV = 0x864C
+# OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D
+# DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E
+# RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9
+# UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA
+# UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB
+# DSDT_MAG_INTENSITY_NV = 0x86DC
+# SHADER_CONSISTENT_NV = 0x86DD
+# TEXTURE_SHADER_NV = 0x86DE
+# SHADER_OPERATION_NV = 0x86DF
+# CULL_MODES_NV = 0x86E0
+# OFFSET_TEXTURE_MATRIX_NV = 0x86E1
+# OFFSET_TEXTURE_SCALE_NV = 0x86E2
+# OFFSET_TEXTURE_BIAS_NV = 0x86E3
+# OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV
+# OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV
+# OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV
+# PREVIOUS_TEXTURE_INPUT_NV = 0x86E4
+# CONST_EYE_NV = 0x86E5
+# PASS_THROUGH_NV = 0x86E6
+# CULL_FRAGMENT_NV = 0x86E7
+# OFFSET_TEXTURE_2D_NV = 0x86E8
+# DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9
+# DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA
+# DOT_PRODUCT_NV = 0x86EC
+# DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED
+# DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE
+# DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0
+# DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1
+# DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2
+# DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3
+# HILO_NV = 0x86F4
+# DSDT_NV = 0x86F5
+# DSDT_MAG_NV = 0x86F6
+# DSDT_MAG_VIB_NV = 0x86F7
+# HILO16_NV = 0x86F8
+# SIGNED_HILO_NV = 0x86F9
+# SIGNED_HILO16_NV = 0x86FA
+# SIGNED_RGBA_NV = 0x86FB
+# SIGNED_RGBA8_NV = 0x86FC
+# SIGNED_RGB_NV = 0x86FE
+# SIGNED_RGB8_NV = 0x86FF
+# SIGNED_LUMINANCE_NV = 0x8701
+# SIGNED_LUMINANCE8_NV = 0x8702
+# SIGNED_LUMINANCE_ALPHA_NV = 0x8703
+# SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704
+# SIGNED_ALPHA_NV = 0x8705
+# SIGNED_ALPHA8_NV = 0x8706
+# SIGNED_INTENSITY_NV = 0x8707
+# SIGNED_INTENSITY8_NV = 0x8708
+# DSDT8_NV = 0x8709
+# DSDT8_MAG8_NV = 0x870A
+# DSDT8_MAG8_INTENSITY8_NV = 0x870B
+# SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C
+# SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D
+# HI_SCALE_NV = 0x870E
+# LO_SCALE_NV = 0x870F
+# DS_SCALE_NV = 0x8710
+# DT_SCALE_NV = 0x8711
+# MAGNITUDE_SCALE_NV = 0x8712
+# VIBRANCE_SCALE_NV = 0x8713
+# HI_BIAS_NV = 0x8714
+# LO_BIAS_NV = 0x8715
+# DS_BIAS_NV = 0x8716
+# DT_BIAS_NV = 0x8717
+# MAGNITUDE_BIAS_NV = 0x8718
+# VIBRANCE_BIAS_NV = 0x8719
+# TEXTURE_BORDER_VALUES_NV = 0x871A
+# TEXTURE_HI_SIZE_NV = 0x871B
+# TEXTURE_LO_SIZE_NV = 0x871C
+# TEXTURE_DS_SIZE_NV = 0x871D
+# TEXTURE_DT_SIZE_NV = 0x871E
+# TEXTURE_MAG_SIZE_NV = 0x871F
+
+# NV_texture_shader2 enum:
+# DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF
+
+# NV_future_use: 0x86EB
+# NV_future_use: 0x86FD
+# NV_future_use: 0x8700
+
+###############################################################################
+
+# ARB: 0x8720-0x873F
+
+# ARB_vertex_blend (additional; see above): 0x8720-0x873F
+
+###############################################################################
+
+# ATI: 0x8740-0x874F
+
+# EXT_texture_env_dot3 enum:
+# DOT3_RGB_EXT = 0x8740
+# DOT3_RGBA_EXT = 0x8741
+
+# ATI_texture_mirror_once enum:
+# MIRROR_CLAMP_ATI = 0x8742
+# MIRROR_CLAMP_TO_EDGE_ATI = 0x8743
+# EXT_texture_mirror_clamp enum:
+# MIRROR_CLAMP_EXT = 0x8742
+# MIRROR_CLAMP_TO_EDGE_EXT = 0x8743
+
+# ATI_texture_env_combine3 enum:
+# MODULATE_ADD_ATI = 0x8744
+# MODULATE_SIGNED_ADD_ATI = 0x8745
+# MODULATE_SUBTRACT_ATI = 0x8746
+
+# ATI_future_use: 0x8747-0x874F
+
+###############################################################################
+
+# MESA: 0x8750-0x875F
+
+# MESA_future_use: 0x8750-0x8757
+
+# MESA_pack_invert enum:
+# PACK_INVERT_MESA = 0x8758
+
+# MESAX_texture_stack enum:
+# TEXTURE_1D_STACK_MESAX = 0x8759
+# TEXTURE_2D_STACK_MESAX = 0x875A
+# PROXY_TEXTURE_1D_STACK_MESAX = 0x875B
+# PROXY_TEXTURE_2D_STACK_MESAX = 0x875C
+# TEXTURE_1D_STACK_BINDING_MESAX = 0x875D
+# TEXTURE_2D_STACK_BINDING_MESAX = 0x875E
+
+# MESA_future_use: 0x875F
+
+###############################################################################
+
+# ATI: 0x8760-0x883F
+
+# ATI_vertex_array_object enum:
+# STATIC_ATI = 0x8760
+# DYNAMIC_ATI = 0x8761
+# PRESERVE_ATI = 0x8762
+# DISCARD_ATI = 0x8763
+# OBJECT_BUFFER_SIZE_ATI = 0x8764
+# OBJECT_BUFFER_USAGE_ATI = 0x8765
+# ARRAY_OBJECT_BUFFER_ATI = 0x8766
+# ARRAY_OBJECT_OFFSET_ATI = 0x8767
+
+# VERSION_1_5 enum: (Promoted for OpenGL 1.5)
+# ARB_vertex_buffer_object enum (additional; aliases some ATI enums; see below)
+# BUFFER_SIZE = 0x8764
+# BUFFER_SIZE_ARB = 0x8764
+# BUFFER_USAGE = 0x8765
+# BUFFER_USAGE_ARB = 0x8765
+
+# ATI_element_array enum:
+# ELEMENT_ARRAY_ATI = 0x8768
+# ELEMENT_ARRAY_TYPE_ATI = 0x8769
+# ELEMENT_ARRAY_POINTER_ATI = 0x876A
+
+# @@@ (extends ATI_element_array, I think???)
+# APPLE_element_array enum:
+# ELEMENT_ARRAY_APPLE = 0x8768
+# ELEMENT_ARRAY_TYPE_APPLE = 0x8769
+# ELEMENT_ARRAY_POINTER_APPLE = 0x876A
+
+# ATI_vertex_streams enum:
+# MAX_VERTEX_STREAMS_ATI = 0x876B
+# VERTEX_STREAM0_ATI = 0x876C
+# VERTEX_STREAM1_ATI = 0x876D
+# VERTEX_STREAM2_ATI = 0x876E
+# VERTEX_STREAM3_ATI = 0x876F
+# VERTEX_STREAM4_ATI = 0x8770
+# VERTEX_STREAM5_ATI = 0x8771
+# VERTEX_STREAM6_ATI = 0x8772
+# VERTEX_STREAM7_ATI = 0x8773
+# VERTEX_SOURCE_ATI = 0x8774
+
+# ATI_envmap_bumpmap enum:
+# BUMP_ROT_MATRIX_ATI = 0x8775
+# BUMP_ROT_MATRIX_SIZE_ATI = 0x8776
+# BUMP_NUM_TEX_UNITS_ATI = 0x8777
+# BUMP_TEX_UNITS_ATI = 0x8778
+# DUDV_ATI = 0x8779
+# DU8DV8_ATI = 0x877A
+# BUMP_ENVMAP_ATI = 0x877B
+# BUMP_TARGET_ATI = 0x877C
+
+# ATI_future_use: 0x877D-0x877F
+
+# EXT_vertex_shader enum:
+# VERTEX_SHADER_EXT = 0x8780
+# VERTEX_SHADER_BINDING_EXT = 0x8781
+# OP_INDEX_EXT = 0x8782
+# OP_NEGATE_EXT = 0x8783
+# OP_DOT3_EXT = 0x8784
+# OP_DOT4_EXT = 0x8785
+# OP_MUL_EXT = 0x8786
+# OP_ADD_EXT = 0x8787
+# OP_MADD_EXT = 0x8788
+# OP_FRAC_EXT = 0x8789
+# OP_MAX_EXT = 0x878A
+# OP_MIN_EXT = 0x878B
+# OP_SET_GE_EXT = 0x878C
+# OP_SET_LT_EXT = 0x878D
+# OP_CLAMP_EXT = 0x878E
+# OP_FLOOR_EXT = 0x878F
+# OP_ROUND_EXT = 0x8790
+# OP_EXP_BASE_2_EXT = 0x8791
+# OP_LOG_BASE_2_EXT = 0x8792
+# OP_POWER_EXT = 0x8793
+# OP_RECIP_EXT = 0x8794
+# OP_RECIP_SQRT_EXT = 0x8795
+# OP_SUB_EXT = 0x8796
+# OP_CROSS_PRODUCT_EXT = 0x8797
+# OP_MULTIPLY_MATRIX_EXT = 0x8798
+# OP_MOV_EXT = 0x8799
+# OUTPUT_VERTEX_EXT = 0x879A
+# OUTPUT_COLOR0_EXT = 0x879B
+# OUTPUT_COLOR1_EXT = 0x879C
+# OUTPUT_TEXTURE_COORD0_EXT = 0x879D
+# OUTPUT_TEXTURE_COORD1_EXT = 0x879E
+# OUTPUT_TEXTURE_COORD2_EXT = 0x879F
+# OUTPUT_TEXTURE_COORD3_EXT = 0x87A0
+# OUTPUT_TEXTURE_COORD4_EXT = 0x87A1
+# OUTPUT_TEXTURE_COORD5_EXT = 0x87A2
+# OUTPUT_TEXTURE_COORD6_EXT = 0x87A3
+# OUTPUT_TEXTURE_COORD7_EXT = 0x87A4
+# OUTPUT_TEXTURE_COORD8_EXT = 0x87A5
+# OUTPUT_TEXTURE_COORD9_EXT = 0x87A6
+# OUTPUT_TEXTURE_COORD10_EXT = 0x87A7
+# OUTPUT_TEXTURE_COORD11_EXT = 0x87A8
+# OUTPUT_TEXTURE_COORD12_EXT = 0x87A9
+# OUTPUT_TEXTURE_COORD13_EXT = 0x87AA
+# OUTPUT_TEXTURE_COORD14_EXT = 0x87AB
+# OUTPUT_TEXTURE_COORD15_EXT = 0x87AC
+# OUTPUT_TEXTURE_COORD16_EXT = 0x87AD
+# OUTPUT_TEXTURE_COORD17_EXT = 0x87AE
+# OUTPUT_TEXTURE_COORD18_EXT = 0x87AF
+# OUTPUT_TEXTURE_COORD19_EXT = 0x87B0
+# OUTPUT_TEXTURE_COORD20_EXT = 0x87B1
+# OUTPUT_TEXTURE_COORD21_EXT = 0x87B2
+# OUTPUT_TEXTURE_COORD22_EXT = 0x87B3
+# OUTPUT_TEXTURE_COORD23_EXT = 0x87B4
+# OUTPUT_TEXTURE_COORD24_EXT = 0x87B5
+# OUTPUT_TEXTURE_COORD25_EXT = 0x87B6
+# OUTPUT_TEXTURE_COORD26_EXT = 0x87B7
+# OUTPUT_TEXTURE_COORD27_EXT = 0x87B8
+# OUTPUT_TEXTURE_COORD28_EXT = 0x87B9
+# OUTPUT_TEXTURE_COORD29_EXT = 0x87BA
+# OUTPUT_TEXTURE_COORD30_EXT = 0x87BB
+# OUTPUT_TEXTURE_COORD31_EXT = 0x87BC
+# OUTPUT_FOG_EXT = 0x87BD
+# SCALAR_EXT = 0x87BE
+# VECTOR_EXT = 0x87BF
+# MATRIX_EXT = 0x87C0
+# VARIANT_EXT = 0x87C1
+# INVARIANT_EXT = 0x87C2
+# LOCAL_CONSTANT_EXT = 0x87C3
+# LOCAL_EXT = 0x87C4
+# MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5
+# MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6
+# MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7
+# MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8
+# MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9
+# MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA
+# MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB
+# MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC
+# MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD
+# MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE
+# VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF
+# VERTEX_SHADER_VARIANTS_EXT = 0x87D0
+# VERTEX_SHADER_INVARIANTS_EXT = 0x87D1
+# VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2
+# VERTEX_SHADER_LOCALS_EXT = 0x87D3
+# VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4
+# X_EXT = 0x87D5
+# Y_EXT = 0x87D6
+# Z_EXT = 0x87D7
+# W_EXT = 0x87D8
+# NEGATIVE_X_EXT = 0x87D9
+# NEGATIVE_Y_EXT = 0x87DA
+# NEGATIVE_Z_EXT = 0x87DB
+# NEGATIVE_W_EXT = 0x87DC
+# ZERO_EXT = 0x87DD
+# ONE_EXT = 0x87DE
+# NEGATIVE_ONE_EXT = 0x87DF
+# NORMALIZED_RANGE_EXT = 0x87E0
+# FULL_RANGE_EXT = 0x87E1
+# CURRENT_VERTEX_EXT = 0x87E2
+# MVP_MATRIX_EXT = 0x87E3
+# VARIANT_VALUE_EXT = 0x87E4
+# VARIANT_DATATYPE_EXT = 0x87E5
+# VARIANT_ARRAY_STRIDE_EXT = 0x87E6
+# VARIANT_ARRAY_TYPE_EXT = 0x87E7
+# VARIANT_ARRAY_EXT = 0x87E8
+# VARIANT_ARRAY_POINTER_EXT = 0x87E9
+# INVARIANT_VALUE_EXT = 0x87EA
+# INVARIANT_DATATYPE_EXT = 0x87EB
+# LOCAL_CONSTANT_VALUE_EXT = 0x87EC
+# LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED
+
+# ATI_pn_triangles enum:
+# PN_TRIANGLES_ATI = 0x87F0
+# MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1
+# PN_TRIANGLES_POINT_MODE_ATI = 0x87F2
+# PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3
+# PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4
+# PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5
+# PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6
+# PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7
+# PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8
+
+# ATI_future_use: 0x87F9-0x87FF
+
+# VERSION_2_0 enum: (Promoted for OpenGL 2.0)
+# ATI_separate_stencil enum:
+# STENCIL_BACK_FUNC = 0x8800 # VERSION_2_0
+# STENCIL_BACK_FUNC_ATI = 0x8800
+# STENCIL_BACK_FAIL = 0x8801 # VERSION_2_0
+# STENCIL_BACK_FAIL_ATI = 0x8801
+# STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 # VERSION_2_0
+# STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802
+# STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 # VERSION_2_0
+# STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803
+
+# ARB_fragment_program enum:
+# FRAGMENT_PROGRAM_ARB = 0x8804
+# PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805
+# PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806
+# PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807
+# PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808
+# PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809
+# PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A
+# MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B
+# MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C
+# MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D
+# MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E
+# MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F
+# MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810
+
+# ATI_future_use: 0x8811-0x8813
+
+# ARB_texture_float enum:
+# ATI_texture_float enum:
+# RGBA32F_ARB = 0x8814
+# RGBA_FLOAT32_ATI = 0x8814
+# RGB32F_ARB = 0x8815
+# RGB_FLOAT32_ATI = 0x8815
+# ALPHA32F_ARB = 0x8816
+# ALPHA_FLOAT32_ATI = 0x8816
+# INTENSITY32F_ARB = 0x8817
+# INTENSITY_FLOAT32_ATI = 0x8817
+# LUMINANCE32F_ARB = 0x8818
+# LUMINANCE_FLOAT32_ATI = 0x8818
+# LUMINANCE_ALPHA32F_ARB = 0x8819
+# LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819
+# RGBA16F_ARB = 0x881A
+# RGBA_FLOAT16_ATI = 0x881A
+# RGB16F_ARB = 0x881B
+# RGB_FLOAT16_ATI = 0x881B
+# ALPHA16F_ARB = 0x881C
+# ALPHA_FLOAT16_ATI = 0x881C
+# INTENSITY16F_ARB = 0x881D
+# INTENSITY_FLOAT16_ATI = 0x881D
+# LUMINANCE16F_ARB = 0x881E
+# LUMINANCE_FLOAT16_ATI = 0x881E
+# LUMINANCE_ALPHA16F_ARB = 0x881F
+# LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F
+
+# ARB_color_buffer_float enum:
+# ATI_pixel_format_float enum: (really WGL_ATI_pixel_format_float)
+# RGBA_FLOAT_MODE_ARB = 0x8820
+# TYPE_RGBA_FLOAT_ATI = 0x8820
+
+# ATI_future_use: 0x8821-0x8823
+
+# VERSION_2_0 enum: (Promoted for OpenGL 2.0)
+# ARB_draw_buffers enum:
+# ATI_draw_buffers enum:
+# MAX_DRAW_BUFFERS = 0x8824 # VERSION_2_0
+# MAX_DRAW_BUFFERS_ARB = 0x8824
+# MAX_DRAW_BUFFERS_ATI = 0x8824
+# DRAW_BUFFER0 = 0x8825 # VERSION_2_0
+# DRAW_BUFFER0_ARB = 0x8825
+# DRAW_BUFFER0_ATI = 0x8825
+# DRAW_BUFFER1 = 0x8826 # VERSION_2_0
+# DRAW_BUFFER1_ARB = 0x8826
+# DRAW_BUFFER1_ATI = 0x8826
+# DRAW_BUFFER2 = 0x8827 # VERSION_2_0
+# DRAW_BUFFER2_ARB = 0x8827
+# DRAW_BUFFER2_ATI = 0x8827
+# DRAW_BUFFER3 = 0x8828 # VERSION_2_0
+# DRAW_BUFFER3_ARB = 0x8828
+# DRAW_BUFFER3_ATI = 0x8828
+# DRAW_BUFFER4 = 0x8829 # VERSION_2_0
+# DRAW_BUFFER4_ARB = 0x8829
+# DRAW_BUFFER4_ATI = 0x8829
+# DRAW_BUFFER5 = 0x882A # VERSION_2_0
+# DRAW_BUFFER5_ARB = 0x882A
+# DRAW_BUFFER5_ATI = 0x882A
+# DRAW_BUFFER6 = 0x882B # VERSION_2_0
+# DRAW_BUFFER6_ARB = 0x882B
+# DRAW_BUFFER6_ATI = 0x882B
+# DRAW_BUFFER7 = 0x882C # VERSION_2_0
+# DRAW_BUFFER7_ARB = 0x882C
+# DRAW_BUFFER7_ATI = 0x882C
+# DRAW_BUFFER8 = 0x882D # VERSION_2_0
+# DRAW_BUFFER8_ARB = 0x882D
+# DRAW_BUFFER8_ATI = 0x882D
+# DRAW_BUFFER9 = 0x882E # VERSION_2_0
+# DRAW_BUFFER9_ARB = 0x882E
+# DRAW_BUFFER9_ATI = 0x882E
+# DRAW_BUFFER10 = 0x882F # VERSION_2_0
+# DRAW_BUFFER10_ARB = 0x882F
+# DRAW_BUFFER10_ATI = 0x882F
+# DRAW_BUFFER11 = 0x8830 # VERSION_2_0
+# DRAW_BUFFER11_ARB = 0x8830
+# DRAW_BUFFER11_ATI = 0x8830
+# DRAW_BUFFER12 = 0x8831 # VERSION_2_0
+# DRAW_BUFFER12_ARB = 0x8831
+# DRAW_BUFFER12_ATI = 0x8831
+# DRAW_BUFFER13 = 0x8832 # VERSION_2_0
+# DRAW_BUFFER13_ARB = 0x8832
+# DRAW_BUFFER13_ATI = 0x8832
+# DRAW_BUFFER14 = 0x8833 # VERSION_2_0
+# DRAW_BUFFER14_ARB = 0x8833
+# DRAW_BUFFER14_ATI = 0x8833
+# DRAW_BUFFER15 = 0x8834 # VERSION_2_0
+# DRAW_BUFFER15_ARB = 0x8834
+# DRAW_BUFFER15_ATI = 0x8834
+
+# ATI_pixel_format_float enum: (really WGL_ATI_pixel_format_float) (additional; see above)
+# COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835
+
+# ATI_future_use: 0x8836-0x883F
+
+# VERSION_2_0 enum: (Promoted for OpenGL 2.0)
+# EXT_blend_equation_separate enum:
+# BLEND_EQUATION_ALPHA = 0x883D # VERSION_2_0
+# BLEND_EQUATION_ALPHA_EXT = 0x883D
+
+###############################################################################
+
+# ARB: 0x8840-0x884F
+
+# ARB_matrix_palette enum:
+# MATRIX_PALETTE_ARB = 0x8840
+# MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841
+# MAX_PALETTE_MATRICES_ARB = 0x8842
+# CURRENT_PALETTE_MATRIX_ARB = 0x8843
+# MATRIX_INDEX_ARRAY_ARB = 0x8844
+# CURRENT_MATRIX_INDEX_ARB = 0x8845
+# MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846
+# MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847
+# MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848
+# MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# ARB_depth_texture enum:
+# TEXTURE_DEPTH_SIZE = 0x884A
+# TEXTURE_DEPTH_SIZE_ARB = 0x884A
+# DEPTH_TEXTURE_MODE = 0x884B
+# DEPTH_TEXTURE_MODE_ARB = 0x884B
+
+# VERSION_1_4 enum: (Promoted for OpenGL 1.4)
+# ARB_shadow enum:
+# EXT_texture_array enum: (additional; see below)
+# TEXTURE_COMPARE_MODE = 0x884C
+# TEXTURE_COMPARE_MODE_ARB = 0x884C
+# TEXTURE_COMPARE_FUNC = 0x884D
+# TEXTURE_COMPARE_FUNC_ARB = 0x884D
+# COMPARE_R_TO_TEXTURE = 0x884E
+# COMPARE_R_TO_TEXTURE_ARB = 0x884E
+# COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E
+
+# ARB_future_use: 0x884F
+
+###############################################################################
+
+# NVIDIA: 0x8850-0x891F
+
+# NV_texture_shader3 enum:
+# OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850
+# OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851
+# OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852
+# OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853
+# OFFSET_HILO_TEXTURE_2D_NV = 0x8854
+# OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855
+# OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856
+# OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857
+# DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858
+# DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859
+# DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A
+# DOT_PRODUCT_PASS_THROUGH_NV = 0x885B
+# DOT_PRODUCT_TEXTURE_1D_NV = 0x885C
+# DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D
+# HILO8_NV = 0x885E
+# SIGNED_HILO8_NV = 0x885F
+# FORCE_BLUE_TO_ONE_NV = 0x8860
+
+# VERSION_2_0 enum: (Promoted for OpenGL 2.0)
+# ARB_point_sprite enum:
+# NV_point_sprite enum:
+# POINT_SPRITE = 0x8861 # VERSION_2_0
+# POINT_SPRITE_ARB = 0x8861
+# POINT_SPRITE_NV = 0x8861
+# COORD_REPLACE = 0x8862 # VERSION_2_0
+# COORD_REPLACE_ARB = 0x8862
+# COORD_REPLACE_NV = 0x8862
+
+# NV_point_sprite enum:
+# POINT_SPRITE_R_MODE_NV = 0x8863
+
+# VERSION_1_5 enum: (Promoted for OpenGL 1.5)
+# ARB_occlusion_query enum:
+# NV_occlusion_query enum:
+# QUERY_COUNTER_BITS = 0x8864
+# QUERY_COUNTER_BITS_ARB = 0x8864
+# PIXEL_COUNTER_BITS_NV = 0x8864
+# CURRENT_QUERY = 0x8865
+# CURRENT_QUERY_ARB = 0x8865
+# CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865
+# QUERY_RESULT = 0x8866
+# QUERY_RESULT_ARB = 0x8866
+# PIXEL_COUNT_NV = 0x8866
+# QUERY_RESULT_AVAILABLE = 0x8867
+# QUERY_RESULT_AVAILABLE_ARB = 0x8867
+# PIXEL_COUNT_AVAILABLE_NV = 0x8867
+
+# NV_fragment_program enum:
+# MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868
+
+# VERSION_2_0 enum: (Promoted from ARB_vertex_shader)
+# ARB_vertex_program enum: (additional; see above)
+# MAX_VERTEX_ATTRIBS = 0x8869 # VERSION_2_0
+# MAX_VERTEX_ATTRIBS_ARB = 0x8869
+# VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A # VERSION_2_0
+# VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A
+
+# NV_future_use: 0x886B-0x886D
+
+# NV_copy_depth_to_color enum:
+# DEPTH_STENCIL_TO_RGBA_NV = 0x886E
+# DEPTH_STENCIL_TO_BGRA_NV = 0x886F
+
+# VERSION_2_0 enum: (Promoted from ARB_fragment_shader; only some values)
+# ARB_vertex_program enum: (additional; see above)
+# ARB_fragment_program enum: (additional; see above)
+# NV_fragment_program enum: (additional; see above)
+# FRAGMENT_PROGRAM_NV = 0x8870
+# MAX_TEXTURE_COORDS = 0x8871 # VERSION_2_0
+# MAX_TEXTURE_COORDS_ARB = 0x8871 # ARB_fragment_program
+# MAX_TEXTURE_COORDS_NV = 0x8871
+# MAX_TEXTURE_IMAGE_UNITS = 0x8872 # VERSION_2_0
+# MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872 # ARB_fragment_program
+# MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872
+# FRAGMENT_PROGRAM_BINDING_NV = 0x8873
+# PROGRAM_ERROR_STRING_ARB = 0x8874 # ARB_vertex_program / ARB_fragment_program
+# PROGRAM_ERROR_STRING_NV = 0x8874
+# PROGRAM_FORMAT_ASCII_ARB = 0x8875 # ARB_vertex_program / ARB_fragment_program
+# PROGRAM_FORMAT_ARB = 0x8876 # ARB_vertex_program / ARB_fragment_program
+
+# 0x8877 *should have been* assigned to PROGRAM_BINDING_ARB. Oops.
+
+# NV_pixel_data_range enum:
+# WRITE_PIXEL_DATA_RANGE_NV = 0x8878
+# READ_PIXEL_DATA_RANGE_NV = 0x8879
+# WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A
+# READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B
+# WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C
+# READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D
+
+# NV_future_use: 0x887E-0x887F
+
+# NV_float_buffer enum:
+# FLOAT_R_NV = 0x8880
+# FLOAT_RG_NV = 0x8881
+# FLOAT_RGB_NV = 0x8882
+# FLOAT_RGBA_NV = 0x8883
+# FLOAT_R16_NV = 0x8884
+# FLOAT_R32_NV = 0x8885
+# FLOAT_RG16_NV = 0x8886
+# FLOAT_RG32_NV = 0x8887
+# FLOAT_RGB16_NV = 0x8888
+# FLOAT_RGB32_NV = 0x8889
+# FLOAT_RGBA16_NV = 0x888A
+# FLOAT_RGBA32_NV = 0x888B
+# TEXTURE_FLOAT_COMPONENTS_NV = 0x888C
+# FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D
+# FLOAT_RGBA_MODE_NV = 0x888E
+
+# NV_texture_expand_normal enum:
+# TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F
+
+# EXT_depth_bounds_test enum:
+# DEPTH_BOUNDS_TEST_EXT = 0x8890
+# DEPTH_BOUNDS_EXT = 0x8891
+
+# VERSION_1_5 enum: (Promoted for OpenGL 1.5)
+# ARB_vertex_buffer_object enum:
+# ARRAY_BUFFER = 0x8892
+# ARRAY_BUFFER_ARB = 0x8892
+# ELEMENT_ARRAY_BUFFER = 0x8893
+# ELEMENT_ARRAY_BUFFER_ARB = 0x8893
+# ARRAY_BUFFER_BINDING = 0x8894
+# ARRAY_BUFFER_BINDING_ARB = 0x8894
+# ELEMENT_ARRAY_BUFFER_BINDING = 0x8895
+# ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895
+# VERTEX_ARRAY_BUFFER_BINDING = 0x8896
+# VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896
+# NORMAL_ARRAY_BUFFER_BINDING = 0x8897
+# NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897
+# COLOR_ARRAY_BUFFER_BINDING = 0x8898
+# COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898
+# INDEX_ARRAY_BUFFER_BINDING = 0x8899
+# INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899
+# TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A
+# TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A
+# EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B
+# EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B
+# SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C
+# SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C
+# FOG_COORD_ARRAY_BUFFER_BINDING = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING
+# FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D
+# FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D
+# WEIGHT_ARRAY_BUFFER_BINDING = 0x889E
+# WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E
+# VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F
+# VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F
+
+# ARB_vertex_program enum: (additional; see above)
+# ARB_fragment_program enum: (additional; see above)
+# PROGRAM_INSTRUCTIONS_ARB = 0x88A0
+# MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1
+# PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2
+# MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3
+# PROGRAM_TEMPORARIES_ARB = 0x88A4
+# MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5
+# PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6
+# MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7
+# PROGRAM_PARAMETERS_ARB = 0x88A8
+# MAX_PROGRAM_PARAMETERS_ARB = 0x88A9
+# PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA
+# MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB
+# PROGRAM_ATTRIBS_ARB = 0x88AC
+# MAX_PROGRAM_ATTRIBS_ARB = 0x88AD
+# PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE
+# MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF
+# PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0
+# MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1
+# PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2
+# MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3
+# MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4
+# MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5
+# PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6
+# TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7
+
+# VERSION_1_5 enum: (Promoted for OpenGL 1.5)
+# ARB_vertex_buffer_object enum: (additional; see above)
+# READ_ONLY = 0x88B8
+# READ_ONLY_ARB = 0x88B8
+# WRITE_ONLY = 0x88B9
+# WRITE_ONLY_ARB = 0x88B9
+# READ_WRITE = 0x88BA
+# READ_WRITE_ARB = 0x88BA
+# BUFFER_ACCESS = 0x88BB
+# BUFFER_ACCESS_ARB = 0x88BB
+# BUFFER_MAPPED = 0x88BC
+# BUFFER_MAPPED_ARB = 0x88BC
+# BUFFER_MAP_POINTER = 0x88BD
+# BUFFER_MAP_POINTER_ARB = 0x88BD
+
+# NV_future_use: 0x88BE
+
+# EXT_timer_query enum:
+# TIME_ELAPSED_EXT = 0x88BF
+
+# ARB_vertex_program enum: (additional; see above)
+# ARB_fragment_program enum: (additional; see above)
+# MATRIX0_ARB = 0x88C0
+# MATRIX1_ARB = 0x88C1
+# MATRIX2_ARB = 0x88C2
+# MATRIX3_ARB = 0x88C3
+# MATRIX4_ARB = 0x88C4
+# MATRIX5_ARB = 0x88C5
+# MATRIX6_ARB = 0x88C6
+# MATRIX7_ARB = 0x88C7
+# MATRIX8_ARB = 0x88C8
+# MATRIX9_ARB = 0x88C9
+# MATRIX10_ARB = 0x88CA
+# MATRIX11_ARB = 0x88CB
+# MATRIX12_ARB = 0x88CC
+# MATRIX13_ARB = 0x88CD
+# MATRIX14_ARB = 0x88CE
+# MATRIX15_ARB = 0x88CF
+# MATRIX16_ARB = 0x88D0
+# MATRIX17_ARB = 0x88D1
+# MATRIX18_ARB = 0x88D2
+# MATRIX19_ARB = 0x88D3
+# MATRIX20_ARB = 0x88D4
+# MATRIX21_ARB = 0x88D5
+# MATRIX22_ARB = 0x88D6
+# MATRIX23_ARB = 0x88D7
+# MATRIX24_ARB = 0x88D8
+# MATRIX25_ARB = 0x88D9
+# MATRIX26_ARB = 0x88DA
+# MATRIX27_ARB = 0x88DB
+# MATRIX28_ARB = 0x88DC
+# MATRIX29_ARB = 0x88DD
+# MATRIX30_ARB = 0x88DE
+# MATRIX31_ARB = 0x88DF
+
+# VERSION_1_5 enum: (Promoted for OpenGL 1.5)
+# ARB_vertex_buffer_object enum: (additional; see above)
+# STREAM_DRAW = 0x88E0
+# STREAM_DRAW_ARB = 0x88E0
+# STREAM_READ = 0x88E1
+# STREAM_READ_ARB = 0x88E1
+# STREAM_COPY = 0x88E2
+# STREAM_COPY_ARB = 0x88E2
+# STATIC_DRAW = 0x88E4
+# STATIC_DRAW_ARB = 0x88E4
+# STATIC_READ = 0x88E5
+# STATIC_READ_ARB = 0x88E5
+# STATIC_COPY = 0x88E6
+# STATIC_COPY_ARB = 0x88E6
+# DYNAMIC_DRAW = 0x88E8
+# DYNAMIC_DRAW_ARB = 0x88E8
+# DYNAMIC_READ = 0x88E9
+# DYNAMIC_READ_ARB = 0x88E9
+# DYNAMIC_COPY = 0x88EA
+# DYNAMIC_COPY_ARB = 0x88EA
+
+# VERSION_2_1 enum:
+# ARB_pixel_buffer_object enum:
+# EXT_pixel_buffer_object enum:
+# PIXEL_PACK_BUFFER = 0x88EB # VERSION_2_1
+# PIXEL_PACK_BUFFER_ARB = 0x88EB # ARB_pixel_buffer_object
+# PIXEL_PACK_BUFFER_EXT = 0x88EB # EXT_pixel_buffer_object
+# PIXEL_UNPACK_BUFFER = 0x88EC # VERSION_2_1
+# PIXEL_UNPACK_BUFFER_ARB = 0x88EC # ARB_pixel_buffer_object
+# PIXEL_UNPACK_BUFFER_EXT = 0x88EC # EXT_pixel_buffer_object
+# PIXEL_PACK_BUFFER_BINDING = 0x88ED # VERSION_2_1
+# PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED # ARB_pixel_buffer_object
+# PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED # EXT_pixel_buffer_object
+# PIXEL_UNPACK_BUFFER_BINDING = 0x88EF # VERSION_2_1
+# PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF # ARB_pixel_buffer_object
+# PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF # EXT_pixel_buffer_object
+
+# ARB_future_use: 0x88E3, 0x88E7, 0x88EE
+# (for extending ARB_vertex_buffer_object):
+
+# EXT_packed_depth_stencil enum: (additional; see above)
+# DEPTH24_STENCIL8_EXT = 0x88F0
+# TEXTURE_STENCIL_SIZE_EXT = 0x88F1
+
+# EXT_stencil_clear_tag enum:
+# STENCIL_TAG_BITS_EXT = 0x88F2
+# STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3
+
+# NV_vertex_program2_option enum: (duplicated in NV_fragment_prgoram2 below)
+# MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4
+# MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5
+
+# NV_fragment_program2 enum:
+# MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4
+# MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5
+# MAX_PROGRAM_IF_DEPTH_NV = 0x88F6
+# MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7
+# MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8
+
+# NV_future_use: 0x88F9-0x88FC
+
+# NV_vertex_program4 enum:
+# VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD
+
+# NV_future_use: 0x88FE
+
+# EXT_texture_array enum: (additional; see below)
+# MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF
+
+# NV_gpu_program4 enum:
+# MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904
+# MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905
+# PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906
+# PROGRAM_RESULT_COMPONENTS_NV = 0x8907
+# MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908
+# MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909
+
+# EXT_stencil_two_side enum:
+# STENCIL_TEST_TWO_SIDE_EXT = 0x8910
+# ACTIVE_STENCIL_FACE_EXT = 0x8911
+
+# EXT_texture_mirror_clamp enum: (additional; see above):
+# MIRROR_CLAMP_TO_BORDER_EXT = 0x8912
+
+# NV_future_use: 0x8913
+
+# VERSION_1_5 enum: (Promoted for OpenGL 1.5)
+# ARB_occlusion_query enum: (additional; see above)
+# SAMPLES_PASSED = 0x8914
+# SAMPLES_PASSED_ARB = 0x8914
+
+# NV_future_use: 0x8915-0x8919
+
+# ARB_color_buffer_float enum: (additional; see above)
+# CLAMP_VERTEX_COLOR_ARB = 0x891A
+# CLAMP_FRAGMENT_COLOR_ARB = 0x891B
+# CLAMP_READ_COLOR_ARB = 0x891C
+# FIXED_ONLY_ARB = 0x891D
+
+# NV_future_use: 0x891E-0x891F
+
+###############################################################################
+
+# ATI: 0x8920-0x897F
+# ATI_fragment_shader enum:
+# FRAGMENT_SHADER_ATI = 0x8920
+# REG_0_ATI = 0x8921
+# REG_1_ATI = 0x8922
+# REG_2_ATI = 0x8923
+# REG_3_ATI = 0x8924
+# REG_4_ATI = 0x8925
+# REG_5_ATI = 0x8926
+# REG_6_ATI = 0x8927
+# REG_7_ATI = 0x8928
+# REG_8_ATI = 0x8929
+# REG_9_ATI = 0x892A
+# REG_10_ATI = 0x892B
+# REG_11_ATI = 0x892C
+# REG_12_ATI = 0x892D
+# REG_13_ATI = 0x892E
+# REG_14_ATI = 0x892F
+# REG_15_ATI = 0x8930
+# REG_16_ATI = 0x8931
+# REG_17_ATI = 0x8932
+# REG_18_ATI = 0x8933
+# REG_19_ATI = 0x8934
+# REG_20_ATI = 0x8935
+# REG_21_ATI = 0x8936
+# REG_22_ATI = 0x8937
+# REG_23_ATI = 0x8938
+# REG_24_ATI = 0x8939
+# REG_25_ATI = 0x893A
+# REG_26_ATI = 0x893B
+# REG_27_ATI = 0x893C
+# REG_28_ATI = 0x893D
+# REG_29_ATI = 0x893E
+# REG_30_ATI = 0x893F
+# REG_31_ATI = 0x8940
+# CON_0_ATI = 0x8941
+# CON_1_ATI = 0x8942
+# CON_2_ATI = 0x8943
+# CON_3_ATI = 0x8944
+# CON_4_ATI = 0x8945
+# CON_5_ATI = 0x8946
+# CON_6_ATI = 0x8947
+# CON_7_ATI = 0x8948
+# CON_8_ATI = 0x8949
+# CON_9_ATI = 0x894A
+# CON_10_ATI = 0x894B
+# CON_11_ATI = 0x894C
+# CON_12_ATI = 0x894D
+# CON_13_ATI = 0x894E
+# CON_14_ATI = 0x894F
+# CON_15_ATI = 0x8950
+# CON_16_ATI = 0x8951
+# CON_17_ATI = 0x8952
+# CON_18_ATI = 0x8953
+# CON_19_ATI = 0x8954
+# CON_20_ATI = 0x8955
+# CON_21_ATI = 0x8956
+# CON_22_ATI = 0x8957
+# CON_23_ATI = 0x8958
+# CON_24_ATI = 0x8959
+# CON_25_ATI = 0x895A
+# CON_26_ATI = 0x895B
+# CON_27_ATI = 0x895C
+# CON_28_ATI = 0x895D
+# CON_29_ATI = 0x895E
+# CON_30_ATI = 0x895F
+# CON_31_ATI = 0x8960
+# MOV_ATI = 0x8961
+# ADD_ATI = 0x8963
+# MUL_ATI = 0x8964
+# SUB_ATI = 0x8965
+# DOT3_ATI = 0x8966
+# DOT4_ATI = 0x8967
+# MAD_ATI = 0x8968
+# LERP_ATI = 0x8969
+# CND_ATI = 0x896A
+# CND0_ATI = 0x896B
+# DOT2_ADD_ATI = 0x896C
+# SECONDARY_INTERPOLATOR_ATI = 0x896D
+# NUM_FRAGMENT_REGISTERS_ATI = 0x896E
+# NUM_FRAGMENT_CONSTANTS_ATI = 0x896F
+# NUM_PASSES_ATI = 0x8970
+# NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971
+# NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972
+# NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973
+# NUM_LOOPBACK_COMPONENTS_ATI = 0x8974
+# COLOR_ALPHA_PAIRING_ATI = 0x8975
+# SWIZZLE_STR_ATI = 0x8976
+# SWIZZLE_STQ_ATI = 0x8977
+# SWIZZLE_STR_DR_ATI = 0x8978
+# SWIZZLE_STQ_DQ_ATI = 0x8979
+# SWIZZLE_STRQ_ATI = 0x897A
+# SWIZZLE_STRQ_DQ_ATI = 0x897B
+# ??? Not clear where to put new types of mask bits yet
+# RED_BIT_ATI = 0x00000001
+# GREEN_BIT_ATI = 0x00000002
+# BLUE_BIT_ATI = 0x00000004
+# 2X_BIT_ATI = 0x00000001
+# 4X_BIT_ATI = 0x00000002
+# 8X_BIT_ATI = 0x00000004
+# HALF_BIT_ATI = 0x00000008
+# QUARTER_BIT_ATI = 0x00000010
+# EIGHTH_BIT_ATI = 0x00000020
+# SATURATE_BIT_ATI = 0x00000040
+# 2X_BIT_ATI = 0x00000001
+# COMP_BIT_ATI = 0x00000002
+# NEGATE_BIT_ATI = 0x00000004
+# BIAS_BIT_ATI = 0x00000008
+
+# ATI_future_use: 0x897C-0x897F
+
+###############################################################################
+
+# Khronos OpenML WG: 0x8980-0x898F
+
+# OML_interlace enum:
+# INTERLACE_OML = 0x8980
+# INTERLACE_READ_OML = 0x8981
+
+# OML_subsample enum:
+# FORMAT_SUBSAMPLE_24_24_OML = 0x8982
+# FORMAT_SUBSAMPLE_244_244_OML = 0x8983
+
+# OML_resample enum:
+# PACK_RESAMPLE_OML = 0x8984
+# UNPACK_RESAMPLE_OML = 0x8985
+# RESAMPLE_REPLICATE_OML = 0x8986
+# RESAMPLE_ZERO_FILL_OML = 0x8987
+# RESAMPLE_AVERAGE_OML = 0x8988
+# RESAMPLE_DECIMATE_OML = 0x8989
+
+# Assigned to Affie Munshi for OES_point_size_array/OES_matrix_get extensions
+# OES_point_size_array enum: 0x898A-
+# OES_matrix_get enum: 0x898F
+
+###############################################################################
+
+# 3dlabs: 0x8990-0x899F
+
+###############################################################################
+
+# Matrox: 0x89A0-0x89FF
+
+###############################################################################
+
+# Apple: 0x8A00-0x8A7F
+# APPLE_vertex_program_evaluators: 0x8A00-0x8A0F?
+
+# APPLE_fence enum:
+# DRAW_PIXELS_APPLE = 0x8A0A
+# FENCE_APPLE = 0x8A0B
+
+# APPLE_future_use: 0x8A0C-0x8A11
+## From Jeremy 2006/10/18 (Bugzilla bug 632) - unknown extension name
+# ELEMENT_ARRAY_APPLE = 0x8A0C
+# ELEMENT_ARRAY_TYPE_APPLE = 0x8A0D
+# ELEMENT_ARRAY_POINTER_APPLE = 0x8A0E
+# COLOR_FLOAT_APPLE = 0x8A0F
+# MIN_PBUFFER_VIEWPORT_DIMS_APPLE = 0x8A10
+# ELEMENT_BUFFER_BINDING_APPLE = 0x8A11
+
+# APPLE_flush_buffer_range enum:
+# BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12
+# BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13
+
+# APPLE_future_use: 0x8A14-0x8A7F
+
+###############################################################################
+
+# Matrox: 0x8A80-0x8AEF
+
+###############################################################################
+
+# Chromium (Brian Paul): 0x8AF0-0x8B2F
+
+###############################################################################
+
+# ARB HLSL shader extensions: 0x8B30-0x8B8F
+
+# VERSION_2_0 enum: (Promoted for OpenGL 2.0; only some values; renaming in many cases)
+# ARB_shader_objects, ARB_vertex_shader, ARB_fragment_shader enum:
+# NV_vertex_program3 enum: (reuses 0x8B4C)
+##Shader types + room for expansion
+# FRAGMENT_SHADER = 0x8B30 # VERSION_2_0
+# FRAGMENT_SHADER_ARB = 0x8B30 # ARB_fragment_shader
+# VERTEX_SHADER = 0x8B31 # VERSION_2_0
+# VERTEX_SHADER_ARB = 0x8B31 # ARB_vertex_shader
+# ARB_future_use: 0x8B32-0x8B3F
+##Container types + room for expansion
+# PROGRAM_OBJECT_ARB = 0x8B40 # ARB_shader_objects
+# ARB_future_use: 0x8B41-0x8B47
+##Misc. shader enums
+# SHADER_OBJECT_ARB = 0x8B48 # ARB_shader_objects
+# MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 # VERSION_2_0
+# MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49 # ARB_fragment_shader
+# MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A # VERSION_2_0
+# MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A # ARB_vertex_shader
+# MAX_VARYING_FLOATS = 0x8B4B # VERSION_2_0
+# MAX_VARYING_FLOATS_ARB = 0x8B4B # ARB_vertex_shader
+# MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C # VERSION_2_0
+# MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C # ARB_vertex_shader, NV_vertex_program3
+# MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D # VERSION_2_0
+# MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D # ARB_vertex_shader
+# OBJECT_TYPE_ARB = 0x8B4E # ARB_shader_objects
+# SHADER_TYPE = 0x8B4F # VERSION_2_0 (renamed)
+# OBJECT_SUBTYPE_ARB = 0x8B4F # ARB_shader_objects
+##Attribute types + room for expansion.
+# FLOAT_VEC2 = 0x8B50 # VERSION_2_0
+# FLOAT_VEC2_ARB = 0x8B50 # ARB_shader_objects
+# FLOAT_VEC3 = 0x8B51 # VERSION_2_0
+# FLOAT_VEC3_ARB = 0x8B51 # ARB_shader_objects
+# FLOAT_VEC4 = 0x8B52 # VERSION_2_0
+# FLOAT_VEC4_ARB = 0x8B52 # ARB_shader_objects
+# INT_VEC2 = 0x8B53 # VERSION_2_0
+# INT_VEC2_ARB = 0x8B53 # ARB_shader_objects
+# INT_VEC3 = 0x8B54 # VERSION_2_0
+# INT_VEC3_ARB = 0x8B54 # ARB_shader_objects
+# INT_VEC4 = 0x8B55 # VERSION_2_0
+# INT_VEC4_ARB = 0x8B55 # ARB_shader_objects
+# BOOL = 0x8B56 # VERSION_2_0
+# BOOL_ARB = 0x8B56 # ARB_shader_objects
+# BOOL_VEC2 = 0x8B57 # VERSION_2_0
+# BOOL_VEC2_ARB = 0x8B57 # ARB_shader_objects
+# BOOL_VEC3 = 0x8B58 # VERSION_2_0
+# BOOL_VEC3_ARB = 0x8B58 # ARB_shader_objects
+# BOOL_VEC4 = 0x8B59 # VERSION_2_0
+# BOOL_VEC4_ARB = 0x8B59 # ARB_shader_objects
+# FLOAT_MAT2 = 0x8B5A # VERSION_2_0
+# FLOAT_MAT2_ARB = 0x8B5A # ARB_shader_objects
+# FLOAT_MAT3 = 0x8B5B # VERSION_2_0
+# FLOAT_MAT3_ARB = 0x8B5B # ARB_shader_objects
+# FLOAT_MAT4 = 0x8B5C # VERSION_2_0
+# FLOAT_MAT4_ARB = 0x8B5C # ARB_shader_objects
+# SAMPLER_1D = 0x8B5D # VERSION_2_0
+# SAMPLER_1D_ARB = 0x8B5D # ARB_shader_objects
+# SAMPLER_2D = 0x8B5E # VERSION_2_0
+# SAMPLER_2D_ARB = 0x8B5E # ARB_shader_objects
+# SAMPLER_3D = 0x8B5F # VERSION_2_0
+# SAMPLER_3D_ARB = 0x8B5F # ARB_shader_objects
+# SAMPLER_CUBE = 0x8B60 # VERSION_2_0
+# SAMPLER_CUBE_ARB = 0x8B60 # ARB_shader_objects
+# SAMPLER_1D_SHADOW = 0x8B61 # VERSION_2_0
+# SAMPLER_1D_SHADOW_ARB = 0x8B61 # ARB_shader_objects
+# SAMPLER_2D_SHADOW = 0x8B62 # VERSION_2_0
+# SAMPLER_2D_SHADOW_ARB = 0x8B62 # ARB_shader_objects
+# SAMPLER_2D_RECT_ARB = 0x8B63 # ARB_shader_objects
+# SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64 # ARB_shader_objects
+# FLOAT_MAT2x3 = 0x8B65 # VERSION_2_1
+# FLOAT_MAT2x4 = 0x8B66 # VERSION_2_1
+# FLOAT_MAT3x2 = 0x8B67 # VERSION_2_1
+# FLOAT_MAT3x4 = 0x8B68 # VERSION_2_1
+# FLOAT_MAT4x2 = 0x8B69 # VERSION_2_1
+# FLOAT_MAT4x3 = 0x8B6A # VERSION_2_1
+# ARB_future_use: 0x8B6B-0x8B7F (for attribute types)
+# DELETE_STATUS = 0x8B80 # VERSION_2_0 (renamed)
+# OBJECT_DELETE_STATUS_ARB = 0x8B80 # ARB_shader_objects
+# COMPILE_STATUS = 0x8B81 # VERSION_2_0 (renamed)
+# OBJECT_COMPILE_STATUS_ARB = 0x8B81 # ARB_shader_objects
+# LINK_STATUS = 0x8B82 # VERSION_2_0 (renamed)
+# OBJECT_LINK_STATUS_ARB = 0x8B82 # ARB_shader_objects
+# VALIDATE_STATUS = 0x8B83 # VERSION_2_0 (renamed)
+# OBJECT_VALIDATE_STATUS_ARB = 0x8B83 # ARB_shader_objects
+# INFO_LOG_LENGTH = 0x8B84 # VERSION_2_0 (renamed)
+# OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84 # ARB_shader_objects
+# ATTACHED_SHADERS = 0x8B85 # VERSION_2_0 (renamed)
+# OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85 # ARB_shader_objects
+# ACTIVE_UNIFORMS = 0x8B86 # VERSION_2_0 (renamed)
+# OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86 # ARB_shader_objects
+# ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 # VERSION_2_0 (renamed)
+# OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87 # ARB_shader_objects
+# SHADER_SOURCE_LENGTH = 0x8B88 # VERSION_2_0 (renamed)
+# OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88 # ARB_shader_objects
+# ACTIVE_ATTRIBUTES = 0x8B89 # VERSION_2_0 (renamed)
+# OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89 # ARB_vertex_shader
+# ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A # VERSION_2_0 (renamed)
+# OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A # ARB_vertex_shader
+# FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B # VERSION_2_0
+# FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B # ARB_fragment_shader
+# SHADING_LANGUAGE_VERSION = 0x8B8C # VERSION_2_0
+# SHADING_LANGUAGE_VERSION_ARB = 0x8B8C # ARB_shading_language_100
+
+# EXT_geometry_shader4 enum: (additional; see below)
+# MAX_VARYING_COMPONENTS_EXT = 0x8B4B
+
+# VERSION_2_0 enum:
+# CURRENT_PROGRAM = 0x8B8D
+# ARB_future_use: 0x8B8E-0x8B8F
+
+###############################################################################
+
+# Khronos OpenGL ES WG: 0x8B90-0x8B9F
+
+# OES_compressed_paletted_texture enum:
+# PALETTE4_RGB8_OES = 0x8B90
+# PALETTE4_RGBA8_OES = 0x8B91
+# PALETTE4_R5_G6_B5_OES = 0x8B92
+# PALETTE4_RGBA4_OES = 0x8B93
+# PALETTE4_RGB5_A1_OES = 0x8B94
+# PALETTE8_RGB8_OES = 0x8B95
+# PALETTE8_RGBA8_OES = 0x8B96
+# PALETTE8_R5_G6_B5_OES = 0x8B97
+# PALETTE8_RGBA4_OES = 0x8B98
+# PALETTE8_RGB5_A1_OES = 0x8B99
+
+# OES_read_format enum:
+# IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A
+# IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B
+
+# Extensions names TBD, for OpenGL ES 1.1
+# These need to go in enumext.spec as well
+# POINT_SIZE_ARRAY_OES = 0x8B9C
+# TEXTURE_CROP_RECT_OES = 0x8B9D
+
+# More Khronos extensions, need to go in enumext.spec
+# MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES = 0x8B9E
+# WEIGHT_INDEX_ARRAY_BUFFER_BINDING_OES = 0x8B9F
+
+###############################################################################
+
+# Seaweed: 0x8BA0-0x8BAF
+
+###############################################################################
+
+# Mesa: 0x8BB0-0x8BBF
+
+###############################################################################
+
+# ATI: 0x8BC0-0x8BFF
+
+###############################################################################
+
+# Imagination Tech.: 0x8C00-0x8C0F
+
+###############################################################################
+
+# NVIDIA: 0x8C10-0x8C8F (Pat Brown)
+
+# ARB_texture_float enum: (additional; see above)
+# TEXTURE_RED_TYPE_ARB = 0x8C10
+# TEXTURE_GREEN_TYPE_ARB = 0x8C11
+# TEXTURE_BLUE_TYPE_ARB = 0x8C12
+# TEXTURE_ALPHA_TYPE_ARB = 0x8C13
+# TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14
+# TEXTURE_INTENSITY_TYPE_ARB = 0x8C15
+# TEXTURE_DEPTH_TYPE_ARB = 0x8C16
+# UNSIGNED_NORMALIZED_ARB = 0x8C17
+
+# EXT_texture_array enum:
+# TEXTURE_1D_ARRAY_EXT = 0x8C18
+# PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19
+# TEXTURE_2D_ARRAY_EXT = 0x8C1A
+# PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B
+# TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C
+# TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D
+
+# NV_future_use: 0x8C1E-0x8C25
+
+# NV_geometry_program4 enum:
+# GEOMETRY_PROGRAM_NV = 0x8C26
+# MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27
+# MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28
+# MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29
+
+# NV_future_use: 0x8C2A-0x8C29
+
+# EXT_texture_buffer_object enum:
+# TEXTURE_BUFFER_EXT = 0x8C2A
+# MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B
+# TEXTURE_BINDING_BUFFER_EXT = 0x8C2C
+# TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D
+# TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E
+
+# NV_future_use: 0x8C2F-0x8C39
+
+# EXT_packed_float enum:
+# R11F_G11F_B10F_EXT = 0x8C3A
+# UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B
+# RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C
+
+# EXT_texture_shared_exponent enum:
+# RGB9_E5_EXT = 0x8C3D
+# UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E
+# TEXTURE_SHARED_SIZE_EXT = 0x8C3F
+
+# VERSION_2_1 enum: (Generic formats promoted for OpenGL 2.1)
+# EXT_texture_sRGB enum:
+# SRGB = 0x8C40 # VERSION_2_1
+# SRGB_EXT = 0x8C40 # EXT_texture_sRGB
+# SRGB8 = 0x8C41 # VERSION_2_1
+# SRGB8_EXT = 0x8C41 # EXT_texture_sRGB
+# SRGB_ALPHA = 0x8C42 # VERSION_2_1
+# SRGB_ALPHA_EXT = 0x8C42 # EXT_texture_sRGB
+# SRGB8_ALPHA8 = 0x8C43 # VERSION_2_1
+# SRGB8_ALPHA8_EXT = 0x8C43 # EXT_texture_sRGB
+# SLUMINANCE_ALPHA = 0x8C44 # VERSION_2_1
+# SLUMINANCE_ALPHA_EXT = 0x8C44 # EXT_texture_sRGB
+# SLUMINANCE8_ALPHA8 = 0x8C45 # VERSION_2_1
+# SLUMINANCE8_ALPHA8_EXT = 0x8C45 # EXT_texture_sRGB
+# SLUMINANCE = 0x8C46 # VERSION_2_1
+# SLUMINANCE_EXT = 0x8C46 # EXT_texture_sRGB
+# SLUMINANCE8 = 0x8C47 # VERSION_2_1
+# SLUMINANCE8_EXT = 0x8C47 # EXT_texture_sRGB
+# COMPRESSED_SRGB = 0x8C48 # VERSION_2_1
+# COMPRESSED_SRGB_EXT = 0x8C48 # EXT_texture_sRGB
+# COMPRESSED_SRGB_ALPHA = 0x8C49 # VERSION_2_1
+# COMPRESSED_SRGB_ALPHA_EXT = 0x8C49 # EXT_texture_sRGB
+# COMPRESSED_SLUMINANCE = 0x8C4A # VERSION_2_1
+# COMPRESSED_SLUMINANCE_EXT = 0x8C4A # EXT_texture_sRGB
+# COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B # VERSION_2_1
+# COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B # EXT_texture_sRGB
+# COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C
+# COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D
+# COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E
+# COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F
+
+# NV_future_use: 0x8C50-0x8C6F
+
+# EXT_texture_compression_latc enum:
+# COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70
+# COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71
+# COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72
+# COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73
+
+# NV_future_use: 0x8C74-0x8C76
+
+# NV_transform_feedback enum:
+# BACK_PRIMARY_COLOR_NV = 0x8C77
+# BACK_SECONDARY_COLOR_NV = 0x8C78
+# TEXTURE_COORD_NV = 0x8C79
+# CLIP_DISTANCE_NV = 0x8C7A
+# VERTEX_ID_NV = 0x8C7B
+# PRIMITIVE_ID_NV = 0x8C7C
+# GENERIC_ATTRIB_NV = 0x8C7D
+# TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E
+# TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F
+# MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80
+# ACTIVE_VARYINGS_NV = 0x8C81
+# ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82
+# TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83
+# TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84
+# TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85
+# TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86
+# PRIMITIVES_GENERATED_NV = 0x8C87
+# TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88
+# RASTERIZER_DISCARD_NV = 0x8C89
+# MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV = 0x8C8A
+# MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B
+# INTERLEAVED_ATTRIBS_NV = 0x8C8C
+# SEPARATE_ATTRIBS_NV = 0x8C8D
+# TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E
+# TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F
+
+###############################################################################
+
+# ATI: 0x8C90-0x8C9F (Affie Munshi, OpenGL ES extensions)
+
+###############################################################################
+
+# OpenGL ARB: 0x8CA0-0x8CAF
+
+# VERSION_2_0 enum:
+# POINT_SPRITE_COORD_ORIGIN = 0x8CA0
+# LOWER_LEFT = 0x8CA1
+# UPPER_LEFT = 0x8CA2
+# STENCIL_BACK_REF = 0x8CA3
+# STENCIL_BACK_VALUE_MASK = 0x8CA4
+# STENCIL_BACK_WRITEMASK = 0x8CA5
+# EXT_framebuffer_object enum: (additional; see below)
+# FRAMEBUFFER_BINDING_EXT = 0x8CA6
+# RENDERBUFFER_BINDING_EXT = 0x8CA7
+# EXT_framebuffer_blit enum:
+# READ_FRAMEBUFFER_EXT = 0x8CA8
+# DRAW_FRAMEBUFFER_EXT = 0x8CA9
+# READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT
+# DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CAA
+# EXT_framebuffer_multisample enum:
+# NV_framebuffer_multisample_coverage enum: (additional; see below)
+# RENDERBUFFER_SAMPLES_EXT = 0x8CAB
+# RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB
+
+# ARB_future_use: 0x8CAC-08CAF
+
+###############################################################################
+
+# 3Dlabs: 0x8CB0-0x8CCF (Barthold Lichtenbelt, 2004/12/1)
+
+###############################################################################
+
+# OpenGL ARB: 0x8CD0-0x8D5F (Framebuffer object specification + headroom)
+
+# EXT_framebuffer_object enum: (additional; see above)
+# FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0
+# FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1
+# FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2
+# FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3
+# FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4
+# FRAMEBUFFER_COMPLETE_EXT = 0x8CD5
+# FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6
+# FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7
+## Removed 2005/09/26 in revision #117 of the extension:
+## FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = 0x8CD8
+# FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9
+# FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA
+# FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB
+# FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC
+# FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD
+## Removed 2005/05/31 in revision #113 of the extension:
+## FRAMEBUFFER_STATUS_ERROR_EXT = 0x8CDE
+# MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF
+# COLOR_ATTACHMENT0_EXT = 0x8CE0
+# COLOR_ATTACHMENT1_EXT = 0x8CE1
+# COLOR_ATTACHMENT2_EXT = 0x8CE2
+# COLOR_ATTACHMENT3_EXT = 0x8CE3
+# COLOR_ATTACHMENT4_EXT = 0x8CE4
+# COLOR_ATTACHMENT5_EXT = 0x8CE5
+# COLOR_ATTACHMENT6_EXT = 0x8CE6
+# COLOR_ATTACHMENT7_EXT = 0x8CE7
+# COLOR_ATTACHMENT8_EXT = 0x8CE8
+# COLOR_ATTACHMENT9_EXT = 0x8CE9
+# COLOR_ATTACHMENT10_EXT = 0x8CEA
+# COLOR_ATTACHMENT11_EXT = 0x8CEB
+# COLOR_ATTACHMENT12_EXT = 0x8CEC
+# COLOR_ATTACHMENT13_EXT = 0x8CED
+# COLOR_ATTACHMENT14_EXT = 0x8CEE
+# COLOR_ATTACHMENT15_EXT = 0x8CEF
+# 0x8CF0-0x8CFF reserved for color attachments 16-31, if needed
+# DEPTH_ATTACHMENT_EXT = 0x8D00
+# 0x8D01-0x8D1F reserved for depth attachments 1-31, if needed
+# STENCIL_ATTACHMENT_EXT = 0x8D20
+# 0x8D21-0x8D3F reserved for stencil attachments 1-31, if needed
+# FRAMEBUFFER_EXT = 0x8D40
+# RENDERBUFFER_EXT = 0x8D41
+# RENDERBUFFER_WIDTH_EXT = 0x8D42
+# RENDERBUFFER_HEIGHT_EXT = 0x8D43
+# RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44
+# 0x8D45 unused (reserved for STENCIL_INDEX_EXT, but now use core STENCIL_INDEX instead)
+# STENCIL_INDEX1_EXT = 0x8D46
+# STENCIL_INDEX4_EXT = 0x8D47
+# STENCIL_INDEX8_EXT = 0x8D48
+# STENCIL_INDEX16_EXT = 0x8D49
+# 0x8D4A-0x8D4D reserved for additional stencil formats
+# Added 2005/05/31 in revision #113 of the extension:
+# RENDERBUFFER_RED_SIZE_EXT = 0x8D50
+# RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51
+# RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52
+# RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53
+# RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54
+# RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55
+# EXT_framebuffer_multisample enum: (additional; see above)
+# Added 2006/10/10 in revision #6b of the extension.
+# FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56
+# MAX_SAMPLES_EXT = 0x8D57
+# 0x8D58-0x8D5F reserved for additional FBO enums
+
+# NV_geometry_program4 enum: (additional; see above)
+# FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4
+
+###############################################################################
+
+# Khronos OpenGL ES WG: 0x8D60-0x8D6F
+
+# Khronos_future_use: 0x8D60-0x8D6F
+
+###############################################################################
+
+# NVIDIA: 0x8D70-0x8DEF
+# Reserved per email from Pat Brown 2005/10/13
+
+# EXT_texture_integer enum:
+# RGBA32UI_EXT = 0x8D70
+# RGB32UI_EXT = 0x8D71
+# ALPHA32UI_EXT = 0x8D72
+# INTENSITY32UI_EXT = 0x8D73
+# LUMINANCE32UI_EXT = 0x8D74
+# LUMINANCE_ALPHA32UI_EXT = 0x8D75
+# RGBA16UI_EXT = 0x8D76
+# RGB16UI_EXT = 0x8D77
+# ALPHA16UI_EXT = 0x8D78
+# INTENSITY16UI_EXT = 0x8D79
+# LUMINANCE16UI_EXT = 0x8D7A
+# LUMINANCE_ALPHA16UI_EXT = 0x8D7B
+# RGBA8UI_EXT = 0x8D7C
+# RGB8UI_EXT = 0x8D7D
+# ALPHA8UI_EXT = 0x8D7E
+# INTENSITY8UI_EXT = 0x8D7F
+# LUMINANCE8UI_EXT = 0x8D80
+# LUMINANCE_ALPHA8UI_EXT = 0x8D81
+# RGBA32I_EXT = 0x8D82
+# RGB32I_EXT = 0x8D83
+# ALPHA32I_EXT = 0x8D84
+# INTENSITY32I_EXT = 0x8D85
+# LUMINANCE32I_EXT = 0x8D86
+# LUMINANCE_ALPHA32I_EXT = 0x8D87
+# RGBA16I_EXT = 0x8D88
+# RGB16I_EXT = 0x8D89
+# ALPHA16I_EXT = 0x8D8A
+# INTENSITY16I_EXT = 0x8D8B
+# LUMINANCE16I_EXT = 0x8D8C
+# LUMINANCE_ALPHA16I_EXT = 0x8D8D
+# RGBA8I_EXT = 0x8D8E
+# RGB8I_EXT = 0x8D8F
+# ALPHA8I_EXT = 0x8D90
+# INTENSITY8I_EXT = 0x8D91
+# LUMINANCE8I_EXT = 0x8D92
+# LUMINANCE_ALPHA8I_EXT = 0x8D93
+# RED_INTEGER_EXT = 0x8D94
+# GREEN_INTEGER_EXT = 0x8D95
+# BLUE_INTEGER_EXT = 0x8D96
+# ALPHA_INTEGER_EXT = 0x8D97
+# RGB_INTEGER_EXT = 0x8D98
+# RGBA_INTEGER_EXT = 0x8D99
+# BGR_INTEGER_EXT = 0x8D9A
+# BGRA_INTEGER_EXT = 0x8D9B
+# LUMINANCE_INTEGER_EXT = 0x8D9C
+# LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D
+# RGBA_INTEGER_MODE_EXT = 0x8D9E
+
+# NV_future_use: 0x8D9F
+
+# NV_parameter_buffer_object enum:
+# MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0
+# MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1
+# VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2
+# GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3
+# FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4
+
+# NV_gpu_program4 enum: (additional; see above)
+# MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5
+# MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6
+
+# NV_geometry_program4 enum: (additional; see above)
+# FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7
+# FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8
+# FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9
+
+# NV_future_use: 0x8DAA
+
+# NV_depth_buffer_float enum:
+# DEPTH_COMPONENT32F_NV = 0x8DAB
+# DEPTH32F_STENCIL8_NV = 0x8DAC
+# FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD
+# DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF
+
+# NV_future_use: 0x8DB0-0x8DB8
+
+# EXT_framebuffer_sRGB enum:
+# FRAMEBUFFER_SRGB_EXT = 0x8DB9
+# FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA
+
+# EXT_texture_compression_rgtc enum:
+# COMPRESSED_RED_RGTC1_EXT = 0x8DBB
+# COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC
+# COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD
+# COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE
+
+# NV_future_use: 0x8DBF
+
+# EXT_gpu_shader4 enum:
+# SAMPLER_1D_ARRAY_EXT = 0x8DC0
+# SAMPLER_2D_ARRAY_EXT = 0x8DC1
+# SAMPLER_BUFFER_EXT = 0x8DC2
+# SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3
+# SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4
+# SAMPLER_CUBE_SHADOW_EXT = 0x8DC5
+# UNSIGNED_INT_VEC2_EXT = 0x8DC6
+# UNSIGNED_INT_VEC3_EXT = 0x8DC7
+# UNSIGNED_INT_VEC4_EXT = 0x8DC8
+# INT_SAMPLER_1D_EXT = 0x8DC9
+# INT_SAMPLER_2D_EXT = 0x8DCA
+# INT_SAMPLER_3D_EXT = 0x8DCB
+# INT_SAMPLER_CUBE_EXT = 0x8DCC
+# INT_SAMPLER_2D_RECT_EXT = 0x8DCD
+# INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE
+# INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF
+# INT_SAMPLER_BUFFER_EXT = 0x8DD0
+# UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1
+# UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2
+# UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3
+# UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4
+# UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5
+# UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6
+# UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7
+# UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8
+
+# EXT_geometry_shader4 enum:
+# GEOMETRY_SHADER_EXT = 0x8DD9
+
+# NV_geometry_program4 enum: (additional; see above)
+# GEOMETRY_VERTICES_OUT_EXT = 0x8DDA
+# GEOMETRY_INPUT_TYPE_EXT = 0x8DDB
+# GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC
+
+# EXT_geometry_shader4 enum: (additional; see above)
+# MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD
+# MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE
+# MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF
+# MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0
+# MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1
+
+# EXT_bindable_uniform enum:
+# MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2
+# MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3
+# MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4
+
+# NV_future_use: 0x8DE5-0x8DEC
+
+# EXT_bindable_uniform enum: (additional; see above)
+# MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED
+# UNIFORM_BUFFER_EXT = 0x8DEE
+# UNIFORM_BUFFER_BINDING_EXT = 0x8DEF
+
+###############################################################################
+
+# Khronos OpenGL ES WG: 0x8DF0-0x8E0F
+
+# Khronos_future_use: 0x8DF0-0x8E0F
+
+###############################################################################
+
+# NVIDIA: 0x8E10-0x8E8F
+# Reserved per email from Michael Gold 2006/8/7
+
+# NV_framebuffer_multisample_coverage enum:
+# RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10
+# MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11
+# MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12
+
+# NV_future_use: 0x8E13-0x8E8F
+
+###############################################################################
+
+# QNX: 0x8E90-0x8E9F
+# https://cvs.khronos.org/bugzilla/show_bug.cgi?id=696
+# For GL_QNX_texture_tiling, GL_QNX_complex_polygon, GL_QNX_stippled_lines
+
+# QNX_future_use: 0x8E90-0x8E9F
+
+###############################################################################
+
+# Imagination Tech.: 0x8EA0-0x8EAF
+
+###############################################################################
+### Please remember that new enumerant allocations must be obtained by request
+### to the Khronos API registrar (see comments at the top of this file)
+### File requests in the Khronos Bugzilla, OpenGL project, Registry component.
+###############################################################################
+
+# Any_vendor_future_use: 0x8EB0-0xFFFF
+#
+# This range must be the last range in the file. To generate a new
+# range, allocate multiples of 16 from the beginning of the
+# Any_vendor_future_use range and update enum.spec
+
+###############################################################################
+
+# ARB: 100000-100999 (GLU enumerants only)
+# ARB: 101000-101999 (Conformance tests only)
+
+###############################################################################
+
+# IBM: 103000-103999
+# CULL_VERTEX_IBM = 103050
+# VERTEX_ARRAY_LIST_IBM = 103070
+# NORMAL_ARRAY_LIST_IBM = 103071
+# COLOR_ARRAY_LIST_IBM = 103072
+# INDEX_ARRAY_LIST_IBM = 103073
+# TEXTURE_COORD_ARRAY_LIST_IBM = 103074
+# EDGE_FLAG_ARRAY_LIST_IBM = 103075
+# FOG_COORDINATE_ARRAY_LIST_IBM = 103076
+# SECONDARY_COLOR_ARRAY_LIST_IBM = 103077
+# VERTEX_ARRAY_LIST_STRIDE_IBM = 103080
+# NORMAL_ARRAY_LIST_STRIDE_IBM = 103081
+# COLOR_ARRAY_LIST_STRIDE_IBM = 103082
+# INDEX_ARRAY_LIST_STRIDE_IBM = 103083
+# TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084
+# EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085
+# FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086
+# SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087
+
+###############################################################################
+
+# NEC: 104000-104999
+# Compaq: 105000-105999
+# KPC: 106000-106999 (Kubota is out of business)
+# PGI: 107000-107999 (Portable was acquired by Template Graphics)
+# E&S: 108000-108999
+
+###############################################################################
diff --git a/Source/Bind/Specifications/enumext.spec b/Source/Bind/Specifications/enumext.spec
new file mode 100644
index 00000000..20540dfc
--- /dev/null
+++ b/Source/Bind/Specifications/enumext.spec
@@ -0,0 +1,4418 @@
+# List of GL enumerants for glext.h header
+#
+# This is NOT the master GL enumerant registry (enum.spec).
+#
+# Unlike enum.spec, enumext.spec is
+# (1) In order by extension number
+# (2) Includes only extensions and 1.2/1.3 core enumerants, since
+# it's assumed all today support at least OpenGL 1.1
+# (3) Has no 'Extensions' section, since enums are always
+# conditionally protected against multiple definition
+# by glextenum.pl.
+# (4) Is processed by glextenum.pl, which has evolved
+# from enum.pl - should merge back into one script.
+
+# glext.h version number - this should be automatically updated,
+# when changing either enum or template spec files.
+
+passthru:
+passthru: /* Header file version number, required by OpenGL ABI for Linux */
+passthru: /* glext.h last updated 2007/02/12 */
+passthru: /* Current version at http://www.opengl.org/registry/ */
+passthru: #define GL_GLEXT_VERSION 39
+
+###############################################################################
+#
+# OpenGL 1.2 enums
+#
+###############################################################################
+
+VERSION_1_2 enum:
+ UNSIGNED_BYTE_3_3_2 = 0x8032 # Equivalent to EXT_packed_pixels
+ UNSIGNED_SHORT_4_4_4_4 = 0x8033
+ UNSIGNED_SHORT_5_5_5_1 = 0x8034
+ UNSIGNED_INT_8_8_8_8 = 0x8035
+ UNSIGNED_INT_10_10_10_2 = 0x8036
+ RESCALE_NORMAL = 0x803A # 1 I # Equivalent to EXT_rescale_normal
+ TEXTURE_BINDING_3D = 0x806A # 1 I
+ PACK_SKIP_IMAGES = 0x806B # 1 I
+ PACK_IMAGE_HEIGHT = 0x806C # 1 F
+ UNPACK_SKIP_IMAGES = 0x806D # 1 I
+ UNPACK_IMAGE_HEIGHT = 0x806E # 1 F
+ TEXTURE_3D = 0x806F # 1 I
+ PROXY_TEXTURE_3D = 0x8070
+ TEXTURE_DEPTH = 0x8071
+ TEXTURE_WRAP_R = 0x8072
+ MAX_3D_TEXTURE_SIZE = 0x8073 # 1 I
+ UNSIGNED_BYTE_2_3_3_REV = 0x8362 # New for OpenGL 1.2
+ UNSIGNED_SHORT_5_6_5 = 0x8363
+ UNSIGNED_SHORT_5_6_5_REV = 0x8364
+ UNSIGNED_SHORT_4_4_4_4_REV = 0x8365
+ UNSIGNED_SHORT_1_5_5_5_REV = 0x8366
+ UNSIGNED_INT_8_8_8_8_REV = 0x8367
+ UNSIGNED_INT_2_10_10_10_REV = 0x8368
+ BGR = 0x80E0
+ BGRA = 0x80E1
+ MAX_ELEMENTS_VERTICES = 0x80E8
+ MAX_ELEMENTS_INDICES = 0x80E9
+ CLAMP_TO_EDGE = 0x812F # Equivalent to SGIS_texture_edge_clamp
+ TEXTURE_MIN_LOD = 0x813A # Equivalent to SGIS_texture_lod
+ TEXTURE_MAX_LOD = 0x813B
+ TEXTURE_BASE_LEVEL = 0x813C
+ TEXTURE_MAX_LEVEL = 0x813D
+ LIGHT_MODEL_COLOR_CONTROL = 0x81F8 # 1 I
+ SINGLE_COLOR = 0x81F9
+ SEPARATE_SPECULAR_COLOR = 0x81FA
+ SMOOTH_POINT_SIZE_RANGE = 0x0B12 # 2 F
+ SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 # 1 F
+ SMOOTH_LINE_WIDTH_RANGE = 0x0B22 # 2 F
+ SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 # 1 F
+ ALIASED_POINT_SIZE_RANGE = 0x846D # 2 F
+ ALIASED_LINE_WIDTH_RANGE = 0x846E # 2 F
+
+ARB_imaging enum:
+ CONSTANT_COLOR = 0x8001 # Equivalent to EXT_blend_color
+ ONE_MINUS_CONSTANT_COLOR = 0x8002
+ CONSTANT_ALPHA = 0x8003
+ ONE_MINUS_CONSTANT_ALPHA = 0x8004
+ BLEND_COLOR = 0x8005 # 4 F
+ FUNC_ADD = 0x8006 # Equivalent to EXT_blend_minmax
+ MIN = 0x8007
+ MAX = 0x8008
+ BLEND_EQUATION = 0x8009 # 1 I
+ FUNC_SUBTRACT = 0x800A # Equivalent to EXT_blend_subtract
+ FUNC_REVERSE_SUBTRACT = 0x800B
+ CONVOLUTION_1D = 0x8010 # 1 I # Equivalent to EXT_convolution
+ CONVOLUTION_2D = 0x8011 # 1 I
+ SEPARABLE_2D = 0x8012 # 1 I
+ CONVOLUTION_BORDER_MODE = 0x8013
+ CONVOLUTION_FILTER_SCALE = 0x8014
+ CONVOLUTION_FILTER_BIAS = 0x8015
+ REDUCE = 0x8016
+ CONVOLUTION_FORMAT = 0x8017
+ CONVOLUTION_WIDTH = 0x8018
+ CONVOLUTION_HEIGHT = 0x8019
+ MAX_CONVOLUTION_WIDTH = 0x801A
+ MAX_CONVOLUTION_HEIGHT = 0x801B
+ POST_CONVOLUTION_RED_SCALE = 0x801C # 1 F
+ POST_CONVOLUTION_GREEN_SCALE = 0x801D # 1 F
+ POST_CONVOLUTION_BLUE_SCALE = 0x801E # 1 F
+ POST_CONVOLUTION_ALPHA_SCALE = 0x801F # 1 F
+ POST_CONVOLUTION_RED_BIAS = 0x8020 # 1 F
+ POST_CONVOLUTION_GREEN_BIAS = 0x8021 # 1 F
+ POST_CONVOLUTION_BLUE_BIAS = 0x8022 # 1 F
+ POST_CONVOLUTION_ALPHA_BIAS = 0x8023 # 1 F
+ HISTOGRAM = 0x8024 # 1 I # Equivalent to EXT_histogram
+ PROXY_HISTOGRAM = 0x8025
+ HISTOGRAM_WIDTH = 0x8026
+ HISTOGRAM_FORMAT = 0x8027
+ HISTOGRAM_RED_SIZE = 0x8028
+ HISTOGRAM_GREEN_SIZE = 0x8029
+ HISTOGRAM_BLUE_SIZE = 0x802A
+ HISTOGRAM_ALPHA_SIZE = 0x802B
+ HISTOGRAM_LUMINANCE_SIZE = 0x802C
+ HISTOGRAM_SINK = 0x802D
+ MINMAX = 0x802E # 1 I
+ MINMAX_FORMAT = 0x802F
+ MINMAX_SINK = 0x8030
+ TABLE_TOO_LARGE = 0x8031
+ COLOR_MATRIX = 0x80B1 # 16 F # Equivalent to SGI_color_matrix
+ COLOR_MATRIX_STACK_DEPTH = 0x80B2 # 1 I
+ MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3 # 1 I
+ POST_COLOR_MATRIX_RED_SCALE = 0x80B4 # 1 F
+ POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5 # 1 F
+ POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6 # 1 F
+ POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7 # 1 F
+ POST_COLOR_MATRIX_RED_BIAS = 0x80B8 # 1 F
+ POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9 # 1 F
+ POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA # 1 F
+ POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB # 1 F
+ COLOR_TABLE = 0x80D0 # 1 I # Equivalent to SGI_color_table
+ POST_CONVOLUTION_COLOR_TABLE = 0x80D1 # 1 I
+ POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2 # 1 I
+ PROXY_COLOR_TABLE = 0x80D3
+ PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5
+ COLOR_TABLE_SCALE = 0x80D6
+ COLOR_TABLE_BIAS = 0x80D7
+ COLOR_TABLE_FORMAT = 0x80D8
+ COLOR_TABLE_WIDTH = 0x80D9
+ COLOR_TABLE_RED_SIZE = 0x80DA
+ COLOR_TABLE_GREEN_SIZE = 0x80DB
+ COLOR_TABLE_BLUE_SIZE = 0x80DC
+ COLOR_TABLE_ALPHA_SIZE = 0x80DD
+ COLOR_TABLE_LUMINANCE_SIZE = 0x80DE
+ COLOR_TABLE_INTENSITY_SIZE = 0x80DF
+ CONSTANT_BORDER = 0x8151
+ REPLICATE_BORDER = 0x8153
+ CONVOLUTION_BORDER_COLOR = 0x8154
+
+
+###############################################################################
+#
+# OpenGL 1.3 enums
+#
+###############################################################################
+
+VERSION_1_3 enum:
+ TEXTURE0 = 0x84C0 # Promoted from ARB_multitexture
+ TEXTURE1 = 0x84C1
+ TEXTURE2 = 0x84C2
+ TEXTURE3 = 0x84C3
+ TEXTURE4 = 0x84C4
+ TEXTURE5 = 0x84C5
+ TEXTURE6 = 0x84C6
+ TEXTURE7 = 0x84C7
+ TEXTURE8 = 0x84C8
+ TEXTURE9 = 0x84C9
+ TEXTURE10 = 0x84CA
+ TEXTURE11 = 0x84CB
+ TEXTURE12 = 0x84CC
+ TEXTURE13 = 0x84CD
+ TEXTURE14 = 0x84CE
+ TEXTURE15 = 0x84CF
+ TEXTURE16 = 0x84D0
+ TEXTURE17 = 0x84D1
+ TEXTURE18 = 0x84D2
+ TEXTURE19 = 0x84D3
+ TEXTURE20 = 0x84D4
+ TEXTURE21 = 0x84D5
+ TEXTURE22 = 0x84D6
+ TEXTURE23 = 0x84D7
+ TEXTURE24 = 0x84D8
+ TEXTURE25 = 0x84D9
+ TEXTURE26 = 0x84DA
+ TEXTURE27 = 0x84DB
+ TEXTURE28 = 0x84DC
+ TEXTURE29 = 0x84DD
+ TEXTURE30 = 0x84DE
+ TEXTURE31 = 0x84DF
+ ACTIVE_TEXTURE = 0x84E0 # 1 I
+ CLIENT_ACTIVE_TEXTURE = 0x84E1 # 1 I
+ MAX_TEXTURE_UNITS = 0x84E2 # 1 I
+ TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 # 16 F # Promoted from ARB_transpose_matrix
+ TRANSPOSE_PROJECTION_MATRIX = 0x84E4 # 16 F
+ TRANSPOSE_TEXTURE_MATRIX = 0x84E5 # 16 F
+ TRANSPOSE_COLOR_MATRIX = 0x84E6 # 16 F
+ MULTISAMPLE = 0x809D # Promoted from ARB_multisample
+ SAMPLE_ALPHA_TO_COVERAGE = 0x809E
+ SAMPLE_ALPHA_TO_ONE = 0x809F
+ SAMPLE_COVERAGE = 0x80A0
+ SAMPLE_BUFFERS = 0x80A8
+ SAMPLES = 0x80A9
+ SAMPLE_COVERAGE_VALUE = 0x80AA
+ SAMPLE_COVERAGE_INVERT = 0x80AB
+ MULTISAMPLE_BIT = 0x20000000
+ NORMAL_MAP = 0x8511 # Promoted from ARB_texture_cube_map
+ REFLECTION_MAP = 0x8512
+ TEXTURE_CUBE_MAP = 0x8513
+ TEXTURE_BINDING_CUBE_MAP = 0x8514
+ TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515
+ TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516
+ TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517
+ TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518
+ TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519
+ TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A
+ PROXY_TEXTURE_CUBE_MAP = 0x851B
+ MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C
+ COMPRESSED_ALPHA = 0x84E9 # Promoted from ARB_texture_compression
+ COMPRESSED_LUMINANCE = 0x84EA
+ COMPRESSED_LUMINANCE_ALPHA = 0x84EB
+ COMPRESSED_INTENSITY = 0x84EC
+ COMPRESSED_RGB = 0x84ED
+ COMPRESSED_RGBA = 0x84EE
+ TEXTURE_COMPRESSION_HINT = 0x84EF
+ TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0
+ TEXTURE_COMPRESSED = 0x86A1
+ NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2
+ COMPRESSED_TEXTURE_FORMATS = 0x86A3
+ CLAMP_TO_BORDER = 0x812D # Promoted from ARB_texture_border_clamp
+ COMBINE = 0x8570 # Promoted from ARB_texture_env_combine
+ COMBINE_RGB = 0x8571
+ COMBINE_ALPHA = 0x8572
+ SOURCE0_RGB = 0x8580
+ SOURCE1_RGB = 0x8581
+ SOURCE2_RGB = 0x8582
+ SOURCE0_ALPHA = 0x8588
+ SOURCE1_ALPHA = 0x8589
+ SOURCE2_ALPHA = 0x858A
+ OPERAND0_RGB = 0x8590
+ OPERAND1_RGB = 0x8591
+ OPERAND2_RGB = 0x8592
+ OPERAND0_ALPHA = 0x8598
+ OPERAND1_ALPHA = 0x8599
+ OPERAND2_ALPHA = 0x859A
+ RGB_SCALE = 0x8573
+ ADD_SIGNED = 0x8574
+ INTERPOLATE = 0x8575
+ SUBTRACT = 0x84E7
+ CONSTANT = 0x8576
+ PRIMARY_COLOR = 0x8577
+ PREVIOUS = 0x8578
+ DOT3_RGB = 0x86AE # Promoted from ARB_texture_env_dot3
+ DOT3_RGBA = 0x86AF
+
+
+###############################################################################
+#
+# OpenGL 1.4 enums
+#
+###############################################################################
+
+VERSION_1_4 enum:
+ BLEND_DST_RGB = 0x80C8
+ BLEND_SRC_RGB = 0x80C9
+ BLEND_DST_ALPHA = 0x80CA
+ BLEND_SRC_ALPHA = 0x80CB
+ POINT_SIZE_MIN = 0x8126 # 1 F
+ POINT_SIZE_MAX = 0x8127 # 1 F
+ POINT_FADE_THRESHOLD_SIZE = 0x8128 # 1 F
+ POINT_DISTANCE_ATTENUATION = 0x8129 # 3 F
+ GENERATE_MIPMAP = 0x8191
+ GENERATE_MIPMAP_HINT = 0x8192 # 1 I
+ DEPTH_COMPONENT16 = 0x81A5
+ DEPTH_COMPONENT24 = 0x81A6
+ DEPTH_COMPONENT32 = 0x81A7
+ MIRRORED_REPEAT = 0x8370
+ FOG_COORDINATE_SOURCE = 0x8450 # 1 I
+ FOG_COORDINATE = 0x8451
+ FRAGMENT_DEPTH = 0x8452
+ CURRENT_FOG_COORDINATE = 0x8453 # 1 F
+ FOG_COORDINATE_ARRAY_TYPE = 0x8454 # 1 I
+ FOG_COORDINATE_ARRAY_STRIDE = 0x8455 # 1 I
+ FOG_COORDINATE_ARRAY_POINTER = 0x8456
+ FOG_COORDINATE_ARRAY = 0x8457 # 1 I
+ COLOR_SUM = 0x8458 # 1 I
+ CURRENT_SECONDARY_COLOR = 0x8459 # 3 F
+ SECONDARY_COLOR_ARRAY_SIZE = 0x845A # 1 I
+ SECONDARY_COLOR_ARRAY_TYPE = 0x845B # 1 I
+ SECONDARY_COLOR_ARRAY_STRIDE = 0x845C # 1 I
+ SECONDARY_COLOR_ARRAY_POINTER = 0x845D
+ SECONDARY_COLOR_ARRAY = 0x845E # 1 I
+ MAX_TEXTURE_LOD_BIAS = 0x84FD
+ TEXTURE_FILTER_CONTROL = 0x8500
+ TEXTURE_LOD_BIAS = 0x8501
+ INCR_WRAP = 0x8507
+ DECR_WRAP = 0x8508
+ TEXTURE_DEPTH_SIZE = 0x884A
+ DEPTH_TEXTURE_MODE = 0x884B
+ TEXTURE_COMPARE_MODE = 0x884C
+ TEXTURE_COMPARE_FUNC = 0x884D
+ COMPARE_R_TO_TEXTURE = 0x884E
+
+
+###############################################################################
+#
+# OpenGL 1.5 enums
+#
+###############################################################################
+
+VERSION_1_5 enum:
+ BUFFER_SIZE = 0x8764 # ARB_vertex_buffer_object
+ BUFFER_USAGE = 0x8765 # ARB_vertex_buffer_object
+ QUERY_COUNTER_BITS = 0x8864 # ARB_occlusion_query
+ CURRENT_QUERY = 0x8865 # ARB_occlusion_query
+ QUERY_RESULT = 0x8866 # ARB_occlusion_query
+ QUERY_RESULT_AVAILABLE = 0x8867 # ARB_occlusion_query
+ ARRAY_BUFFER = 0x8892 # ARB_vertex_buffer_object
+ ELEMENT_ARRAY_BUFFER = 0x8893 # ARB_vertex_buffer_object
+ ARRAY_BUFFER_BINDING = 0x8894 # ARB_vertex_buffer_object
+ ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 # ARB_vertex_buffer_object
+ VERTEX_ARRAY_BUFFER_BINDING = 0x8896 # ARB_vertex_buffer_object
+ NORMAL_ARRAY_BUFFER_BINDING = 0x8897 # ARB_vertex_buffer_object
+ COLOR_ARRAY_BUFFER_BINDING = 0x8898 # ARB_vertex_buffer_object
+ INDEX_ARRAY_BUFFER_BINDING = 0x8899 # ARB_vertex_buffer_object
+ TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A # ARB_vertex_buffer_object
+ EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B # ARB_vertex_buffer_object
+ SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C # ARB_vertex_buffer_object
+ FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D # ARB_vertex_buffer_object
+ WEIGHT_ARRAY_BUFFER_BINDING = 0x889E # ARB_vertex_buffer_object
+ VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F # ARB_vertex_buffer_object
+ READ_ONLY = 0x88B8 # ARB_vertex_buffer_object
+ WRITE_ONLY = 0x88B9 # ARB_vertex_buffer_object
+ READ_WRITE = 0x88BA # ARB_vertex_buffer_object
+ BUFFER_ACCESS = 0x88BB # ARB_vertex_buffer_object
+ BUFFER_MAPPED = 0x88BC # ARB_vertex_buffer_object
+ BUFFER_MAP_POINTER = 0x88BD # ARB_vertex_buffer_object
+ STREAM_DRAW = 0x88E0 # ARB_vertex_buffer_object
+ STREAM_READ = 0x88E1 # ARB_vertex_buffer_object
+ STREAM_COPY = 0x88E2 # ARB_vertex_buffer_object
+ STATIC_DRAW = 0x88E4 # ARB_vertex_buffer_object
+ STATIC_READ = 0x88E5 # ARB_vertex_buffer_object
+ STATIC_COPY = 0x88E6 # ARB_vertex_buffer_object
+ DYNAMIC_DRAW = 0x88E8 # ARB_vertex_buffer_object
+ DYNAMIC_READ = 0x88E9 # ARB_vertex_buffer_object
+ DYNAMIC_COPY = 0x88EA # ARB_vertex_buffer_object
+ SAMPLES_PASSED = 0x8914 # ARB_occlusion_query
+# New naming scheme
+ FOG_COORD_SRC = GL_FOG_COORDINATE_SOURCE
+ FOG_COORD = GL_FOG_COORDINATE
+ CURRENT_FOG_COORD = GL_CURRENT_FOG_COORDINATE
+ FOG_COORD_ARRAY_TYPE = GL_FOG_COORDINATE_ARRAY_TYPE
+ FOG_COORD_ARRAY_STRIDE = GL_FOG_COORDINATE_ARRAY_STRIDE
+ FOG_COORD_ARRAY_POINTER = GL_FOG_COORDINATE_ARRAY_POINTER
+ FOG_COORD_ARRAY = GL_FOG_COORDINATE_ARRAY
+ FOG_COORD_ARRAY_BUFFER_BINDING = GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING
+ SRC0_RGB = GL_SOURCE0_RGB
+ SRC1_RGB = GL_SOURCE1_RGB
+ SRC2_RGB = GL_SOURCE2_RGB
+ SRC0_ALPHA = GL_SOURCE0_ALPHA
+ SRC1_ALPHA = GL_SOURCE1_ALPHA
+ SRC2_ALPHA = GL_SOURCE2_ALPHA
+
+
+###############################################################################
+#
+# OpenGL 2.0 enums
+#
+###############################################################################
+
+VERSION_2_0 enum:
+ BLEND_EQUATION_RGB = GL_BLEND_EQUATION # EXT_blend_equation_separate
+ VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 # ARB_vertex_shader
+ VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 # ARB_vertex_shader
+ VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 # ARB_vertex_shader
+ VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 # ARB_vertex_shader
+ CURRENT_VERTEX_ATTRIB = 0x8626 # ARB_vertex_shader
+ VERTEX_PROGRAM_POINT_SIZE = 0x8642 # ARB_vertex_shader
+ VERTEX_PROGRAM_TWO_SIDE = 0x8643 # ARB_vertex_shader
+ VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 # ARB_vertex_shader
+ STENCIL_BACK_FUNC = 0x8800 # ARB_stencil_two_side
+ STENCIL_BACK_FAIL = 0x8801 # ARB_stencil_two_side
+ STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 # ARB_stencil_two_side
+ STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 # ARB_stencil_two_side
+ MAX_DRAW_BUFFERS = 0x8824 # ARB_draw_buffers
+ DRAW_BUFFER0 = 0x8825 # ARB_draw_buffers
+ DRAW_BUFFER1 = 0x8826 # ARB_draw_buffers
+ DRAW_BUFFER2 = 0x8827 # ARB_draw_buffers
+ DRAW_BUFFER3 = 0x8828 # ARB_draw_buffers
+ DRAW_BUFFER4 = 0x8829 # ARB_draw_buffers
+ DRAW_BUFFER5 = 0x882A # ARB_draw_buffers
+ DRAW_BUFFER6 = 0x882B # ARB_draw_buffers
+ DRAW_BUFFER7 = 0x882C # ARB_draw_buffers
+ DRAW_BUFFER8 = 0x882D # ARB_draw_buffers
+ DRAW_BUFFER9 = 0x882E # ARB_draw_buffers
+ DRAW_BUFFER10 = 0x882F # ARB_draw_buffers
+ DRAW_BUFFER11 = 0x8830 # ARB_draw_buffers
+ DRAW_BUFFER12 = 0x8831 # ARB_draw_buffers
+ DRAW_BUFFER13 = 0x8832 # ARB_draw_buffers
+ DRAW_BUFFER14 = 0x8833 # ARB_draw_buffers
+ DRAW_BUFFER15 = 0x8834 # ARB_draw_buffers
+ BLEND_EQUATION_ALPHA = 0x883D # EXT_blend_equation_separate
+ POINT_SPRITE = 0x8861 # ARB_point_sprite
+ COORD_REPLACE = 0x8862 # ARB_point_sprite
+ MAX_VERTEX_ATTRIBS = 0x8869 # ARB_vertex_shader
+ VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A # ARB_vertex_shader
+ MAX_TEXTURE_COORDS = 0x8871 # ARB_vertex_shader, ARB_fragment_shader
+ MAX_TEXTURE_IMAGE_UNITS = 0x8872 # ARB_vertex_shader, ARB_fragment_shader
+ FRAGMENT_SHADER = 0x8B30 # ARB_fragment_shader
+ VERTEX_SHADER = 0x8B31 # ARB_vertex_shader
+ MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 # ARB_fragment_shader
+ MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A # ARB_vertex_shader
+ MAX_VARYING_FLOATS = 0x8B4B # ARB_vertex_shader
+ MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C # ARB_vertex_shader
+ MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D # ARB_vertex_shader
+ SHADER_TYPE = 0x8B4F # ARB_shader_objects
+ FLOAT_VEC2 = 0x8B50 # ARB_shader_objects
+ FLOAT_VEC3 = 0x8B51 # ARB_shader_objects
+ FLOAT_VEC4 = 0x8B52 # ARB_shader_objects
+ INT_VEC2 = 0x8B53 # ARB_shader_objects
+ INT_VEC3 = 0x8B54 # ARB_shader_objects
+ INT_VEC4 = 0x8B55 # ARB_shader_objects
+ BOOL = 0x8B56 # ARB_shader_objects
+ BOOL_VEC2 = 0x8B57 # ARB_shader_objects
+ BOOL_VEC3 = 0x8B58 # ARB_shader_objects
+ BOOL_VEC4 = 0x8B59 # ARB_shader_objects
+ FLOAT_MAT2 = 0x8B5A # ARB_shader_objects
+ FLOAT_MAT3 = 0x8B5B # ARB_shader_objects
+ FLOAT_MAT4 = 0x8B5C # ARB_shader_objects
+ SAMPLER_1D = 0x8B5D # ARB_shader_objects
+ SAMPLER_2D = 0x8B5E # ARB_shader_objects
+ SAMPLER_3D = 0x8B5F # ARB_shader_objects
+ SAMPLER_CUBE = 0x8B60 # ARB_shader_objects
+ SAMPLER_1D_SHADOW = 0x8B61 # ARB_shader_objects
+ SAMPLER_2D_SHADOW = 0x8B62 # ARB_shader_objects
+ DELETE_STATUS = 0x8B80 # ARB_shader_objects
+ COMPILE_STATUS = 0x8B81 # ARB_shader_objects
+ LINK_STATUS = 0x8B82 # ARB_shader_objects
+ VALIDATE_STATUS = 0x8B83 # ARB_shader_objects
+ INFO_LOG_LENGTH = 0x8B84 # ARB_shader_objects
+ ATTACHED_SHADERS = 0x8B85 # ARB_shader_objects
+ ACTIVE_UNIFORMS = 0x8B86 # ARB_shader_objects
+ ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 # ARB_shader_objects
+ SHADER_SOURCE_LENGTH = 0x8B88 # ARB_shader_objects
+ ACTIVE_ATTRIBUTES = 0x8B89 # ARB_vertex_shader
+ ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A # ARB_vertex_shader
+ FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B # ARB_fragment_shader
+ SHADING_LANGUAGE_VERSION = 0x8B8C # ARB_shading_language_100
+ CURRENT_PROGRAM = 0x8B8D # ARB_shader_objects (added for 2.0)
+ POINT_SPRITE_COORD_ORIGIN = 0x8CA0 # ARB_point_sprite (added for 2.0)
+ LOWER_LEFT = 0x8CA1 # ARB_point_sprite (added for 2.0)
+ UPPER_LEFT = 0x8CA2 # ARB_point_sprite (added for 2.0)
+ STENCIL_BACK_REF = 0x8CA3 # ARB_stencil_two_side
+ STENCIL_BACK_VALUE_MASK = 0x8CA4 # ARB_stencil_two_side
+ STENCIL_BACK_WRITEMASK = 0x8CA5 # ARB_stencil_two_side
+
+###############################################################################
+#
+# OpenGL 2.1 enums
+#
+###############################################################################
+
+VERSION_2_1 enum:
+ CURRENT_RASTER_SECONDARY_COLOR = 0x845F # New for 2.1
+ PIXEL_PACK_BUFFER = 0x88EB # ARB_pixel_buffer_object
+ PIXEL_UNPACK_BUFFER = 0x88EC # ARB_pixel_buffer_object
+ PIXEL_PACK_BUFFER_BINDING = 0x88ED # ARB_pixel_buffer_object
+ PIXEL_UNPACK_BUFFER_BINDING = 0x88EF # ARB_pixel_buffer_object
+ FLOAT_MAT2x3 = 0x8B65 # New for 2.1
+ FLOAT_MAT2x4 = 0x8B66 # New for 2.1
+ FLOAT_MAT3x2 = 0x8B67 # New for 2.1
+ FLOAT_MAT3x4 = 0x8B68 # New for 2.1
+ FLOAT_MAT4x2 = 0x8B69 # New for 2.1
+ FLOAT_MAT4x3 = 0x8B6A # New for 2.1
+ SRGB = 0x8C40 # EXT_texture_sRGB
+ SRGB8 = 0x8C41 # EXT_texture_sRGB
+ SRGB_ALPHA = 0x8C42 # EXT_texture_sRGB
+ SRGB8_ALPHA8 = 0x8C43 # EXT_texture_sRGB
+ SLUMINANCE_ALPHA = 0x8C44 # EXT_texture_sRGB
+ SLUMINANCE8_ALPHA8 = 0x8C45 # EXT_texture_sRGB
+ SLUMINANCE = 0x8C46 # EXT_texture_sRGB
+ SLUMINANCE8 = 0x8C47 # EXT_texture_sRGB
+ COMPRESSED_SRGB = 0x8C48 # EXT_texture_sRGB
+ COMPRESSED_SRGB_ALPHA = 0x8C49 # EXT_texture_sRGB
+ COMPRESSED_SLUMINANCE = 0x8C4A # EXT_texture_sRGB
+ COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B # EXT_texture_sRGB
+
+
+###############################################################################
+#
+# ARB extensions, in ARB extension order
+#
+###############################################################################
+
+###############################################################################
+
+# ARB Extension #1
+ARB_multitexture enum:
+ TEXTURE0_ARB = 0x84C0
+ TEXTURE1_ARB = 0x84C1
+ TEXTURE2_ARB = 0x84C2
+ TEXTURE3_ARB = 0x84C3
+ TEXTURE4_ARB = 0x84C4
+ TEXTURE5_ARB = 0x84C5
+ TEXTURE6_ARB = 0x84C6
+ TEXTURE7_ARB = 0x84C7
+ TEXTURE8_ARB = 0x84C8
+ TEXTURE9_ARB = 0x84C9
+ TEXTURE10_ARB = 0x84CA
+ TEXTURE11_ARB = 0x84CB
+ TEXTURE12_ARB = 0x84CC
+ TEXTURE13_ARB = 0x84CD
+ TEXTURE14_ARB = 0x84CE
+ TEXTURE15_ARB = 0x84CF
+ TEXTURE16_ARB = 0x84D0
+ TEXTURE17_ARB = 0x84D1
+ TEXTURE18_ARB = 0x84D2
+ TEXTURE19_ARB = 0x84D3
+ TEXTURE20_ARB = 0x84D4
+ TEXTURE21_ARB = 0x84D5
+ TEXTURE22_ARB = 0x84D6
+ TEXTURE23_ARB = 0x84D7
+ TEXTURE24_ARB = 0x84D8
+ TEXTURE25_ARB = 0x84D9
+ TEXTURE26_ARB = 0x84DA
+ TEXTURE27_ARB = 0x84DB
+ TEXTURE28_ARB = 0x84DC
+ TEXTURE29_ARB = 0x84DD
+ TEXTURE30_ARB = 0x84DE
+ TEXTURE31_ARB = 0x84DF
+ ACTIVE_TEXTURE_ARB = 0x84E0 # 1 I
+ CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1 # 1 I
+ MAX_TEXTURE_UNITS_ARB = 0x84E2 # 1 I
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #2 - GLX_ARB_get_proc_address
+
+###############################################################################
+
+# ARB Extension #3
+ARB_transpose_matrix enum:
+ TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3 # 16 F
+ TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4 # 16 F
+ TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5 # 16 F
+ TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6 # 16 F
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #4 - WGL_ARB_buffer_region
+
+###############################################################################
+
+# ARB Extension #5
+ARB_multisample enum:
+ MULTISAMPLE_ARB = 0x809D
+ SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E
+ SAMPLE_ALPHA_TO_ONE_ARB = 0x809F
+ SAMPLE_COVERAGE_ARB = 0x80A0
+ SAMPLE_BUFFERS_ARB = 0x80A8
+ SAMPLES_ARB = 0x80A9
+ SAMPLE_COVERAGE_VALUE_ARB = 0x80AA
+ SAMPLE_COVERAGE_INVERT_ARB = 0x80AB
+ MULTISAMPLE_BIT_ARB = 0x20000000
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #6
+ARB_texture_env_add enum:
+
+###############################################################################
+
+# ARB Extension #7
+ARB_texture_cube_map enum:
+ NORMAL_MAP_ARB = 0x8511
+ REFLECTION_MAP_ARB = 0x8512
+ TEXTURE_CUBE_MAP_ARB = 0x8513
+ TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514
+ TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515
+ TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516
+ TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517
+ TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518
+ TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519
+ TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A
+ PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B
+ MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #8 - WGL_ARB_extensions_string
+# ARB Extension #9 - WGL_ARB_pixel_format
+# ARB Extension #10 - WGL_ARB_make_current_read
+# ARB Extension #11 - WGL_ARB_pbuffer
+
+###############################################################################
+
+# ARB Extension #12
+ARB_texture_compression enum:
+ COMPRESSED_ALPHA_ARB = 0x84E9
+ COMPRESSED_LUMINANCE_ARB = 0x84EA
+ COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB
+ COMPRESSED_INTENSITY_ARB = 0x84EC
+ COMPRESSED_RGB_ARB = 0x84ED
+ COMPRESSED_RGBA_ARB = 0x84EE
+ TEXTURE_COMPRESSION_HINT_ARB = 0x84EF
+ TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0
+ TEXTURE_COMPRESSED_ARB = 0x86A1
+ NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2
+ COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3
+
+###############################################################################
+
+# ARB Extension #13
+# Promoted from #36 SGIS_texture_border_clamp
+ARB_texture_border_clamp enum:
+ CLAMP_TO_BORDER_ARB = 0x812D
+
+###############################################################################
+
+# ARB Extension #14 - promoted from #54 EXT_point_parameters
+# Promoted from #54 {SGIS,EXT}_point_parameters
+ARB_point_parameters enum:
+ POINT_SIZE_MIN_ARB = 0x8126 # 1 F
+ POINT_SIZE_MAX_ARB = 0x8127 # 1 F
+ POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128 # 1 F
+ POINT_DISTANCE_ATTENUATION_ARB = 0x8129 # 3 F
+
+###############################################################################
+
+# ARB Extension #15
+ARB_vertex_blend enum:
+ MAX_VERTEX_UNITS_ARB = 0x86A4
+ ACTIVE_VERTEX_UNITS_ARB = 0x86A5
+ WEIGHT_SUM_UNITY_ARB = 0x86A6
+ VERTEX_BLEND_ARB = 0x86A7
+ CURRENT_WEIGHT_ARB = 0x86A8
+ WEIGHT_ARRAY_TYPE_ARB = 0x86A9
+ WEIGHT_ARRAY_STRIDE_ARB = 0x86AA
+ WEIGHT_ARRAY_SIZE_ARB = 0x86AB
+ WEIGHT_ARRAY_POINTER_ARB = 0x86AC
+ WEIGHT_ARRAY_ARB = 0x86AD
+ MODELVIEW0_ARB = 0x1700
+ MODELVIEW1_ARB = 0x850A
+ MODELVIEW2_ARB = 0x8722
+ MODELVIEW3_ARB = 0x8723
+ MODELVIEW4_ARB = 0x8724
+ MODELVIEW5_ARB = 0x8725
+ MODELVIEW6_ARB = 0x8726
+ MODELVIEW7_ARB = 0x8727
+ MODELVIEW8_ARB = 0x8728
+ MODELVIEW9_ARB = 0x8729
+ MODELVIEW10_ARB = 0x872A
+ MODELVIEW11_ARB = 0x872B
+ MODELVIEW12_ARB = 0x872C
+ MODELVIEW13_ARB = 0x872D
+ MODELVIEW14_ARB = 0x872E
+ MODELVIEW15_ARB = 0x872F
+ MODELVIEW16_ARB = 0x8730
+ MODELVIEW17_ARB = 0x8731
+ MODELVIEW18_ARB = 0x8732
+ MODELVIEW19_ARB = 0x8733
+ MODELVIEW20_ARB = 0x8734
+ MODELVIEW21_ARB = 0x8735
+ MODELVIEW22_ARB = 0x8736
+ MODELVIEW23_ARB = 0x8737
+ MODELVIEW24_ARB = 0x8738
+ MODELVIEW25_ARB = 0x8739
+ MODELVIEW26_ARB = 0x873A
+ MODELVIEW27_ARB = 0x873B
+ MODELVIEW28_ARB = 0x873C
+ MODELVIEW29_ARB = 0x873D
+ MODELVIEW30_ARB = 0x873E
+ MODELVIEW31_ARB = 0x873F
+
+###############################################################################
+
+# ARB Extension #16
+ARB_matrix_palette enum:
+ MATRIX_PALETTE_ARB = 0x8840
+ MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841
+ MAX_PALETTE_MATRICES_ARB = 0x8842
+ CURRENT_PALETTE_MATRIX_ARB = 0x8843
+ MATRIX_INDEX_ARRAY_ARB = 0x8844
+ CURRENT_MATRIX_INDEX_ARB = 0x8845
+ MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846
+ MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847
+ MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848
+ MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849
+
+###############################################################################
+
+# ARB Extension #17
+# Shares enum values with EXT_texture_env_combine
+ARB_texture_env_combine enum:
+ COMBINE_ARB = 0x8570
+ COMBINE_RGB_ARB = 0x8571
+ COMBINE_ALPHA_ARB = 0x8572
+ SOURCE0_RGB_ARB = 0x8580
+ SOURCE1_RGB_ARB = 0x8581
+ SOURCE2_RGB_ARB = 0x8582
+ SOURCE0_ALPHA_ARB = 0x8588
+ SOURCE1_ALPHA_ARB = 0x8589
+ SOURCE2_ALPHA_ARB = 0x858A
+ OPERAND0_RGB_ARB = 0x8590
+ OPERAND1_RGB_ARB = 0x8591
+ OPERAND2_RGB_ARB = 0x8592
+ OPERAND0_ALPHA_ARB = 0x8598
+ OPERAND1_ALPHA_ARB = 0x8599
+ OPERAND2_ALPHA_ARB = 0x859A
+ RGB_SCALE_ARB = 0x8573
+ ADD_SIGNED_ARB = 0x8574
+ INTERPOLATE_ARB = 0x8575
+ SUBTRACT_ARB = 0x84E7
+ CONSTANT_ARB = 0x8576
+ PRIMARY_COLOR_ARB = 0x8577
+ PREVIOUS_ARB = 0x8578
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #18
+ARB_texture_env_crossbar enum:
+
+###############################################################################
+
+# ARB Extension #19
+# Promoted from #220 EXT_texture_env_dot3; enum values changed
+ARB_texture_env_dot3 enum:
+ DOT3_RGB_ARB = 0x86AE
+ DOT3_RGBA_ARB = 0x86AF
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #20 - WGL_ARB_render_texture
+
+###############################################################################
+
+# ARB Extension #21
+ARB_texture_mirrored_repeat enum:
+ MIRRORED_REPEAT_ARB = 0x8370
+
+###############################################################################
+
+# ARB Extension #22
+ARB_depth_texture enum:
+ DEPTH_COMPONENT16_ARB = 0x81A5
+ DEPTH_COMPONENT24_ARB = 0x81A6
+ DEPTH_COMPONENT32_ARB = 0x81A7
+ TEXTURE_DEPTH_SIZE_ARB = 0x884A
+ DEPTH_TEXTURE_MODE_ARB = 0x884B
+
+###############################################################################
+
+# ARB Extension #23
+ARB_shadow enum:
+ TEXTURE_COMPARE_MODE_ARB = 0x884C
+ TEXTURE_COMPARE_FUNC_ARB = 0x884D
+ COMPARE_R_TO_TEXTURE_ARB = 0x884E
+
+###############################################################################
+
+# ARB Extension #24
+ARB_shadow_ambient enum:
+ TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #25
+ARB_window_pos enum:
+
+###############################################################################
+
+# ARB Extension #26
+# ARB_vertex_program enums are shared by ARB_fragment_program are so marked.
+# Unfortunately, PROGRAM_BINDING_ARB does accidentally reuse 0x8677 -
+# this was a spec editing typo that's now uncorrectable.
+ARB_vertex_program enum:
+ COLOR_SUM_ARB = 0x8458
+ VERTEX_PROGRAM_ARB = 0x8620
+ VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622
+ VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623
+ VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624
+ VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625
+ CURRENT_VERTEX_ATTRIB_ARB = 0x8626
+ PROGRAM_LENGTH_ARB = 0x8627 # shared
+ PROGRAM_STRING_ARB = 0x8628 # shared
+ MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E # shared
+ MAX_PROGRAM_MATRICES_ARB = 0x862F # shared
+ CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640 # shared
+ CURRENT_MATRIX_ARB = 0x8641 # shared
+ VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642
+ VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643
+ VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645
+ PROGRAM_ERROR_POSITION_ARB = 0x864B # shared
+ PROGRAM_BINDING_ARB = 0x8677 # shared
+ MAX_VERTEX_ATTRIBS_ARB = 0x8869
+ VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A
+ PROGRAM_ERROR_STRING_ARB = 0x8874 # shared
+ PROGRAM_FORMAT_ASCII_ARB = 0x8875 # shared
+ PROGRAM_FORMAT_ARB = 0x8876 # shared
+ PROGRAM_INSTRUCTIONS_ARB = 0x88A0 # shared
+ MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1 # shared
+ PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2 # shared
+ MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3 # shared
+ PROGRAM_TEMPORARIES_ARB = 0x88A4 # shared
+ MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5 # shared
+ PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6 # shared
+ MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7 # shared
+ PROGRAM_PARAMETERS_ARB = 0x88A8 # shared
+ MAX_PROGRAM_PARAMETERS_ARB = 0x88A9 # shared
+ PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA # shared
+ MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB # shared
+ PROGRAM_ATTRIBS_ARB = 0x88AC # shared
+ MAX_PROGRAM_ATTRIBS_ARB = 0x88AD # shared
+ PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE # shared
+ MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF # shared
+ PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0 # shared
+ MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1 # shared
+ PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2 # shared
+ MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3 # shared
+ MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4 # shared
+ MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5 # shared
+ PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6 # shared
+ TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7 # shared
+ MATRIX0_ARB = 0x88C0 # shared
+ MATRIX1_ARB = 0x88C1 # shared
+ MATRIX2_ARB = 0x88C2 # shared
+ MATRIX3_ARB = 0x88C3 # shared
+ MATRIX4_ARB = 0x88C4 # shared
+ MATRIX5_ARB = 0x88C5 # shared
+ MATRIX6_ARB = 0x88C6 # shared
+ MATRIX7_ARB = 0x88C7 # shared
+ MATRIX8_ARB = 0x88C8 # shared
+ MATRIX9_ARB = 0x88C9 # shared
+ MATRIX10_ARB = 0x88CA # shared
+ MATRIX11_ARB = 0x88CB # shared
+ MATRIX12_ARB = 0x88CC # shared
+ MATRIX13_ARB = 0x88CD # shared
+ MATRIX14_ARB = 0x88CE # shared
+ MATRIX15_ARB = 0x88CF # shared
+ MATRIX16_ARB = 0x88D0 # shared
+ MATRIX17_ARB = 0x88D1 # shared
+ MATRIX18_ARB = 0x88D2 # shared
+ MATRIX19_ARB = 0x88D3 # shared
+ MATRIX20_ARB = 0x88D4 # shared
+ MATRIX21_ARB = 0x88D5 # shared
+ MATRIX22_ARB = 0x88D6 # shared
+ MATRIX23_ARB = 0x88D7 # shared
+ MATRIX24_ARB = 0x88D8 # shared
+ MATRIX25_ARB = 0x88D9 # shared
+ MATRIX26_ARB = 0x88DA # shared
+ MATRIX27_ARB = 0x88DB # shared
+ MATRIX28_ARB = 0x88DC # shared
+ MATRIX29_ARB = 0x88DD # shared
+ MATRIX30_ARB = 0x88DE # shared
+ MATRIX31_ARB = 0x88DF # shared
+
+###############################################################################
+
+# ARB Extension #27
+# Some ARB_fragment_program enums are shared with ARB_vertex_program,
+# and are only included in that #define block, for now.
+ARB_fragment_program enum:
+# PROGRAM_LENGTH_ARB = 0x8627 # shared
+# PROGRAM_STRING_ARB = 0x8628 # shared
+# MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E # shared
+# MAX_PROGRAM_MATRICES_ARB = 0x862F # shared
+# CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640 # shared
+# CURRENT_MATRIX_ARB = 0x8641 # shared
+# PROGRAM_ERROR_POSITION_ARB = 0x864B # shared
+# PROGRAM_BINDING_ARB = 0x8677 # shared
+ FRAGMENT_PROGRAM_ARB = 0x8804
+ PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805
+ PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806
+ PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807
+ PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808
+ PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809
+ PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A
+ MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B
+ MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C
+ MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D
+ MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E
+ MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F
+ MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810
+ MAX_TEXTURE_COORDS_ARB = 0x8871
+ MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872
+# PROGRAM_ERROR_STRING_ARB = 0x8874 # shared
+# PROGRAM_FORMAT_ASCII_ARB = 0x8875 # shared
+# PROGRAM_FORMAT_ARB = 0x8876 # shared
+# PROGRAM_INSTRUCTIONS_ARB = 0x88A0 # shared
+# MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1 # shared
+# PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2 # shared
+# MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3 # shared
+# PROGRAM_TEMPORARIES_ARB = 0x88A4 # shared
+# MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5 # shared
+# PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6 # shared
+# MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7 # shared
+# PROGRAM_PARAMETERS_ARB = 0x88A8 # shared
+# MAX_PROGRAM_PARAMETERS_ARB = 0x88A9 # shared
+# PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA # shared
+# MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB # shared
+# PROGRAM_ATTRIBS_ARB = 0x88AC # shared
+# MAX_PROGRAM_ATTRIBS_ARB = 0x88AD # shared
+# PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE # shared
+# MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF # shared
+# PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0 # shared
+# MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1 # shared
+# PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2 # shared
+# MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3 # shared
+# MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4 # shared
+# MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5 # shared
+# PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6 # shared
+# TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7 # shared
+# MATRIX0_ARB = 0x88C0 # shared
+# MATRIX1_ARB = 0x88C1 # shared
+# MATRIX2_ARB = 0x88C2 # shared
+# MATRIX3_ARB = 0x88C3 # shared
+# MATRIX4_ARB = 0x88C4 # shared
+# MATRIX5_ARB = 0x88C5 # shared
+# MATRIX6_ARB = 0x88C6 # shared
+# MATRIX7_ARB = 0x88C7 # shared
+# MATRIX8_ARB = 0x88C8 # shared
+# MATRIX9_ARB = 0x88C9 # shared
+# MATRIX10_ARB = 0x88CA # shared
+# MATRIX11_ARB = 0x88CB # shared
+# MATRIX12_ARB = 0x88CC # shared
+# MATRIX13_ARB = 0x88CD # shared
+# MATRIX14_ARB = 0x88CE # shared
+# MATRIX15_ARB = 0x88CF # shared
+# MATRIX16_ARB = 0x88D0 # shared
+# MATRIX17_ARB = 0x88D1 # shared
+# MATRIX18_ARB = 0x88D2 # shared
+# MATRIX19_ARB = 0x88D3 # shared
+# MATRIX20_ARB = 0x88D4 # shared
+# MATRIX21_ARB = 0x88D5 # shared
+# MATRIX22_ARB = 0x88D6 # shared
+# MATRIX23_ARB = 0x88D7 # shared
+# MATRIX24_ARB = 0x88D8 # shared
+# MATRIX25_ARB = 0x88D9 # shared
+# MATRIX26_ARB = 0x88DA # shared
+# MATRIX27_ARB = 0x88DB # shared
+# MATRIX28_ARB = 0x88DC # shared
+# MATRIX29_ARB = 0x88DD # shared
+# MATRIX30_ARB = 0x88DE # shared
+# MATRIX31_ARB = 0x88DF # shared
+
+
+###############################################################################
+
+# ARB Extension #28
+ARB_vertex_buffer_object enum:
+ BUFFER_SIZE_ARB = 0x8764
+ BUFFER_USAGE_ARB = 0x8765
+ ARRAY_BUFFER_ARB = 0x8892
+ ELEMENT_ARRAY_BUFFER_ARB = 0x8893
+ ARRAY_BUFFER_BINDING_ARB = 0x8894
+ ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895
+ VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896
+ NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897
+ COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898
+ INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899
+ TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A
+ EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B
+ SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C
+ FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D
+ WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E
+ VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F
+ READ_ONLY_ARB = 0x88B8
+ WRITE_ONLY_ARB = 0x88B9
+ READ_WRITE_ARB = 0x88BA
+ BUFFER_ACCESS_ARB = 0x88BB
+ BUFFER_MAPPED_ARB = 0x88BC
+ BUFFER_MAP_POINTER_ARB = 0x88BD
+ STREAM_DRAW_ARB = 0x88E0
+ STREAM_READ_ARB = 0x88E1
+ STREAM_COPY_ARB = 0x88E2
+ STATIC_DRAW_ARB = 0x88E4
+ STATIC_READ_ARB = 0x88E5
+ STATIC_COPY_ARB = 0x88E6
+ DYNAMIC_DRAW_ARB = 0x88E8
+ DYNAMIC_READ_ARB = 0x88E9
+ DYNAMIC_COPY_ARB = 0x88EA
+
+###############################################################################
+
+# ARB Extension #29
+ARB_occlusion_query enum:
+ QUERY_COUNTER_BITS_ARB = 0x8864
+ CURRENT_QUERY_ARB = 0x8865
+ QUERY_RESULT_ARB = 0x8866
+ QUERY_RESULT_AVAILABLE_ARB = 0x8867
+ SAMPLES_PASSED_ARB = 0x8914
+
+###############################################################################
+
+# ARB Extension #30
+ARB_shader_objects enum:
+ PROGRAM_OBJECT_ARB = 0x8B40
+ SHADER_OBJECT_ARB = 0x8B48
+ OBJECT_TYPE_ARB = 0x8B4E
+ OBJECT_SUBTYPE_ARB = 0x8B4F
+ FLOAT_VEC2_ARB = 0x8B50
+ FLOAT_VEC3_ARB = 0x8B51
+ FLOAT_VEC4_ARB = 0x8B52
+ INT_VEC2_ARB = 0x8B53
+ INT_VEC3_ARB = 0x8B54
+ INT_VEC4_ARB = 0x8B55
+ BOOL_ARB = 0x8B56
+ BOOL_VEC2_ARB = 0x8B57
+ BOOL_VEC3_ARB = 0x8B58
+ BOOL_VEC4_ARB = 0x8B59
+ FLOAT_MAT2_ARB = 0x8B5A
+ FLOAT_MAT3_ARB = 0x8B5B
+ FLOAT_MAT4_ARB = 0x8B5C
+ SAMPLER_1D_ARB = 0x8B5D
+ SAMPLER_2D_ARB = 0x8B5E
+ SAMPLER_3D_ARB = 0x8B5F
+ SAMPLER_CUBE_ARB = 0x8B60
+ SAMPLER_1D_SHADOW_ARB = 0x8B61
+ SAMPLER_2D_SHADOW_ARB = 0x8B62
+ SAMPLER_2D_RECT_ARB = 0x8B63
+ SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64
+ OBJECT_DELETE_STATUS_ARB = 0x8B80
+ OBJECT_COMPILE_STATUS_ARB = 0x8B81
+ OBJECT_LINK_STATUS_ARB = 0x8B82
+ OBJECT_VALIDATE_STATUS_ARB = 0x8B83
+ OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84
+ OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85
+ OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86
+ OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87
+ OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88
+
+###############################################################################
+
+# ARB Extension #31
+# Additional enums are reused from ARB_vertex/fragment_program and ARB_shader_objects
+ARB_vertex_shader enum:
+ VERTEX_SHADER_ARB = 0x8B31
+ MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A
+ MAX_VARYING_FLOATS_ARB = 0x8B4B
+ MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C
+ MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D
+ OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89
+ OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A
+
+###############################################################################
+
+# ARB Extension #32
+# Additional enums are reused from ARB_fragment_program and ARB_shader_objects
+ARB_fragment_shader enum:
+ FRAGMENT_SHADER_ARB = 0x8B30
+ MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49
+ FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B
+
+###############################################################################
+
+# ARB Extension #33
+ARB_shading_language_100 enum:
+ SHADING_LANGUAGE_VERSION_ARB = 0x8B8C
+
+###############################################################################
+
+# ARB Extension #34
+# No new tokens
+ARB_texture_non_power_of_two enum:
+
+###############################################################################
+
+# ARB Extension #35
+ARB_point_sprite enum:
+ POINT_SPRITE_ARB = 0x8861
+ COORD_REPLACE_ARB = 0x8862
+
+###############################################################################
+
+# ARB Extension #36
+# No new tokens
+ARB_fragment_program_shadow enum:
+
+###############################################################################
+
+# ARB Extension #37
+ARB_draw_buffers enum:
+ MAX_DRAW_BUFFERS_ARB = 0x8824
+ DRAW_BUFFER0_ARB = 0x8825
+ DRAW_BUFFER1_ARB = 0x8826
+ DRAW_BUFFER2_ARB = 0x8827
+ DRAW_BUFFER3_ARB = 0x8828
+ DRAW_BUFFER4_ARB = 0x8829
+ DRAW_BUFFER5_ARB = 0x882A
+ DRAW_BUFFER6_ARB = 0x882B
+ DRAW_BUFFER7_ARB = 0x882C
+ DRAW_BUFFER8_ARB = 0x882D
+ DRAW_BUFFER9_ARB = 0x882E
+ DRAW_BUFFER10_ARB = 0x882F
+ DRAW_BUFFER11_ARB = 0x8830
+ DRAW_BUFFER12_ARB = 0x8831
+ DRAW_BUFFER13_ARB = 0x8832
+ DRAW_BUFFER14_ARB = 0x8833
+ DRAW_BUFFER15_ARB = 0x8834
+
+###############################################################################
+
+# ARB Extension #38
+ARB_texture_rectangle enum:
+ TEXTURE_RECTANGLE_ARB = 0x84F5
+ TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6
+ PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7
+ MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8
+
+###############################################################################
+
+# ARB Extension #39
+ARB_color_buffer_float enum:
+ RGBA_FLOAT_MODE_ARB = 0x8820
+ CLAMP_VERTEX_COLOR_ARB = 0x891A
+ CLAMP_FRAGMENT_COLOR_ARB = 0x891B
+ CLAMP_READ_COLOR_ARB = 0x891C
+ FIXED_ONLY_ARB = 0x891D
+
+###############################################################################
+
+# ARB Extension #40
+ARB_half_float_pixel enum:
+ HALF_FLOAT_ARB = 0x140B
+
+###############################################################################
+
+# ARB Extension #41
+ARB_texture_float enum:
+ TEXTURE_RED_TYPE_ARB = 0x8C10
+ TEXTURE_GREEN_TYPE_ARB = 0x8C11
+ TEXTURE_BLUE_TYPE_ARB = 0x8C12
+ TEXTURE_ALPHA_TYPE_ARB = 0x8C13
+ TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14
+ TEXTURE_INTENSITY_TYPE_ARB = 0x8C15
+ TEXTURE_DEPTH_TYPE_ARB = 0x8C16
+ UNSIGNED_NORMALIZED_ARB = 0x8C17
+ RGBA32F_ARB = 0x8814
+ RGB32F_ARB = 0x8815
+ ALPHA32F_ARB = 0x8816
+ INTENSITY32F_ARB = 0x8817
+ LUMINANCE32F_ARB = 0x8818
+ LUMINANCE_ALPHA32F_ARB = 0x8819
+ RGBA16F_ARB = 0x881A
+ RGB16F_ARB = 0x881B
+ ALPHA16F_ARB = 0x881C
+ INTENSITY16F_ARB = 0x881D
+ LUMINANCE16F_ARB = 0x881E
+ LUMINANCE_ALPHA16F_ARB = 0x881F
+
+###############################################################################
+
+# ARB Extension #42
+ARB_pixel_buffer_object enum:
+ PIXEL_PACK_BUFFER_ARB = 0x88EB
+ PIXEL_UNPACK_BUFFER_ARB = 0x88EC
+ PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED
+ PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF
+
+
+###############################################################################
+#
+# non-ARB extensions follow, in registry order
+#
+###############################################################################
+
+###############################################################################
+
+# Extension #1
+EXT_abgr enum:
+ ABGR_EXT = 0x8000
+
+###############################################################################
+
+# Extension #2
+EXT_blend_color enum:
+ CONSTANT_COLOR_EXT = 0x8001
+ ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002
+ CONSTANT_ALPHA_EXT = 0x8003
+ ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004
+ BLEND_COLOR_EXT = 0x8005 # 4 F
+
+###############################################################################
+
+# Extension #3
+EXT_polygon_offset enum:
+ POLYGON_OFFSET_EXT = 0x8037
+ POLYGON_OFFSET_FACTOR_EXT = 0x8038
+ POLYGON_OFFSET_BIAS_EXT = 0x8039 # 1 F
+
+###############################################################################
+
+# Extension #4
+EXT_texture enum:
+ ALPHA4_EXT = 0x803B
+ ALPHA8_EXT = 0x803C
+ ALPHA12_EXT = 0x803D
+ ALPHA16_EXT = 0x803E
+ LUMINANCE4_EXT = 0x803F
+ LUMINANCE8_EXT = 0x8040
+ LUMINANCE12_EXT = 0x8041
+ LUMINANCE16_EXT = 0x8042
+ LUMINANCE4_ALPHA4_EXT = 0x8043
+ LUMINANCE6_ALPHA2_EXT = 0x8044
+ LUMINANCE8_ALPHA8_EXT = 0x8045
+ LUMINANCE12_ALPHA4_EXT = 0x8046
+ LUMINANCE12_ALPHA12_EXT = 0x8047
+ LUMINANCE16_ALPHA16_EXT = 0x8048
+ INTENSITY_EXT = 0x8049
+ INTENSITY4_EXT = 0x804A
+ INTENSITY8_EXT = 0x804B
+ INTENSITY12_EXT = 0x804C
+ INTENSITY16_EXT = 0x804D
+ RGB2_EXT = 0x804E
+ RGB4_EXT = 0x804F
+ RGB5_EXT = 0x8050
+ RGB8_EXT = 0x8051
+ RGB10_EXT = 0x8052
+ RGB12_EXT = 0x8053
+ RGB16_EXT = 0x8054
+ RGBA2_EXT = 0x8055
+ RGBA4_EXT = 0x8056
+ RGB5_A1_EXT = 0x8057
+ RGBA8_EXT = 0x8058
+ RGB10_A2_EXT = 0x8059
+ RGBA12_EXT = 0x805A
+ RGBA16_EXT = 0x805B
+ TEXTURE_RED_SIZE_EXT = 0x805C
+ TEXTURE_GREEN_SIZE_EXT = 0x805D
+ TEXTURE_BLUE_SIZE_EXT = 0x805E
+ TEXTURE_ALPHA_SIZE_EXT = 0x805F
+ TEXTURE_LUMINANCE_SIZE_EXT = 0x8060
+ TEXTURE_INTENSITY_SIZE_EXT = 0x8061
+ REPLACE_EXT = 0x8062
+ PROXY_TEXTURE_1D_EXT = 0x8063
+ PROXY_TEXTURE_2D_EXT = 0x8064
+ TEXTURE_TOO_LARGE_EXT = 0x8065
+
+###############################################################################
+
+# Extension #5 - skipped
+
+###############################################################################
+
+# Extension #6
+EXT_texture3D enum:
+ PACK_SKIP_IMAGES_EXT = 0x806B # 1 I
+ PACK_IMAGE_HEIGHT_EXT = 0x806C # 1 F
+ UNPACK_SKIP_IMAGES_EXT = 0x806D # 1 I
+ UNPACK_IMAGE_HEIGHT_EXT = 0x806E # 1 F
+ TEXTURE_3D_EXT = 0x806F # 1 I
+ PROXY_TEXTURE_3D_EXT = 0x8070
+ TEXTURE_DEPTH_EXT = 0x8071
+ TEXTURE_WRAP_R_EXT = 0x8072
+ MAX_3D_TEXTURE_SIZE_EXT = 0x8073 # 1 I
+
+###############################################################################
+
+# Extension #7
+SGIS_texture_filter4 enum:
+ FILTER4_SGIS = 0x8146
+ TEXTURE_FILTER4_SIZE_SGIS = 0x8147
+
+###############################################################################
+
+# Extension #8 - skipped
+
+###############################################################################
+
+# No new tokens
+# Extension #9
+EXT_subtexture enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #10
+EXT_copy_texture enum:
+
+###############################################################################
+
+# Extension #11
+EXT_histogram enum:
+ HISTOGRAM_EXT = 0x8024 # 1 I
+ PROXY_HISTOGRAM_EXT = 0x8025
+ HISTOGRAM_WIDTH_EXT = 0x8026
+ HISTOGRAM_FORMAT_EXT = 0x8027
+ HISTOGRAM_RED_SIZE_EXT = 0x8028
+ HISTOGRAM_GREEN_SIZE_EXT = 0x8029
+ HISTOGRAM_BLUE_SIZE_EXT = 0x802A
+ HISTOGRAM_ALPHA_SIZE_EXT = 0x802B
+ HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C
+ HISTOGRAM_SINK_EXT = 0x802D
+ MINMAX_EXT = 0x802E # 1 I
+ MINMAX_FORMAT_EXT = 0x802F
+ MINMAX_SINK_EXT = 0x8030
+ TABLE_TOO_LARGE_EXT = 0x8031
+
+###############################################################################
+
+# Extension #12
+EXT_convolution enum:
+ CONVOLUTION_1D_EXT = 0x8010 # 1 I
+ CONVOLUTION_2D_EXT = 0x8011 # 1 I
+ SEPARABLE_2D_EXT = 0x8012 # 1 I
+ CONVOLUTION_BORDER_MODE_EXT = 0x8013
+ CONVOLUTION_FILTER_SCALE_EXT = 0x8014
+ CONVOLUTION_FILTER_BIAS_EXT = 0x8015
+ REDUCE_EXT = 0x8016
+ CONVOLUTION_FORMAT_EXT = 0x8017
+ CONVOLUTION_WIDTH_EXT = 0x8018
+ CONVOLUTION_HEIGHT_EXT = 0x8019
+ MAX_CONVOLUTION_WIDTH_EXT = 0x801A
+ MAX_CONVOLUTION_HEIGHT_EXT = 0x801B
+ POST_CONVOLUTION_RED_SCALE_EXT = 0x801C # 1 F
+ POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D # 1 F
+ POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E # 1 F
+ POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F # 1 F
+ POST_CONVOLUTION_RED_BIAS_EXT = 0x8020 # 1 F
+ POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021 # 1 F
+ POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022 # 1 F
+ POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023 # 1 F
+
+###############################################################################
+
+# Extension #13
+SGI_color_matrix enum:
+ COLOR_MATRIX_SGI = 0x80B1 # 16 F
+ COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2 # 1 I
+ MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3 # 1 I
+ POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4 # 1 F
+ POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5 # 1 F
+ POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6 # 1 F
+ POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7 # 1 F
+ POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8 # 1 F
+ POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9 # 1 F
+ POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA # 1 F
+ POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB # 1 F
+
+###############################################################################
+
+# Extension #14
+SGI_color_table enum:
+ COLOR_TABLE_SGI = 0x80D0 # 1 I
+ POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1 # 1 I
+ POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2 # 1 I
+ PROXY_COLOR_TABLE_SGI = 0x80D3
+ PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5
+ COLOR_TABLE_SCALE_SGI = 0x80D6
+ COLOR_TABLE_BIAS_SGI = 0x80D7
+ COLOR_TABLE_FORMAT_SGI = 0x80D8
+ COLOR_TABLE_WIDTH_SGI = 0x80D9
+ COLOR_TABLE_RED_SIZE_SGI = 0x80DA
+ COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB
+ COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC
+ COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD
+ COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE
+ COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF
+
+###############################################################################
+
+# Extension #15
+SGIS_pixel_texture enum:
+ PIXEL_TEXTURE_SGIS = 0x8353 # 1 I
+ PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354 # 1 I
+ PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355 # 1 I
+ PIXEL_GROUP_COLOR_SGIS = 0x8356 # 1 I
+
+###############################################################################
+
+# Extension #15a
+SGIX_pixel_texture enum:
+ PIXEL_TEX_GEN_SGIX = 0x8139 # 1 I
+ PIXEL_TEX_GEN_MODE_SGIX = 0x832B # 1 I
+
+###############################################################################
+
+# Extension #16
+SGIS_texture4D enum:
+ PACK_SKIP_VOLUMES_SGIS = 0x8130 # 1 I
+ PACK_IMAGE_DEPTH_SGIS = 0x8131 # 1 I
+ UNPACK_SKIP_VOLUMES_SGIS = 0x8132 # 1 I
+ UNPACK_IMAGE_DEPTH_SGIS = 0x8133 # 1 I
+ TEXTURE_4D_SGIS = 0x8134 # 1 I
+ PROXY_TEXTURE_4D_SGIS = 0x8135
+ TEXTURE_4DSIZE_SGIS = 0x8136
+ TEXTURE_WRAP_Q_SGIS = 0x8137
+ MAX_4D_TEXTURE_SIZE_SGIS = 0x8138 # 1 I
+ TEXTURE_4D_BINDING_SGIS = 0x814F # 1 I
+
+###############################################################################
+
+# Extension #17
+SGI_texture_color_table enum:
+ TEXTURE_COLOR_TABLE_SGI = 0x80BC # 1 I
+ PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD
+
+###############################################################################
+
+# Extension #18
+EXT_cmyka enum:
+ CMYK_EXT = 0x800C
+ CMYKA_EXT = 0x800D
+ PACK_CMYK_HINT_EXT = 0x800E # 1 I
+ UNPACK_CMYK_HINT_EXT = 0x800F # 1 I
+
+###############################################################################
+
+# Extension #19 - skipped
+
+###############################################################################
+
+# Extension #20
+EXT_texture_object enum:
+ TEXTURE_PRIORITY_EXT = 0x8066
+ TEXTURE_RESIDENT_EXT = 0x8067
+ TEXTURE_1D_BINDING_EXT = 0x8068
+ TEXTURE_2D_BINDING_EXT = 0x8069
+ TEXTURE_3D_BINDING_EXT = 0x806A # 1 I
+
+###############################################################################
+
+# Extension #21
+SGIS_detail_texture enum:
+ DETAIL_TEXTURE_2D_SGIS = 0x8095
+ DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096 # 1 I
+ LINEAR_DETAIL_SGIS = 0x8097
+ LINEAR_DETAIL_ALPHA_SGIS = 0x8098
+ LINEAR_DETAIL_COLOR_SGIS = 0x8099
+ DETAIL_TEXTURE_LEVEL_SGIS = 0x809A
+ DETAIL_TEXTURE_MODE_SGIS = 0x809B
+ DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C
+
+###############################################################################
+
+# Extension #22
+SGIS_sharpen_texture enum:
+ LINEAR_SHARPEN_SGIS = 0x80AD
+ LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE
+ LINEAR_SHARPEN_COLOR_SGIS = 0x80AF
+ SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0
+
+###############################################################################
+
+# Extension #23
+EXT_packed_pixels enum:
+ UNSIGNED_BYTE_3_3_2_EXT = 0x8032
+ UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033
+ UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034
+ UNSIGNED_INT_8_8_8_8_EXT = 0x8035
+ UNSIGNED_INT_10_10_10_2_EXT = 0x8036
+
+###############################################################################
+
+# Extension #24
+SGIS_texture_lod enum:
+ TEXTURE_MIN_LOD_SGIS = 0x813A
+ TEXTURE_MAX_LOD_SGIS = 0x813B
+ TEXTURE_BASE_LEVEL_SGIS = 0x813C
+ TEXTURE_MAX_LEVEL_SGIS = 0x813D
+
+###############################################################################
+
+# Extension #25
+SGIS_multisample enum:
+ MULTISAMPLE_SGIS = 0x809D # 1 I
+ SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E # 1 I
+ SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F # 1 I
+ SAMPLE_MASK_SGIS = 0x80A0 # 1 I
+ 1PASS_SGIS = 0x80A1
+ 2PASS_0_SGIS = 0x80A2
+ 2PASS_1_SGIS = 0x80A3
+ 4PASS_0_SGIS = 0x80A4
+ 4PASS_1_SGIS = 0x80A5
+ 4PASS_2_SGIS = 0x80A6
+ 4PASS_3_SGIS = 0x80A7
+ SAMPLE_BUFFERS_SGIS = 0x80A8 # 1 I
+ SAMPLES_SGIS = 0x80A9 # 1 I
+ SAMPLE_MASK_VALUE_SGIS = 0x80AA # 1 F
+ SAMPLE_MASK_INVERT_SGIS = 0x80AB # 1 I
+ SAMPLE_PATTERN_SGIS = 0x80AC # 1 I
+
+###############################################################################
+
+# Extension #26 - no specification?
+# SGIS_premultiply_blend enum:
+
+##############################################################################
+
+# Extension #27
+# Diamond ships an otherwise identical IBM_rescale_normal extension;
+# Dan Brokenshire says this is deprecated and should not be advertised.
+EXT_rescale_normal enum:
+ RESCALE_NORMAL_EXT = 0x803A # 1 I
+
+###############################################################################
+
+# Extension #28 - GLX_EXT_visual_info
+
+###############################################################################
+
+# Extension #29 - skipped
+
+###############################################################################
+
+# Extension #30
+EXT_vertex_array enum:
+ VERTEX_ARRAY_EXT = 0x8074
+ NORMAL_ARRAY_EXT = 0x8075
+ COLOR_ARRAY_EXT = 0x8076
+ INDEX_ARRAY_EXT = 0x8077
+ TEXTURE_COORD_ARRAY_EXT = 0x8078
+ EDGE_FLAG_ARRAY_EXT = 0x8079
+ VERTEX_ARRAY_SIZE_EXT = 0x807A
+ VERTEX_ARRAY_TYPE_EXT = 0x807B
+ VERTEX_ARRAY_STRIDE_EXT = 0x807C
+ VERTEX_ARRAY_COUNT_EXT = 0x807D # 1 I
+ NORMAL_ARRAY_TYPE_EXT = 0x807E
+ NORMAL_ARRAY_STRIDE_EXT = 0x807F
+ NORMAL_ARRAY_COUNT_EXT = 0x8080 # 1 I
+ COLOR_ARRAY_SIZE_EXT = 0x8081
+ COLOR_ARRAY_TYPE_EXT = 0x8082
+ COLOR_ARRAY_STRIDE_EXT = 0x8083
+ COLOR_ARRAY_COUNT_EXT = 0x8084 # 1 I
+ INDEX_ARRAY_TYPE_EXT = 0x8085
+ INDEX_ARRAY_STRIDE_EXT = 0x8086
+ INDEX_ARRAY_COUNT_EXT = 0x8087 # 1 I
+ TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088
+ TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089
+ TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A
+ TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B # 1 I
+ EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C
+ EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D # 1 I
+ VERTEX_ARRAY_POINTER_EXT = 0x808E
+ NORMAL_ARRAY_POINTER_EXT = 0x808F
+ COLOR_ARRAY_POINTER_EXT = 0x8090
+ INDEX_ARRAY_POINTER_EXT = 0x8091
+ TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092
+ EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093
+
+###############################################################################
+
+# Extension #31
+EXT_misc_attribute enum:
+# MISC_BIT = 0x????
+
+###############################################################################
+
+# Extension #32
+SGIS_generate_mipmap enum:
+ GENERATE_MIPMAP_SGIS = 0x8191
+ GENERATE_MIPMAP_HINT_SGIS = 0x8192 # 1 I
+
+###############################################################################
+
+# Extension #33
+SGIX_clipmap enum:
+ LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170
+ TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171
+ TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172
+ TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173
+ TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174
+ TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175
+ TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176
+ MAX_CLIPMAP_DEPTH_SGIX = 0x8177 # 1 I
+ MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178 # 1 I
+ NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D
+ NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E
+ LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F
+
+###############################################################################
+
+# Extension #34
+SGIX_shadow enum:
+ TEXTURE_COMPARE_SGIX = 0x819A
+ TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B
+ TEXTURE_LEQUAL_R_SGIX = 0x819C
+ TEXTURE_GEQUAL_R_SGIX = 0x819D
+
+###############################################################################
+
+# Extension #35
+SGIS_texture_edge_clamp enum:
+ CLAMP_TO_EDGE_SGIS = 0x812F
+
+###############################################################################
+
+# Extension #36
+# Promoted to ARB_texture_border_clamp
+SGIS_texture_border_clamp enum:
+ CLAMP_TO_BORDER_SGIS = 0x812D
+
+###############################################################################
+
+# Extension #37
+EXT_blend_minmax enum:
+ FUNC_ADD_EXT = 0x8006
+ MIN_EXT = 0x8007
+ MAX_EXT = 0x8008
+ BLEND_EQUATION_EXT = 0x8009 # 1 I
+
+###############################################################################
+
+# Extension #38
+EXT_blend_subtract enum:
+ FUNC_SUBTRACT_EXT = 0x800A
+ FUNC_REVERSE_SUBTRACT_EXT = 0x800B
+
+###############################################################################
+
+# No new tokens
+# Extension #39
+EXT_blend_logic_op enum:
+
+###############################################################################
+
+# Extension #40 - GLX_SGI_swap_control
+# Extension #41 - GLX_SGI_video_sync
+# Extension #42 - GLX_SGI_make_current_read
+# Extension #43 - GLX_SGIX_video_source
+# Extension #44 - GLX_EXT_visual_rating
+
+###############################################################################
+
+# Extension #45
+SGIX_interlace enum:
+ INTERLACE_SGIX = 0x8094 # 1 I
+
+###############################################################################
+
+# Extension #46
+SGIX_pixel_tiles enum:
+ PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E # 1 I
+ PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F # 1 I
+ PIXEL_TILE_WIDTH_SGIX = 0x8140 # 1 I
+ PIXEL_TILE_HEIGHT_SGIX = 0x8141 # 1 I
+ PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142 # 1 I
+ PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143 # 1 I
+ PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144 # 1 I
+ PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145 # 1 I
+
+###############################################################################
+
+# Extension #47 - GLX_EXT_import_context
+
+###############################################################################
+
+# Extension #48 - skipped
+
+###############################################################################
+
+# Extension #49 - GLX_SGIX_fbconfig
+# Extension #50 - GLX_SGIX_pbuffer
+
+###############################################################################
+
+# Extension #51
+SGIS_texture_select enum:
+ DUAL_ALPHA4_SGIS = 0x8110
+ DUAL_ALPHA8_SGIS = 0x8111
+ DUAL_ALPHA12_SGIS = 0x8112
+ DUAL_ALPHA16_SGIS = 0x8113
+ DUAL_LUMINANCE4_SGIS = 0x8114
+ DUAL_LUMINANCE8_SGIS = 0x8115
+ DUAL_LUMINANCE12_SGIS = 0x8116
+ DUAL_LUMINANCE16_SGIS = 0x8117
+ DUAL_INTENSITY4_SGIS = 0x8118
+ DUAL_INTENSITY8_SGIS = 0x8119
+ DUAL_INTENSITY12_SGIS = 0x811A
+ DUAL_INTENSITY16_SGIS = 0x811B
+ DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C
+ DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D
+ QUAD_ALPHA4_SGIS = 0x811E
+ QUAD_ALPHA8_SGIS = 0x811F
+ QUAD_LUMINANCE4_SGIS = 0x8120
+ QUAD_LUMINANCE8_SGIS = 0x8121
+ QUAD_INTENSITY4_SGIS = 0x8122
+ QUAD_INTENSITY8_SGIS = 0x8123
+ DUAL_TEXTURE_SELECT_SGIS = 0x8124
+ QUAD_TEXTURE_SELECT_SGIS = 0x8125
+
+###############################################################################
+
+# Extension #52
+SGIX_sprite enum:
+ SPRITE_SGIX = 0x8148 # 1 I
+ SPRITE_MODE_SGIX = 0x8149 # 1 I
+ SPRITE_AXIS_SGIX = 0x814A # 3 F
+ SPRITE_TRANSLATION_SGIX = 0x814B # 3 F
+ SPRITE_AXIAL_SGIX = 0x814C
+ SPRITE_OBJECT_ALIGNED_SGIX = 0x814D
+ SPRITE_EYE_ALIGNED_SGIX = 0x814E
+
+###############################################################################
+
+# Extension #53
+SGIX_texture_multi_buffer enum:
+ TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E
+
+###############################################################################
+
+# Extension #54
+# EXT form promoted from SGIS form; both are included
+EXT_point_parameters enum:
+ POINT_SIZE_MIN_EXT = 0x8126 # 1 F
+ POINT_SIZE_MAX_EXT = 0x8127 # 1 F
+ POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128 # 1 F
+ DISTANCE_ATTENUATION_EXT = 0x8129 # 3 F
+
+SGIS_point_parameters enum:
+ POINT_SIZE_MIN_SGIS = 0x8126 # 1 F
+ POINT_SIZE_MAX_SGIS = 0x8127 # 1 F
+ POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128 # 1 F
+ DISTANCE_ATTENUATION_SGIS = 0x8129 # 3 F
+
+###############################################################################
+
+# Extension #55
+SGIX_instruments enum:
+ INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180
+ INSTRUMENT_MEASUREMENTS_SGIX = 0x8181 # 1 I
+
+###############################################################################
+
+# Extension #56
+SGIX_texture_scale_bias enum:
+ POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179
+ POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A
+ POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B # 2 F
+ POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C # 2 F
+
+###############################################################################
+
+# Extension #57
+SGIX_framezoom enum:
+ FRAMEZOOM_SGIX = 0x818B # 1 I
+ FRAMEZOOM_FACTOR_SGIX = 0x818C # 1 I
+ MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D # 1 I
+
+###############################################################################
+
+# No new tokens
+# Extension #58
+SGIX_tag_sample_buffer enum:
+
+###############################################################################
+
+# Extension #59
+FfdMaskSGIX enum:
+ TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001
+ GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002
+SGIX_polynomial_ffd enum:
+ GEOMETRY_DEFORMATION_SGIX = 0x8194
+ TEXTURE_DEFORMATION_SGIX = 0x8195
+ DEFORMATIONS_MASK_SGIX = 0x8196 # 1 I
+ MAX_DEFORMATION_ORDER_SGIX = 0x8197
+
+###############################################################################
+
+# Extension #60
+SGIX_reference_plane enum:
+ REFERENCE_PLANE_SGIX = 0x817D # 1 I
+ REFERENCE_PLANE_EQUATION_SGIX = 0x817E # 4 F
+
+###############################################################################
+
+# No new tokens
+# Extension #61
+SGIX_flush_raster enum:
+
+###############################################################################
+
+# Extension #62 - GLX_SGIX_cushion
+
+###############################################################################
+
+# Extension #63
+SGIX_depth_texture enum:
+ DEPTH_COMPONENT16_SGIX = 0x81A5
+ DEPTH_COMPONENT24_SGIX = 0x81A6
+ DEPTH_COMPONENT32_SGIX = 0x81A7
+
+###############################################################################
+
+# Extension #64
+SGIS_fog_function enum:
+ FOG_FUNC_SGIS = 0x812A
+ FOG_FUNC_POINTS_SGIS = 0x812B # 1 I
+ MAX_FOG_FUNC_POINTS_SGIS = 0x812C # 1 I
+
+###############################################################################
+
+# Extension #65
+SGIX_fog_offset enum:
+ FOG_OFFSET_SGIX = 0x8198 # 1 I
+ FOG_OFFSET_VALUE_SGIX = 0x8199 # 4 F
+
+###############################################################################
+
+# Extension #66
+HP_image_transform enum:
+ IMAGE_SCALE_X_HP = 0x8155
+ IMAGE_SCALE_Y_HP = 0x8156
+ IMAGE_TRANSLATE_X_HP = 0x8157
+ IMAGE_TRANSLATE_Y_HP = 0x8158
+ IMAGE_ROTATE_ANGLE_HP = 0x8159
+ IMAGE_ROTATE_ORIGIN_X_HP = 0x815A
+ IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B
+ IMAGE_MAG_FILTER_HP = 0x815C
+ IMAGE_MIN_FILTER_HP = 0x815D
+ IMAGE_CUBIC_WEIGHT_HP = 0x815E
+ CUBIC_HP = 0x815F
+ AVERAGE_HP = 0x8160
+ IMAGE_TRANSFORM_2D_HP = 0x8161
+ POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162
+ PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163
+
+###############################################################################
+
+# Extension #67
+HP_convolution_border_modes enum:
+ IGNORE_BORDER_HP = 0x8150
+ CONSTANT_BORDER_HP = 0x8151
+ REPLICATE_BORDER_HP = 0x8153
+ CONVOLUTION_BORDER_COLOR_HP = 0x8154
+
+###############################################################################
+
+#@ Unknown tokens
+# Extension #68
+INGR_palette_buffer enum:
+
+###############################################################################
+
+# Extension #69
+SGIX_texture_add_env enum:
+ TEXTURE_ENV_BIAS_SGIX = 0x80BE
+
+###############################################################################
+
+# Extension #70 - skipped
+# Extension #71 - skipped
+# Extension #72 - skipped
+# Extension #73 - skipped
+
+###############################################################################
+
+# No new tokens
+# Extension #74
+EXT_color_subtable enum:
+
+###############################################################################
+
+# Extension #75 - GLU_EXT_object_space_tess
+
+###############################################################################
+
+# Extension #76
+PGI_vertex_hints enum:
+ VERTEX_DATA_HINT_PGI = 0x1A22A
+ VERTEX_CONSISTENT_HINT_PGI = 0x1A22B
+ MATERIAL_SIDE_HINT_PGI = 0x1A22C
+ MAX_VERTEX_HINT_PGI = 0x1A22D
+ COLOR3_BIT_PGI = 0x00010000
+ COLOR4_BIT_PGI = 0x00020000
+ EDGEFLAG_BIT_PGI = 0x00040000
+ INDEX_BIT_PGI = 0x00080000
+ MAT_AMBIENT_BIT_PGI = 0x00100000
+ MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000
+ MAT_DIFFUSE_BIT_PGI = 0x00400000
+ MAT_EMISSION_BIT_PGI = 0x00800000
+ MAT_COLOR_INDEXES_BIT_PGI = 0x01000000
+ MAT_SHININESS_BIT_PGI = 0x02000000
+ MAT_SPECULAR_BIT_PGI = 0x04000000
+ NORMAL_BIT_PGI = 0x08000000
+ TEXCOORD1_BIT_PGI = 0x10000000
+ TEXCOORD2_BIT_PGI = 0x20000000
+ TEXCOORD3_BIT_PGI = 0x40000000
+ TEXCOORD4_BIT_PGI = 0x80000000
+ VERTEX23_BIT_PGI = 0x00000004
+ VERTEX4_BIT_PGI = 0x00000008
+
+###############################################################################
+
+# Extension #77
+PGI_misc_hints enum:
+ PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8
+ CONSERVE_MEMORY_HINT_PGI = 0x1A1FD
+ RECLAIM_MEMORY_HINT_PGI = 0x1A1FE
+ NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202
+ NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203
+ NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204
+ ALWAYS_FAST_HINT_PGI = 0x1A20C
+ ALWAYS_SOFT_HINT_PGI = 0x1A20D
+ ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E
+ ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F
+ ALLOW_DRAW_FRG_HINT_PGI = 0x1A210
+ ALLOW_DRAW_MEM_HINT_PGI = 0x1A211
+ STRICT_DEPTHFUNC_HINT_PGI = 0x1A216
+ STRICT_LIGHTING_HINT_PGI = 0x1A217
+ STRICT_SCISSOR_HINT_PGI = 0x1A218
+ FULL_STIPPLE_HINT_PGI = 0x1A219
+ CLIP_NEAR_HINT_PGI = 0x1A220
+ CLIP_FAR_HINT_PGI = 0x1A221
+ WIDE_LINE_HINT_PGI = 0x1A222
+ BACK_NORMALS_HINT_PGI = 0x1A223
+
+###############################################################################
+
+# Extension #78
+EXT_paletted_texture enum:
+ COLOR_INDEX1_EXT = 0x80E2
+ COLOR_INDEX2_EXT = 0x80E3
+ COLOR_INDEX4_EXT = 0x80E4
+ COLOR_INDEX8_EXT = 0x80E5
+ COLOR_INDEX12_EXT = 0x80E6
+ COLOR_INDEX16_EXT = 0x80E7
+ TEXTURE_INDEX_SIZE_EXT = 0x80ED
+
+###############################################################################
+
+# Extension #79
+EXT_clip_volume_hint enum:
+ CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0
+
+###############################################################################
+
+# Extension #80
+SGIX_list_priority enum:
+ LIST_PRIORITY_SGIX = 0x8182
+
+###############################################################################
+
+# Extension #81
+SGIX_ir_instrument1 enum:
+ IR_INSTRUMENT1_SGIX = 0x817F # 1 I
+
+###############################################################################
+
+# Extension #82
+SGIX_calligraphic_fragment enum:
+ CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183 # 1 I
+
+###############################################################################
+
+# Extension #83 - GLX_SGIX_video_resize
+
+###############################################################################
+
+# Extension #84
+SGIX_texture_lod_bias enum:
+ TEXTURE_LOD_BIAS_S_SGIX = 0x818E
+ TEXTURE_LOD_BIAS_T_SGIX = 0x818F
+ TEXTURE_LOD_BIAS_R_SGIX = 0x8190
+
+###############################################################################
+
+# Extension #85 - skipped
+
+###############################################################################
+
+# Extension #86 - GLX_SGIX_dmbuffer
+
+###############################################################################
+
+# Extension #87 - skipped
+# Extension #88 - skipped
+# Extension #89 - skipped
+
+###############################################################################
+
+# Extension #90
+SGIX_shadow_ambient enum:
+ SHADOW_AMBIENT_SGIX = 0x80BF
+
+###############################################################################
+
+# Extension #91 - GLX_SGIX_swap_group
+# Extension #92 - GLX_SGIX_swap_barrier
+
+###############################################################################
+
+# No new tokens
+# Extension #93
+EXT_index_texture enum:
+
+###############################################################################
+
+# Extension #94
+# Promoted from SGI?
+EXT_index_material enum:
+ INDEX_MATERIAL_EXT = 0x81B8
+ INDEX_MATERIAL_PARAMETER_EXT = 0x81B9
+ INDEX_MATERIAL_FACE_EXT = 0x81BA
+
+###############################################################################
+
+# Extension #95
+# Promoted from SGI?
+EXT_index_func enum:
+ INDEX_TEST_EXT = 0x81B5
+ INDEX_TEST_FUNC_EXT = 0x81B6
+ INDEX_TEST_REF_EXT = 0x81B7
+
+###############################################################################
+
+# Extension #96
+# Promoted from SGI?
+EXT_index_array_formats enum:
+ IUI_V2F_EXT = 0x81AD
+ IUI_V3F_EXT = 0x81AE
+ IUI_N3F_V2F_EXT = 0x81AF
+ IUI_N3F_V3F_EXT = 0x81B0
+ T2F_IUI_V2F_EXT = 0x81B1
+ T2F_IUI_V3F_EXT = 0x81B2
+ T2F_IUI_N3F_V2F_EXT = 0x81B3
+ T2F_IUI_N3F_V3F_EXT = 0x81B4
+
+###############################################################################
+
+# Extension #97
+# Promoted from SGI?
+EXT_compiled_vertex_array enum:
+ ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8
+ ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9
+
+###############################################################################
+
+# Extension #98
+# Promoted from SGI?
+EXT_cull_vertex enum:
+ CULL_VERTEX_EXT = 0x81AA
+ CULL_VERTEX_EYE_POSITION_EXT = 0x81AB
+ CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC
+
+###############################################################################
+
+# Extension #99 - skipped
+
+###############################################################################
+
+# Extension #100 - GLU_EXT_nurbs_tessellator
+
+###############################################################################
+
+# Extension #101
+SGIX_ycrcb enum:
+ YCRCB_422_SGIX = 0x81BB
+ YCRCB_444_SGIX = 0x81BC
+
+###############################################################################
+
+# Extension #102
+SGIX_fragment_lighting enum:
+ FRAGMENT_LIGHTING_SGIX = 0x8400 # 1 I
+ FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401 # 1 I
+ FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402 # 1 I
+ FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403 # 1 I
+ MAX_FRAGMENT_LIGHTS_SGIX = 0x8404 # 1 I
+ MAX_ACTIVE_LIGHTS_SGIX = 0x8405 # 1 I
+ CURRENT_RASTER_NORMAL_SGIX = 0x8406 # 1 I
+ LIGHT_ENV_MODE_SGIX = 0x8407 # 1 I
+ FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408 # 1 I
+ FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409 # 1 I
+ FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A # 4 F
+ FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B # 1 I
+ FRAGMENT_LIGHT0_SGIX = 0x840C # 1 I
+ FRAGMENT_LIGHT1_SGIX = 0x840D
+ FRAGMENT_LIGHT2_SGIX = 0x840E
+ FRAGMENT_LIGHT3_SGIX = 0x840F
+ FRAGMENT_LIGHT4_SGIX = 0x8410
+ FRAGMENT_LIGHT5_SGIX = 0x8411
+ FRAGMENT_LIGHT6_SGIX = 0x8412
+ FRAGMENT_LIGHT7_SGIX = 0x8413
+
+# SGIX_fragment_lighting_future_use: 0x8414-0x842B
+
+###############################################################################
+
+# Extension #103 - skipped
+# Extension #104 - skipped
+# Extension #105 - skipped
+# Extension #106 - skipped
+# Extension #107 - skipped
+# Extension #108 - skipped
+# Extension #109 - skipped
+
+###############################################################################
+
+# Extension #110
+IBM_rasterpos_clip enum:
+ RASTER_POSITION_UNCLIPPED_IBM = 0x19262
+
+###############################################################################
+
+# Extension #111
+HP_texture_lighting enum:
+ TEXTURE_LIGHTING_MODE_HP = 0x8167
+ TEXTURE_POST_SPECULAR_HP = 0x8168
+ TEXTURE_PRE_SPECULAR_HP = 0x8169
+
+###############################################################################
+
+# Extension #112
+EXT_draw_range_elements enum:
+ MAX_ELEMENTS_VERTICES_EXT = 0x80E8
+ MAX_ELEMENTS_INDICES_EXT = 0x80E9
+
+###############################################################################
+
+# Extension #113
+WIN_phong_shading enum:
+ PHONG_WIN = 0x80EA
+ PHONG_HINT_WIN = 0x80EB
+
+###############################################################################
+
+# Extension #114
+WIN_specular_fog enum:
+ FOG_SPECULAR_TEXTURE_WIN = 0x80EC
+
+###############################################################################
+
+# Extension #115 - skipped
+# Extension #116 - skipped
+
+###############################################################################
+
+# Extension #117
+EXT_light_texture enum:
+ FRAGMENT_MATERIAL_EXT = 0x8349
+ FRAGMENT_NORMAL_EXT = 0x834A
+ FRAGMENT_COLOR_EXT = 0x834C
+ ATTENUATION_EXT = 0x834D
+ SHADOW_ATTENUATION_EXT = 0x834E
+ TEXTURE_APPLICATION_MODE_EXT = 0x834F # 1 I
+ TEXTURE_LIGHT_EXT = 0x8350 # 1 I
+ TEXTURE_MATERIAL_FACE_EXT = 0x8351 # 1 I
+ TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352 # 1 I
+ use EXT_fog_coord FRAGMENT_DEPTH_EXT
+
+###############################################################################
+
+# Extension #118 - skipped
+
+###############################################################################
+
+# Extension #119
+SGIX_blend_alpha_minmax enum:
+ ALPHA_MIN_SGIX = 0x8320
+ ALPHA_MAX_SGIX = 0x8321
+
+###############################################################################
+
+# Extension #120 - skipped
+# Extension #121 - skipped
+# Extension #122 - skipped
+# Extension #123 - skipped
+# Extension #124 - skipped
+# Extension #125 - skipped
+
+###############################################################################
+
+# Extension #126
+SGIX_impact_pixel_texture enum:
+ PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184
+ PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185
+ PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186
+ PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187
+ PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188
+ PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189
+ PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A
+
+###############################################################################
+
+# Extension #127 - skipped
+# Extension #128 - skipped
+
+###############################################################################
+
+# Extension #129
+EXT_bgra enum:
+ BGR_EXT = 0x80E0
+ BGRA_EXT = 0x80E1
+
+###############################################################################
+
+# Extension #130 - skipped
+# Extension #131 - skipped
+
+###############################################################################
+
+# Extension #132
+SGIX_async enum:
+ ASYNC_MARKER_SGIX = 0x8329
+
+###############################################################################
+
+# Extension #133
+SGIX_async_pixel enum:
+ ASYNC_TEX_IMAGE_SGIX = 0x835C
+ ASYNC_DRAW_PIXELS_SGIX = 0x835D
+ ASYNC_READ_PIXELS_SGIX = 0x835E
+ MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F
+ MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360
+ MAX_ASYNC_READ_PIXELS_SGIX = 0x8361
+
+###############################################################################
+
+# Extension #134
+SGIX_async_histogram enum:
+ ASYNC_HISTOGRAM_SGIX = 0x832C
+ MAX_ASYNC_HISTOGRAM_SGIX = 0x832D
+
+###############################################################################
+
+# Intel has not implemented this; enums never assigned
+# Extension #135
+INTEL_texture_scissor enum:
+# TEXTURE_SCISSOR_INTEL = 0x????
+# TEXTURE_SCISSOR_INTEL = 0x????
+# TEXTURE_SCISSOR_FUNC_INTEL = 0x????
+# TEXTURE_SCISSOR_S_INTEL = 0x????
+# TEXTURE_SCISSOR_T_INTEL = 0x????
+# TEXTURE_SCISSOR_R_INTEL = 0x????
+
+###############################################################################
+
+# Extension #136
+INTEL_parallel_arrays enum:
+ PARALLEL_ARRAYS_INTEL = 0x83F4
+ VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5
+ NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6
+ COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7
+ TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8
+
+###############################################################################
+
+# Extension #137
+HP_occlusion_test enum:
+ OCCLUSION_TEST_HP = 0x8165
+ OCCLUSION_TEST_RESULT_HP = 0x8166
+
+###############################################################################
+
+# Extension #138
+EXT_pixel_transform enum:
+ PIXEL_TRANSFORM_2D_EXT = 0x8330
+ PIXEL_MAG_FILTER_EXT = 0x8331
+ PIXEL_MIN_FILTER_EXT = 0x8332
+ PIXEL_CUBIC_WEIGHT_EXT = 0x8333
+ CUBIC_EXT = 0x8334
+ AVERAGE_EXT = 0x8335
+ PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336
+ MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337
+ PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338
+
+###############################################################################
+
+# Unknown enum values
+# Extension #139
+EXT_pixel_transform_color_table enum:
+
+# PIXEL_TRANSFORM_COLOR_TABLE_EXT
+# PROXY_PIXEL_TRANSFORM_COLOR_TABLE_EXT
+
+###############################################################################
+
+# Extension #140 - skipped
+
+###############################################################################
+
+# Extension #141
+EXT_shared_texture_palette enum:
+ SHARED_TEXTURE_PALETTE_EXT = 0x81FB
+
+###############################################################################
+
+# Extension #142 - GLX_SGIS_blended_overlay
+
+###############################################################################
+
+# Extension #143 - SGIS_shared_multisample
+# MULTISAMPLE_SUB_RECT_POSITION_SGIS =
+# MULTISAMPLE_SUB_RECT_DIMS_SGIS =
+
+###############################################################################
+
+# Extension #144
+EXT_separate_specular_color enum:
+ LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8
+ SINGLE_COLOR_EXT = 0x81F9
+ SEPARATE_SPECULAR_COLOR_EXT = 0x81FA
+
+###############################################################################
+
+# Extension #145
+EXT_secondary_color enum:
+ COLOR_SUM_EXT = 0x8458 # 1 I
+ CURRENT_SECONDARY_COLOR_EXT = 0x8459 # 3 F
+ SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A # 1 I
+ SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B # 1 I
+ SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C # 1 I
+ SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D
+ SECONDARY_COLOR_ARRAY_EXT = 0x845E # 1 I
+
+###############################################################################
+
+# Dead extension - EXT_texture_env_combine was finished instead
+# Extension #146
+#EXT_texture_env enum:
+
+###############################################################################
+
+# Extension #147
+EXT_texture_perturb_normal enum:
+ PERTURB_EXT = 0x85AE
+ TEXTURE_NORMAL_EXT = 0x85AF
+
+###############################################################################
+
+# No new tokens
+# Extension #148
+# Diamond ships an otherwise identical IBM_multi_draw_arrays extension;
+# Dan Brokenshire says this is deprecated and should not be advertised.
+EXT_multi_draw_arrays enum:
+
+###############################################################################
+
+# Extension #149
+EXT_fog_coord enum:
+ FOG_COORDINATE_SOURCE_EXT = 0x8450 # 1 I
+ FOG_COORDINATE_EXT = 0x8451
+ FRAGMENT_DEPTH_EXT = 0x8452
+ CURRENT_FOG_COORDINATE_EXT = 0x8453 # 1 F
+ FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454 # 1 I
+ FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455 # 1 I
+ FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456
+ FOG_COORDINATE_ARRAY_EXT = 0x8457 # 1 I
+
+###############################################################################
+
+# Extension #150 - skipped
+# Extension #151 - skipped
+# Extension #152 - skipped
+# Extension #153 - skipped
+# Extension #154 - skipped
+
+###############################################################################
+
+# Extension #155
+REND_screen_coordinates enum:
+ SCREEN_COORDINATES_REND = 0x8490
+ INVERTED_SCREEN_W_REND = 0x8491
+
+###############################################################################
+
+# Extension #156
+EXT_coordinate_frame enum:
+ TANGENT_ARRAY_EXT = 0x8439
+ BINORMAL_ARRAY_EXT = 0x843A
+ CURRENT_TANGENT_EXT = 0x843B
+ CURRENT_BINORMAL_EXT = 0x843C
+ TANGENT_ARRAY_TYPE_EXT = 0x843E
+ TANGENT_ARRAY_STRIDE_EXT = 0x843F
+ BINORMAL_ARRAY_TYPE_EXT = 0x8440
+ BINORMAL_ARRAY_STRIDE_EXT = 0x8441
+ TANGENT_ARRAY_POINTER_EXT = 0x8442
+ BINORMAL_ARRAY_POINTER_EXT = 0x8443
+ MAP1_TANGENT_EXT = 0x8444
+ MAP2_TANGENT_EXT = 0x8445
+ MAP1_BINORMAL_EXT = 0x8446
+ MAP2_BINORMAL_EXT = 0x8447
+
+###############################################################################
+
+# Extension #157 - skipped
+
+###############################################################################
+
+# Extension #158
+EXT_texture_env_combine enum:
+ COMBINE_EXT = 0x8570
+ COMBINE_RGB_EXT = 0x8571
+ COMBINE_ALPHA_EXT = 0x8572
+ RGB_SCALE_EXT = 0x8573
+ ADD_SIGNED_EXT = 0x8574
+ INTERPOLATE_EXT = 0x8575
+ CONSTANT_EXT = 0x8576
+ PRIMARY_COLOR_EXT = 0x8577
+ PREVIOUS_EXT = 0x8578
+ SOURCE0_RGB_EXT = 0x8580
+ SOURCE1_RGB_EXT = 0x8581
+ SOURCE2_RGB_EXT = 0x8582
+ SOURCE0_ALPHA_EXT = 0x8588
+ SOURCE1_ALPHA_EXT = 0x8589
+ SOURCE2_ALPHA_EXT = 0x858A
+ OPERAND0_RGB_EXT = 0x8590
+ OPERAND1_RGB_EXT = 0x8591
+ OPERAND2_RGB_EXT = 0x8592
+ OPERAND0_ALPHA_EXT = 0x8598
+ OPERAND1_ALPHA_EXT = 0x8599
+ OPERAND2_ALPHA_EXT = 0x859A
+
+###############################################################################
+
+# Extension #159
+APPLE_specular_vector enum:
+ LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0
+
+###############################################################################
+
+# Extension #160
+APPLE_transform_hint enum:
+ TRANSFORM_HINT_APPLE = 0x85B1
+
+###############################################################################
+
+# Extension #161
+SGIX_fog_scale enum:
+ FOG_SCALE_SGIX = 0x81FC
+ FOG_SCALE_VALUE_SGIX = 0x81FD
+
+###############################################################################
+
+# Extension #162 - skipped
+
+###############################################################################
+
+# Extension #163
+SUNX_constant_data enum:
+ UNPACK_CONSTANT_DATA_SUNX = 0x81D5
+ TEXTURE_CONSTANT_DATA_SUNX = 0x81D6
+
+###############################################################################
+
+# Extension #164
+SUN_global_alpha enum:
+ GLOBAL_ALPHA_SUN = 0x81D9
+ GLOBAL_ALPHA_FACTOR_SUN = 0x81DA
+
+###############################################################################
+
+# Extension #165
+SUN_triangle_list enum:
+ RESTART_SUN = 0x0001
+ REPLACE_MIDDLE_SUN = 0x0002
+ REPLACE_OLDEST_SUN = 0x0003
+ TRIANGLE_LIST_SUN = 0x81D7
+ REPLACEMENT_CODE_SUN = 0x81D8
+ REPLACEMENT_CODE_ARRAY_SUN = 0x85C0
+ REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1
+ REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2
+ REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3
+ R1UI_V3F_SUN = 0x85C4
+ R1UI_C4UB_V3F_SUN = 0x85C5
+ R1UI_C3F_V3F_SUN = 0x85C6
+ R1UI_N3F_V3F_SUN = 0x85C7
+ R1UI_C4F_N3F_V3F_SUN = 0x85C8
+ R1UI_T2F_V3F_SUN = 0x85C9
+ R1UI_T2F_N3F_V3F_SUN = 0x85CA
+ R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB
+
+###############################################################################
+
+# No new tokens
+# Extension #166
+SUN_vertex enum:
+
+###############################################################################
+
+# Extension #167 - WGL_EXT_display_color_table
+# Extension #168 - WGL_EXT_extensions_string
+# Extension #169 - WGL_EXT_make_current_read
+# Extension #170 - WGL_EXT_pixel_format
+# Extension #171 - WGL_EXT_pbuffer
+# Extension #172 - WGL_EXT_swap_control
+
+###############################################################################
+
+# Extension #173
+EXT_blend_func_separate enum:
+ BLEND_DST_RGB_EXT = 0x80C8
+ BLEND_SRC_RGB_EXT = 0x80C9
+ BLEND_DST_ALPHA_EXT = 0x80CA
+ BLEND_SRC_ALPHA_EXT = 0x80CB
+
+###############################################################################
+
+# Extension #174
+INGR_color_clamp enum:
+ RED_MIN_CLAMP_INGR = 0x8560
+ GREEN_MIN_CLAMP_INGR = 0x8561
+ BLUE_MIN_CLAMP_INGR = 0x8562
+ ALPHA_MIN_CLAMP_INGR = 0x8563
+ RED_MAX_CLAMP_INGR = 0x8564
+ GREEN_MAX_CLAMP_INGR = 0x8565
+ BLUE_MAX_CLAMP_INGR = 0x8566
+ ALPHA_MAX_CLAMP_INGR = 0x8567
+
+###############################################################################
+
+# Extension #175
+INGR_interlace_read enum:
+ INTERLACE_READ_INGR = 0x8568
+
+###############################################################################
+
+# Extension #176
+EXT_stencil_wrap enum:
+ INCR_WRAP_EXT = 0x8507
+ DECR_WRAP_EXT = 0x8508
+
+###############################################################################
+
+# Extension #177 - skipped
+
+###############################################################################
+
+# Extension #178
+EXT_422_pixels enum:
+ 422_EXT = 0x80CC
+ 422_REV_EXT = 0x80CD
+ 422_AVERAGE_EXT = 0x80CE
+ 422_REV_AVERAGE_EXT = 0x80CF
+
+###############################################################################
+
+# Extension #179
+NV_texgen_reflection enum:
+ NORMAL_MAP_NV = 0x8511
+ REFLECTION_MAP_NV = 0x8512
+
+###############################################################################
+
+# Extension #180 - skipped
+# Extension #181 - skipped
+
+###############################################################################
+
+# Is this shipping? No extension number assigned.
+# Extension #?
+EXT_texture_cube_map enum:
+ NORMAL_MAP_EXT = 0x8511
+ REFLECTION_MAP_EXT = 0x8512
+ TEXTURE_CUBE_MAP_EXT = 0x8513
+ TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514
+ TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515
+ TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516
+ TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517
+ TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518
+ TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519
+ TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A
+ PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B
+ MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C
+
+###############################################################################
+
+# Extension #182
+SUN_convolution_border_modes enum:
+ WRAP_BORDER_SUN = 0x81D4
+
+###############################################################################
+
+# Extension #183 - GLX_SUN_transparent_index
+
+###############################################################################
+
+# Extension #184 - skipped
+
+###############################################################################
+
+# No new tokens
+# Extension #185
+EXT_texture_env_add enum:
+
+###############################################################################
+
+# Extension #186
+EXT_texture_lod_bias enum:
+ MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD
+ TEXTURE_FILTER_CONTROL_EXT = 0x8500
+ TEXTURE_LOD_BIAS_EXT = 0x8501
+
+###############################################################################
+
+# Extension #187
+EXT_texture_filter_anisotropic enum:
+ TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE
+ MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF
+
+###############################################################################
+
+# Extension #188
+EXT_vertex_weighting enum:
+ MODELVIEW0_STACK_DEPTH_EXT = GL_MODELVIEW_STACK_DEPTH
+ MODELVIEW1_STACK_DEPTH_EXT = 0x8502
+ MODELVIEW0_MATRIX_EXT = GL_MODELVIEW_MATRIX
+ MODELVIEW1_MATRIX_EXT = 0x8506
+ VERTEX_WEIGHTING_EXT = 0x8509
+ MODELVIEW0_EXT = GL_MODELVIEW
+ MODELVIEW1_EXT = 0x850A
+ CURRENT_VERTEX_WEIGHT_EXT = 0x850B
+ VERTEX_WEIGHT_ARRAY_EXT = 0x850C
+ VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D
+ VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E
+ VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F
+ VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510
+
+###############################################################################
+
+# Extension #189
+NV_light_max_exponent enum:
+ MAX_SHININESS_NV = 0x8504
+ MAX_SPOT_EXPONENT_NV = 0x8505
+
+###############################################################################
+
+# Extension #190
+NV_vertex_array_range enum:
+ VERTEX_ARRAY_RANGE_NV = 0x851D
+ VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E
+ VERTEX_ARRAY_RANGE_VALID_NV = 0x851F
+ MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520
+ VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521
+
+###############################################################################
+
+# Extension #191
+NV_register_combiners enum:
+ REGISTER_COMBINERS_NV = 0x8522
+ VARIABLE_A_NV = 0x8523
+ VARIABLE_B_NV = 0x8524
+ VARIABLE_C_NV = 0x8525
+ VARIABLE_D_NV = 0x8526
+ VARIABLE_E_NV = 0x8527
+ VARIABLE_F_NV = 0x8528
+ VARIABLE_G_NV = 0x8529
+ CONSTANT_COLOR0_NV = 0x852A
+ CONSTANT_COLOR1_NV = 0x852B
+ PRIMARY_COLOR_NV = 0x852C
+ SECONDARY_COLOR_NV = 0x852D
+ SPARE0_NV = 0x852E
+ SPARE1_NV = 0x852F
+ DISCARD_NV = 0x8530
+ E_TIMES_F_NV = 0x8531
+ SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532
+ UNSIGNED_IDENTITY_NV = 0x8536
+ UNSIGNED_INVERT_NV = 0x8537
+ EXPAND_NORMAL_NV = 0x8538
+ EXPAND_NEGATE_NV = 0x8539
+ HALF_BIAS_NORMAL_NV = 0x853A
+ HALF_BIAS_NEGATE_NV = 0x853B
+ SIGNED_IDENTITY_NV = 0x853C
+ SIGNED_NEGATE_NV = 0x853D
+ SCALE_BY_TWO_NV = 0x853E
+ SCALE_BY_FOUR_NV = 0x853F
+ SCALE_BY_ONE_HALF_NV = 0x8540
+ BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541
+ COMBINER_INPUT_NV = 0x8542
+ COMBINER_MAPPING_NV = 0x8543
+ COMBINER_COMPONENT_USAGE_NV = 0x8544
+ COMBINER_AB_DOT_PRODUCT_NV = 0x8545
+ COMBINER_CD_DOT_PRODUCT_NV = 0x8546
+ COMBINER_MUX_SUM_NV = 0x8547
+ COMBINER_SCALE_NV = 0x8548
+ COMBINER_BIAS_NV = 0x8549
+ COMBINER_AB_OUTPUT_NV = 0x854A
+ COMBINER_CD_OUTPUT_NV = 0x854B
+ COMBINER_SUM_OUTPUT_NV = 0x854C
+ MAX_GENERAL_COMBINERS_NV = 0x854D
+ NUM_GENERAL_COMBINERS_NV = 0x854E
+ COLOR_SUM_CLAMP_NV = 0x854F
+ COMBINER0_NV = 0x8550
+ COMBINER1_NV = 0x8551
+ COMBINER2_NV = 0x8552
+ COMBINER3_NV = 0x8553
+ COMBINER4_NV = 0x8554
+ COMBINER5_NV = 0x8555
+ COMBINER6_NV = 0x8556
+ COMBINER7_NV = 0x8557
+ use ARB_multitexture TEXTURE0_ARB
+ use ARB_multitexture TEXTURE1_ARB
+ use BlendingFactorDest ZERO
+ use DrawBufferMode NONE
+ use GetPName FOG
+
+###############################################################################
+
+# Extension #192
+NV_fog_distance enum:
+ FOG_DISTANCE_MODE_NV = 0x855A
+ EYE_RADIAL_NV = 0x855B
+ EYE_PLANE_ABSOLUTE_NV = 0x855C
+ use TextureGenParameter EYE_PLANE
+
+###############################################################################
+
+# Extension #193
+NV_texgen_emboss enum:
+ EMBOSS_LIGHT_NV = 0x855D
+ EMBOSS_CONSTANT_NV = 0x855E
+ EMBOSS_MAP_NV = 0x855F
+
+###############################################################################
+
+# No new tokens
+# Extension #194
+NV_blend_square enum:
+
+###############################################################################
+
+# Extension #195
+NV_texture_env_combine4 enum:
+ COMBINE4_NV = 0x8503
+ SOURCE3_RGB_NV = 0x8583
+ SOURCE3_ALPHA_NV = 0x858B
+ OPERAND3_RGB_NV = 0x8593
+ OPERAND3_ALPHA_NV = 0x859B
+
+###############################################################################
+
+# No new tokens
+# Extension #196
+MESA_resize_buffers enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #197
+MESA_window_pos enum:
+
+###############################################################################
+
+# Extension #198
+EXT_texture_compression_s3tc enum:
+ COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0
+ COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1
+ COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2
+ COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3
+
+###############################################################################
+
+# Extension #199
+IBM_cull_vertex enum:
+ CULL_VERTEX_IBM = 103050
+
+###############################################################################
+
+# No new tokens
+# Extension #200
+IBM_multimode_draw_arrays enum:
+
+###############################################################################
+
+# Extension #201
+IBM_vertex_array_lists enum:
+ VERTEX_ARRAY_LIST_IBM = 103070
+ NORMAL_ARRAY_LIST_IBM = 103071
+ COLOR_ARRAY_LIST_IBM = 103072
+ INDEX_ARRAY_LIST_IBM = 103073
+ TEXTURE_COORD_ARRAY_LIST_IBM = 103074
+ EDGE_FLAG_ARRAY_LIST_IBM = 103075
+ FOG_COORDINATE_ARRAY_LIST_IBM = 103076
+ SECONDARY_COLOR_ARRAY_LIST_IBM = 103077
+ VERTEX_ARRAY_LIST_STRIDE_IBM = 103080
+ NORMAL_ARRAY_LIST_STRIDE_IBM = 103081
+ COLOR_ARRAY_LIST_STRIDE_IBM = 103082
+ INDEX_ARRAY_LIST_STRIDE_IBM = 103083
+ TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084
+ EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085
+ FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086
+ SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087
+
+###############################################################################
+
+# Extension #202
+SGIX_subsample enum:
+ PACK_SUBSAMPLE_RATE_SGIX = 0x85A0
+ UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1
+ PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2
+ PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3
+ PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4
+
+###############################################################################
+
+# Extension #203
+SGIX_ycrcb_subsample enum:
+ PACK_SUBSAMPLE_RATE_SGIX = 0x85A0
+ UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1
+ PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2
+ PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3
+ PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4
+
+###############################################################################
+
+# Extension #204
+SGIX_ycrcba enum:
+ YCRCB_SGIX = 0x8318
+ YCRCBA_SGIX = 0x8319
+
+###############################################################################
+
+# Extension #205
+SGI_depth_pass_instrument enum:
+ DEPTH_PASS_INSTRUMENT_SGIX = 0x8310
+ DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311
+ DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312
+
+###############################################################################
+
+# Extension #206
+3DFX_texture_compression_FXT1 enum:
+ COMPRESSED_RGB_FXT1_3DFX = 0x86B0
+ COMPRESSED_RGBA_FXT1_3DFX = 0x86B1
+
+###############################################################################
+
+# Extension #207
+3DFX_multisample enum:
+ MULTISAMPLE_3DFX = 0x86B2
+ SAMPLE_BUFFERS_3DFX = 0x86B3
+ SAMPLES_3DFX = 0x86B4
+ MULTISAMPLE_BIT_3DFX = 0x20000000
+
+###############################################################################
+
+# No new tokens
+# Extension #208
+3DFX_tbuffer enum:
+
+###############################################################################
+
+# Extension #209
+EXT_multisample enum:
+ MULTISAMPLE_EXT = 0x809D
+ SAMPLE_ALPHA_TO_MASK_EXT = 0x809E
+ SAMPLE_ALPHA_TO_ONE_EXT = 0x809F
+ SAMPLE_MASK_EXT = 0x80A0
+ 1PASS_EXT = 0x80A1
+ 2PASS_0_EXT = 0x80A2
+ 2PASS_1_EXT = 0x80A3
+ 4PASS_0_EXT = 0x80A4
+ 4PASS_1_EXT = 0x80A5
+ 4PASS_2_EXT = 0x80A6
+ 4PASS_3_EXT = 0x80A7
+ SAMPLE_BUFFERS_EXT = 0x80A8 # 1 I
+ SAMPLES_EXT = 0x80A9 # 1 I
+ SAMPLE_MASK_VALUE_EXT = 0x80AA # 1 F
+ SAMPLE_MASK_INVERT_EXT = 0x80AB # 1 I
+ SAMPLE_PATTERN_EXT = 0x80AC # 1 I
+ MULTISAMPLE_BIT_EXT = 0x20000000
+
+###############################################################################
+
+# Extension #210
+SGIX_vertex_preclip enum:
+ VERTEX_PRECLIP_SGIX = 0x83EE
+ VERTEX_PRECLIP_HINT_SGIX = 0x83EF
+
+###############################################################################
+
+# Extension #211
+SGIX_convolution_accuracy enum:
+ CONVOLUTION_HINT_SGIX = 0x8316 # 1 I
+
+###############################################################################
+
+# Extension #212
+SGIX_resample enum:
+ PACK_RESAMPLE_SGIX = 0x842C
+ UNPACK_RESAMPLE_SGIX = 0x842D
+ RESAMPLE_REPLICATE_SGIX = 0x842E
+ RESAMPLE_ZERO_FILL_SGIX = 0x842F
+ RESAMPLE_DECIMATE_SGIX = 0x8430
+
+###############################################################################
+
+# Extension #213
+SGIS_point_line_texgen enum:
+ EYE_DISTANCE_TO_POINT_SGIS = 0x81F0
+ OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1
+ EYE_DISTANCE_TO_LINE_SGIS = 0x81F2
+ OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3
+ EYE_POINT_SGIS = 0x81F4
+ OBJECT_POINT_SGIS = 0x81F5
+ EYE_LINE_SGIS = 0x81F6
+ OBJECT_LINE_SGIS = 0x81F7
+
+###############################################################################
+
+# Extension #214
+SGIS_texture_color_mask enum:
+ TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF
+
+###############################################################################
+
+# Extension #220
+# Promoted to ARB_texture_env_dot3, enum values changed
+EXT_texture_env_dot3 enum:
+ DOT3_RGB_EXT = 0x8740
+ DOT3_RGBA_EXT = 0x8741
+
+###############################################################################
+
+# Extension #221
+ATI_texture_mirror_once enum:
+ MIRROR_CLAMP_ATI = 0x8742
+ MIRROR_CLAMP_TO_EDGE_ATI = 0x8743
+
+###############################################################################
+
+# Extension #222
+NV_fence enum:
+ ALL_COMPLETED_NV = 0x84F2
+ FENCE_STATUS_NV = 0x84F3
+ FENCE_CONDITION_NV = 0x84F4
+
+###############################################################################
+
+# Extension #224
+IBM_texture_mirrored_repeat enum:
+ MIRRORED_REPEAT_IBM = 0x8370
+
+###############################################################################
+
+# Extension #225
+NV_evaluators enum:
+ EVAL_2D_NV = 0x86C0
+ EVAL_TRIANGULAR_2D_NV = 0x86C1
+ MAP_TESSELLATION_NV = 0x86C2
+ MAP_ATTRIB_U_ORDER_NV = 0x86C3
+ MAP_ATTRIB_V_ORDER_NV = 0x86C4
+ EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5
+ EVAL_VERTEX_ATTRIB0_NV = 0x86C6
+ EVAL_VERTEX_ATTRIB1_NV = 0x86C7
+ EVAL_VERTEX_ATTRIB2_NV = 0x86C8
+ EVAL_VERTEX_ATTRIB3_NV = 0x86C9
+ EVAL_VERTEX_ATTRIB4_NV = 0x86CA
+ EVAL_VERTEX_ATTRIB5_NV = 0x86CB
+ EVAL_VERTEX_ATTRIB6_NV = 0x86CC
+ EVAL_VERTEX_ATTRIB7_NV = 0x86CD
+ EVAL_VERTEX_ATTRIB8_NV = 0x86CE
+ EVAL_VERTEX_ATTRIB9_NV = 0x86CF
+ EVAL_VERTEX_ATTRIB10_NV = 0x86D0
+ EVAL_VERTEX_ATTRIB11_NV = 0x86D1
+ EVAL_VERTEX_ATTRIB12_NV = 0x86D2
+ EVAL_VERTEX_ATTRIB13_NV = 0x86D3
+ EVAL_VERTEX_ATTRIB14_NV = 0x86D4
+ EVAL_VERTEX_ATTRIB15_NV = 0x86D5
+ MAX_MAP_TESSELLATION_NV = 0x86D6
+ MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7
+
+###############################################################################
+
+# Extension #226
+NV_packed_depth_stencil enum:
+ DEPTH_STENCIL_NV = 0x84F9
+ UNSIGNED_INT_24_8_NV = 0x84FA
+
+###############################################################################
+
+# Extension #227
+NV_register_combiners2 enum:
+ PER_STAGE_CONSTANTS_NV = 0x8535
+
+###############################################################################
+
+# No new tokens
+# Extension #228
+NV_texture_compression_vtc enum:
+
+###############################################################################
+
+# Extension #229
+NV_texture_rectangle enum:
+ TEXTURE_RECTANGLE_NV = 0x84F5
+ TEXTURE_BINDING_RECTANGLE_NV = 0x84F6
+ PROXY_TEXTURE_RECTANGLE_NV = 0x84F7
+ MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8
+
+###############################################################################
+
+# Extension #230
+NV_texture_shader enum:
+ OFFSET_TEXTURE_RECTANGLE_NV = 0x864C
+ OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D
+ DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E
+ RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9
+ UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA
+ UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB
+ DSDT_MAG_INTENSITY_NV = 0x86DC
+ SHADER_CONSISTENT_NV = 0x86DD
+ TEXTURE_SHADER_NV = 0x86DE
+ SHADER_OPERATION_NV = 0x86DF
+ CULL_MODES_NV = 0x86E0
+ OFFSET_TEXTURE_MATRIX_NV = 0x86E1
+ OFFSET_TEXTURE_SCALE_NV = 0x86E2
+ OFFSET_TEXTURE_BIAS_NV = 0x86E3
+ OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV
+ OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV
+ OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV
+ PREVIOUS_TEXTURE_INPUT_NV = 0x86E4
+ CONST_EYE_NV = 0x86E5
+ PASS_THROUGH_NV = 0x86E6
+ CULL_FRAGMENT_NV = 0x86E7
+ OFFSET_TEXTURE_2D_NV = 0x86E8
+ DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9
+ DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA
+ DOT_PRODUCT_NV = 0x86EC
+ DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED
+ DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE
+ DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0
+ DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1
+ DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2
+ DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3
+ HILO_NV = 0x86F4
+ DSDT_NV = 0x86F5
+ DSDT_MAG_NV = 0x86F6
+ DSDT_MAG_VIB_NV = 0x86F7
+ HILO16_NV = 0x86F8
+ SIGNED_HILO_NV = 0x86F9
+ SIGNED_HILO16_NV = 0x86FA
+ SIGNED_RGBA_NV = 0x86FB
+ SIGNED_RGBA8_NV = 0x86FC
+ SIGNED_RGB_NV = 0x86FE
+ SIGNED_RGB8_NV = 0x86FF
+ SIGNED_LUMINANCE_NV = 0x8701
+ SIGNED_LUMINANCE8_NV = 0x8702
+ SIGNED_LUMINANCE_ALPHA_NV = 0x8703
+ SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704
+ SIGNED_ALPHA_NV = 0x8705
+ SIGNED_ALPHA8_NV = 0x8706
+ SIGNED_INTENSITY_NV = 0x8707
+ SIGNED_INTENSITY8_NV = 0x8708
+ DSDT8_NV = 0x8709
+ DSDT8_MAG8_NV = 0x870A
+ DSDT8_MAG8_INTENSITY8_NV = 0x870B
+ SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C
+ SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D
+ HI_SCALE_NV = 0x870E
+ LO_SCALE_NV = 0x870F
+ DS_SCALE_NV = 0x8710
+ DT_SCALE_NV = 0x8711
+ MAGNITUDE_SCALE_NV = 0x8712
+ VIBRANCE_SCALE_NV = 0x8713
+ HI_BIAS_NV = 0x8714
+ LO_BIAS_NV = 0x8715
+ DS_BIAS_NV = 0x8716
+ DT_BIAS_NV = 0x8717
+ MAGNITUDE_BIAS_NV = 0x8718
+ VIBRANCE_BIAS_NV = 0x8719
+ TEXTURE_BORDER_VALUES_NV = 0x871A
+ TEXTURE_HI_SIZE_NV = 0x871B
+ TEXTURE_LO_SIZE_NV = 0x871C
+ TEXTURE_DS_SIZE_NV = 0x871D
+ TEXTURE_DT_SIZE_NV = 0x871E
+ TEXTURE_MAG_SIZE_NV = 0x871F
+
+###############################################################################
+
+# Extension #231
+NV_texture_shader2 enum:
+ DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF
+
+###############################################################################
+
+# Extension #232
+NV_vertex_array_range2 enum:
+ VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533
+
+###############################################################################
+
+# Extension #233
+NV_vertex_program enum:
+ VERTEX_PROGRAM_NV = 0x8620
+ VERTEX_STATE_PROGRAM_NV = 0x8621
+ ATTRIB_ARRAY_SIZE_NV = 0x8623
+ ATTRIB_ARRAY_STRIDE_NV = 0x8624
+ ATTRIB_ARRAY_TYPE_NV = 0x8625
+ CURRENT_ATTRIB_NV = 0x8626
+ PROGRAM_LENGTH_NV = 0x8627
+ PROGRAM_STRING_NV = 0x8628
+ MODELVIEW_PROJECTION_NV = 0x8629
+ IDENTITY_NV = 0x862A
+ INVERSE_NV = 0x862B
+ TRANSPOSE_NV = 0x862C
+ INVERSE_TRANSPOSE_NV = 0x862D
+ MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E
+ MAX_TRACK_MATRICES_NV = 0x862F
+ MATRIX0_NV = 0x8630
+ MATRIX1_NV = 0x8631
+ MATRIX2_NV = 0x8632
+ MATRIX3_NV = 0x8633
+ MATRIX4_NV = 0x8634
+ MATRIX5_NV = 0x8635
+ MATRIX6_NV = 0x8636
+ MATRIX7_NV = 0x8637
+##################
+#
+# Reserved:
+#
+# MATRIX8_NV = 0x8638
+# MATRIX9_NV = 0x8639
+# MATRIX10_NV = 0x863A
+# MATRIX11_NV = 0x863B
+# MATRIX12_NV = 0x863C
+# MATRIX13_NV = 0x863D
+# MATRIX14_NV = 0x863E
+# MATRIX15_NV = 0x863F
+#
+###################
+ CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640
+ CURRENT_MATRIX_NV = 0x8641
+ VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642
+ VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643
+ PROGRAM_PARAMETER_NV = 0x8644
+ ATTRIB_ARRAY_POINTER_NV = 0x8645
+ PROGRAM_TARGET_NV = 0x8646
+ PROGRAM_RESIDENT_NV = 0x8647
+ TRACK_MATRIX_NV = 0x8648
+ TRACK_MATRIX_TRANSFORM_NV = 0x8649
+ VERTEX_PROGRAM_BINDING_NV = 0x864A
+ PROGRAM_ERROR_POSITION_NV = 0x864B
+ VERTEX_ATTRIB_ARRAY0_NV = 0x8650
+ VERTEX_ATTRIB_ARRAY1_NV = 0x8651
+ VERTEX_ATTRIB_ARRAY2_NV = 0x8652
+ VERTEX_ATTRIB_ARRAY3_NV = 0x8653
+ VERTEX_ATTRIB_ARRAY4_NV = 0x8654
+ VERTEX_ATTRIB_ARRAY5_NV = 0x8655
+ VERTEX_ATTRIB_ARRAY6_NV = 0x8656
+ VERTEX_ATTRIB_ARRAY7_NV = 0x8657
+ VERTEX_ATTRIB_ARRAY8_NV = 0x8658
+ VERTEX_ATTRIB_ARRAY9_NV = 0x8659
+ VERTEX_ATTRIB_ARRAY10_NV = 0x865A
+ VERTEX_ATTRIB_ARRAY11_NV = 0x865B
+ VERTEX_ATTRIB_ARRAY12_NV = 0x865C
+ VERTEX_ATTRIB_ARRAY13_NV = 0x865D
+ VERTEX_ATTRIB_ARRAY14_NV = 0x865E
+ VERTEX_ATTRIB_ARRAY15_NV = 0x865F
+ MAP1_VERTEX_ATTRIB0_4_NV = 0x8660
+ MAP1_VERTEX_ATTRIB1_4_NV = 0x8661
+ MAP1_VERTEX_ATTRIB2_4_NV = 0x8662
+ MAP1_VERTEX_ATTRIB3_4_NV = 0x8663
+ MAP1_VERTEX_ATTRIB4_4_NV = 0x8664
+ MAP1_VERTEX_ATTRIB5_4_NV = 0x8665
+ MAP1_VERTEX_ATTRIB6_4_NV = 0x8666
+ MAP1_VERTEX_ATTRIB7_4_NV = 0x8667
+ MAP1_VERTEX_ATTRIB8_4_NV = 0x8668
+ MAP1_VERTEX_ATTRIB9_4_NV = 0x8669
+ MAP1_VERTEX_ATTRIB10_4_NV = 0x866A
+ MAP1_VERTEX_ATTRIB11_4_NV = 0x866B
+ MAP1_VERTEX_ATTRIB12_4_NV = 0x866C
+ MAP1_VERTEX_ATTRIB13_4_NV = 0x866D
+ MAP1_VERTEX_ATTRIB14_4_NV = 0x866E
+ MAP1_VERTEX_ATTRIB15_4_NV = 0x866F
+ MAP2_VERTEX_ATTRIB0_4_NV = 0x8670
+ MAP2_VERTEX_ATTRIB1_4_NV = 0x8671
+ MAP2_VERTEX_ATTRIB2_4_NV = 0x8672
+ MAP2_VERTEX_ATTRIB3_4_NV = 0x8673
+ MAP2_VERTEX_ATTRIB4_4_NV = 0x8674
+ MAP2_VERTEX_ATTRIB5_4_NV = 0x8675
+ MAP2_VERTEX_ATTRIB6_4_NV = 0x8676
+ MAP2_VERTEX_ATTRIB7_4_NV = 0x8677
+ MAP2_VERTEX_ATTRIB8_4_NV = 0x8678
+ MAP2_VERTEX_ATTRIB9_4_NV = 0x8679
+ MAP2_VERTEX_ATTRIB10_4_NV = 0x867A
+ MAP2_VERTEX_ATTRIB11_4_NV = 0x867B
+ MAP2_VERTEX_ATTRIB12_4_NV = 0x867C
+ MAP2_VERTEX_ATTRIB13_4_NV = 0x867D
+ MAP2_VERTEX_ATTRIB14_4_NV = 0x867E
+ MAP2_VERTEX_ATTRIB15_4_NV = 0x867F
+
+###############################################################################
+
+# Extension #235
+SGIX_texture_coordinate_clamp enum:
+ TEXTURE_MAX_CLAMP_S_SGIX = 0x8369
+ TEXTURE_MAX_CLAMP_T_SGIX = 0x836A
+ TEXTURE_MAX_CLAMP_R_SGIX = 0x836B
+
+###############################################################################
+
+# Extension #236
+SGIX_scalebias_hint enum:
+ SCALEBIAS_HINT_SGIX = 0x8322
+
+###############################################################################
+
+# Extension #237 - GLX_OML_swap_method
+# Extension #238 - GLX_OML_sync_control
+
+###############################################################################
+
+# Extension #239
+OML_interlace enum:
+ INTERLACE_OML = 0x8980
+ INTERLACE_READ_OML = 0x8981
+
+###############################################################################
+
+# Extension #240
+OML_subsample enum:
+ FORMAT_SUBSAMPLE_24_24_OML = 0x8982
+ FORMAT_SUBSAMPLE_244_244_OML = 0x8983
+
+###############################################################################
+
+# Extension #241
+OML_resample enum:
+ PACK_RESAMPLE_OML = 0x8984
+ UNPACK_RESAMPLE_OML = 0x8985
+ RESAMPLE_REPLICATE_OML = 0x8986
+ RESAMPLE_ZERO_FILL_OML = 0x8987
+ RESAMPLE_AVERAGE_OML = 0x8988
+ RESAMPLE_DECIMATE_OML = 0x8989
+
+###############################################################################
+
+# Extension #242 - WGL_OML_sync_control
+
+###############################################################################
+
+# Extension #243
+NV_copy_depth_to_color enum:
+ DEPTH_STENCIL_TO_RGBA_NV = 0x886E
+ DEPTH_STENCIL_TO_BGRA_NV = 0x886F
+
+###############################################################################
+
+# Extension #244
+ATI_envmap_bumpmap enum:
+ BUMP_ROT_MATRIX_ATI = 0x8775
+ BUMP_ROT_MATRIX_SIZE_ATI = 0x8776
+ BUMP_NUM_TEX_UNITS_ATI = 0x8777
+ BUMP_TEX_UNITS_ATI = 0x8778
+ DUDV_ATI = 0x8779
+ DU8DV8_ATI = 0x877A
+ BUMP_ENVMAP_ATI = 0x877B
+ BUMP_TARGET_ATI = 0x877C
+
+###############################################################################
+
+# Extension #245
+ATI_fragment_shader enum:
+ FRAGMENT_SHADER_ATI = 0x8920
+ REG_0_ATI = 0x8921
+ REG_1_ATI = 0x8922
+ REG_2_ATI = 0x8923
+ REG_3_ATI = 0x8924
+ REG_4_ATI = 0x8925
+ REG_5_ATI = 0x8926
+ REG_6_ATI = 0x8927
+ REG_7_ATI = 0x8928
+ REG_8_ATI = 0x8929
+ REG_9_ATI = 0x892A
+ REG_10_ATI = 0x892B
+ REG_11_ATI = 0x892C
+ REG_12_ATI = 0x892D
+ REG_13_ATI = 0x892E
+ REG_14_ATI = 0x892F
+ REG_15_ATI = 0x8930
+ REG_16_ATI = 0x8931
+ REG_17_ATI = 0x8932
+ REG_18_ATI = 0x8933
+ REG_19_ATI = 0x8934
+ REG_20_ATI = 0x8935
+ REG_21_ATI = 0x8936
+ REG_22_ATI = 0x8937
+ REG_23_ATI = 0x8938
+ REG_24_ATI = 0x8939
+ REG_25_ATI = 0x893A
+ REG_26_ATI = 0x893B
+ REG_27_ATI = 0x893C
+ REG_28_ATI = 0x893D
+ REG_29_ATI = 0x893E
+ REG_30_ATI = 0x893F
+ REG_31_ATI = 0x8940
+ CON_0_ATI = 0x8941
+ CON_1_ATI = 0x8942
+ CON_2_ATI = 0x8943
+ CON_3_ATI = 0x8944
+ CON_4_ATI = 0x8945
+ CON_5_ATI = 0x8946
+ CON_6_ATI = 0x8947
+ CON_7_ATI = 0x8948
+ CON_8_ATI = 0x8949
+ CON_9_ATI = 0x894A
+ CON_10_ATI = 0x894B
+ CON_11_ATI = 0x894C
+ CON_12_ATI = 0x894D
+ CON_13_ATI = 0x894E
+ CON_14_ATI = 0x894F
+ CON_15_ATI = 0x8950
+ CON_16_ATI = 0x8951
+ CON_17_ATI = 0x8952
+ CON_18_ATI = 0x8953
+ CON_19_ATI = 0x8954
+ CON_20_ATI = 0x8955
+ CON_21_ATI = 0x8956
+ CON_22_ATI = 0x8957
+ CON_23_ATI = 0x8958
+ CON_24_ATI = 0x8959
+ CON_25_ATI = 0x895A
+ CON_26_ATI = 0x895B
+ CON_27_ATI = 0x895C
+ CON_28_ATI = 0x895D
+ CON_29_ATI = 0x895E
+ CON_30_ATI = 0x895F
+ CON_31_ATI = 0x8960
+ MOV_ATI = 0x8961
+ ADD_ATI = 0x8963
+ MUL_ATI = 0x8964
+ SUB_ATI = 0x8965
+ DOT3_ATI = 0x8966
+ DOT4_ATI = 0x8967
+ MAD_ATI = 0x8968
+ LERP_ATI = 0x8969
+ CND_ATI = 0x896A
+ CND0_ATI = 0x896B
+ DOT2_ADD_ATI = 0x896C
+ SECONDARY_INTERPOLATOR_ATI = 0x896D
+ NUM_FRAGMENT_REGISTERS_ATI = 0x896E
+ NUM_FRAGMENT_CONSTANTS_ATI = 0x896F
+ NUM_PASSES_ATI = 0x8970
+ NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971
+ NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972
+ NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973
+ NUM_LOOPBACK_COMPONENTS_ATI = 0x8974
+ COLOR_ALPHA_PAIRING_ATI = 0x8975
+ SWIZZLE_STR_ATI = 0x8976
+ SWIZZLE_STQ_ATI = 0x8977
+ SWIZZLE_STR_DR_ATI = 0x8978
+ SWIZZLE_STQ_DQ_ATI = 0x8979
+ SWIZZLE_STRQ_ATI = 0x897A
+ SWIZZLE_STRQ_DQ_ATI = 0x897B
+ RED_BIT_ATI = 0x00000001
+ GREEN_BIT_ATI = 0x00000002
+ BLUE_BIT_ATI = 0x00000004
+ 2X_BIT_ATI = 0x00000001
+ 4X_BIT_ATI = 0x00000002
+ 8X_BIT_ATI = 0x00000004
+ HALF_BIT_ATI = 0x00000008
+ QUARTER_BIT_ATI = 0x00000010
+ EIGHTH_BIT_ATI = 0x00000020
+ SATURATE_BIT_ATI = 0x00000040
+ 2X_BIT_ATI = 0x00000001
+ COMP_BIT_ATI = 0x00000002
+ NEGATE_BIT_ATI = 0x00000004
+ BIAS_BIT_ATI = 0x00000008
+
+###############################################################################
+
+# Extension #246
+ATI_pn_triangles enum:
+ PN_TRIANGLES_ATI = 0x87F0
+ MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1
+ PN_TRIANGLES_POINT_MODE_ATI = 0x87F2
+ PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3
+ PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4
+ PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5
+ PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6
+ PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7
+ PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8
+
+###############################################################################
+
+# Extension #247
+ATI_vertex_array_object enum:
+ STATIC_ATI = 0x8760
+ DYNAMIC_ATI = 0x8761
+ PRESERVE_ATI = 0x8762
+ DISCARD_ATI = 0x8763
+ OBJECT_BUFFER_SIZE_ATI = 0x8764
+ OBJECT_BUFFER_USAGE_ATI = 0x8765
+ ARRAY_OBJECT_BUFFER_ATI = 0x8766
+ ARRAY_OBJECT_OFFSET_ATI = 0x8767
+
+###############################################################################
+
+# Extension #248
+EXT_vertex_shader enum:
+ VERTEX_SHADER_EXT = 0x8780
+ VERTEX_SHADER_BINDING_EXT = 0x8781
+ OP_INDEX_EXT = 0x8782
+ OP_NEGATE_EXT = 0x8783
+ OP_DOT3_EXT = 0x8784
+ OP_DOT4_EXT = 0x8785
+ OP_MUL_EXT = 0x8786
+ OP_ADD_EXT = 0x8787
+ OP_MADD_EXT = 0x8788
+ OP_FRAC_EXT = 0x8789
+ OP_MAX_EXT = 0x878A
+ OP_MIN_EXT = 0x878B
+ OP_SET_GE_EXT = 0x878C
+ OP_SET_LT_EXT = 0x878D
+ OP_CLAMP_EXT = 0x878E
+ OP_FLOOR_EXT = 0x878F
+ OP_ROUND_EXT = 0x8790
+ OP_EXP_BASE_2_EXT = 0x8791
+ OP_LOG_BASE_2_EXT = 0x8792
+ OP_POWER_EXT = 0x8793
+ OP_RECIP_EXT = 0x8794
+ OP_RECIP_SQRT_EXT = 0x8795
+ OP_SUB_EXT = 0x8796
+ OP_CROSS_PRODUCT_EXT = 0x8797
+ OP_MULTIPLY_MATRIX_EXT = 0x8798
+ OP_MOV_EXT = 0x8799
+ OUTPUT_VERTEX_EXT = 0x879A
+ OUTPUT_COLOR0_EXT = 0x879B
+ OUTPUT_COLOR1_EXT = 0x879C
+ OUTPUT_TEXTURE_COORD0_EXT = 0x879D
+ OUTPUT_TEXTURE_COORD1_EXT = 0x879E
+ OUTPUT_TEXTURE_COORD2_EXT = 0x879F
+ OUTPUT_TEXTURE_COORD3_EXT = 0x87A0
+ OUTPUT_TEXTURE_COORD4_EXT = 0x87A1
+ OUTPUT_TEXTURE_COORD5_EXT = 0x87A2
+ OUTPUT_TEXTURE_COORD6_EXT = 0x87A3
+ OUTPUT_TEXTURE_COORD7_EXT = 0x87A4
+ OUTPUT_TEXTURE_COORD8_EXT = 0x87A5
+ OUTPUT_TEXTURE_COORD9_EXT = 0x87A6
+ OUTPUT_TEXTURE_COORD10_EXT = 0x87A7
+ OUTPUT_TEXTURE_COORD11_EXT = 0x87A8
+ OUTPUT_TEXTURE_COORD12_EXT = 0x87A9
+ OUTPUT_TEXTURE_COORD13_EXT = 0x87AA
+ OUTPUT_TEXTURE_COORD14_EXT = 0x87AB
+ OUTPUT_TEXTURE_COORD15_EXT = 0x87AC
+ OUTPUT_TEXTURE_COORD16_EXT = 0x87AD
+ OUTPUT_TEXTURE_COORD17_EXT = 0x87AE
+ OUTPUT_TEXTURE_COORD18_EXT = 0x87AF
+ OUTPUT_TEXTURE_COORD19_EXT = 0x87B0
+ OUTPUT_TEXTURE_COORD20_EXT = 0x87B1
+ OUTPUT_TEXTURE_COORD21_EXT = 0x87B2
+ OUTPUT_TEXTURE_COORD22_EXT = 0x87B3
+ OUTPUT_TEXTURE_COORD23_EXT = 0x87B4
+ OUTPUT_TEXTURE_COORD24_EXT = 0x87B5
+ OUTPUT_TEXTURE_COORD25_EXT = 0x87B6
+ OUTPUT_TEXTURE_COORD26_EXT = 0x87B7
+ OUTPUT_TEXTURE_COORD27_EXT = 0x87B8
+ OUTPUT_TEXTURE_COORD28_EXT = 0x87B9
+ OUTPUT_TEXTURE_COORD29_EXT = 0x87BA
+ OUTPUT_TEXTURE_COORD30_EXT = 0x87BB
+ OUTPUT_TEXTURE_COORD31_EXT = 0x87BC
+ OUTPUT_FOG_EXT = 0x87BD
+ SCALAR_EXT = 0x87BE
+ VECTOR_EXT = 0x87BF
+ MATRIX_EXT = 0x87C0
+ VARIANT_EXT = 0x87C1
+ INVARIANT_EXT = 0x87C2
+ LOCAL_CONSTANT_EXT = 0x87C3
+ LOCAL_EXT = 0x87C4
+ MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5
+ MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6
+ MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7
+ MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8
+ MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9
+ MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA
+ MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB
+ MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC
+ MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD
+ MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE
+ VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF
+ VERTEX_SHADER_VARIANTS_EXT = 0x87D0
+ VERTEX_SHADER_INVARIANTS_EXT = 0x87D1
+ VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2
+ VERTEX_SHADER_LOCALS_EXT = 0x87D3
+ VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4
+ X_EXT = 0x87D5
+ Y_EXT = 0x87D6
+ Z_EXT = 0x87D7
+ W_EXT = 0x87D8
+ NEGATIVE_X_EXT = 0x87D9
+ NEGATIVE_Y_EXT = 0x87DA
+ NEGATIVE_Z_EXT = 0x87DB
+ NEGATIVE_W_EXT = 0x87DC
+ ZERO_EXT = 0x87DD
+ ONE_EXT = 0x87DE
+ NEGATIVE_ONE_EXT = 0x87DF
+ NORMALIZED_RANGE_EXT = 0x87E0
+ FULL_RANGE_EXT = 0x87E1
+ CURRENT_VERTEX_EXT = 0x87E2
+ MVP_MATRIX_EXT = 0x87E3
+ VARIANT_VALUE_EXT = 0x87E4
+ VARIANT_DATATYPE_EXT = 0x87E5
+ VARIANT_ARRAY_STRIDE_EXT = 0x87E6
+ VARIANT_ARRAY_TYPE_EXT = 0x87E7
+ VARIANT_ARRAY_EXT = 0x87E8
+ VARIANT_ARRAY_POINTER_EXT = 0x87E9
+ INVARIANT_VALUE_EXT = 0x87EA
+ INVARIANT_DATATYPE_EXT = 0x87EB
+ LOCAL_CONSTANT_VALUE_EXT = 0x87EC
+ LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED
+
+###############################################################################
+
+# Extension #249
+ATI_vertex_streams enum:
+ MAX_VERTEX_STREAMS_ATI = 0x876B
+ VERTEX_STREAM0_ATI = 0x876C
+ VERTEX_STREAM1_ATI = 0x876D
+ VERTEX_STREAM2_ATI = 0x876E
+ VERTEX_STREAM3_ATI = 0x876F
+ VERTEX_STREAM4_ATI = 0x8770
+ VERTEX_STREAM5_ATI = 0x8771
+ VERTEX_STREAM6_ATI = 0x8772
+ VERTEX_STREAM7_ATI = 0x8773
+ VERTEX_SOURCE_ATI = 0x8774
+
+###############################################################################
+
+# Extension #250 - WGL_I3D_digital_video_control
+# Extension #251 - WGL_I3D_gamma
+# Extension #252 - WGL_I3D_genlock
+# Extension #253 - WGL_I3D_image_buffer
+# Extension #254 - WGL_I3D_swap_frame_lock
+# Extension #255 - WGL_I3D_swap_frame_usage
+
+###############################################################################
+
+# Extension #256
+ATI_element_array enum:
+ ELEMENT_ARRAY_ATI = 0x8768
+ ELEMENT_ARRAY_TYPE_ATI = 0x8769
+ ELEMENT_ARRAY_POINTER_ATI = 0x876A
+
+###############################################################################
+
+# Extension #257
+SUN_mesh_array enum:
+ QUAD_MESH_SUN = 0x8614
+ TRIANGLE_MESH_SUN = 0x8615
+
+###############################################################################
+
+# Extension #258
+SUN_slice_accum enum:
+ SLICE_ACCUM_SUN = 0x85CC
+
+###############################################################################
+
+# Extension #259
+NV_multisample_filter_hint enum:
+ MULTISAMPLE_FILTER_HINT_NV = 0x8534
+
+###############################################################################
+
+# Extension #260
+NV_depth_clamp enum:
+ DEPTH_CLAMP_NV = 0x864F
+
+###############################################################################
+
+# Extension #261
+NV_occlusion_query enum:
+ PIXEL_COUNTER_BITS_NV = 0x8864
+ CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865
+ PIXEL_COUNT_NV = 0x8866
+ PIXEL_COUNT_AVAILABLE_NV = 0x8867
+
+###############################################################################
+
+# Extension #262
+NV_point_sprite enum:
+ POINT_SPRITE_NV = 0x8861
+ COORD_REPLACE_NV = 0x8862
+ POINT_SPRITE_R_MODE_NV = 0x8863
+
+###############################################################################
+
+# Extension #263 - WGL_NV_render_depth_texture
+# Extension #264 - WGL_NV_render_texture_rectangle
+
+###############################################################################
+
+# Extension #265
+NV_texture_shader3 enum:
+ OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850
+ OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851
+ OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852
+ OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853
+ OFFSET_HILO_TEXTURE_2D_NV = 0x8854
+ OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855
+ OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856
+ OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857
+ DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858
+ DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859
+ DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A
+ DOT_PRODUCT_PASS_THROUGH_NV = 0x885B
+ DOT_PRODUCT_TEXTURE_1D_NV = 0x885C
+ DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D
+ HILO8_NV = 0x885E
+ SIGNED_HILO8_NV = 0x885F
+ FORCE_BLUE_TO_ONE_NV = 0x8860
+
+###############################################################################
+
+# No new tokens
+# Extension #266
+NV_vertex_program1_1 enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #267
+EXT_shadow_funcs enum:
+
+###############################################################################
+
+# Extension #268
+EXT_stencil_two_side enum:
+ STENCIL_TEST_TWO_SIDE_EXT = 0x8910
+ ACTIVE_STENCIL_FACE_EXT = 0x8911
+
+###############################################################################
+
+# Extension #269
+ATI_text_fragment_shader enum:
+ TEXT_FRAGMENT_SHADER_ATI = 0x8200
+
+###############################################################################
+
+# Extension #270
+APPLE_client_storage enum:
+ UNPACK_CLIENT_STORAGE_APPLE = 0x85B2
+
+###############################################################################
+
+# Extension #271
+# @@@ (extends ATI_element_array, I think???)
+APPLE_element_array enum:
+ ELEMENT_ARRAY_APPLE = 0x8768
+ ELEMENT_ARRAY_TYPE_APPLE = 0x8769
+ ELEMENT_ARRAY_POINTER_APPLE = 0x876A
+
+###############################################################################
+
+# Extension #272
+APPLE_fence enum:
+ DRAW_PIXELS_APPLE = 0x8A0A
+ FENCE_APPLE = 0x8A0B
+
+###############################################################################
+
+# Extension #273
+APPLE_vertex_array_object enum:
+ VERTEX_ARRAY_BINDING_APPLE = 0x85B5
+
+###############################################################################
+
+# Extension #274
+# @@@ How does this interact with NV_vertex_array_range?
+APPLE_vertex_array_range enum:
+ VERTEX_ARRAY_RANGE_APPLE = 0x851D
+ VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E
+ VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F
+ VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521
+ STORAGE_CACHED_APPLE = 0x85BE
+ STORAGE_SHARED_APPLE = 0x85BF
+
+###############################################################################
+
+# Extension #275
+APPLE_ycbcr_422 enum:
+ YCBCR_422_APPLE = 0x85B9
+ UNSIGNED_SHORT_8_8_APPLE = 0x85BA
+ UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB
+
+###############################################################################
+
+# Extension #276
+S3_s3tc enum:
+ RGB_S3TC = 0x83A0
+ RGB4_S3TC = 0x83A1
+ RGBA_S3TC = 0x83A2
+ RGBA4_S3TC = 0x83A3
+
+###############################################################################
+
+# Extension #277
+ATI_draw_buffers enum:
+ MAX_DRAW_BUFFERS_ATI = 0x8824
+ DRAW_BUFFER0_ATI = 0x8825
+ DRAW_BUFFER1_ATI = 0x8826
+ DRAW_BUFFER2_ATI = 0x8827
+ DRAW_BUFFER3_ATI = 0x8828
+ DRAW_BUFFER4_ATI = 0x8829
+ DRAW_BUFFER5_ATI = 0x882A
+ DRAW_BUFFER6_ATI = 0x882B
+ DRAW_BUFFER7_ATI = 0x882C
+ DRAW_BUFFER8_ATI = 0x882D
+ DRAW_BUFFER9_ATI = 0x882E
+ DRAW_BUFFER10_ATI = 0x882F
+ DRAW_BUFFER11_ATI = 0x8830
+ DRAW_BUFFER12_ATI = 0x8831
+ DRAW_BUFFER13_ATI = 0x8832
+ DRAW_BUFFER14_ATI = 0x8833
+ DRAW_BUFFER15_ATI = 0x8834
+
+###############################################################################
+
+# Extension #278
+# This is really a WGL extension, but if defined there are
+# some associated GL enumerants.
+ATI_pixel_format_float enum:
+ TYPE_RGBA_FLOAT_ATI = 0x8820
+ COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835
+
+###############################################################################
+
+# Extension #279
+ATI_texture_env_combine3 enum:
+ MODULATE_ADD_ATI = 0x8744
+ MODULATE_SIGNED_ADD_ATI = 0x8745
+ MODULATE_SUBTRACT_ATI = 0x8746
+
+###############################################################################
+
+# Extension #280
+ATI_texture_float enum:
+ RGBA_FLOAT32_ATI = 0x8814
+ RGB_FLOAT32_ATI = 0x8815
+ ALPHA_FLOAT32_ATI = 0x8816
+ INTENSITY_FLOAT32_ATI = 0x8817
+ LUMINANCE_FLOAT32_ATI = 0x8818
+ LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819
+ RGBA_FLOAT16_ATI = 0x881A
+ RGB_FLOAT16_ATI = 0x881B
+ ALPHA_FLOAT16_ATI = 0x881C
+ INTENSITY_FLOAT16_ATI = 0x881D
+ LUMINANCE_FLOAT16_ATI = 0x881E
+ LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F
+
+###############################################################################
+
+# Extension #281 (also WGL_NV_float_buffer)
+NV_float_buffer enum:
+ FLOAT_R_NV = 0x8880
+ FLOAT_RG_NV = 0x8881
+ FLOAT_RGB_NV = 0x8882
+ FLOAT_RGBA_NV = 0x8883
+ FLOAT_R16_NV = 0x8884
+ FLOAT_R32_NV = 0x8885
+ FLOAT_RG16_NV = 0x8886
+ FLOAT_RG32_NV = 0x8887
+ FLOAT_RGB16_NV = 0x8888
+ FLOAT_RGB32_NV = 0x8889
+ FLOAT_RGBA16_NV = 0x888A
+ FLOAT_RGBA32_NV = 0x888B
+ TEXTURE_FLOAT_COMPONENTS_NV = 0x888C
+ FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D
+ FLOAT_RGBA_MODE_NV = 0x888E
+
+###############################################################################
+
+# Extension #282
+NV_fragment_program enum:
+ MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868
+ FRAGMENT_PROGRAM_NV = 0x8870
+ MAX_TEXTURE_COORDS_NV = 0x8871
+ MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872
+ FRAGMENT_PROGRAM_BINDING_NV = 0x8873
+ PROGRAM_ERROR_STRING_NV = 0x8874
+
+###############################################################################
+
+# Extension #283
+NV_half_float enum:
+ HALF_FLOAT_NV = 0x140B
+
+###############################################################################
+
+# Extension #284
+NV_pixel_data_range enum:
+ WRITE_PIXEL_DATA_RANGE_NV = 0x8878
+ READ_PIXEL_DATA_RANGE_NV = 0x8879
+ WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A
+ READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B
+ WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C
+ READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D
+
+###############################################################################
+
+# Extension #285
+NV_primitive_restart enum:
+ PRIMITIVE_RESTART_NV = 0x8558
+ PRIMITIVE_RESTART_INDEX_NV = 0x8559
+
+###############################################################################
+
+# Extension #286
+NV_texture_expand_normal enum:
+ TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F
+
+###############################################################################
+
+# No new tokens
+# Extension #287
+NV_vertex_program2 enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #288
+ATI_map_object_buffer enum:
+
+###############################################################################
+
+# Extension #289
+ATI_separate_stencil enum:
+ STENCIL_BACK_FUNC_ATI = 0x8800
+ STENCIL_BACK_FAIL_ATI = 0x8801
+ STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802
+ STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803
+
+###############################################################################
+
+# No new tokens
+# Extension #290
+ATI_vertex_attrib_array_object enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #291 - OpenGL ES only, not in glext.h
+# OES_byte_coordinates enum:
+
+###############################################################################
+
+# Extension #292 - OpenGL ES only, not in glext.h
+# OES_fixed_point enum:
+# FIXED_OES = 0x140C
+
+###############################################################################
+
+# No new tokens
+# Extension #293 - OpenGL ES only, not in glext.h
+# OES_single_precision enum:
+
+###############################################################################
+
+# Extension #294 - OpenGL ES only, not in glext.h
+# OES_compressed_paletted_texture enum:
+# PALETTE4_RGB8_OES = 0x8B90
+# PALETTE4_RGBA8_OES = 0x8B91
+# PALETTE4_R5_G6_B5_OES = 0x8B92
+# PALETTE4_RGBA4_OES = 0x8B93
+# PALETTE4_RGB5_A1_OES = 0x8B94
+# PALETTE8_RGB8_OES = 0x8B95
+# PALETTE8_RGBA8_OES = 0x8B96
+# PALETTE8_R5_G6_B5_OES = 0x8B97
+# PALETTE8_RGBA4_OES = 0x8B98
+# PALETTE8_RGB5_A1_OES = 0x8B99
+
+###############################################################################
+
+# Extension #295 - This is an OpenGL ES extension, but also implemented in Mesa
+OES_read_format enum:
+ IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A
+ IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B
+
+###############################################################################
+
+# No new tokens
+# Extension #296 - OpenGL ES only, not in glext.h
+# OES_query_matrix enum:
+
+###############################################################################
+
+# Extension #297
+EXT_depth_bounds_test enum:
+ DEPTH_BOUNDS_TEST_EXT = 0x8890
+ DEPTH_BOUNDS_EXT = 0x8891
+
+###############################################################################
+
+# Extension #298
+EXT_texture_mirror_clamp enum:
+ MIRROR_CLAMP_EXT = 0x8742
+ MIRROR_CLAMP_TO_EDGE_EXT = 0x8743
+ MIRROR_CLAMP_TO_BORDER_EXT = 0x8912
+
+###############################################################################
+
+# Extension #299
+EXT_blend_equation_separate enum:
+ BLEND_EQUATION_RGB_EXT = GL_BLEND_EQUATION
+ BLEND_EQUATION_ALPHA_EXT = 0x883D
+
+###############################################################################
+
+# Extension #300
+MESA_pack_invert enum:
+ PACK_INVERT_MESA = 0x8758
+
+###############################################################################
+
+# Extension #301
+MESA_ycbcr_texture enum:
+ UNSIGNED_SHORT_8_8_MESA = 0x85BA
+ UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB
+ YCBCR_MESA = 0x8757
+
+###############################################################################
+
+# Extension #302
+EXT_pixel_buffer_object enum:
+ PIXEL_PACK_BUFFER_EXT = 0x88EB
+ PIXEL_UNPACK_BUFFER_EXT = 0x88EC
+ PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED
+ PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF
+
+###############################################################################
+
+# No new tokens
+# Extension #303
+NV_fragment_program_option enum:
+
+###############################################################################
+
+# Extension #304
+NV_fragment_program2 enum:
+ MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4
+ MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5
+ MAX_PROGRAM_IF_DEPTH_NV = 0x88F6
+ MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7
+ MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8
+
+###############################################################################
+
+# Extension #305
+NV_vertex_program2_option enum:
+ use NV_fragment_program2 MAX_PROGRAM_EXEC_INSTRUCTIONS_NV
+ use NV_fragment_program2 MAX_PROGRAM_CALL_DEPTH_NV
+
+###############################################################################
+
+# Extension #306
+NV_vertex_program3 enum:
+ use ARB_vertex_shader MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
+
+###############################################################################
+
+# Extension #307 - GLX_SGIX_hyperpipe
+# Extension #308 - GLX_MESA_agp_offset
+# Extension #309 - GL_EXT_texture_compression_dxt1 (OpenGL ES only, subset of _s3tc version)
+
+###############################################################################
+
+# Extension #310
+EXT_framebuffer_object enum:
+ INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506
+ MAX_RENDERBUFFER_SIZE_EXT = 0x84E8
+ FRAMEBUFFER_BINDING_EXT = 0x8CA6
+ RENDERBUFFER_BINDING_EXT = 0x8CA7
+ FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0
+ FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4
+ FRAMEBUFFER_COMPLETE_EXT = 0x8CD5
+ FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6
+ FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7
+## Removed 2005/09/26 in revision #117 of the extension:
+## FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = 0x8CD8
+ FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9
+ FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA
+ FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB
+ FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC
+ FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD
+## Removed 2005/05/31 in revision #113 of the extension:
+## FRAMEBUFFER_STATUS_ERROR_EXT = 0x8CDE
+ MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF
+ COLOR_ATTACHMENT0_EXT = 0x8CE0
+ COLOR_ATTACHMENT1_EXT = 0x8CE1
+ COLOR_ATTACHMENT2_EXT = 0x8CE2
+ COLOR_ATTACHMENT3_EXT = 0x8CE3
+ COLOR_ATTACHMENT4_EXT = 0x8CE4
+ COLOR_ATTACHMENT5_EXT = 0x8CE5
+ COLOR_ATTACHMENT6_EXT = 0x8CE6
+ COLOR_ATTACHMENT7_EXT = 0x8CE7
+ COLOR_ATTACHMENT8_EXT = 0x8CE8
+ COLOR_ATTACHMENT9_EXT = 0x8CE9
+ COLOR_ATTACHMENT10_EXT = 0x8CEA
+ COLOR_ATTACHMENT11_EXT = 0x8CEB
+ COLOR_ATTACHMENT12_EXT = 0x8CEC
+ COLOR_ATTACHMENT13_EXT = 0x8CED
+ COLOR_ATTACHMENT14_EXT = 0x8CEE
+ COLOR_ATTACHMENT15_EXT = 0x8CEF
+ DEPTH_ATTACHMENT_EXT = 0x8D00
+ STENCIL_ATTACHMENT_EXT = 0x8D20
+ FRAMEBUFFER_EXT = 0x8D40
+ RENDERBUFFER_EXT = 0x8D41
+ RENDERBUFFER_WIDTH_EXT = 0x8D42
+ RENDERBUFFER_HEIGHT_EXT = 0x8D43
+ RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44
+# removed STENCIL_INDEX_EXT = 0x8D45 in rev. #114 of the spec
+ STENCIL_INDEX1_EXT = 0x8D46
+ STENCIL_INDEX4_EXT = 0x8D47
+ STENCIL_INDEX8_EXT = 0x8D48
+ STENCIL_INDEX16_EXT = 0x8D49
+ RENDERBUFFER_RED_SIZE_EXT = 0x8D50
+ RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51
+ RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52
+ RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53
+ RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54
+ RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55
+
+###############################################################################
+
+# No new tokens
+# Extension #311
+GREMEDY_string_marker enum:
+
+###############################################################################
+
+# Extension #312
+EXT_packed_depth_stencil enum:
+ DEPTH_STENCIL_EXT = 0x84F9
+ UNSIGNED_INT_24_8_EXT = 0x84FA
+ DEPTH24_STENCIL8_EXT = 0x88F0
+ TEXTURE_STENCIL_SIZE_EXT = 0x88F1
+
+###############################################################################
+
+# Extension #313 - WGL_3DL_stereo_control
+
+###############################################################################
+
+# Extension #314
+EXT_stencil_clear_tag enum:
+ STENCIL_TAG_BITS_EXT = 0x88F2
+ STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3
+
+###############################################################################
+
+# Extension #315
+EXT_texture_sRGB enum:
+ SRGB_EXT = 0x8C40
+ SRGB8_EXT = 0x8C41
+ SRGB_ALPHA_EXT = 0x8C42
+ SRGB8_ALPHA8_EXT = 0x8C43
+ SLUMINANCE_ALPHA_EXT = 0x8C44
+ SLUMINANCE8_ALPHA8_EXT = 0x8C45
+ SLUMINANCE_EXT = 0x8C46
+ SLUMINANCE8_EXT = 0x8C47
+ COMPRESSED_SRGB_EXT = 0x8C48
+ COMPRESSED_SRGB_ALPHA_EXT = 0x8C49
+ COMPRESSED_SLUMINANCE_EXT = 0x8C4A
+ COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B
+ COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F
+
+###############################################################################
+
+# Extension #316
+EXT_framebuffer_blit enum:
+ READ_FRAMEBUFFER_EXT = 0x8CA8
+ DRAW_FRAMEBUFFER_EXT = 0x8CA9
+ READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT
+ DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CAA
+
+###############################################################################
+
+# Extension #317
+EXT_framebuffer_multisample enum:
+ RENDERBUFFER_SAMPLES_EXT = 0x8CAB
+ FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56
+ MAX_SAMPLES_EXT = 0x8D57
+
+###############################################################################
+
+# Extension #318
+MESAX_texture_stack enum:
+ TEXTURE_1D_STACK_MESAX = 0x8759
+ TEXTURE_2D_STACK_MESAX = 0x875A
+ PROXY_TEXTURE_1D_STACK_MESAX = 0x875B
+ PROXY_TEXTURE_2D_STACK_MESAX = 0x875C
+ TEXTURE_1D_STACK_BINDING_MESAX = 0x875D
+ TEXTURE_2D_STACK_BINDING_MESAX = 0x875E
+
+###############################################################################
+
+# Extension #319
+EXT_timer_query enum:
+ TIME_ELAPSED_EXT = 0x88BF
+
+###############################################################################
+
+# No new tokens
+# Extension #320
+EXT_gpu_program_parameters enum:
+
+###############################################################################
+
+# Extension #321
+APPLE_flush_buffer_range enum:
+ BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12
+ BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13
+
+###############################################################################
+
+# Extension #322
+NV_gpu_program4 enum:
+ MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904
+ MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905
+ PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906
+ PROGRAM_RESULT_COMPONENTS_NV = 0x8907
+ MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908
+ MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909
+ MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5
+ MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6
+
+###############################################################################
+
+# Extension #323
+NV_geometry_program4 enum:
+ LINES_ADJACENCY_EXT = 0x000A
+ LINE_STRIP_ADJACENCY_EXT = 0x000B
+ TRIANGLES_ADJACENCY_EXT = 0x000C
+ TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D
+ GEOMETRY_PROGRAM_NV = 0x8C26
+ MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27
+ MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28
+ GEOMETRY_VERTICES_OUT_EXT = 0x8DDA
+ GEOMETRY_INPUT_TYPE_EXT = 0x8DDB
+ GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC
+ MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29
+ FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7
+ FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8
+ FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4
+ PROGRAM_POINT_SIZE_EXT = 0x8642
+
+###############################################################################
+
+# Extension #324
+EXT_geometry_shader4 enum:
+ GEOMETRY_SHADER_EXT = 0x8DD9
+ use NV_geometry_program4 GEOMETRY_VERTICES_OUT_EXT
+ use NV_geometry_program4 GEOMETRY_INPUT_TYPE_EXT
+ use NV_geometry_program4 GEOMETRY_OUTPUT_TYPE_EXT
+ use NV_geometry_program4 MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT
+ MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD
+ MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE
+ MAX_VARYING_COMPONENTS_EXT = 0x8B4B
+ MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF
+ MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0
+ MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1
+ use NV_geometry_program4 LINES_ADJACENCY_EXT
+ use NV_geometry_program4 LINE_STRIP_ADJACENCY_EXT
+ use NV_geometry_program4 TRIANGLES_ADJACENCY_EXT
+ use NV_geometry_program4 TRIANGLE_STRIP_ADJACENCY_EXT
+ use NV_geometry_program4 FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT
+ use NV_geometry_program4 FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT
+ use NV_geometry_program4 FRAMEBUFFER_ATTACHMENT_LAYERED_EXT
+ use NV_geometry_program4 FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT
+ use NV_geometry_program4 PROGRAM_POINT_SIZE_EXT
+
+###############################################################################
+
+# Extension #325
+NV_vertex_program4 enum:
+ VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD
+
+###############################################################################
+
+# Extension #326
+EXT_gpu_shader4 enum:
+ SAMPLER_1D_ARRAY_EXT = 0x8DC0
+ SAMPLER_2D_ARRAY_EXT = 0x8DC1
+ SAMPLER_BUFFER_EXT = 0x8DC2
+ SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3
+ SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4
+ SAMPLER_CUBE_SHADOW_EXT = 0x8DC5
+ UNSIGNED_INT_VEC2_EXT = 0x8DC6
+ UNSIGNED_INT_VEC3_EXT = 0x8DC7
+ UNSIGNED_INT_VEC4_EXT = 0x8DC8
+ INT_SAMPLER_1D_EXT = 0x8DC9
+ INT_SAMPLER_2D_EXT = 0x8DCA
+ INT_SAMPLER_3D_EXT = 0x8DCB
+ INT_SAMPLER_CUBE_EXT = 0x8DCC
+ INT_SAMPLER_2D_RECT_EXT = 0x8DCD
+ INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE
+ INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF
+ INT_SAMPLER_BUFFER_EXT = 0x8DD0
+ UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1
+ UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2
+ UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3
+ UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4
+ UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5
+ UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6
+ UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7
+ UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8
+
+###############################################################################
+
+# No new tokens
+# Extension #327
+EXT_draw_instanced enum:
+
+###############################################################################
+
+# Extension #328
+EXT_packed_float enum:
+ R11F_G11F_B10F_EXT = 0x8C3A
+ UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B
+ RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C
+
+###############################################################################
+
+# Extension #329
+EXT_texture_array enum:
+ TEXTURE_1D_ARRAY_EXT = 0x8C18
+ PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19
+ TEXTURE_2D_ARRAY_EXT = 0x8C1A
+ PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B
+ TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C
+ TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D
+ MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF
+ COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E
+ use NV_geometry_program4 FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT
+
+###############################################################################
+
+# Extension #330
+EXT_texture_buffer_object enum:
+ TEXTURE_BUFFER_EXT = 0x8C2A
+ MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B
+ TEXTURE_BINDING_BUFFER_EXT = 0x8C2C
+ TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D
+ TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E
+
+###############################################################################
+
+# Extension #331
+EXT_texture_compression_latc enum:
+ COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70
+ COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71
+ COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72
+ COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73
+
+###############################################################################
+
+# Extension #332
+EXT_texture_compression_rgtc enum:
+ COMPRESSED_RED_RGTC1_EXT = 0x8DBB
+ COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC
+ COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD
+ COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE
+
+###############################################################################
+
+# Extension #333
+EXT_texture_shared_exponent enum:
+ RGB9_E5_EXT = 0x8C3D
+ UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E
+ TEXTURE_SHARED_SIZE_EXT = 0x8C3F
+
+###############################################################################
+
+# Extension #334
+NV_depth_buffer_float enum:
+ DEPTH_COMPONENT32F_NV = 0x8DAB
+ DEPTH32F_STENCIL8_NV = 0x8DAC
+ FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD
+ DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF
+
+###############################################################################
+
+# No new tokens
+# Extension #335
+NV_fragment_program4 enum:
+
+###############################################################################
+
+# Extension #336
+NV_framebuffer_multisample_coverage enum:
+ RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB
+ RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10
+ MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11
+ MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12
+
+###############################################################################
+
+# Extension #337
+# ??? Also WGL/GLX extensions ???
+EXT_framebuffer_sRGB enum:
+ FRAMEBUFFER_SRGB_EXT = 0x8DB9
+ FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA
+
+###############################################################################
+
+# No new tokens
+# Extension #338
+NV_geometry_shader4 enum:
+
+###############################################################################
+
+# Extension #339
+NV_parameter_buffer_object enum:
+ MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0
+ MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1
+ VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2
+ GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3
+ FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4
+
+###############################################################################
+
+# No new tokens
+# Extension #340
+EXT_draw_buffers2 enum:
+
+###############################################################################
+
+# Extension #341
+NV_transform_feedback enum:
+ BACK_PRIMARY_COLOR_NV = 0x8C77
+ BACK_SECONDARY_COLOR_NV = 0x8C78
+ TEXTURE_COORD_NV = 0x8C79
+ CLIP_DISTANCE_NV = 0x8C7A
+ VERTEX_ID_NV = 0x8C7B
+ PRIMITIVE_ID_NV = 0x8C7C
+ GENERIC_ATTRIB_NV = 0x8C7D
+ TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E
+ TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80
+ ACTIVE_VARYINGS_NV = 0x8C81
+ ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82
+ TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83
+ TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84
+ TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85
+ TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86
+ PRIMITIVES_GENERATED_NV = 0x8C87
+ TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88
+ RASTERIZER_DISCARD_NV = 0x8C89
+ MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV = 0x8C8A
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B
+ INTERLEAVED_ATTRIBS_NV = 0x8C8C
+ SEPARATE_ATTRIBS_NV = 0x8C8D
+ TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E
+ TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F
+
+###############################################################################
+
+# Extension #342
+EXT_bindable_uniform enum:
+ MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2
+ MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3
+ MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4
+ MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED
+ UNIFORM_BUFFER_EXT = 0x8DEE
+ UNIFORM_BUFFER_BINDING_EXT = 0x8DEF
+
+###############################################################################
+
+# Extension #343
+EXT_texture_integer enum:
+ RGBA32UI_EXT = 0x8D70
+ RGB32UI_EXT = 0x8D71
+ ALPHA32UI_EXT = 0x8D72
+ INTENSITY32UI_EXT = 0x8D73
+ LUMINANCE32UI_EXT = 0x8D74
+ LUMINANCE_ALPHA32UI_EXT = 0x8D75
+ RGBA16UI_EXT = 0x8D76
+ RGB16UI_EXT = 0x8D77
+ ALPHA16UI_EXT = 0x8D78
+ INTENSITY16UI_EXT = 0x8D79
+ LUMINANCE16UI_EXT = 0x8D7A
+ LUMINANCE_ALPHA16UI_EXT = 0x8D7B
+ RGBA8UI_EXT = 0x8D7C
+ RGB8UI_EXT = 0x8D7D
+ ALPHA8UI_EXT = 0x8D7E
+ INTENSITY8UI_EXT = 0x8D7F
+ LUMINANCE8UI_EXT = 0x8D80
+ LUMINANCE_ALPHA8UI_EXT = 0x8D81
+ RGBA32I_EXT = 0x8D82
+ RGB32I_EXT = 0x8D83
+ ALPHA32I_EXT = 0x8D84
+ INTENSITY32I_EXT = 0x8D85
+ LUMINANCE32I_EXT = 0x8D86
+ LUMINANCE_ALPHA32I_EXT = 0x8D87
+ RGBA16I_EXT = 0x8D88
+ RGB16I_EXT = 0x8D89
+ ALPHA16I_EXT = 0x8D8A
+ INTENSITY16I_EXT = 0x8D8B
+ LUMINANCE16I_EXT = 0x8D8C
+ LUMINANCE_ALPHA16I_EXT = 0x8D8D
+ RGBA8I_EXT = 0x8D8E
+ RGB8I_EXT = 0x8D8F
+ ALPHA8I_EXT = 0x8D90
+ INTENSITY8I_EXT = 0x8D91
+ LUMINANCE8I_EXT = 0x8D92
+ LUMINANCE_ALPHA8I_EXT = 0x8D93
+ RED_INTEGER_EXT = 0x8D94
+ GREEN_INTEGER_EXT = 0x8D95
+ BLUE_INTEGER_EXT = 0x8D96
+ ALPHA_INTEGER_EXT = 0x8D97
+ RGB_INTEGER_EXT = 0x8D98
+ RGBA_INTEGER_EXT = 0x8D99
+ BGR_INTEGER_EXT = 0x8D9A
+ BGRA_INTEGER_EXT = 0x8D9B
+ LUMINANCE_INTEGER_EXT = 0x8D9C
+ LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D
+ RGBA_INTEGER_MODE_EXT = 0x8D9E
+
+###############################################################################
+
+# Extension #344 - GLX_EXT_texture_from_pixmap
+
diff --git a/Source/Bind/Specifications/enumglu.spec b/Source/Bind/Specifications/enumglu.spec
new file mode 100644
index 00000000..e8624b8b
--- /dev/null
+++ b/Source/Bind/Specifications/enumglu.spec
@@ -0,0 +1,251 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2002 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+
+###############################################################################
+Extensions define:
+ EXT_object_space_tess = 1
+ EXT_nurbs_tessellator = 1
+
+###############################################################################
+
+Boolean enum:
+ FALSE = 0
+ TRUE = 1
+
+###############################################################################
+
+Version enum:
+ VERSION_1_1 = 1
+ VERSION_1_2 = 1
+ VERSION_1_3 = 1
+
+###############################################################################
+
+StringName enum:
+ VERSION = 100800
+ EXTENSIONS = 100801
+
+###############################################################################
+
+ErrorCode enum:
+ INVALID_ENUM = 100900
+ INVALID_VALUE = 100901
+ OUT_OF_MEMORY = 100902
+########INCOMPATIBLE_GL_VERSION = 100903
+ INVALID_OPERATION = 100904
+
+###############################################################################
+
+Filter4TypeSGIS enum:
+ LAGRANGIAN_SGI = 100300
+ MITCHELL_NETRAVALI_SGI = 100301
+
+###############################################################################
+
+NurbsDisplay enum:
+ use QuadricDrawStyle FILL
+ OUTLINE_POLYGON = 100240
+ OUTLINE_PATCH = 100241
+
+NurbsCallback enum:
+ NURBS_ERROR = 100103
+ ERROR = 100103
+
+ NURBS_BEGIN = 100164
+ NURBS_BEGIN_EXT = 100164
+ NURBS_VERTEX = 100165
+ NURBS_VERTEX_EXT = 100165
+ NURBS_NORMAL = 100166
+ NURBS_NORMAL_EXT = 100166
+ NURBS_COLOR = 100167
+ NURBS_COLOR_EXT = 100167
+ NURBS_TEXTURE_COORD = 100168
+ NURBS_TEXTURE_COORD_EXT = 100168
+ NURBS_END = 100169
+ NURBS_END_EXT = 100169
+
+ NURBS_BEGIN_DATA = 100170
+ NURBS_BEGIN_DATA_EXT = 100170
+ NURBS_VERTEX_DATA = 100171
+ NURBS_VERTEX_DATA_EXT = 100171
+ NURBS_NORMAL_DATA = 100172
+ NURBS_NORMAL_DATA_EXT = 100172
+ NURBS_COLOR_DATA = 100173
+ NURBS_COLOR_DATA_EXT = 100173
+ NURBS_TEXTURE_COORD_DATA = 100174
+ NURBS_TEXTURE_COORD_DATA_EXT = 100174
+ NURBS_END_DATA = 100175
+ NURBS_END_DATA_EXT = 100175
+
+NurbsError enum:
+ NURBS_ERROR1 = 100251
+ NURBS_ERROR2 = 100252
+ NURBS_ERROR3 = 100253
+ NURBS_ERROR4 = 100254
+ NURBS_ERROR5 = 100255
+ NURBS_ERROR6 = 100256
+ NURBS_ERROR7 = 100257
+ NURBS_ERROR8 = 100258
+ NURBS_ERROR9 = 100259
+ NURBS_ERROR10 = 100260
+ NURBS_ERROR11 = 100261
+ NURBS_ERROR12 = 100262
+ NURBS_ERROR13 = 100263
+ NURBS_ERROR14 = 100264
+ NURBS_ERROR15 = 100265
+ NURBS_ERROR16 = 100266
+ NURBS_ERROR17 = 100267
+ NURBS_ERROR18 = 100268
+ NURBS_ERROR19 = 100269
+ NURBS_ERROR20 = 100270
+ NURBS_ERROR21 = 100271
+ NURBS_ERROR22 = 100272
+ NURBS_ERROR23 = 100273
+ NURBS_ERROR24 = 100274
+ NURBS_ERROR25 = 100275
+ NURBS_ERROR26 = 100276
+ NURBS_ERROR27 = 100277
+ NURBS_ERROR28 = 100278
+ NURBS_ERROR29 = 100279
+ NURBS_ERROR30 = 100280
+ NURBS_ERROR31 = 100281
+ NURBS_ERROR32 = 100282
+ NURBS_ERROR33 = 100283
+ NURBS_ERROR34 = 100284
+ NURBS_ERROR35 = 100285
+ NURBS_ERROR36 = 100286
+ NURBS_ERROR37 = 100287
+
+NurbsProperty enum:
+ AUTO_LOAD_MATRIX = 100200
+ CULLING = 100201
+ SAMPLING_TOLERANCE = 100203
+ DISPLAY_MODE = 100204
+ PARAMETRIC_TOLERANCE = 100202
+ SAMPLING_METHOD = 100205
+ U_STEP = 100206
+ V_STEP = 100207
+
+ NURBS_MODE = 100160
+ NURBS_MODE_EXT = 100160
+ NURBS_TESSELLATOR = 100161
+ NURBS_TESSELLATOR_EXT = 100161
+ NURBS_RENDERER = 100162
+ NURBS_RENDERER_EXT = 100162
+
+NurbsSampling enum:
+ OBJECT_PARAMETRIC_ERROR = 100208
+ OBJECT_PARAMETRIC_ERROR_EXT = 100208
+ OBJECT_PATH_LENGTH = 100209
+ OBJECT_PATH_LENGTH_EXT = 100209
+
+ PATH_LENGTH = 100215
+ PARAMETRIC_ERROR = 100216
+ DOMAIN_DISTANCE = 100217
+
+NurbsTrim enum:
+ MAP1_TRIM_2 = 100210
+ MAP1_TRIM_3 = 100211
+
+###############################################################################
+
+QuadricDrawStyle enum:
+ POINT = 100010
+ LINE = 100011
+ FILL = 100012
+ SILHOUETTE = 100013
+
+QuadricCallback enum:
+ use NurbsCallback ERROR
+
+QuadricNormal enum:
+ SMOOTH = 100000
+ FLAT = 100001
+ NONE = 100002
+
+QuadricOrientation enum:
+ OUTSIDE = 100020
+ INSIDE = 100021
+
+###############################################################################
+
+TessCallback enum:
+ TESS_BEGIN = 100100
+ BEGIN = 100100
+ TESS_VERTEX = 100101
+ VERTEX = 100101
+ TESS_END = 100102
+ END = 100102
+ TESS_ERROR = 100103
+ ERROR = 100103
+ TESS_EDGE_FLAG = 100104
+ EDGE_FLAG = 100104
+ TESS_COMBINE = 100105
+ TESS_BEGIN_DATA = 100106
+ TESS_VERTEX_DATA = 100107
+ TESS_END_DATA = 100108
+ TESS_ERROR_DATA = 100109
+ TESS_EDGE_FLAG_DATA = 100110
+ TESS_COMBINE_DATA = 100111
+
+TessContour enum:
+ CW = 100120
+ CCW = 100121
+ INTERIOR = 100122
+ EXTERIOR = 100123
+ UNKNOWN = 100124
+
+TessProperty enum:
+ TESS_WINDING_RULE = 100140
+ TESS_BOUNDARY_ONLY = 100141
+ TESS_TOLERANCE = 100142
+
+TessError enum:
+ TESS_ERROR1 = 100151
+ TESS_ERROR2 = 100152
+ TESS_ERROR3 = 100153
+ TESS_ERROR4 = 100154
+ TESS_ERROR5 = 100155
+ TESS_ERROR6 = 100156
+ TESS_ERROR7 = 100157
+ TESS_ERROR8 = 100158
+ TESS_MISSING_BEGIN_POLYGON = 100151
+ TESS_MISSING_BEGIN_CONTOUR = 100152
+ TESS_MISSING_END_POLYGON = 100153
+ TESS_MISSING_END_CONTOUR = 100154
+ TESS_COORD_TOO_LARGE = 100155
+ TESS_NEED_COMBINE_CALLBACK = 100156
+
+TessWinding enum:
+ TESS_WINDING_ODD = 100130
+ TESS_WINDING_NONZERO = 100131
+ TESS_WINDING_POSITIVE = 100132
+ TESS_WINDING_NEGATIVE = 100133
+ TESS_WINDING_ABS_GEQ_TWO = 100134
+
+###############################################################################
+
diff --git a/Source/Bind/Specifications/gl.spec b/Source/Bind/Specifications/gl.spec
new file mode 100644
index 00000000..41545c01
--- /dev/null
+++ b/Source/Bind/Specifications/gl.spec
@@ -0,0 +1,21981 @@
+# gl.spec file
+# DON'T REMOVE PREVIOUS LINE!!! libspec depends on it!
+#
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2005 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+
+# @@ NOTE - need to distinguish extensions via some (new?) flag for glext.pl
+# @@ NOTE - 'alias' commands are not yet used in SI generator scripts, but should be
+# @@ NOTE - SI should support GLX protocol for at least these extensions:
+# AreTexturesResidentEXT BindTextureEXT DeleteTexturesEXT GenTexturesEXT IsTextureEXT
+
+required-props:
+param: retval retained
+dlflags: notlistable handcode
+glxflags: client-intercept client-handcode server-handcode EXT SGI ignore ARB
+vectorequiv: *
+category: display-list drawing drawing-control feedback framebuf misc modeling pixel-op pixel-rw state-req xform 1_1 VERSION_1_2 VERSION_1_3 VERSION_1_4 VERSION_1_5 VERSION_2_0 VERSION_2_1 ATI_element_array ATI_envmap_bumpmap ATI_fragment_shader ATI_pn_triangles ATI_vertex_array_object ATI_vertex_streams EXT_blend_color EXT_blend_minmax EXT_convolution EXT_copy_texture EXT_histogram EXT_polygon_offset EXT_subtexture EXT_texture3D EXT_texture_object EXT_vertex_array EXT_vertex_shader SGIS_detail_texture SGIS_multisample SGIS_pixel_texture ARB_point_parameters EXT_point_parameters SGIS_point_parameters SGIS_sharpen_texture SGIS_texture4D SGIS_texture_filter4 SGIX_async SGIX_flush_raster SGIX_fragment_lighting SGIX_framezoom SGIX_igloo_interface SGIX_instruments SGIX_list_priority SGIX_pixel_texture SGIX_polynomial_ffd SGIX_reference_plane SGIX_sprite SGIX_tag_sample_buffer SGI_color_table ARB_multitexture ARB_multisample ARB_texture_compression ARB_transpose_matrix ARB_vertex_blend ARB_matrix_palette EXT_compiled_vertex_array EXT_cull_vertex EXT_index_func EXT_index_material EXT_draw_range_elements EXT_vertex_weighting INGR_blend_func_separate NV_evaluators NV_fence NV_occlusion_query NV_point_sprite NV_register_combiners NV_register_combiners2 NV_vertex_array_range NV_vertex_program NV_vertex_program1_1_dcc MESA_resize_buffers MESA_window_pos PGI_misc_hints EXT_fog_coord EXT_blend_func_separate EXT_color_subtable EXT_coordinate_frame EXT_light_texture EXT_multi_draw_arrays EXT_paletted_texture EXT_pixel_transform EXT_secondary_color EXT_texture_perturb_normal HP_image_transform IBM_multimode_draw_arrays IBM_vertex_array_lists INTEL_parallel_arrays SUNX_constant_data SUN_global_alpha SUN_mesh_array SUN_triangle_list SUN_vertex 3DFX_tbuffer EXT_multisample SGIS_fog_function SGIS_texture_color_mask ARB_window_pos EXT_stencil_two_side EXT_depth_bounds_test EXT_blend_equation_separate ARB_vertex_program ARB_fragment_program ARB_vertex_buffer_object ARB_occlusion_query ARB_shader_objects ARB_vertex_shader ARB_fragment_shader S3_s3tc ATI_draw_buffers ATI_texture_env_combine3 ATI_texture_float NV_float_buffer NV_fragment_program NV_half_float NV_pixel_data_range NV_primitive_restart NV_texture_expand_normal NV_texture_expand_normal NV_vertex_program2 APPLE_element_array APPLE_fence APPLE_vertex_array_object APPLE_vertex_array_range ATI_draw_buffers NV_fragment_program NV_half_float NV_pixel_data_range NV_primitive_restart ATI_map_object_buffer ATI_separate_stencil ATI_vertex_attrib_array_object ARB_draw_buffers ARB_texture_rectangle ARB_color_buffer_float EXT_framebuffer_object GREMEDY_string_marker EXT_stencil_clear_tag EXT_framebuffer_blit EXT_framebuffer_multisample MESAX_texture_stack EXT_timer_query EXT_gpu_program_parameters APPLE_flush_buffer_range NV_gpu_program4 NV_geometry_program4 EXT_geometry_shader4 NV_vertex_program4 EXT_gpu_shader4 EXT_draw_instanced EXT_texture_buffer_object NV_depth_buffer_float NV_framebuffer_multisample_coverage NV_parameter_buffer_object EXT_draw_buffers2 NV_transform_feedback EXT_bindable_uniform EXT_texture_integer
+
+# categories for extensions with no functions - need not be included now
+# ARB_texture_env_add ARB_texture_cube_map ARB_texture_border_clamp ARB_shading_language_100 ARB_texture_non_power_of_two ARB_point_sprite ARB_half_float_pixel ARB_texture_float ARB_pixel_buffer_object EXT_abgr EXT_texture SGI_color_matrix SGI_texture_color_table EXT_cmyka EXT_packed_pixels SGIS_texture_lod EXT_rescale_normal EXT_misc_attribute SGIS_generate_mipmap SGIX_clipmap SGIX_shadow SGIS_texture_edge_clamp SGIS_texture_border_clamp EXT_blend_subtract EXT_blend_logic_op SGIX_async_histogram SGIX_async_pixel SGIX_interlace SGIX_pixel_tiles SGIX_texture_select SGIX_texture_multi_buffer SGIX_texture_scale_bias SGIX_depth_texture SGIX_fog_offset HP_convolution_border_modes SGIX_texture_add_env PGI_vertex_hints EXT_clip_volume_hint SGIX_ir_instrument1 SGIX_calligraphic_fragment SGIX_texture_lod_bias SGIX_shadow_ambient EXT_index_texture EXT_index_array_formats SGIX_ycrcb IBM_rasterpos_clip HP_texture_lighting WIN_phong_shading WIN_specular_fog SGIX_blend_alpha_minmax EXT_bgra HP_occlusion_test EXT_pixel_transform_color_table EXT_shared_texture_palette EXT_separate_specular_color EXT_texture_env REND_screen_coordinates EXT_texture_env_combine APPLE_specular_vector APPLE_transform_hint SGIX_fog_scale INGR_color_clamp INGR_interlace_read EXT_stencil_wrap EXT_422_pixels NV_texgen_reflection SUN_convolution_border_modes SUN_slice_accum EXT_texture_env_add EXT_texture_lod_bias EXT_texture_filter_anisotropic NV_light_max_exponent NV_fog_distance NV_texgen_emboss NV_blend_square NV_texture_env_combine4 NV_packed_depth_stencil NV_texture_compression_vtc NV_texture_rectangle NV_texture_shader NV_texture_shader2 NV_vertex_array_range2 IBM_cull_vertex SGIX_subsample SGIX_ycrcba SGIX_ycrcb_subsample SGIX_depth_pass_instrument 3DFX_texture_compression_FXT1 3DFX_multisample SGIX_vertex_preclip SGIX_convolution_accuracy SGIX_resample SGIX_scalebias_hint SGIX_texture_coordinate_clamp EXT_shadow_funcs MESA_pack_invert MESA_ycbcr_texture EXT_packed_float EXT_texture_array EXT_texture_compression_latc EXT_texture_compression_rgtc EXT_texture_shared_exponent NV_fragment_program4 EXT_framebuffer_sRGB NV_geometry_shader4
+
+version: 1.0 1.1 1.2 1.3 1.4 1.5 2.0 2.1
+glxsingle: *
+glxropcode: *
+glxvendorpriv: *
+glsflags: capture-handcode client get gl-enum ignore matrix pixel-null pixel-pack pixel-unpack
+glsopcode: *
+glsalias: *
+wglflags: client-handcode server-handcode small-data batchable
+extension: future not_implemented soft WINSOFT NV10 NV20 NV50
+alias: *
+offset: *
+# These properties are picked up from NVIDIA .spec files, we don't use them
+glfflags: *
+beginend: *
+glxvectorequiv: *
+
+###############################################################################
+#
+# GLX opcodes
+# glxsingle: 101-159 (1.0-1.2 core)
+# 160 (ARB_texture_compression)
+# glxropcode: 1-196 (1.2 core; ropcode 140 unused?!)
+# 197-213 (ARB_multitexture)
+# 214-219 (ARB_texture_compression)
+# 220-228 (ARB_vertex_blend)
+# 229 (ARB_multisample)
+# 230 (ARB_window_pos)
+# 2048-2082 (SGI extensions)
+# 4096-4123 (1.2 core and multivendor EXT)
+# 4124-4142 (EXT extensions)
+# XFree86 dispatch offsets: 0-645
+# 578-641 NV_vertex_program
+# GLS opcodes: 0x0030-0x0269
+#
+# New opcodes and offsets must be allocated by SGI in the master registry file;
+# a copy of this is in doc/registry/extensions/extensions.reserved, but only
+# the copy maintained by SGI is the official and current version.
+#
+###############################################################################
+
+###############################################################################
+#
+# things to remember when adding an extension command
+#
+# - append new ARB and non-ARB extensions to the appropriate portion of
+# the spec file, in extension number order.
+# - use tabs, not spaces
+# - set glsflags to "ignore" until GLS is updated to support the new command
+# - set glxflags to "ignore" until GLX is updated to support the new command
+# - add new data types to typemaps/spec2wire.map
+# - add extension name in alphabetical order to category list
+# - add commands within an extension in spec order
+# - use existing command entries as a model (where possible)
+# - when reserving new glxropcodes, update
+# gfx/lib/opengl/doc/glspec/extensions.reserved to indicate this
+#
+###############################################################################
+
+# New type declarations
+
+passthru: #include
+
+passthru: #ifndef GL_VERSION_2_0
+passthru: /* GL type for program/shader text */
+passthru: typedef char GLchar; /* native character */
+passthru: #endif
+passthru:
+passthru: #ifndef GL_VERSION_1_5
+passthru: /* GL types for handling large vertex buffer objects */
+passthru: typedef ptrdiff_t GLintptr;
+passthru: typedef ptrdiff_t GLsizeiptr;
+passthru: #endif
+passthru:
+passthru: #ifndef GL_ARB_vertex_buffer_object
+passthru: /* GL types for handling large vertex buffer objects */
+passthru: typedef ptrdiff_t GLintptrARB;
+passthru: typedef ptrdiff_t GLsizeiptrARB;
+passthru: #endif
+passthru:
+passthru: #ifndef GL_ARB_shader_objects
+passthru: /* GL types for handling shader object handles and program/shader text */
+passthru: typedef char GLcharARB; /* native character */
+passthru: typedef unsigned int GLhandleARB; /* shader object handle */
+passthru: #endif
+passthru:
+passthru: /* GL types for "half" precision (s10e5) float data in host memory */
+passthru: #ifndef GL_ARB_half_float_pixel
+passthru: typedef unsigned short GLhalfARB;
+passthru: #endif
+passthru:
+passthru: #ifndef GL_NV_half_float
+passthru: typedef unsigned short GLhalfNV;
+passthru: #endif
+passthru:
+passthru: #ifndef GLEXT_64_TYPES_DEFINED
+passthru: /* This code block is duplicated in glext.h, so must be protected */
+passthru: #define GLEXT_64_TYPES_DEFINED
+passthru: /* Define int32_t, int64_t, and uint64_t types for UST/MSC */
+passthru: /* (as used in the GL_EXT_timer_query extension). */
+passthru: #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+passthru: #include
+passthru: #elif defined(__sun__)
+passthru: #include
+passthru: #if defined(__STDC__)
+passthru: #if defined(__arch64__)
+passthru: typedef long int int64_t;
+passthru: typedef unsigned long int uint64_t;
+passthru: #else
+passthru: typedef long long int int64_t;
+passthru: typedef unsigned long long int uint64_t;
+passthru: #endif /* __arch64__ */
+passthru: #endif /* __STDC__ */
+passthru: #elif defined( __VMS )
+passthru: #include
+passthru: #elif defined(__SCO__) || defined(__USLC__)
+passthru: #include
+passthru: #elif defined(__UNIXOS2__) || defined(__SOL64__)
+passthru: typedef long int int32_t;
+passthru: typedef long long int int64_t;
+passthru: typedef unsigned long long int uint64_t;
+passthru: #elif defined(_WIN32) && defined(__GNUC__)
+passthru: #include
+passthru: #elif defined(_WIN32)
+passthru: typedef __int32 int32_t;
+passthru: typedef __int64 int64_t;
+passthru: typedef unsigned __int64 uint64_t;
+passthru: #else
+passthru: #include /* Fallback option */
+passthru: #endif
+passthru: #endif
+passthru:
+passthru: #ifndef GL_EXT_timer_query
+passthru: typedef int64_t GLint64EXT;
+passthru: typedef uint64_t GLuint64EXT;
+passthru: #endif
+passthru:
+
+###############################################################################
+#
+# display-list commands
+#
+###############################################################################
+
+NewList(list, mode)
+ return void
+ param list List in value
+ param mode ListMode in value
+ dlflags notlistable
+ category display-list
+ version 1.0
+ glxsingle 101
+ glsopcode 0x0030
+ wglflags batchable
+ offset 0
+
+EndList()
+ return void
+ dlflags notlistable
+ category display-list
+ version 1.0
+ glxsingle 102
+ glsopcode 0x0031
+ wglflags batchable
+ offset 1
+
+CallList(list)
+ return void
+ param list List in value
+ category display-list
+ version 1.0
+ glxropcode 1
+ glsopcode 0x0032
+ offset 2
+
+CallLists(n, type, lists)
+ return void
+ param n SizeI in value
+ param type ListNameType in value
+ param lists Void in array [COMPSIZE(n/type)]
+ category display-list
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 2
+ glsopcode 0x0033
+ offset 3
+
+DeleteLists(list, range)
+ return void
+ param list List in value
+ param range SizeI in value
+ dlflags notlistable
+ category display-list
+ version 1.0
+ glxsingle 103
+ glsopcode 0x0034
+ wglflags batchable
+ offset 4
+
+GenLists(range)
+ return List
+ param range SizeI in value
+ dlflags notlistable
+ category display-list
+ version 1.0
+ glxsingle 104
+ glsopcode 0x0035
+ offset 5
+
+ListBase(base)
+ return void
+ param base List in value
+ category display-list
+ version 1.0
+ glxropcode 3
+ glsopcode 0x0036
+ offset 6
+
+###############################################################################
+#
+# drawing commands
+#
+###############################################################################
+
+Begin(mode)
+ return void
+ param mode BeginMode in value
+ category drawing
+ version 1.0
+ glxropcode 4
+ glsopcode 0x0037
+ offset 7
+
+Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap)
+ return void
+ param width SizeI in value
+ param height SizeI in value
+ param xorig CoordF in value
+ param yorig CoordF in value
+ param xmove CoordF in value
+ param ymove CoordF in value
+ param bitmap UInt8 in array [COMPSIZE(width/height)]
+ category drawing
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 5
+ glsflags pixel-unpack
+ glsopcode 0x0038
+ wglflags client-handcode server-handcode
+ offset 8
+
+Color3b(red, green, blue)
+ return void
+ param red ColorB in value
+ param green ColorB in value
+ param blue ColorB in value
+ category drawing
+ vectorequiv Color3bv
+ version 1.0
+ offset 9
+
+Color3bv(v)
+ return void
+ param v ColorB in array [3]
+ category drawing
+ version 1.0
+ glxropcode 6
+ glsopcode 0x0039
+ offset 10
+
+Color3d(red, green, blue)
+ return void
+ param red ColorD in value
+ param green ColorD in value
+ param blue ColorD in value
+ category drawing
+ vectorequiv Color3dv
+ version 1.0
+ offset 11
+
+Color3dv(v)
+ return void
+ param v ColorD in array [3]
+ category drawing
+ version 1.0
+ glxropcode 7
+ glsopcode 0x003A
+ offset 12
+
+Color3f(red, green, blue)
+ return void
+ param red ColorF in value
+ param green ColorF in value
+ param blue ColorF in value
+ category drawing
+ vectorequiv Color3fv
+ version 1.0
+ offset 13
+
+Color3fv(v)
+ return void
+ param v ColorF in array [3]
+ category drawing
+ version 1.0
+ glxropcode 8
+ glsopcode 0x003B
+ offset 14
+
+Color3i(red, green, blue)
+ return void
+ param red ColorI in value
+ param green ColorI in value
+ param blue ColorI in value
+ category drawing
+ vectorequiv Color3iv
+ version 1.0
+ offset 15
+
+Color3iv(v)
+ return void
+ param v ColorI in array [3]
+ category drawing
+ version 1.0
+ glxropcode 9
+ glsopcode 0x003C
+ offset 16
+
+Color3s(red, green, blue)
+ return void
+ param red ColorS in value
+ param green ColorS in value
+ param blue ColorS in value
+ category drawing
+ vectorequiv Color3sv
+ version 1.0
+ offset 17
+
+Color3sv(v)
+ return void
+ param v ColorS in array [3]
+ category drawing
+ version 1.0
+ glxropcode 10
+ glsopcode 0x003D
+ offset 18
+
+Color3ub(red, green, blue)
+ return void
+ param red ColorUB in value
+ param green ColorUB in value
+ param blue ColorUB in value
+ category drawing
+ vectorequiv Color3ubv
+ version 1.0
+ offset 19
+
+Color3ubv(v)
+ return void
+ param v ColorUB in array [3]
+ category drawing
+ version 1.0
+ glxropcode 11
+ glsopcode 0x003E
+ offset 20
+
+Color3ui(red, green, blue)
+ return void
+ param red ColorUI in value
+ param green ColorUI in value
+ param blue ColorUI in value
+ category drawing
+ vectorequiv Color3uiv
+ version 1.0
+ offset 21
+
+Color3uiv(v)
+ return void
+ param v ColorUI in array [3]
+ category drawing
+ version 1.0
+ glxropcode 12
+ glsopcode 0x003F
+ offset 22
+
+Color3us(red, green, blue)
+ return void
+ param red ColorUS in value
+ param green ColorUS in value
+ param blue ColorUS in value
+ category drawing
+ vectorequiv Color3usv
+ version 1.0
+ offset 23
+
+Color3usv(v)
+ return void
+ param v ColorUS in array [3]
+ category drawing
+ version 1.0
+ glxropcode 13
+ glsopcode 0x0040
+ offset 24
+
+Color4b(red, green, blue, alpha)
+ return void
+ param red ColorB in value
+ param green ColorB in value
+ param blue ColorB in value
+ param alpha ColorB in value
+ category drawing
+ vectorequiv Color4bv
+ version 1.0
+ offset 25
+
+Color4bv(v)
+ return void
+ param v ColorB in array [4]
+ category drawing
+ version 1.0
+ glxropcode 14
+ glsopcode 0x0041
+ offset 26
+
+Color4d(red, green, blue, alpha)
+ return void
+ param red ColorD in value
+ param green ColorD in value
+ param blue ColorD in value
+ param alpha ColorD in value
+ category drawing
+ vectorequiv Color4dv
+ version 1.0
+ offset 27
+
+Color4dv(v)
+ return void
+ param v ColorD in array [4]
+ category drawing
+ version 1.0
+ glxropcode 15
+ glsopcode 0x0042
+ offset 28
+
+Color4f(red, green, blue, alpha)
+ return void
+ param red ColorF in value
+ param green ColorF in value
+ param blue ColorF in value
+ param alpha ColorF in value
+ category drawing
+ vectorequiv Color4fv
+ version 1.0
+ offset 29
+
+Color4fv(v)
+ return void
+ param v ColorF in array [4]
+ category drawing
+ version 1.0
+ glxropcode 16
+ glsopcode 0x0043
+ offset 30
+
+Color4i(red, green, blue, alpha)
+ return void
+ param red ColorI in value
+ param green ColorI in value
+ param blue ColorI in value
+ param alpha ColorI in value
+ category drawing
+ vectorequiv Color4iv
+ version 1.0
+ offset 31
+
+Color4iv(v)
+ return void
+ param v ColorI in array [4]
+ category drawing
+ version 1.0
+ glxropcode 17
+ glsopcode 0x0044
+ offset 32
+
+Color4s(red, green, blue, alpha)
+ return void
+ param red ColorS in value
+ param green ColorS in value
+ param blue ColorS in value
+ param alpha ColorS in value
+ category drawing
+ vectorequiv Color4sv
+ version 1.0
+ offset 33
+
+Color4sv(v)
+ return void
+ param v ColorS in array [4]
+ category drawing
+ version 1.0
+ glxropcode 18
+ glsopcode 0x0045
+ offset 34
+
+Color4ub(red, green, blue, alpha)
+ return void
+ param red ColorUB in value
+ param green ColorUB in value
+ param blue ColorUB in value
+ param alpha ColorUB in value
+ category drawing
+ vectorequiv Color4ubv
+ version 1.0
+ offset 35
+
+Color4ubv(v)
+ return void
+ param v ColorUB in array [4]
+ category drawing
+ version 1.0
+ glxropcode 19
+ glsopcode 0x0046
+ offset 36
+
+Color4ui(red, green, blue, alpha)
+ return void
+ param red ColorUI in value
+ param green ColorUI in value
+ param blue ColorUI in value
+ param alpha ColorUI in value
+ category drawing
+ vectorequiv Color4uiv
+ version 1.0
+ offset 37
+
+Color4uiv(v)
+ return void
+ param v ColorUI in array [4]
+ category drawing
+ version 1.0
+ glxropcode 20
+ glsopcode 0x0047
+ offset 38
+
+Color4us(red, green, blue, alpha)
+ return void
+ param red ColorUS in value
+ param green ColorUS in value
+ param blue ColorUS in value
+ param alpha ColorUS in value
+ category drawing
+ vectorequiv Color4usv
+ version 1.0
+ offset 39
+
+Color4usv(v)
+ return void
+ param v ColorUS in array [4]
+ category drawing
+ version 1.0
+ glxropcode 21
+ glsopcode 0x0048
+ offset 40
+
+EdgeFlag(flag)
+ return void
+ param flag Boolean in value
+ category drawing
+ vectorequiv EdgeFlagv
+ version 1.0
+ offset 41
+
+EdgeFlagv(flag)
+ return void
+ param flag Boolean in array [1]
+ category drawing
+ version 1.0
+ glxropcode 22
+ glsopcode 0x0049
+ offset 42
+
+End()
+ return void
+ category drawing
+ version 1.0
+ glxropcode 23
+ glsopcode 0x004A
+ offset 43
+
+Indexd(c)
+ return void
+ param c ColorIndexValueD in value
+ category drawing
+ vectorequiv Indexdv
+ version 1.0
+ offset 44
+
+Indexdv(c)
+ return void
+ param c ColorIndexValueD in array [1]
+ category drawing
+ version 1.0
+ glxropcode 24
+ glsopcode 0x004B
+ offset 45
+
+Indexf(c)
+ return void
+ param c ColorIndexValueF in value
+ category drawing
+ vectorequiv Indexfv
+ version 1.0
+ offset 46
+
+Indexfv(c)
+ return void
+ param c ColorIndexValueF in array [1]
+ category drawing
+ version 1.0
+ glxropcode 25
+ glsopcode 0x004C
+ offset 47
+
+Indexi(c)
+ return void
+ param c ColorIndexValueI in value
+ category drawing
+ vectorequiv Indexiv
+ version 1.0
+ offset 48
+
+Indexiv(c)
+ return void
+ param c ColorIndexValueI in array [1]
+ category drawing
+ version 1.0
+ glxropcode 26
+ glsopcode 0x004D
+ offset 49
+
+Indexs(c)
+ return void
+ param c ColorIndexValueS in value
+ category drawing
+ vectorequiv Indexsv
+ version 1.0
+ offset 50
+
+Indexsv(c)
+ return void
+ param c ColorIndexValueS in array [1]
+ category drawing
+ version 1.0
+ glxropcode 27
+ glsopcode 0x004E
+ offset 51
+
+Normal3b(nx, ny, nz)
+ return void
+ param nx Int8 in value
+ param ny Int8 in value
+ param nz Int8 in value
+ category drawing
+ vectorequiv Normal3bv
+ version 1.0
+ offset 52
+
+Normal3bv(v)
+ return void
+ param v Int8 in array [3]
+ category drawing
+ version 1.0
+ glxropcode 28
+ glsopcode 0x004F
+ offset 53
+
+Normal3d(nx, ny, nz)
+ return void
+ param nx CoordD in value
+ param ny CoordD in value
+ param nz CoordD in value
+ category drawing
+ vectorequiv Normal3dv
+ version 1.0
+ offset 54
+
+Normal3dv(v)
+ return void
+ param v CoordD in array [3]
+ category drawing
+ version 1.0
+ glxropcode 29
+ glsopcode 0x0050
+ offset 55
+
+Normal3f(nx, ny, nz)
+ return void
+ param nx CoordF in value
+ param ny CoordF in value
+ param nz CoordF in value
+ category drawing
+ vectorequiv Normal3fv
+ version 1.0
+ offset 56
+
+Normal3fv(v)
+ return void
+ param v CoordF in array [3]
+ category drawing
+ version 1.0
+ glxropcode 30
+ glsopcode 0x0051
+ offset 57
+
+Normal3i(nx, ny, nz)
+ return void
+ param nx Int32 in value
+ param ny Int32 in value
+ param nz Int32 in value
+ category drawing
+ vectorequiv Normal3iv
+ version 1.0
+ offset 58
+
+Normal3iv(v)
+ return void
+ param v Int32 in array [3]
+ category drawing
+ version 1.0
+ glxropcode 31
+ glsopcode 0x0052
+ offset 59
+
+Normal3s(nx, ny, nz)
+ return void
+ param nx Int16 in value
+ param ny Int16 in value
+ param nz Int16 in value
+ category drawing
+ vectorequiv Normal3sv
+ version 1.0
+ offset 60
+
+Normal3sv(v)
+ return void
+ param v Int16 in array [3]
+ category drawing
+ version 1.0
+ glxropcode 32
+ glsopcode 0x0053
+ offset 61
+
+RasterPos2d(x, y)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ category drawing
+ vectorequiv RasterPos2dv
+ version 1.0
+ offset 62
+
+RasterPos2dv(v)
+ return void
+ param v CoordD in array [2]
+ category drawing
+ version 1.0
+ glxropcode 33
+ glsopcode 0x0054
+ offset 63
+
+RasterPos2f(x, y)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ category drawing
+ vectorequiv RasterPos2fv
+ version 1.0
+ offset 64
+
+RasterPos2fv(v)
+ return void
+ param v CoordF in array [2]
+ category drawing
+ version 1.0
+ glxropcode 34
+ glsopcode 0x0055
+ offset 65
+
+RasterPos2i(x, y)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ category drawing
+ vectorequiv RasterPos2iv
+ version 1.0
+ offset 66
+
+RasterPos2iv(v)
+ return void
+ param v CoordI in array [2]
+ category drawing
+ version 1.0
+ glxropcode 35
+ glsopcode 0x0056
+ offset 67
+
+RasterPos2s(x, y)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ category drawing
+ vectorequiv RasterPos2sv
+ version 1.0
+ offset 68
+
+RasterPos2sv(v)
+ return void
+ param v CoordS in array [2]
+ category drawing
+ version 1.0
+ glxropcode 36
+ glsopcode 0x0057
+ offset 69
+
+RasterPos3d(x, y, z)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ vectorequiv RasterPos3dv
+ category drawing
+ version 1.0
+ offset 70
+
+RasterPos3dv(v)
+ return void
+ param v CoordD in array [3]
+ category drawing
+ version 1.0
+ glxropcode 37
+ glsopcode 0x0058
+ offset 71
+
+RasterPos3f(x, y, z)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ category drawing
+ vectorequiv RasterPos3fv
+ version 1.0
+ offset 72
+
+RasterPos3fv(v)
+ return void
+ param v CoordF in array [3]
+ category drawing
+ version 1.0
+ glxropcode 38
+ glsopcode 0x0059
+ offset 73
+
+RasterPos3i(x, y, z)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ category drawing
+ vectorequiv RasterPos3iv
+ version 1.0
+ offset 74
+
+RasterPos3iv(v)
+ return void
+ param v CoordI in array [3]
+ category drawing
+ version 1.0
+ glxropcode 39
+ glsopcode 0x005A
+ offset 75
+
+RasterPos3s(x, y, z)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ category drawing
+ vectorequiv RasterPos3sv
+ version 1.0
+ offset 76
+
+RasterPos3sv(v)
+ return void
+ param v CoordS in array [3]
+ category drawing
+ version 1.0
+ glxropcode 40
+ glsopcode 0x005B
+ offset 77
+
+RasterPos4d(x, y, z, w)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ param w CoordD in value
+ vectorequiv RasterPos4dv
+ category drawing
+ version 1.0
+ offset 78
+
+RasterPos4dv(v)
+ return void
+ param v CoordD in array [4]
+ category drawing
+ version 1.0
+ glxropcode 41
+ glsopcode 0x005C
+ offset 79
+
+RasterPos4f(x, y, z, w)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ param w CoordF in value
+ category drawing
+ vectorequiv RasterPos4fv
+ version 1.0
+ offset 80
+
+RasterPos4fv(v)
+ return void
+ param v CoordF in array [4]
+ category drawing
+ version 1.0
+ glxropcode 42
+ glsopcode 0x005D
+ offset 81
+
+RasterPos4i(x, y, z, w)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ param w CoordI in value
+ category drawing
+ vectorequiv RasterPos4iv
+ version 1.0
+ offset 82
+
+RasterPos4iv(v)
+ return void
+ param v CoordI in array [4]
+ category drawing
+ version 1.0
+ glxropcode 43
+ glsopcode 0x005E
+ offset 83
+
+RasterPos4s(x, y, z, w)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ param w CoordS in value
+ category drawing
+ vectorequiv RasterPos4sv
+ version 1.0
+ offset 84
+
+RasterPos4sv(v)
+ return void
+ param v CoordS in array [4]
+ category drawing
+ version 1.0
+ glxropcode 44
+ glsopcode 0x005F
+ offset 85
+
+Rectd(x1, y1, x2, y2)
+ return void
+ param x1 CoordD in value
+ param y1 CoordD in value
+ param x2 CoordD in value
+ param y2 CoordD in value
+ category drawing
+ vectorequiv Rectdv
+ version 1.0
+ offset 86
+
+Rectdv(v1, v2)
+ return void
+ param v1 CoordD in array [2]
+ param v2 CoordD in array [2]
+ category drawing
+ version 1.0
+ glxropcode 45
+ glsopcode 0x0060
+ offset 87
+
+Rectf(x1, y1, x2, y2)
+ return void
+ param x1 CoordF in value
+ param y1 CoordF in value
+ param x2 CoordF in value
+ param y2 CoordF in value
+ category drawing
+ vectorequiv Rectfv
+ version 1.0
+ offset 88
+
+Rectfv(v1, v2)
+ return void
+ param v1 CoordF in array [2]
+ param v2 CoordF in array [2]
+ category drawing
+ version 1.0
+ glxropcode 46
+ glsopcode 0x0061
+ offset 89
+
+Recti(x1, y1, x2, y2)
+ return void
+ param x1 CoordI in value
+ param y1 CoordI in value
+ param x2 CoordI in value
+ param y2 CoordI in value
+ category drawing
+ vectorequiv Rectiv
+ version 1.0
+ offset 90
+
+Rectiv(v1, v2)
+ return void
+ param v1 CoordI in array [2]
+ param v2 CoordI in array [2]
+ category drawing
+ version 1.0
+ glxropcode 47
+ glsopcode 0x0062
+ offset 91
+
+Rects(x1, y1, x2, y2)
+ return void
+ param x1 CoordS in value
+ param y1 CoordS in value
+ param x2 CoordS in value
+ param y2 CoordS in value
+ category drawing
+ vectorequiv Rectsv
+ version 1.0
+ offset 92
+
+Rectsv(v1, v2)
+ return void
+ param v1 CoordS in array [2]
+ param v2 CoordS in array [2]
+ category drawing
+ version 1.0
+ glxropcode 48
+ glsopcode 0x0063
+ offset 93
+
+TexCoord1d(s)
+ return void
+ param s CoordD in value
+ category drawing
+ vectorequiv TexCoord1dv
+ version 1.0
+ offset 94
+
+TexCoord1dv(v)
+ return void
+ param v CoordD in array [1]
+ category drawing
+ version 1.0
+ glxropcode 49
+ glsopcode 0x0064
+ offset 95
+
+TexCoord1f(s)
+ return void
+ param s CoordF in value
+ category drawing
+ vectorequiv TexCoord1fv
+ version 1.0
+ offset 96
+
+TexCoord1fv(v)
+ return void
+ param v CoordF in array [1]
+ category drawing
+ version 1.0
+ glxropcode 50
+ glsopcode 0x0065
+ offset 97
+
+TexCoord1i(s)
+ return void
+ param s CoordI in value
+ category drawing
+ vectorequiv TexCoord1iv
+ version 1.0
+ offset 98
+
+TexCoord1iv(v)
+ return void
+ param v CoordI in array [1]
+ category drawing
+ version 1.0
+ glxropcode 51
+ glsopcode 0x0066
+ offset 99
+
+TexCoord1s(s)
+ return void
+ param s CoordS in value
+ category drawing
+ vectorequiv TexCoord1sv
+ version 1.0
+ offset 100
+
+TexCoord1sv(v)
+ return void
+ param v CoordS in array [1]
+ category drawing
+ version 1.0
+ glxropcode 52
+ glsopcode 0x0067
+ offset 101
+
+TexCoord2d(s, t)
+ return void
+ param s CoordD in value
+ param t CoordD in value
+ category drawing
+ vectorequiv TexCoord2dv
+ version 1.0
+ offset 102
+
+TexCoord2dv(v)
+ return void
+ param v CoordD in array [2]
+ category drawing
+ version 1.0
+ glxropcode 53
+ glsopcode 0x0068
+ offset 103
+
+TexCoord2f(s, t)
+ return void
+ param s CoordF in value
+ param t CoordF in value
+ category drawing
+ vectorequiv TexCoord2fv
+ version 1.0
+ offset 104
+
+TexCoord2fv(v)
+ return void
+ param v CoordF in array [2]
+ category drawing
+ version 1.0
+ glxropcode 54
+ glsopcode 0x0069
+ offset 105
+
+TexCoord2i(s, t)
+ return void
+ param s CoordI in value
+ param t CoordI in value
+ category drawing
+ vectorequiv TexCoord2iv
+ version 1.0
+ offset 106
+
+TexCoord2iv(v)
+ return void
+ param v CoordI in array [2]
+ category drawing
+ version 1.0
+ glxropcode 55
+ glsopcode 0x006A
+ offset 107
+
+TexCoord2s(s, t)
+ return void
+ param s CoordS in value
+ param t CoordS in value
+ category drawing
+ vectorequiv TexCoord2sv
+ version 1.0
+ offset 108
+
+TexCoord2sv(v)
+ return void
+ param v CoordS in array [2]
+ category drawing
+ version 1.0
+ glxropcode 56
+ glsopcode 0x006B
+ offset 109
+
+TexCoord3d(s, t, r)
+ return void
+ param s CoordD in value
+ param t CoordD in value
+ param r CoordD in value
+ category drawing
+ vectorequiv TexCoord3dv
+ version 1.0
+ offset 110
+
+TexCoord3dv(v)
+ return void
+ param v CoordD in array [3]
+ category drawing
+ version 1.0
+ glxropcode 57
+ glsopcode 0x006C
+ offset 111
+
+TexCoord3f(s, t, r)
+ return void
+ param s CoordF in value
+ param t CoordF in value
+ param r CoordF in value
+ category drawing
+ vectorequiv TexCoord3fv
+ version 1.0
+ offset 112
+
+TexCoord3fv(v)
+ return void
+ param v CoordF in array [3]
+ category drawing
+ version 1.0
+ glxropcode 58
+ glsopcode 0x006D
+ offset 113
+
+TexCoord3i(s, t, r)
+ return void
+ param s CoordI in value
+ param t CoordI in value
+ param r CoordI in value
+ category drawing
+ vectorequiv TexCoord3iv
+ version 1.0
+ offset 114
+
+TexCoord3iv(v)
+ return void
+ param v CoordI in array [3]
+ category drawing
+ version 1.0
+ glxropcode 59
+ glsopcode 0x006E
+ offset 115
+
+TexCoord3s(s, t, r)
+ return void
+ param s CoordS in value
+ param t CoordS in value
+ param r CoordS in value
+ category drawing
+ vectorequiv TexCoord3sv
+ version 1.0
+ offset 116
+
+TexCoord3sv(v)
+ return void
+ param v CoordS in array [3]
+ category drawing
+ version 1.0
+ glxropcode 60
+ glsopcode 0x006F
+ offset 117
+
+TexCoord4d(s, t, r, q)
+ return void
+ param s CoordD in value
+ param t CoordD in value
+ param r CoordD in value
+ param q CoordD in value
+ category drawing
+ vectorequiv TexCoord4dv
+ version 1.0
+ offset 118
+
+TexCoord4dv(v)
+ return void
+ param v CoordD in array [4]
+ category drawing
+ version 1.0
+ glxropcode 61
+ glsopcode 0x0070
+ offset 119
+
+TexCoord4f(s, t, r, q)
+ return void
+ param s CoordF in value
+ param t CoordF in value
+ param r CoordF in value
+ param q CoordF in value
+ category drawing
+ vectorequiv TexCoord4fv
+ version 1.0
+ offset 120
+
+TexCoord4fv(v)
+ return void
+ param v CoordF in array [4]
+ category drawing
+ version 1.0
+ glxropcode 62
+ glsopcode 0x0071
+ offset 121
+
+TexCoord4i(s, t, r, q)
+ return void
+ param s CoordI in value
+ param t CoordI in value
+ param r CoordI in value
+ param q CoordI in value
+ category drawing
+ vectorequiv TexCoord4iv
+ version 1.0
+ offset 122
+
+TexCoord4iv(v)
+ return void
+ param v CoordI in array [4]
+ category drawing
+ version 1.0
+ glxropcode 63
+ glsopcode 0x0072
+ offset 123
+
+TexCoord4s(s, t, r, q)
+ return void
+ param s CoordS in value
+ param t CoordS in value
+ param r CoordS in value
+ param q CoordS in value
+ category drawing
+ vectorequiv TexCoord4sv
+ version 1.0
+ offset 124
+
+TexCoord4sv(v)
+ return void
+ param v CoordS in array [4]
+ category drawing
+ version 1.0
+ glxropcode 64
+ glsopcode 0x0073
+ offset 125
+
+Vertex2d(x, y)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ category drawing
+ vectorequiv Vertex2dv
+ version 1.0
+ offset 126
+
+Vertex2dv(v)
+ return void
+ param v CoordD in array [2]
+ category drawing
+ version 1.0
+ glxropcode 65
+ glsopcode 0x0074
+ offset 127
+
+Vertex2f(x, y)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ category drawing
+ vectorequiv Vertex2fv
+ version 1.0
+ offset 128
+
+Vertex2fv(v)
+ return void
+ param v CoordF in array [2]
+ category drawing
+ version 1.0
+ glxropcode 66
+ glsopcode 0x0075
+ offset 129
+
+Vertex2i(x, y)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ category drawing
+ vectorequiv Vertex2iv
+ version 1.0
+ offset 130
+
+Vertex2iv(v)
+ return void
+ param v CoordI in array [2]
+ category drawing
+ version 1.0
+ glxropcode 67
+ glsopcode 0x0076
+ offset 131
+
+Vertex2s(x, y)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ category drawing
+ vectorequiv Vertex2sv
+ version 1.0
+ offset 132
+
+Vertex2sv(v)
+ return void
+ param v CoordS in array [2]
+ category drawing
+ version 1.0
+ glxropcode 68
+ glsopcode 0x0077
+ offset 133
+
+Vertex3d(x, y, z)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ category drawing
+ vectorequiv Vertex3dv
+ version 1.0
+ offset 134
+
+Vertex3dv(v)
+ return void
+ param v CoordD in array [3]
+ category drawing
+ version 1.0
+ glxropcode 69
+ glsopcode 0x0078
+ offset 135
+
+Vertex3f(x, y, z)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ category drawing
+ vectorequiv Vertex3fv
+ version 1.0
+ offset 136
+
+Vertex3fv(v)
+ return void
+ param v CoordF in array [3]
+ category drawing
+ version 1.0
+ glxropcode 70
+ glsopcode 0x0079
+ offset 137
+
+Vertex3i(x, y, z)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ category drawing
+ vectorequiv Vertex3iv
+ version 1.0
+ offset 138
+
+Vertex3iv(v)
+ return void
+ param v CoordI in array [3]
+ category drawing
+ version 1.0
+ glxropcode 71
+ glsopcode 0x007A
+ offset 139
+
+Vertex3s(x, y, z)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ category drawing
+ vectorequiv Vertex3sv
+ version 1.0
+ offset 140
+
+Vertex3sv(v)
+ return void
+ param v CoordS in array [3]
+ category drawing
+ version 1.0
+ glxropcode 72
+ glsopcode 0x007B
+ offset 141
+
+Vertex4d(x, y, z, w)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ param w CoordD in value
+ category drawing
+ vectorequiv Vertex4dv
+ version 1.0
+ offset 142
+
+Vertex4dv(v)
+ return void
+ param v CoordD in array [4]
+ category drawing
+ version 1.0
+ glxropcode 73
+ glsopcode 0x007C
+ offset 143
+
+Vertex4f(x, y, z, w)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ param w CoordF in value
+ category drawing
+ vectorequiv Vertex4fv
+ version 1.0
+ offset 144
+
+Vertex4fv(v)
+ return void
+ param v CoordF in array [4]
+ category drawing
+ version 1.0
+ glxropcode 74
+ glsopcode 0x007D
+ offset 145
+
+Vertex4i(x, y, z, w)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ param w CoordI in value
+ category drawing
+ vectorequiv Vertex4iv
+ version 1.0
+ offset 146
+
+Vertex4iv(v)
+ return void
+ param v CoordI in array [4]
+ category drawing
+ version 1.0
+ glxropcode 75
+ glsopcode 0x007E
+ offset 147
+
+Vertex4s(x, y, z, w)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ param w CoordS in value
+ category drawing
+ vectorequiv Vertex4sv
+ version 1.0
+ offset 148
+
+Vertex4sv(v)
+ return void
+ param v CoordS in array [4]
+ category drawing
+ version 1.0
+ glxropcode 76
+ glsopcode 0x007F
+ offset 149
+
+###############################################################################
+#
+# drawing-control commands
+#
+###############################################################################
+
+ClipPlane(plane, equation)
+ return void
+ param plane ClipPlaneName in value
+ param equation Float64 in array [4]
+ category drawing-control
+ version 1.0
+ glxropcode 77
+ glsopcode 0x0080
+ offset 150
+
+ColorMaterial(face, mode)
+ return void
+ param face MaterialFace in value
+ param mode ColorMaterialParameter in value
+ category drawing-control
+ version 1.0
+ glxropcode 78
+ glsopcode 0x0081
+ offset 151
+
+CullFace(mode)
+ return void
+ param mode CullFaceMode in value
+ category drawing-control
+ version 1.0
+ glxropcode 79
+ glsopcode 0x0082
+ offset 152
+
+Fogf(pname, param)
+ return void
+ param pname FogParameter in value
+ param param CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 80
+ glsflags gl-enum
+ glsopcode 0x0083
+ wglflags small-data
+ offset 153
+
+Fogfv(pname, params)
+ return void
+ param pname FogParameter in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 81
+ glsflags gl-enum
+ glsopcode 0x0084
+ wglflags small-data
+ offset 154
+
+Fogi(pname, param)
+ return void
+ param pname FogParameter in value
+ param param CheckedInt32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 82
+ glsflags gl-enum
+ glsopcode 0x0085
+ wglflags small-data
+ offset 155
+
+Fogiv(pname, params)
+ return void
+ param pname FogParameter in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 83
+ glsflags gl-enum
+ glsopcode 0x0086
+ wglflags small-data
+ offset 156
+
+FrontFace(mode)
+ return void
+ param mode FrontFaceDirection in value
+ category drawing-control
+ version 1.0
+ glxropcode 84
+ glsopcode 0x0087
+ offset 157
+
+Hint(target, mode)
+ return void
+ param target HintTarget in value
+ param mode HintMode in value
+ category drawing-control
+ version 1.0
+ glxropcode 85
+ glsopcode 0x0088
+ offset 158
+
+Lightf(light, pname, param)
+ return void
+ param light LightName in value
+ param pname LightParameter in value
+ param param CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 86
+ glsopcode 0x0089
+ wglflags small-data
+ offset 159
+
+Lightfv(light, pname, params)
+ return void
+ param light LightName in value
+ param pname LightParameter in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 87
+ glsopcode 0x008A
+ wglflags small-data
+ offset 160
+
+Lighti(light, pname, param)
+ return void
+ param light LightName in value
+ param pname LightParameter in value
+ param param CheckedInt32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 88
+ glsopcode 0x008B
+ wglflags small-data
+ offset 161
+
+Lightiv(light, pname, params)
+ return void
+ param light LightName in value
+ param pname LightParameter in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 89
+ glsopcode 0x008C
+ wglflags small-data
+ offset 162
+
+LightModelf(pname, param)
+ return void
+ param pname LightModelParameter in value
+ param param Float32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 90
+ glsflags gl-enum
+ glsopcode 0x008D
+ wglflags small-data
+ offset 163
+
+LightModelfv(pname, params)
+ return void
+ param pname LightModelParameter in value
+ param params Float32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 91
+ glsflags gl-enum
+ glsopcode 0x008E
+ wglflags small-data
+ offset 164
+
+LightModeli(pname, param)
+ return void
+ param pname LightModelParameter in value
+ param param Int32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 92
+ glsflags gl-enum
+ glsopcode 0x008F
+ wglflags small-data
+ offset 165
+
+LightModeliv(pname, params)
+ return void
+ param pname LightModelParameter in value
+ param params Int32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 93
+ glsflags gl-enum
+ glsopcode 0x0090
+ wglflags small-data
+ offset 166
+
+LineStipple(factor, pattern)
+ return void
+ param factor CheckedInt32 in value
+ param pattern LineStipple in value
+ category drawing-control
+ version 1.0
+ glxropcode 94
+ glsopcode 0x0091
+ offset 167
+
+LineWidth(width)
+ return void
+ param width CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 95
+ glsopcode 0x0092
+ offset 168
+
+Materialf(face, pname, param)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param param CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 96
+ glsopcode 0x0093
+ wglflags small-data
+ offset 169
+
+Materialfv(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 97
+ glsopcode 0x0094
+ wglflags small-data
+ offset 170
+
+Materiali(face, pname, param)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param param CheckedInt32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 98
+ glsopcode 0x0095
+ wglflags small-data
+ offset 171
+
+Materialiv(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 99
+ glsopcode 0x0096
+ wglflags small-data
+ offset 172
+
+PointSize(size)
+ return void
+ param size CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 100
+ glsopcode 0x0097
+ offset 173
+
+PolygonMode(face, mode)
+ return void
+ param face MaterialFace in value
+ param mode PolygonMode in value
+ category drawing-control
+ version 1.0
+ glxropcode 101
+ glsopcode 0x0098
+ offset 174
+
+PolygonStipple(mask)
+ return void
+ param mask UInt8 in array [COMPSIZE()]
+ category drawing-control
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 102
+ glsflags pixel-unpack
+ glsopcode 0x0099
+ wglflags client-handcode server-handcode
+ offset 175
+
+Scissor(x, y, width, height)
+ return void
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category drawing-control
+ version 1.0
+ glxropcode 103
+ glsopcode 0x009A
+ offset 176
+
+ShadeModel(mode)
+ return void
+ param mode ShadingModel in value
+ category drawing-control
+ version 1.0
+ glxropcode 104
+ glsopcode 0x009B
+ offset 177
+
+TexParameterf(target, pname, param)
+ return void
+ param target TextureTarget in value
+ param pname TextureParameterName in value
+ param param CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 105
+ glsflags gl-enum
+ glsopcode 0x009C
+ wglflags small-data
+ offset 178
+
+TexParameterfv(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname TextureParameterName in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 106
+ glsflags gl-enum
+ glsopcode 0x009D
+ wglflags small-data
+ offset 179
+
+TexParameteri(target, pname, param)
+ return void
+ param target TextureTarget in value
+ param pname TextureParameterName in value
+ param param CheckedInt32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 107
+ glsflags gl-enum
+ glsopcode 0x009E
+ wglflags small-data
+ offset 180
+
+TexParameteriv(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname TextureParameterName in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 108
+ glsflags gl-enum
+ glsopcode 0x009F
+ wglflags small-data
+ offset 181
+
+TexImage1D(target, level, internalformat, width, border, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat TextureComponentCount in value
+ param width SizeI in value
+ param border CheckedInt32 in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width)]
+ category drawing-control
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 109
+ glsflags pixel-null pixel-unpack
+ glsopcode 0x00A0
+ wglflags client-handcode server-handcode
+ offset 182
+
+TexImage2D(target, level, internalformat, width, height, border, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat TextureComponentCount in value
+ param width SizeI in value
+ param height SizeI in value
+ param border CheckedInt32 in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height)]
+ category drawing-control
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 110
+ glsflags pixel-null pixel-unpack
+ glsopcode 0x00A1
+ wglflags client-handcode server-handcode
+ offset 183
+
+TexEnvf(target, pname, param)
+ return void
+ param target TextureEnvTarget in value
+ param pname TextureEnvParameter in value
+ param param CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 111
+ glsflags gl-enum
+ glsopcode 0x00A2
+ wglflags small-data
+ offset 184
+
+TexEnvfv(target, pname, params)
+ return void
+ param target TextureEnvTarget in value
+ param pname TextureEnvParameter in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 112
+ glsflags gl-enum
+ glsopcode 0x00A3
+ wglflags small-data
+ offset 185
+
+TexEnvi(target, pname, param)
+ return void
+ param target TextureEnvTarget in value
+ param pname TextureEnvParameter in value
+ param param CheckedInt32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 113
+ glsflags gl-enum
+ glsopcode 0x00A4
+ wglflags small-data
+ offset 186
+
+TexEnviv(target, pname, params)
+ return void
+ param target TextureEnvTarget in value
+ param pname TextureEnvParameter in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 114
+ glsflags gl-enum
+ glsopcode 0x00A5
+ wglflags small-data
+ offset 187
+
+TexGend(coord, pname, param)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param param Float64 in value
+ category drawing-control
+ version 1.0
+ glxropcode 115
+ glsflags gl-enum
+ glsopcode 0x00A6
+ wglflags small-data
+ offset 188
+
+TexGendv(coord, pname, params)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param params Float64 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 116
+ glsflags gl-enum
+ glsopcode 0x00A7
+ wglflags small-data
+ offset 189
+
+TexGenf(coord, pname, param)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param param CheckedFloat32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 117
+ glsflags gl-enum
+ glsopcode 0x00A8
+ wglflags small-data
+ offset 190
+
+TexGenfv(coord, pname, params)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 118
+ glsflags gl-enum
+ glsopcode 0x00A9
+ wglflags small-data
+ offset 191
+
+TexGeni(coord, pname, param)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param param CheckedInt32 in value
+ category drawing-control
+ version 1.0
+ glxropcode 119
+ glsflags gl-enum
+ glsopcode 0x00AA
+ wglflags small-data
+ offset 192
+
+TexGeniv(coord, pname, params)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category drawing-control
+ version 1.0
+ glxropcode 120
+ glsflags gl-enum
+ glsopcode 0x00AB
+ wglflags small-data
+ offset 193
+
+###############################################################################
+#
+# feedback commands
+#
+###############################################################################
+
+FeedbackBuffer(size, type, buffer)
+ return void
+ param size SizeI in value
+ param type FeedbackType in value
+ param buffer FeedbackElement out array [size] retained
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category feedback
+ version 1.0
+ glxsingle 105
+ glsflags client
+ glsopcode 0x00AC
+ wglflags client-handcode server-handcode batchable
+ offset 194
+
+SelectBuffer(size, buffer)
+ return void
+ param size SizeI in value
+ param buffer SelectName out array [size] retained
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category feedback
+ version 1.0
+ glxsingle 106
+ glsflags client
+ glsopcode 0x00AD
+ wglflags client-handcode server-handcode batchable
+ offset 195
+
+RenderMode(mode)
+ return Int32
+ param mode RenderingMode in value
+ category feedback
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxsingle 107
+ glsopcode 0x00AE
+ wglflags client-handcode server-handcode
+ offset 196
+
+InitNames()
+ return void
+ category feedback
+ version 1.0
+ glxropcode 121
+ glsopcode 0x00AF
+ offset 197
+
+LoadName(name)
+ return void
+ param name SelectName in value
+ category feedback
+ version 1.0
+ glxropcode 122
+ glsopcode 0x00B0
+ offset 198
+
+PassThrough(token)
+ return void
+ param token FeedbackElement in value
+ category feedback
+ version 1.0
+ glxropcode 123
+ glsopcode 0x00B1
+ offset 199
+
+PopName()
+ return void
+ category feedback
+ version 1.0
+ glxropcode 124
+ glsopcode 0x00B2
+ offset 200
+
+PushName(name)
+ return void
+ param name SelectName in value
+ category feedback
+ version 1.0
+ glxropcode 125
+ glsopcode 0x00B3
+ offset 201
+
+###############################################################################
+#
+# framebuf commands
+#
+###############################################################################
+
+DrawBuffer(mode)
+ return void
+ param mode DrawBufferMode in value
+ category framebuf
+ version 1.0
+ glxropcode 126
+ glsopcode 0x00B4
+ offset 202
+
+Clear(mask)
+ return void
+ param mask ClearBufferMask in value
+ category framebuf
+ version 1.0
+ glxropcode 127
+ glsopcode 0x00B5
+ offset 203
+
+ClearAccum(red, green, blue, alpha)
+ return void
+ param red Float32 in value
+ param green Float32 in value
+ param blue Float32 in value
+ param alpha Float32 in value
+ category framebuf
+ version 1.0
+ glxropcode 128
+ glsopcode 0x00B6
+ offset 204
+
+ClearIndex(c)
+ return void
+ param c MaskedColorIndexValueF in value
+ category framebuf
+ version 1.0
+ glxropcode 129
+ glsopcode 0x00B7
+ offset 205
+
+ClearColor(red, green, blue, alpha)
+ return void
+ param red ClampedColorF in value
+ param green ClampedColorF in value
+ param blue ClampedColorF in value
+ param alpha ClampedColorF in value
+ category framebuf
+ version 1.0
+ glxropcode 130
+ glsopcode 0x00B8
+ offset 206
+
+ClearStencil(s)
+ return void
+ param s StencilValue in value
+ category framebuf
+ version 1.0
+ glxropcode 131
+ glsopcode 0x00B9
+ offset 207
+
+ClearDepth(depth)
+ return void
+ param depth ClampedFloat64 in value
+ category framebuf
+ version 1.0
+ glxropcode 132
+ glsopcode 0x00BA
+ offset 208
+
+StencilMask(mask)
+ return void
+ param mask MaskedStencilValue in value
+ category framebuf
+ version 1.0
+ glxropcode 133
+ glsopcode 0x00BB
+ offset 209
+
+ColorMask(red, green, blue, alpha)
+ return void
+ param red Boolean in value
+ param green Boolean in value
+ param blue Boolean in value
+ param alpha Boolean in value
+ category framebuf
+ version 1.0
+ glxropcode 134
+ glsopcode 0x00BC
+ offset 210
+
+DepthMask(flag)
+ return void
+ param flag Boolean in value
+ category framebuf
+ version 1.0
+ glxropcode 135
+ glsopcode 0x00BD
+ offset 211
+
+IndexMask(mask)
+ return void
+ param mask MaskedColorIndexValueI in value
+ category framebuf
+ version 1.0
+ glxropcode 136
+ glsopcode 0x00BE
+ offset 212
+
+###############################################################################
+#
+# misc commands
+#
+###############################################################################
+
+Accum(op, value)
+ return void
+ param op AccumOp in value
+ param value CoordF in value
+ category misc
+ version 1.0
+ glxropcode 137
+ glsopcode 0x00BF
+ offset 213
+
+Disable(cap)
+ return void
+ param cap EnableCap in value
+ category misc
+ version 1.0
+ dlflags handcode
+ glxflags client-handcode client-intercept
+ glxropcode 138
+ glsflags client
+ glsopcode 0x00C0
+ offset 214
+
+Enable(cap)
+ return void
+ param cap EnableCap in value
+ category misc
+ version 1.0
+ dlflags handcode
+ glxflags client-handcode client-intercept
+ glxropcode 139
+ glsflags client
+ glsopcode 0x00C1
+ offset 215
+
+Finish()
+ return void
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category misc
+ version 1.0
+ glxsingle 108
+ glsopcode 0x00C2
+ offset 216
+
+Flush()
+ return void
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ category misc
+ version 1.0
+ glxsingle 142
+ glsopcode 0x00C3
+ offset 217
+
+PopAttrib()
+ return void
+ category misc
+ version 1.0
+ glxropcode 141
+ glsopcode 0x00C4
+ offset 218
+
+PushAttrib(mask)
+ return void
+ param mask AttribMask in value
+ category misc
+ version 1.0
+ glxropcode 142
+ glsopcode 0x00C5
+ offset 219
+
+###############################################################################
+#
+# modeling commands
+#
+###############################################################################
+
+Map1d(target, u1, u2, stride, order, points)
+ return void
+ param target MapTarget in value
+ param u1 CoordD in value
+ param u2 CoordD in value
+ param stride Int32 in value
+ param order CheckedInt32 in value
+ param points CoordD in array [COMPSIZE(target/stride/order)]
+ category modeling
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 143
+ glsflags capture-handcode
+ glsopcode 0x00C6
+ wglflags client-handcode server-handcode
+ offset 220
+
+Map1f(target, u1, u2, stride, order, points)
+ return void
+ param target MapTarget in value
+ param u1 CoordF in value
+ param u2 CoordF in value
+ param stride Int32 in value
+ param order CheckedInt32 in value
+ param points CoordF in array [COMPSIZE(target/stride/order)]
+ category modeling
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 144
+ glsflags capture-handcode
+ glsopcode 0x00C7
+ wglflags client-handcode server-handcode
+ offset 221
+
+Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points)
+ return void
+ param target MapTarget in value
+ param u1 CoordD in value
+ param u2 CoordD in value
+ param ustride Int32 in value
+ param uorder CheckedInt32 in value
+ param v1 CoordD in value
+ param v2 CoordD in value
+ param vstride Int32 in value
+ param vorder CheckedInt32 in value
+ param points CoordD in array [COMPSIZE(target/ustride/uorder/vstride/vorder)]
+ category modeling
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 145
+ glsflags capture-handcode
+ glsopcode 0x00C8
+ wglflags client-handcode server-handcode
+ offset 222
+
+Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points)
+ return void
+ param target MapTarget in value
+ param u1 CoordF in value
+ param u2 CoordF in value
+ param ustride Int32 in value
+ param uorder CheckedInt32 in value
+ param v1 CoordF in value
+ param v2 CoordF in value
+ param vstride Int32 in value
+ param vorder CheckedInt32 in value
+ param points CoordF in array [COMPSIZE(target/ustride/uorder/vstride/vorder)]
+ category modeling
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 146
+ glsflags capture-handcode
+ glsopcode 0x00C9
+ wglflags client-handcode server-handcode
+ offset 223
+
+MapGrid1d(un, u1, u2)
+ return void
+ param un Int32 in value
+ param u1 CoordD in value
+ param u2 CoordD in value
+ category modeling
+ version 1.0
+ glxropcode 147
+ glsopcode 0x00CA
+ offset 224
+
+MapGrid1f(un, u1, u2)
+ return void
+ param un Int32 in value
+ param u1 CoordF in value
+ param u2 CoordF in value
+ category modeling
+ version 1.0
+ glxropcode 148
+ glsopcode 0x00CB
+ offset 225
+
+MapGrid2d(un, u1, u2, vn, v1, v2)
+ return void
+ param un Int32 in value
+ param u1 CoordD in value
+ param u2 CoordD in value
+ param vn Int32 in value
+ param v1 CoordD in value
+ param v2 CoordD in value
+ category modeling
+ version 1.0
+ glxropcode 149
+ glsopcode 0x00CC
+ offset 226
+
+MapGrid2f(un, u1, u2, vn, v1, v2)
+ return void
+ param un Int32 in value
+ param u1 CoordF in value
+ param u2 CoordF in value
+ param vn Int32 in value
+ param v1 CoordF in value
+ param v2 CoordF in value
+ category modeling
+ version 1.0
+ glxropcode 150
+ glsopcode 0x00CD
+ offset 227
+
+EvalCoord1d(u)
+ return void
+ param u CoordD in value
+ category modeling
+ vectorequiv EvalCoord1dv
+ version 1.0
+ offset 228
+
+EvalCoord1dv(u)
+ return void
+ param u CoordD in array [1]
+ category modeling
+ version 1.0
+ glxropcode 151
+ glsopcode 0x00CE
+ offset 229
+
+EvalCoord1f(u)
+ return void
+ param u CoordF in value
+ category modeling
+ vectorequiv EvalCoord1fv
+ version 1.0
+ offset 230
+
+EvalCoord1fv(u)
+ return void
+ param u CoordF in array [1]
+ category modeling
+ version 1.0
+ glxropcode 152
+ glsopcode 0x00CF
+ offset 231
+
+EvalCoord2d(u, v)
+ return void
+ param u CoordD in value
+ param v CoordD in value
+ category modeling
+ vectorequiv EvalCoord2dv
+ version 1.0
+ offset 232
+
+EvalCoord2dv(u)
+ return void
+ param u CoordD in array [2]
+ category modeling
+ version 1.0
+ glxropcode 153
+ glsopcode 0x00D0
+ offset 233
+
+EvalCoord2f(u, v)
+ return void
+ param u CoordF in value
+ param v CoordF in value
+ category modeling
+ vectorequiv EvalCoord2fv
+ version 1.0
+ offset 234
+
+EvalCoord2fv(u)
+ return void
+ param u CoordF in array [2]
+ category modeling
+ version 1.0
+ glxropcode 154
+ glsopcode 0x00D1
+ offset 235
+
+EvalMesh1(mode, i1, i2)
+ return void
+ param mode MeshMode1 in value
+ param i1 CheckedInt32 in value
+ param i2 CheckedInt32 in value
+ category modeling
+ version 1.0
+ glxropcode 155
+ glsopcode 0x00D2
+ offset 236
+
+EvalPoint1(i)
+ return void
+ param i Int32 in value
+ category modeling
+ version 1.0
+ glxropcode 156
+ glsopcode 0x00D3
+ offset 237
+
+EvalMesh2(mode, i1, i2, j1, j2)
+ return void
+ param mode MeshMode2 in value
+ param i1 CheckedInt32 in value
+ param i2 CheckedInt32 in value
+ param j1 CheckedInt32 in value
+ param j2 CheckedInt32 in value
+ category modeling
+ version 1.0
+ glxropcode 157
+ glsopcode 0x00D4
+ offset 238
+
+EvalPoint2(i, j)
+ return void
+ param i CheckedInt32 in value
+ param j CheckedInt32 in value
+ category modeling
+ version 1.0
+ glxropcode 158
+ glsopcode 0x00D5
+ offset 239
+
+###############################################################################
+#
+# pixel-op commands
+#
+###############################################################################
+
+AlphaFunc(func, ref)
+ return void
+ param func AlphaFunction in value
+ param ref ClampedFloat32 in value
+ category pixel-op
+ version 1.0
+ glxropcode 159
+ glsopcode 0x00D6
+ offset 240
+
+BlendFunc(sfactor, dfactor)
+ return void
+ param sfactor BlendingFactorSrc in value
+ param dfactor BlendingFactorDest in value
+ category pixel-op
+ version 1.0
+ glxropcode 160
+ glsopcode 0x00D7
+ offset 241
+
+LogicOp(opcode)
+ return void
+ param opcode LogicOp in value
+ category pixel-op
+ version 1.0
+ glxropcode 161
+ glsopcode 0x00D8
+ offset 242
+
+StencilFunc(func, ref, mask)
+ return void
+ param func StencilFunction in value
+ param ref ClampedStencilValue in value
+ param mask MaskedStencilValue in value
+ category pixel-op
+ version 1.0
+ glxropcode 162
+ glsopcode 0x00D9
+ offset 243
+
+StencilOp(fail, zfail, zpass)
+ return void
+ param fail StencilOp in value
+ param zfail StencilOp in value
+ param zpass StencilOp in value
+ category pixel-op
+ version 1.0
+ glxropcode 163
+ glsopcode 0x00DA
+ offset 244
+
+DepthFunc(func)
+ return void
+ param func DepthFunction in value
+ category pixel-op
+ version 1.0
+ glxropcode 164
+ glsopcode 0x00DB
+ offset 245
+
+###############################################################################
+#
+# pixel-rw commands
+#
+###############################################################################
+
+PixelZoom(xfactor, yfactor)
+ return void
+ param xfactor Float32 in value
+ param yfactor Float32 in value
+ category pixel-rw
+ version 1.0
+ glxropcode 165
+ glsopcode 0x00DC
+ offset 246
+
+PixelTransferf(pname, param)
+ return void
+ param pname PixelTransferParameter in value
+ param param CheckedFloat32 in value
+ category pixel-rw
+ version 1.0
+ glxropcode 166
+ glsflags gl-enum
+ glsopcode 0x00DD
+ offset 247
+
+PixelTransferi(pname, param)
+ return void
+ param pname PixelTransferParameter in value
+ param param CheckedInt32 in value
+ category pixel-rw
+ version 1.0
+ glxropcode 167
+ glsflags gl-enum
+ glsopcode 0x00DE
+ offset 248
+
+PixelStoref(pname, param)
+ return void
+ param pname PixelStoreParameter in value
+ param param CheckedFloat32 in value
+ dlflags notlistable
+ glxflags client-handcode
+ category pixel-rw
+ version 1.0
+ glxsingle 109
+ glsflags client gl-enum
+ glsopcode 0x00DF
+ wglflags batchable
+ offset 249
+
+PixelStorei(pname, param)
+ return void
+ param pname PixelStoreParameter in value
+ param param CheckedInt32 in value
+ dlflags notlistable
+ glxflags client-handcode
+ category pixel-rw
+ version 1.0
+ glxsingle 110
+ glsflags client gl-enum
+ glsopcode 0x00E0
+ wglflags batchable
+ offset 250
+
+PixelMapfv(map, mapsize, values)
+ return void
+ param map PixelMap in value
+ param mapsize CheckedInt32 in value
+ param values Float32 in array [mapsize]
+ category pixel-rw
+ glxflags client-handcode
+ version 1.0
+ glxropcode 168
+ glsopcode 0x00E1
+ offset 251
+
+PixelMapuiv(map, mapsize, values)
+ return void
+ param map PixelMap in value
+ param mapsize CheckedInt32 in value
+ param values UInt32 in array [mapsize]
+ category pixel-rw
+ glxflags client-handcode
+ version 1.0
+ glxropcode 169
+ glsopcode 0x00E2
+ offset 252
+
+PixelMapusv(map, mapsize, values)
+ return void
+ param map PixelMap in value
+ param mapsize CheckedInt32 in value
+ param values UInt16 in array [mapsize]
+ category pixel-rw
+ glxflags client-handcode
+ version 1.0
+ glxropcode 170
+ glsopcode 0x00E3
+ offset 253
+
+ReadBuffer(mode)
+ return void
+ param mode ReadBufferMode in value
+ category pixel-rw
+ version 1.0
+ glxropcode 171
+ glsopcode 0x00E4
+ offset 254
+
+CopyPixels(x, y, width, height, type)
+ return void
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ param type PixelCopyType in value
+ category pixel-rw
+ version 1.0
+ glxropcode 172
+ glsopcode 0x00E5
+ offset 255
+
+ReadPixels(x, y, width, height, format, type, pixels)
+ return void
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void out array [COMPSIZE(format/type/width/height)]
+ category pixel-rw
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxsingle 111
+ glsflags get pixel-pack
+ glsopcode 0x00E6
+ wglflags client-handcode server-handcode
+ offset 256
+
+DrawPixels(width, height, format, type, pixels)
+ return void
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height)]
+ category pixel-rw
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxropcode 173
+ glsflags pixel-unpack
+ glsopcode 0x00E7
+ wglflags client-handcode server-handcode
+ offset 257
+
+###############################################################################
+#
+# state-req commands
+#
+###############################################################################
+
+GetBooleanv(pname, params)
+ return void
+ param pname GetPName in value
+ param params Boolean out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode
+ version 1.0
+ glxsingle 112
+ glsflags client get
+ glsopcode 0x00E8
+ wglflags small-data
+ offset 258
+
+GetClipPlane(plane, equation)
+ return void
+ param plane ClipPlaneName in value
+ param equation Float64 out array [4]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 113
+ glxflags client-handcode server-handcode
+ glsflags get
+ glsopcode 0x00E9
+ offset 259
+
+GetDoublev(pname, params)
+ return void
+ param pname GetPName in value
+ param params Float64 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode
+ version 1.0
+ glxsingle 114
+ glsflags client get
+ glsopcode 0x00EA
+ wglflags small-data
+ offset 260
+
+GetError()
+ return ErrorCode
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode
+ version 1.0
+ glxsingle 115
+ glsflags get
+ glsopcode 0x00EB
+ offset 261
+
+GetFloatv(pname, params)
+ return void
+ param pname GetPName in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode
+ version 1.0
+ glxsingle 116
+ glsflags client get
+ glsopcode 0x00EC
+ wglflags small-data
+ offset 262
+
+GetIntegerv(pname, params)
+ return void
+ param pname GetPName in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode
+ version 1.0
+ glxsingle 117
+ glsflags client get
+ glsopcode 0x00ED
+ wglflags small-data
+ offset 263
+
+GetLightfv(light, pname, params)
+ return void
+ param light LightName in value
+ param pname LightParameter in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 118
+ glsflags get
+ glsopcode 0x00EE
+ wglflags small-data
+ offset 264
+
+GetLightiv(light, pname, params)
+ return void
+ param light LightName in value
+ param pname LightParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 119
+ glsflags get
+ glsopcode 0x00EF
+ wglflags small-data
+ offset 265
+
+GetMapdv(target, query, v)
+ return void
+ param target MapTarget in value
+ param query GetMapQuery in value
+ param v Float64 out array [COMPSIZE(target/query)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 120
+ glsflags get
+ glsopcode 0x00F0
+ offset 266
+
+GetMapfv(target, query, v)
+ return void
+ param target MapTarget in value
+ param query GetMapQuery in value
+ param v Float32 out array [COMPSIZE(target/query)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 121
+ glsflags get
+ glsopcode 0x00F1
+ offset 267
+
+GetMapiv(target, query, v)
+ return void
+ param target MapTarget in value
+ param query GetMapQuery in value
+ param v Int32 out array [COMPSIZE(target/query)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 122
+ glsflags get
+ glsopcode 0x00F2
+ offset 268
+
+GetMaterialfv(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 123
+ glsflags get
+ glsopcode 0x00F3
+ wglflags small-data
+ offset 269
+
+GetMaterialiv(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 124
+ glsflags get
+ glsopcode 0x00F4
+ wglflags small-data
+ offset 270
+
+GetPixelMapfv(map, values)
+ return void
+ param map PixelMap in value
+ param values Float32 out array [COMPSIZE(map)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 125
+ glsflags get
+ glsopcode 0x00F5
+ offset 271
+
+GetPixelMapuiv(map, values)
+ return void
+ param map PixelMap in value
+ param values UInt32 out array [COMPSIZE(map)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 126
+ glsflags get
+ glsopcode 0x00F6
+ offset 272
+
+GetPixelMapusv(map, values)
+ return void
+ param map PixelMap in value
+ param values UInt16 out array [COMPSIZE(map)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 127
+ glsflags get
+ glsopcode 0x00F7
+ offset 273
+
+GetPolygonStipple(mask)
+ return void
+ param mask UInt8 out array [COMPSIZE()]
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxsingle 128
+ glsflags get pixel-pack
+ glsopcode 0x00F8
+ wglflags client-handcode server-handcode
+ offset 274
+
+GetString(name)
+ return String
+ param name StringName in value
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxsingle 129
+ glsflags get
+ glsopcode 0x00F9
+ wglflags client-handcode server-handcode
+ offset 275
+
+GetTexEnvfv(target, pname, params)
+ return void
+ param target TextureEnvTarget in value
+ param pname TextureEnvParameter in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 130
+ glsflags get
+ glsopcode 0x00FA
+ wglflags small-data
+ offset 276
+
+GetTexEnviv(target, pname, params)
+ return void
+ param target TextureEnvTarget in value
+ param pname TextureEnvParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 131
+ glsflags get
+ glsopcode 0x00FB
+ wglflags small-data
+ offset 277
+
+GetTexGendv(coord, pname, params)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param params Float64 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 132
+ glsflags get
+ glsopcode 0x00FC
+ wglflags small-data
+ offset 278
+
+GetTexGenfv(coord, pname, params)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 133
+ glsflags get
+ glsopcode 0x00FD
+ wglflags small-data
+ offset 279
+
+GetTexGeniv(coord, pname, params)
+ return void
+ param coord TextureCoordName in value
+ param pname TextureGenParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 134
+ glsflags get
+ glsopcode 0x00FE
+ wglflags small-data
+ offset 280
+
+GetTexImage(target, level, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void out array [COMPSIZE(target/level/format/type)]
+ category state-req
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.0
+ glxsingle 135
+ glsflags get pixel-pack
+ glsopcode 0x00FF
+ wglflags client-handcode server-handcode
+ offset 281
+
+GetTexParameterfv(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname GetTextureParameter in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 136
+ glsflags get
+ glsopcode 0x0100
+ wglflags small-data
+ offset 282
+
+GetTexParameteriv(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname GetTextureParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 137
+ glsflags get
+ glsopcode 0x0101
+ wglflags small-data
+ offset 283
+
+GetTexLevelParameterfv(target, level, pname, params)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param pname GetTextureParameter in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 138
+ glsflags get
+ glsopcode 0x0102
+ wglflags small-data
+ offset 284
+
+GetTexLevelParameteriv(target, level, pname, params)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param pname GetTextureParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 139
+ glsflags get
+ glsopcode 0x0103
+ wglflags small-data
+ offset 285
+
+IsEnabled(cap)
+ return Boolean
+ param cap EnableCap in value
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxflags client-handcode client-intercept
+ glxsingle 140
+ glsflags client get
+ glsopcode 0x0104
+ offset 286
+
+IsList(list)
+ return Boolean
+ param list List in value
+ category state-req
+ dlflags notlistable
+ version 1.0
+ glxsingle 141
+ glsflags get
+ glsopcode 0x0105
+ offset 287
+
+###############################################################################
+#
+# xform commands
+#
+###############################################################################
+
+DepthRange(near, far)
+ return void
+ param near ClampedFloat64 in value
+ param far ClampedFloat64 in value
+ category xform
+ version 1.0
+ glxropcode 174
+ glsopcode 0x0106
+ offset 288
+
+Frustum(left, right, bottom, top, zNear, zFar)
+ return void
+ param left Float64 in value
+ param right Float64 in value
+ param bottom Float64 in value
+ param top Float64 in value
+ param zNear Float64 in value
+ param zFar Float64 in value
+ category xform
+ version 1.0
+ glxropcode 175
+ glsopcode 0x0107
+ offset 289
+
+LoadIdentity()
+ return void
+ category xform
+ version 1.0
+ glxropcode 176
+ glsopcode 0x0108
+ offset 290
+
+LoadMatrixf(m)
+ return void
+ param m Float32 in array [16]
+ category xform
+ version 1.0
+ glxropcode 177
+ glsflags matrix
+ glsopcode 0x0109
+ offset 291
+
+LoadMatrixd(m)
+ return void
+ param m Float64 in array [16]
+ category xform
+ version 1.0
+ glxropcode 178
+ glsflags matrix
+ glsopcode 0x010A
+ offset 292
+
+MatrixMode(mode)
+ return void
+ param mode MatrixMode in value
+ category xform
+ version 1.0
+ glxropcode 179
+ glsopcode 0x010B
+ offset 293
+
+MultMatrixf(m)
+ return void
+ param m Float32 in array [16]
+ category xform
+ version 1.0
+ glxropcode 180
+ glsflags matrix
+ glsopcode 0x010C
+ offset 294
+
+MultMatrixd(m)
+ return void
+ param m Float64 in array [16]
+ category xform
+ version 1.0
+ glxropcode 181
+ glsflags matrix
+ glsopcode 0x010D
+ offset 295
+
+Ortho(left, right, bottom, top, zNear, zFar)
+ return void
+ param left Float64 in value
+ param right Float64 in value
+ param bottom Float64 in value
+ param top Float64 in value
+ param zNear Float64 in value
+ param zFar Float64 in value
+ category xform
+ version 1.0
+ glxropcode 182
+ glsopcode 0x010E
+ offset 296
+
+PopMatrix()
+ return void
+ category xform
+ version 1.0
+ glxropcode 183
+ glsopcode 0x010F
+ offset 297
+
+PushMatrix()
+ return void
+ category xform
+ version 1.0
+ glxropcode 184
+ glsopcode 0x0110
+ offset 298
+
+Rotated(angle, x, y, z)
+ return void
+ param angle Float64 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ category xform
+ version 1.0
+ glxropcode 185
+ glsopcode 0x0111
+ offset 299
+
+Rotatef(angle, x, y, z)
+ return void
+ param angle Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category xform
+ version 1.0
+ glxropcode 186
+ glsopcode 0x0112
+ offset 300
+
+Scaled(x, y, z)
+ return void
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ category xform
+ version 1.0
+ glxropcode 187
+ glsopcode 0x0113
+ offset 301
+
+Scalef(x, y, z)
+ return void
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category xform
+ version 1.0
+ glxropcode 188
+ glsopcode 0x0114
+ offset 302
+
+Translated(x, y, z)
+ return void
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ category xform
+ version 1.0
+ glxropcode 189
+ glsopcode 0x0115
+ offset 303
+
+Translatef(x, y, z)
+ return void
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category xform
+ version 1.0
+ glxropcode 190
+ glsopcode 0x0116
+ offset 304
+
+Viewport(x, y, width, height)
+ return void
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category xform
+ version 1.0
+ glxropcode 191
+ glsopcode 0x0117
+ offset 305
+
+###############################################################################
+#
+# OpenGL 1.1 commands
+#
+###############################################################################
+
+ArrayElement(i)
+ return void
+ param i Int32 in value
+ category 1_1
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsopcode 0x013E
+ offset 306
+
+ColorPointer(size, type, stride, pointer)
+ return void
+ param size Int32 in value
+ param type ColorPointerType in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x0152
+ offset 308
+
+DisableClientState(array)
+ return void
+ param array EnableCap in value
+ category 1_1
+ version 1.1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ glsflags client
+ glsopcode 0x0153
+ offset 309
+
+DrawArrays(mode, first, count)
+ return void
+ param mode BeginMode in value
+ param first Int32 in value
+ param count SizeI in value
+ category 1_1
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glxropcode 193
+ glsopcode 0x0258
+ offset 310
+
+DrawElements(mode, count, type, indices)
+ return void
+ param mode BeginMode in value
+ param count SizeI in value
+ param type DrawElementsType in value
+ param indices Void in array [COMPSIZE(count/type)]
+ category 1_1
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsopcode 0x0154
+ offset 311
+
+EdgeFlagPointer(stride, pointer)
+ return void
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(stride)] retained
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x0155
+ offset 312
+
+EnableClientState(array)
+ return void
+ param array EnableCap in value
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x0156
+ offset 313
+
+GetPointerv(pname, params)
+ return void
+ param pname GetPointervPName in value
+ param params VoidPointer out array [1]
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client get
+ glsopcode 0x0142
+ offset 329
+
+IndexPointer(type, stride, pointer)
+ return void
+ param type IndexPointerType in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x0157
+ offset 314
+
+InterleavedArrays(format, stride, pointer)
+ return void
+ param format InterleavedArrayFormat in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(format/stride)] retained
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x0158
+ offset 317
+
+NormalPointer(type, stride, pointer)
+ return void
+ param type NormalPointerType in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x0159
+ offset 318
+
+TexCoordPointer(size, type, stride, pointer)
+ return void
+ param size Int32 in value
+ param type TexCoordPointerType in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x015A
+ offset 320
+
+VertexPointer(size, type, stride, pointer)
+ return void
+ param size Int32 in value
+ param type VertexPointerType in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ category 1_1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags client
+ glsopcode 0x015B
+ offset 321
+
+PolygonOffset(factor, units)
+ return void
+ param factor Float32 in value
+ param units Float32 in value
+ category 1_1
+ version 1.1
+ glxropcode 192
+ glsopcode 0x015C
+ offset 319
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CopyTexImage1D(target, level, internalformat, x, y, width, border)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param border CheckedInt32 in value
+ category 1_1
+ version 1.1
+ glxropcode 4119
+ glxflags EXT
+ glsopcode 0x014D
+ offset 323
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CopyTexImage2D(target, level, internalformat, x, y, width, height, border)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ param border CheckedInt32 in value
+ category 1_1
+ version 1.1
+ glxropcode 4120
+ glxflags EXT
+ glsopcode 0x014E
+ offset 324
+
+CopyTexSubImage1D(target, level, xoffset, x, y, width)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category 1_1
+ version 1.1
+ glxropcode 4121
+ glxflags EXT
+ glsopcode 0x014F
+ offset 325
+
+CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category 1_1
+ version 1.1
+ glxropcode 4122
+ glxflags EXT
+ glsopcode 0x0150
+ offset 326
+
+TexSubImage1D(target, level, xoffset, width, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width)]
+ category 1_1
+ dlflags handcode
+ glxflags EXT client-handcode server-handcode
+ version 1.1
+ glxropcode 4099
+ glsflags pixel-unpack
+ glsopcode 0x0123
+ offset 332
+
+TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height)]
+ category 1_1
+ dlflags handcode
+ glxflags EXT client-handcode server-handcode
+ version 1.1
+ glxropcode 4100
+ glsflags pixel-unpack
+ glsopcode 0x0124
+ offset 333
+
+AreTexturesResident(n, textures, residences)
+ return Boolean
+ param n SizeI in value
+ param textures Texture in array [n]
+ param residences Boolean out array [n]
+ category 1_1
+ glxsingle 143
+ dlflags notlistable
+ version 1.1
+ glsflags get
+ glsopcode 0x0259
+ offset 322
+
+BindTexture(target, texture)
+ return void
+ param target TextureTarget in value
+ param texture Texture in value
+ category 1_1
+ version 1.1
+ glxropcode 4117
+ glxflags EXT
+ glsopcode 0x0148
+ offset 307
+
+DeleteTextures(n, textures)
+ return void
+ param n SizeI in value
+ param textures Texture in array [n]
+ category 1_1
+ dlflags notlistable
+ version 1.1
+ glxsingle 144
+ glsopcode 0x025A
+ offset 327
+
+GenTextures(n, textures)
+ return void
+ param n SizeI in value
+ param textures Texture out array [n]
+ category 1_1
+ dlflags notlistable
+ version 1.1
+ glxsingle 145
+ glsopcode 0x025B
+ offset 328
+
+IsTexture(texture)
+ return Boolean
+ param texture Texture in value
+ category 1_1
+ dlflags notlistable
+ version 1.1
+ glxsingle 146
+ glsflags get
+ glsopcode 0x025C
+ offset 330
+
+PrioritizeTextures(n, textures, priorities)
+ return void
+ param n SizeI in value
+ param textures Texture in array [n]
+ param priorities ClampedFloat32 in array [n]
+ category 1_1
+ version 1.1
+ glxropcode 4118
+ glxflags EXT
+ glsopcode 0x014C
+ offset 331
+
+Indexub(c)
+ return void
+ param c ColorIndexValueUB in value
+ category 1_1
+ vectorequiv Indexubv
+ version 1.1
+ offset 315
+
+Indexubv(c)
+ return void
+ param c ColorIndexValueUB in array [1]
+ category 1_1
+ version 1.1
+ glxropcode 194
+ glsopcode 0x015D
+ offset 316
+
+PopClientAttrib()
+ return void
+ category 1_1
+ version 1.1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ glsflags client
+ glsopcode 0x015E
+ offset 334
+
+PushClientAttrib(mask)
+ return void
+ param mask ClientAttribMask in value
+ category 1_1
+ version 1.1
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ glsflags client
+ glsopcode 0x015F
+ offset 335
+
+###############################################################################
+###############################################################################
+#
+# OpenGL 1.2 commands
+#
+###############################################################################
+###############################################################################
+
+BlendColor(red, green, blue, alpha)
+ return void
+ param red ClampedColorF in value
+ param green ClampedColorF in value
+ param blue ClampedColorF in value
+ param alpha ClampedColorF in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4096
+ glsopcode 0x0120
+ offset 336
+
+BlendEquation(mode)
+ return void
+ param mode BlendEquationMode in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4097
+ glsopcode 0x0121
+ offset 337
+
+DrawRangeElements(mode, start, end, count, type, indices)
+ return void
+ param mode BeginMode in value
+ param start UInt32 in value
+ param end UInt32 in value
+ param count SizeI in value
+ param type DrawElementsType in value
+ param indices Void in array [COMPSIZE(count/type)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.2
+ glsopcode 0x0190
+ offset 338
+
+# OpenGL 1.2 (SGI_color_table) commands
+
+ColorTable(target, internalformat, width, format, type, table)
+ return void
+ param target ColorTableTarget in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param table Void in array [COMPSIZE(format/type/width)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.2
+ glxropcode 2053
+ glsflags pixel-unpack
+ glsopcode 0x0167
+ offset 339
+
+ColorTableParameterfv(target, pname, params)
+ return void
+ param target ColorTableTarget in value
+ param pname ColorTableParameterPName in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 2054
+ glsopcode 0x0168
+ offset 340
+
+ColorTableParameteriv(target, pname, params)
+ return void
+ param target ColorTableTarget in value
+ param pname ColorTableParameterPName in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 2055
+ glsopcode 0x0169
+ offset 341
+
+CopyColorTable(target, internalformat, x, y, width)
+ return void
+ param target ColorTableTarget in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 2056
+ glsopcode 0x016A
+ offset 342
+
+GetColorTable(target, format, type, table)
+ return void
+ param target ColorTableTarget in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param table Void out array [COMPSIZE(target/format/type)]
+ category VERSION_1_2
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.2
+ glxsingle 147
+ glsflags get pixel-pack
+ glsopcode 0x025D
+ offset 343
+
+GetColorTableParameterfv(target, pname, params)
+ return void
+ param target ColorTableTarget in value
+ param pname GetColorTableParameterPName in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 148
+ glsflags get
+ glsopcode 0x025E
+ offset 344
+
+GetColorTableParameteriv(target, pname, params)
+ return void
+ param target ColorTableTarget in value
+ param pname GetColorTableParameterPName in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 149
+ glsflags get
+ glsopcode 0x025F
+ offset 345
+
+# OpenGL 1.2 (EXT_color_subtable) commands
+
+ColorSubTable(target, start, count, format, type, data)
+ return void
+ param target ColorTableTarget in value
+ param start SizeI in value
+ param count SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param data Void in array [COMPSIZE(format/type/count)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode server-handcode
+ version 1.2
+ glxropcode 195
+ glsflags pixel-unpack
+ glsopcode 0x018E
+ offset 346
+
+CopyColorSubTable(target, start, x, y, width)
+ return void
+ param target ColorTableTarget in value
+ param start SizeI in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category VERSION_1_2
+ version 1.2
+ glxropcode 196
+ glsopcode 0x018F
+ offset 347
+
+# OpenGL 1.2 (EXT_convolution) commands
+
+ConvolutionFilter1D(target, internalformat, width, format, type, image)
+ return void
+ param target ConvolutionTarget in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param image Void in array [COMPSIZE(format/type/width)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.2
+ glxropcode 4101
+ glsflags pixel-unpack
+ glsopcode 0x0125
+ offset 348
+
+ConvolutionFilter2D(target, internalformat, width, height, format, type, image)
+ return void
+ param target ConvolutionTarget in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param image Void in array [COMPSIZE(format/type/width/height)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.2
+ glxropcode 4102
+ glsflags pixel-unpack
+ glsopcode 0x0126
+ offset 349
+
+ConvolutionParameterf(target, pname, params)
+ return void
+ param target ConvolutionTarget in value
+ param pname ConvolutionParameter in value
+ param params CheckedFloat32 in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4103
+ glsflags gl-enum
+ glsopcode 0x0127
+ offset 350
+
+ConvolutionParameterfv(target, pname, params)
+ return void
+ param target ConvolutionTarget in value
+ param pname ConvolutionParameter in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4104
+ glsflags gl-enum
+ glsopcode 0x0128
+ offset 351
+
+ConvolutionParameteri(target, pname, params)
+ return void
+ param target ConvolutionTarget in value
+ param pname ConvolutionParameter in value
+ param params CheckedInt32 in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4105
+ glsflags gl-enum
+ glsopcode 0x0129
+ offset 352
+
+ConvolutionParameteriv(target, pname, params)
+ return void
+ param target ConvolutionTarget in value
+ param pname ConvolutionParameter in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4106
+ glsflags gl-enum
+ glsopcode 0x012A
+ offset 353
+
+CopyConvolutionFilter1D(target, internalformat, x, y, width)
+ return void
+ param target ConvolutionTarget in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4107
+ glsopcode 0x012B
+ offset 354
+
+CopyConvolutionFilter2D(target, internalformat, x, y, width, height)
+ return void
+ param target ConvolutionTarget in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4108
+ glsopcode 0x012C
+ offset 355
+
+GetConvolutionFilter(target, format, type, image)
+ return void
+ param target ConvolutionTarget in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param image Void out array [COMPSIZE(target/format/type)]
+ category VERSION_1_2
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.2
+ glxsingle 150
+ glsflags get pixel-pack
+ glsopcode 0x0260
+ offset 356
+
+GetConvolutionParameterfv(target, pname, params)
+ return void
+ param target ConvolutionTarget in value
+ param pname GetConvolutionParameterPName in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 151
+ glsflags get
+ glsopcode 0x0261
+ offset 357
+
+GetConvolutionParameteriv(target, pname, params)
+ return void
+ param target ConvolutionTarget in value
+ param pname GetConvolutionParameterPName in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 152
+ glsflags get
+ glsopcode 0x0262
+ offset 358
+
+GetSeparableFilter(target, format, type, row, column, span)
+ return void
+ param target SeparableTarget in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param row Void out array [COMPSIZE(target/format/type)]
+ param column Void out array [COMPSIZE(target/format/type)]
+ param span Void out array [COMPSIZE(target/format/type)]
+ category VERSION_1_2
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.2
+ glxsingle 153
+ glsflags get pixel-pack
+ glsopcode 0x0263
+ offset 359
+
+SeparableFilter2D(target, internalformat, width, height, format, type, row, column)
+ return void
+ param target SeparableTarget in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param row Void in array [COMPSIZE(target/format/type/width)]
+ param column Void in array [COMPSIZE(target/format/type/height)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.2
+ glxropcode 4109
+ glsflags pixel-unpack
+ glsopcode 0x0131
+ offset 360
+
+# OpenGL 1.2 (EXT_histogram) commands
+
+GetHistogram(target, reset, format, type, values)
+ return void
+ param target HistogramTarget in value
+ param reset Boolean in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param values Void out array [COMPSIZE(target/format/type)]
+ category VERSION_1_2
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.2
+ glxsingle 154
+ glsflags get pixel-pack
+ glsopcode 0x0264
+ offset 361
+
+GetHistogramParameterfv(target, pname, params)
+ return void
+ param target HistogramTarget in value
+ param pname GetHistogramParameterPName in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 155
+ glsflags get
+ glsopcode 0x0265
+ offset 362
+
+GetHistogramParameteriv(target, pname, params)
+ return void
+ param target HistogramTarget in value
+ param pname GetHistogramParameterPName in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 156
+ glsflags get
+ glsopcode 0x0266
+ offset 363
+
+GetMinmax(target, reset, format, type, values)
+ return void
+ param target MinmaxTarget in value
+ param reset Boolean in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param values Void out array [COMPSIZE(target/format/type)]
+ category VERSION_1_2
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.2
+ glxsingle 157
+ glsflags get pixel-pack
+ glsopcode 0x0267
+ offset 364
+
+GetMinmaxParameterfv(target, pname, params)
+ return void
+ param target MinmaxTarget in value
+ param pname GetMinmaxParameterPName in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 158
+ glsflags get
+ glsopcode 0x0268
+ offset 365
+
+GetMinmaxParameteriv(target, pname, params)
+ return void
+ param target MinmaxTarget in value
+ param pname GetMinmaxParameterPName in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category VERSION_1_2
+ dlflags notlistable
+ version 1.2
+ glxsingle 159
+ glsflags get
+ glsopcode 0x0269
+ offset 366
+
+Histogram(target, width, internalformat, sink)
+ return void
+ param target HistogramTarget in value
+ param width SizeI in value
+ param internalformat PixelInternalFormat in value
+ param sink Boolean in value
+ category VERSION_1_2
+ dlflags handcode
+ glxflags EXT
+ version 1.2
+ glxropcode 4110
+ glsopcode 0x0138
+ offset 367
+
+Minmax(target, internalformat, sink)
+ return void
+ param target MinmaxTarget in value
+ param internalformat PixelInternalFormat in value
+ param sink Boolean in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4111
+ glsopcode 0x0139
+ offset 368
+
+ResetHistogram(target)
+ return void
+ param target HistogramTarget in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4112
+ glsopcode 0x013A
+ offset 369
+
+ResetMinmax(target)
+ return void
+ param target MinmaxTarget in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4113
+ glsopcode 0x013B
+ offset 370
+
+# OpenGL 1.2 (EXT_texture3D) commands
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat TextureComponentCount in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param border CheckedInt32 in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height/depth)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.2
+ glxropcode 4114
+ glsflags pixel-null pixel-unpack
+ glsopcode 0x013C
+ offset 371
+
+TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param zoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height/depth)]
+ category VERSION_1_2
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.2
+ glxropcode 4115
+ glsflags pixel-unpack
+ glsopcode 0x013D
+ offset 372
+
+# OpenGL 1.2 (EXT_copy_texture) commands (specific to texture3D)
+
+CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param zoffset CheckedInt32 in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category VERSION_1_2
+ glxflags EXT
+ version 1.2
+ glxropcode 4123
+ glsopcode 0x0151
+ offset 373
+
+###############################################################################
+###############################################################################
+#
+# OpenGL 1.3 commands
+#
+###############################################################################
+###############################################################################
+
+# OpenGL 1.3 (ARB_multitexture) commands
+
+ActiveTexture(texture)
+ return void
+ param texture TextureUnit in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 197
+ glsopcode 0x01B1
+ offset 374
+
+ClientActiveTexture(texture)
+ return void
+ param texture TextureUnit in value
+ category VERSION_1_3
+ dlflags notlistable
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.3
+ glsflags client
+ glsopcode 0x01B2
+ offset 375
+
+MultiTexCoord1d(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord1dv
+ offset 376
+
+MultiTexCoord1dv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [1]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 198
+ glsopcode 0x01B3
+ offset 377
+
+MultiTexCoord1f(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord1fv
+ offset 378
+
+MultiTexCoord1fv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [1]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 199
+ glsopcode 0x01B4
+ offset 379
+
+MultiTexCoord1i(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord1iv
+ offset 380
+
+MultiTexCoord1iv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [1]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 200
+ glsopcode 0x01B5
+ offset 381
+
+MultiTexCoord1s(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord1sv
+ offset 382
+
+MultiTexCoord1sv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [1]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 201
+ glsopcode 0x01B6
+ offset 383
+
+MultiTexCoord2d(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ param t CoordD in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord2dv
+ offset 384
+
+MultiTexCoord2dv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [2]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 202
+ glsopcode 0x01B7
+ offset 385
+
+MultiTexCoord2f(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ param t CoordF in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord2fv
+ offset 386
+
+MultiTexCoord2fv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [2]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 203
+ glsopcode 0x01B8
+ offset 387
+
+MultiTexCoord2i(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ param t CoordI in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord2iv
+ offset 388
+
+MultiTexCoord2iv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [2]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 204
+ glsopcode 0x01B9
+ offset 389
+
+MultiTexCoord2s(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ param t CoordS in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord2sv
+ offset 390
+
+MultiTexCoord2sv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [2]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 205
+ glsopcode 0x01BA
+ offset 391
+
+MultiTexCoord3d(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ param t CoordD in value
+ param r CoordD in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord3dv
+ offset 392
+
+MultiTexCoord3dv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [3]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 206
+ glsopcode 0x01BB
+ offset 393
+
+MultiTexCoord3f(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ param t CoordF in value
+ param r CoordF in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord3fv
+ offset 394
+
+MultiTexCoord3fv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [3]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 207
+ glsopcode 0x01BC
+ offset 395
+
+MultiTexCoord3i(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ param t CoordI in value
+ param r CoordI in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord3iv
+ offset 396
+
+MultiTexCoord3iv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [3]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 208
+ glsopcode 0x01BD
+ offset 397
+
+MultiTexCoord3s(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ param t CoordS in value
+ param r CoordS in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord3sv
+ offset 398
+
+MultiTexCoord3sv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [3]
+ category VERSION_1_3
+ version 1.3
+ glxflags ARB
+ glxropcode 209
+ glsopcode 0x01BE
+ offset 399
+
+MultiTexCoord4d(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ param t CoordD in value
+ param r CoordD in value
+ param q CoordD in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord4dv
+ offset 400
+
+MultiTexCoord4dv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [4]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 210
+ glsopcode 0x01BF
+ offset 401
+
+MultiTexCoord4f(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ param t CoordF in value
+ param r CoordF in value
+ param q CoordF in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord4fv
+ offset 402
+
+MultiTexCoord4fv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [4]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 211
+ glsopcode 0x01C0
+ offset 403
+
+MultiTexCoord4i(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ param t CoordI in value
+ param r CoordI in value
+ param q CoordI in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord4iv
+ offset 404
+
+MultiTexCoord4iv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [4]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 212
+ glsopcode 0x01C1
+ offset 405
+
+MultiTexCoord4s(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ param t CoordS in value
+ param r CoordS in value
+ param q CoordS in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ vectorequiv MultiTexCoord4sv
+ offset 406
+
+MultiTexCoord4sv(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [4]
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 213
+ glsopcode 0x01C2
+ offset 407
+
+# OpenGL 1.3 (ARB_transpose_matrix) commands
+
+LoadTransposeMatrixf(m)
+ return void
+ param m Float32 in array [16]
+ category VERSION_1_3
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.3
+ glsflags matrix
+ glsopcode 0x01C3
+ offset 408
+
+LoadTransposeMatrixd(m)
+ return void
+ param m Float64 in array [16]
+ category VERSION_1_3
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.3
+ glsflags matrix
+ glsopcode 0x01C4
+ offset 409
+
+MultTransposeMatrixf(m)
+ return void
+ param m Float32 in array [16]
+ category VERSION_1_3
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.3
+ glsflags matrix
+ glsopcode 0x01C5
+ offset 410
+
+MultTransposeMatrixd(m)
+ return void
+ param m Float64 in array [16]
+ category VERSION_1_3
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.3
+ glsflags matrix
+ glsopcode 0x01C6
+ offset 411
+
+# OpenGL 1.3 (ARB_multisample) commands
+
+SampleCoverage(value, invert)
+ return void
+ param value ClampedFloat32 in value
+ param invert Boolean in value
+ category VERSION_1_3
+ glxflags ARB
+ version 1.3
+ glxropcode 229
+ glsopcode 0x01C7
+ offset 412
+
+# OpenGL 1.3 (ARB_texture_compression) commands
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param border CheckedInt32 in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category VERSION_1_3
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.3
+ glxropcode 216
+ glsopcode 0x01C9
+ wglflags client-handcode server-handcode
+ offset 554
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param border CheckedInt32 in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category VERSION_1_3
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.3
+ glxropcode 215
+ glsopcode 0x01CA
+ wglflags client-handcode server-handcode
+ offset 555
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param border CheckedInt32 in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category VERSION_1_3
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.3
+ glxropcode 214
+ glsopcode 0x01CB
+ wglflags client-handcode server-handcode
+ offset 556
+
+CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param zoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param format PixelFormat in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category VERSION_1_3
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.3
+ glxropcode 219
+ glsopcode 0x01CC
+ wglflags client-handcode server-handcode
+ offset 557
+
+CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category VERSION_1_3
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.3
+ glxropcode 218
+ glsopcode 0x01CD
+ wglflags client-handcode server-handcode
+ offset 558
+
+CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category VERSION_1_3
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.3
+ glxropcode 217
+ glsopcode 0x01CE
+ wglflags client-handcode server-handcode
+ offset 559
+
+GetCompressedTexImage(target, level, img)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param img CompressedTextureARB out array [COMPSIZE(target/level)]
+ category VERSION_1_3
+ dlflags notlistable
+ glxflags ARB client-handcode server-handcode
+ version 1.3
+ glxsingle 160
+ glsflags get
+ glsopcode 0x01CF
+ wglflags client-handcode server-handcode
+ offset 560
+
+
+###############################################################################
+###############################################################################
+#
+# OpenGL 1.4 commands
+#
+###############################################################################
+###############################################################################
+
+# OpenGL 1.4 (EXT_blend_func_separate) commands
+
+BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)
+ return void
+ param sfactorRGB BlendFuncSeparateParameterEXT in value
+ param dfactorRGB BlendFuncSeparateParameterEXT in value
+ param sfactorAlpha BlendFuncSeparateParameterEXT in value
+ param dfactorAlpha BlendFuncSeparateParameterEXT in value
+ category VERSION_1_4
+ glxropcode 4134
+ version 1.4
+ extension
+ glsopcode 0x01DC
+ offset 537
+
+# OpenGL 1.4 (EXT_fog_coord) commands
+
+FogCoordf(coord)
+ return void
+ param coord CoordF in value
+ category VERSION_1_4
+ vectorequiv FogCoordfv
+ version 1.4
+ offset 545
+
+FogCoordfv(coord)
+ return void
+ param coord CoordF in array [1]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4124
+ glsopcode 0x01D8
+ offset 546
+
+FogCoordd(coord)
+ return void
+ param coord CoordD in value
+ category VERSION_1_4
+ vectorequiv FogCoorddv
+ version 1.4
+ offset 547
+
+FogCoorddv(coord)
+ return void
+ param coord CoordD in array [1]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4125
+ glsopcode 0x01DA
+ offset 548
+
+FogCoordPointer(type, stride, pointer)
+ return void
+ param type FogPointerTypeEXT in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category VERSION_1_4
+ dlflags notlistable
+ version 1.4
+ glxflags client-handcode server-handcode
+ glsflags client
+ glsopcode 0x01DB
+ offset 549
+
+# OpenGL 1.4 (EXT_multi_draw_arrays) commands
+
+# first and count are really 'in'
+MultiDrawArrays(mode, first, count, primcount)
+ return void
+ param mode BeginMode in value
+ param first Int32 out array [COMPSIZE(count)]
+ param count SizeI out array [COMPSIZE(primcount)]
+ param primcount SizeI in value
+ category VERSION_1_4
+ version 1.4
+ glxropcode ?
+ glsflags ignore
+ offset 644
+
+MultiDrawElements(mode, count, type, indices, primcount)
+ return void
+ param mode BeginMode in value
+ param count SizeI in array [COMPSIZE(primcount)]
+ param type DrawElementsType in value
+ param indices VoidPointer in array [COMPSIZE(primcount)]
+ param primcount SizeI in value
+ category VERSION_1_4
+ version 1.4
+ glxropcode ?
+ glsflags ignore
+ offset 645
+
+# OpenGL 1.4 (ARB_point_parameters, NV_point_sprite) commands
+
+PointParameterf(pname, param)
+ return void
+ param pname PointParameterNameARB in value
+ param param CheckedFloat32 in value
+ category VERSION_1_4
+ version 1.4
+ glxropcode 2065
+ extension
+ glsopcode 0x0177
+ offset 458
+
+PointParameterfv(pname, params)
+ return void
+ param pname PointParameterNameARB in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 2066
+ extension
+ glsopcode 0x0178
+ offset 459
+
+PointParameteri(pname, param)
+ return void
+ param pname PointParameterNameARB in value
+ param param Int32 in value
+ category VERSION_1_4
+ version 1.4
+ extension soft WINSOFT NV20
+ glxropcode 4221
+ glsflags ignore
+ offset 642
+
+PointParameteriv(pname, params)
+ return void
+ param pname PointParameterNameARB in value
+ param params Int32 in array [COMPSIZE(pname)]
+ category VERSION_1_4
+ version 1.4
+ extension soft WINSOFT NV20
+ glxropcode 4222re
+ glsflags ignore
+ offset 643
+
+# OpenGL 1.4 (EXT_secondary_color) commands
+
+SecondaryColor3b(red, green, blue)
+ return void
+ param red ColorB in value
+ param green ColorB in value
+ param blue ColorB in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3bv
+ version 1.4
+ offset 561
+
+SecondaryColor3bv(v)
+ return void
+ param v ColorB in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4126
+ glsopcode 0x01FD
+ offset 562
+
+SecondaryColor3d(red, green, blue)
+ return void
+ param red ColorD in value
+ param green ColorD in value
+ param blue ColorD in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3dv
+ version 1.4
+ offset 563
+
+SecondaryColor3dv(v)
+ return void
+ param v ColorD in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4130
+ glsopcode 0x01FE
+ offset 564
+
+SecondaryColor3f(red, green, blue)
+ return void
+ param red ColorF in value
+ param green ColorF in value
+ param blue ColorF in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3fv
+ version 1.4
+ offset 565
+
+SecondaryColor3fv(v)
+ return void
+ param v ColorF in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4129
+ glsopcode 0x01FF
+ offset 566
+
+SecondaryColor3i(red, green, blue)
+ return void
+ param red ColorI in value
+ param green ColorI in value
+ param blue ColorI in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3iv
+ version 1.4
+ offset 567
+
+SecondaryColor3iv(v)
+ return void
+ param v ColorI in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4128
+ glsopcode 0x0200
+ offset 568
+
+SecondaryColor3s(red, green, blue)
+ return void
+ param red ColorS in value
+ param green ColorS in value
+ param blue ColorS in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3sv
+ version 1.4
+ offset 569
+
+SecondaryColor3sv(v)
+ return void
+ param v ColorS in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4127
+ glsopcode 0x0201
+ offset 570
+
+SecondaryColor3ub(red, green, blue)
+ return void
+ param red ColorUB in value
+ param green ColorUB in value
+ param blue ColorUB in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3ubv
+ version 1.4
+ offset 571
+
+SecondaryColor3ubv(v)
+ return void
+ param v ColorUB in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4131
+ glsopcode 0x0202
+ offset 572
+
+SecondaryColor3ui(red, green, blue)
+ return void
+ param red ColorUI in value
+ param green ColorUI in value
+ param blue ColorUI in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3uiv
+ version 1.4
+ offset 573
+
+SecondaryColor3uiv(v)
+ return void
+ param v ColorUI in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4133
+ glsopcode 0x0203
+ offset 574
+
+SecondaryColor3us(red, green, blue)
+ return void
+ param red ColorUS in value
+ param green ColorUS in value
+ param blue ColorUS in value
+ category VERSION_1_4
+ vectorequiv SecondaryColor3usv
+ version 1.4
+ offset 575
+
+SecondaryColor3usv(v)
+ return void
+ param v ColorUS in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 4132
+ glsopcode 0x0204
+ offset 576
+
+SecondaryColorPointer(size, type, stride, pointer)
+ return void
+ param size Int32 in value
+ param type ColorPointerType in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ category VERSION_1_4
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ version 1.4
+ extension
+ glsflags client
+ glsopcode 0x0205
+ offset 577
+
+# OpenGL 1.4 (ARB_window_pos) commands
+# Note: all WindowPos* entry points use glxropcode ropcode 230, with 3 float parameters
+
+WindowPos2d(x, y)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ category VERSION_1_4
+ vectorequiv WindowPos2dv
+ version 1.4
+ offset 513
+
+WindowPos2dv(v)
+ return void
+ param v CoordD in array [2]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F0
+ offset 514
+
+WindowPos2f(x, y)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ category VERSION_1_4
+ vectorequiv WindowPos2fv
+ version 1.4
+ offset 515
+
+WindowPos2fv(v)
+ return void
+ param v CoordF in array [2]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F1
+ offset 516
+
+WindowPos2i(x, y)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ category VERSION_1_4
+ vectorequiv WindowPos2iv
+ version 1.4
+ offset 517
+
+WindowPos2iv(v)
+ return void
+ param v CoordI in array [2]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F2
+ offset 518
+
+WindowPos2s(x, y)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ category VERSION_1_4
+ vectorequiv WindowPos2sv
+ version 1.4
+ offset 519
+
+WindowPos2sv(v)
+ return void
+ param v CoordS in array [2]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F3
+ offset 520
+
+WindowPos3d(x, y, z)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ vectorequiv WindowPos3dv
+ category VERSION_1_4
+ version 1.4
+ offset 521
+
+WindowPos3dv(v)
+ return void
+ param v CoordD in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F4
+ offset 522
+
+WindowPos3f(x, y, z)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ category VERSION_1_4
+ vectorequiv WindowPos3fv
+ version 1.4
+ offset 523
+
+WindowPos3fv(v)
+ return void
+ param v CoordF in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F5
+ offset 524
+
+WindowPos3i(x, y, z)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ category VERSION_1_4
+ vectorequiv WindowPos3iv
+ version 1.4
+ offset 525
+
+WindowPos3iv(v)
+ return void
+ param v CoordI in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F6
+ offset 526
+
+WindowPos3s(x, y, z)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ category VERSION_1_4
+ vectorequiv WindowPos3sv
+ version 1.4
+ offset 527
+
+WindowPos3sv(v)
+ return void
+ param v CoordS in array [3]
+ category VERSION_1_4
+ version 1.4
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ glsopcode 0x01F7
+ offset 528
+
+
+###############################################################################
+###############################################################################
+#
+# OpenGL 1.5 commands
+#
+###############################################################################
+###############################################################################
+
+# OpenGL 1.5 (ARB_occlusion_query) commands
+
+GenQueries(n, ids)
+ return void
+ param n SizeI in value
+ param ids UInt32 out array [n]
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxsingle 162
+ glxflags ignore
+ glsopcode ?
+ offset 700
+
+DeleteQueries(n, ids)
+ return void
+ param n SizeI in value
+ param ids UInt32 in array [n]
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxsingle 161
+ glxflags ignore
+ glsopcode ?
+ offset 701
+
+IsQuery(id)
+ return Boolean
+ param id UInt32 in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxsingle 163
+ glxflags ignore
+ glsopcode ?
+ offset 702
+
+BeginQuery(target, id)
+ return void
+ param target GLenum in value
+ param id UInt32 in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode 231
+ glxflags ignore
+ glsopcode ?
+ offset 703
+
+EndQuery(target)
+ return void
+ param target GLenum in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode 232
+ glxflags ignore
+ glsopcode ?
+ offset 704
+
+GetQueryiv(target, pname, params)
+ return void
+ param target GLenum in value
+ param pname GLenum in value
+ param params Int32 out array [pname]
+ category VERSION_1_5
+ dlflags notlistable
+ version 1.5
+ extension
+ glxsingle 164
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 705
+
+GetQueryObjectiv(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname GLenum in value
+ param params Int32 out array [pname]
+ category VERSION_1_5
+ dlflags notlistable
+ version 1.5
+ extension
+ glxsingle 165
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 706
+
+GetQueryObjectuiv(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname GLenum in value
+ param params UInt32 out array [pname]
+ category VERSION_1_5
+ dlflags notlistable
+ version 1.5
+ extension
+ glxsingle 166
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 707
+
+# OpenGL 1.5 (ARB_vertex_buffer_object) commands
+
+BindBuffer(target, buffer)
+ return void
+ param target BufferTargetARB in value
+ param buffer UInt32 in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 688
+
+DeleteBuffers(n, buffers)
+ return void
+ param n SizeI in value
+ param buffers ConstUInt32 in array [n]
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 691
+
+GenBuffers(n, buffers)
+ return void
+ param n SizeI in value
+ param buffers UInt32 out array [n]
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 692
+
+IsBuffer(buffer)
+ return Boolean
+ param buffer UInt32 in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 696
+
+BufferData(target, size, data, usage)
+ return void
+ param target BufferTargetARB in value
+ param size BufferSize in value
+ param data ConstVoid in array [size]
+ param usage BufferUsageARB in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 689
+
+BufferSubData(target, offset, size, data)
+ return void
+ param target BufferTargetARB in value
+ param offset BufferOffset in value
+ param size BufferSize in value
+ param data ConstVoid in array [size]
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 690
+
+GetBufferSubData(target, offset, size, data)
+ return void
+ param target BufferTargetARB in value
+ param offset BufferOffset in value
+ param size BufferSize in value
+ param data Void out array [size]
+ category VERSION_1_5
+ dlflags notlistable
+ version 1.5
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 695
+
+MapBuffer(target, access)
+ return VoidPointer
+ param target BufferTargetARB in value
+ param access BufferAccessARB in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 697
+
+UnmapBuffer(target)
+ return Boolean
+ param target BufferTargetARB in value
+ category VERSION_1_5
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 698
+
+GetBufferParameteriv(target, pname, params)
+ return void
+ param target BufferTargetARB in value
+ param pname BufferPNameARB in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category VERSION_1_5
+ dlflags notlistable
+ version 1.5
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 693
+
+GetBufferPointerv(target, pname, params)
+ return void
+ param target BufferTargetARB in value
+ param pname BufferPointerNameARB in value
+ param params VoidPointer out array [1]
+ category VERSION_1_5
+ dlflags notlistable
+ version 1.5
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 694
+
+# OpenGL 1.5 (EXT_shadow_funcs) commands - none
+
+
+###############################################################################
+###############################################################################
+#
+# OpenGL 2.0 commands
+#
+###############################################################################
+###############################################################################
+
+# OpenGL 2.0 (EXT_blend_equation_separate) commands
+
+BlendEquationSeparate(modeRGB, modeAlpha)
+ return void
+ param modeRGB BlendEquationModeEXT in value
+ param modeAlpha BlendEquationModeEXT in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode 4228
+ glsopcode ?
+
+# OpenGL 2.0 (ARB_draw_buffers) commands
+
+DrawBuffers(n, bufs)
+ return void
+ param n SizeI in value
+ param bufs DrawBufferModeATI in array [n]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode 233
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+# OpenGL 2.0 (ARB_stencil_two_side) commands
+
+StencilOpSeparate(face, sfail, dpfail, dppass)
+ return void
+ param face StencilFaceDirection in value
+ param sfail StencilOp in value
+ param dpfail StencilOp in value
+ param dppass StencilOp in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+StencilFuncSeparate(frontfunc, backfunc, ref, mask)
+ return void
+ param frontfunc StencilFunction in value
+ param backfunc StencilFunction in value
+ param ref ClampedStencilValue in value
+ param mask MaskedStencilValue in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+StencilMaskSeparate(face, mask)
+ return void
+ param face StencilFaceDirection in value
+ param mask MaskedStencilValue in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+# OpenGL 2.0 (ARB_shader_objects / ARB_vertex_shader / ARB_fragment_shader) commands
+
+AttachShader(program, shader)
+ return void
+ param program UInt32 in value
+ param shader UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+BindAttribLocation(program, index, name)
+ return void
+ param program UInt32 in value
+ param index UInt32 in value
+ param name Char in array []
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+CompileShader(shader)
+ return void
+ param shader UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+CreateProgram()
+ return UInt32
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+CreateShader(type)
+ return UInt32
+ param type GLenum in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DeleteProgram(program)
+ return void
+ param program UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DeleteShader(shader)
+ return void
+ param shader UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DetachShader(program, shader)
+ return void
+ param program UInt32 in value
+ param shader UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DisableVertexAttribArray(index)
+ return void
+ param index UInt32 in value
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 666
+
+EnableVertexAttribArray(index)
+ return void
+ param index UInt32 in value
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 665
+
+GetActiveAttrib(program, index, bufSize, length, size, type, name)
+ return void
+ param program UInt32 in value
+ param index UInt32 in value
+ param bufSize SizeI in value
+ param length SizeI out array [1]
+ param size Int32 out array [1]
+ param type GLenum out array [1]
+ param name Char out array []
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetActiveUniform(program, index, bufSize, length, size, type, name)
+ return void
+ param program UInt32 in value
+ param index UInt32 in value
+ param bufSize SizeI in value
+ param length SizeI out array [1]
+ param size Int32 out array [1]
+ param type GLenum out array [1]
+ param name Char out array []
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetAttachedShaders(program, maxCount, count, obj)
+ return void
+ param program UInt32 in value
+ param maxCount SizeI in value
+ param count SizeI out array [1]
+ param obj UInt32 out array [count]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetAttribLocation(program, name)
+ return Int32
+ param program UInt32 in value
+ param name Char in array []
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetProgramiv(program, pname, params)
+ return void
+ param program UInt32 in value
+ param pname GLenum in value
+ param params Int32 out array [pname]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetProgramInfoLog(program, bufSize, length, infoLog)
+ return void
+ param program UInt32 in value
+ param bufSize SizeI in value
+ param length SizeI out array [1]
+ param infoLog Char out array [length]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetShaderiv(shader, pname, params)
+ return void
+ param shader UInt32 in value
+ param pname GLenum in value
+ param params Int32 out array [pname]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetShaderInfoLog(shader, bufSize, length, infoLog)
+ return void
+ param shader UInt32 in value
+ param bufSize SizeI in value
+ param length SizeI out array [1]
+ param infoLog Char out array [length]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetShaderSource(shader, bufSize, length, source)
+ return void
+ param shader UInt32 in value
+ param bufSize SizeI in value
+ param length SizeI out array [1]
+ param source Char out array [length]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetUniformLocation(program, name)
+ return Int32
+ param program UInt32 in value
+ param name Char in array []
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetUniformfv(program, location, params)
+ return void
+ param program UInt32 in value
+ param location Int32 in value
+ param params Float32 out array [location]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetUniformiv(program, location, params)
+ return void
+ param program UInt32 in value
+ param location Int32 in value
+ param params Int32 out array [location]
+ category VERSION_2_0
+ dlflags notlistable
+ version 2.0
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetVertexAttribdv(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPropertyARB in value
+ param params Float64 out array [4]
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxvendorpriv 1301
+ glsflags client get
+ glsopcode 0x0232
+ offset 588
+
+GetVertexAttribfv(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPropertyARB in value
+ param params Float32 out array [4]
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxvendorpriv 1302
+ glsflags client get
+ glsopcode 0x0233
+ offset 589
+
+GetVertexAttribiv(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPropertyARB in value
+ param params Int32 out array [4]
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxvendorpriv 1303
+ glsflags client get
+ glsopcode 0x0234
+ offset 590
+
+GetVertexAttribPointerv(index, pname, pointer)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPointerPropertyARB in value
+ param pointer VoidPointer out array [1]
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags client get
+ glsopcode 0x0235
+ offset 591
+
+IsProgram(program)
+ return Boolean
+ param program UInt32 in value
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxvendorpriv 1304
+ glsflags get
+ glsopcode 0x0236
+ offset 592
+
+IsShader(shader)
+ return Boolean
+ param shader UInt32 in value
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxvendorpriv ?
+ glsflags get
+ glsopcode ?
+ offset ?
+
+LinkProgram(program)
+ return void
+ param program UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+ShaderSource(shader, count, string, length)
+ return void
+ param shader UInt32 in value
+ param count SizeI in value
+ param string CharPointer in array [count]
+ param length Int32 in array [1]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UseProgram(program)
+ return void
+ param program UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform1f(location, v0)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform2f(location, v0, v1)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ param v1 Float32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform3f(location, v0, v1, v2)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ param v1 Float32 in value
+ param v2 Float32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform4f(location, v0, v1, v2, v3)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ param v1 Float32 in value
+ param v2 Float32 in value
+ param v3 Float32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform1i(location, v0)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform2i(location, v0, v1)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ param v1 Int32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform3i(location, v0, v1, v2)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ param v1 Int32 in value
+ param v2 Int32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform4i(location, v0, v1, v2, v3)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ param v1 Int32 in value
+ param v2 Int32 in value
+ param v3 Int32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform1fv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform2fv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform3fv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform4fv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform1iv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform2iv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform3iv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Uniform4iv(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix2fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix3fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix4fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [count]
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+ValidateProgram(program)
+ return void
+ param program UInt32 in value
+ category VERSION_2_0
+ version 2.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib1d(index, x)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib1dv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 603
+
+VertexAttrib1dv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [1]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4197
+ glsopcode 0x0240
+ offset 604
+
+VertexAttrib1f(index, x)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib1fv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 605
+
+VertexAttrib1fv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [1]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4193
+ glsopcode 0x023F
+ offset 606
+
+VertexAttrib1s(index, x)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib1sv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 607
+
+VertexAttrib1sv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [1]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4189
+ glsopcode 0x023E
+ offset 608
+
+VertexAttrib2d(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib2dv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 609
+
+VertexAttrib2dv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [2]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4198
+ glsopcode 0x0243
+ offset 610
+
+VertexAttrib2f(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib2fv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 611
+
+VertexAttrib2fv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [2]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4194
+ glsopcode 0x0242
+ offset 612
+
+VertexAttrib2s(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib2sv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 613
+
+VertexAttrib2sv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [2]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4190
+ glsopcode 0x0241
+ offset 614
+
+VertexAttrib3d(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib3dv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 615
+
+VertexAttrib3dv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [3]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4199
+ glsopcode 0x0246
+ offset 616
+
+VertexAttrib3f(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib3fv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 617
+
+VertexAttrib3fv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [3]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4195
+ glsopcode 0x0245
+ offset 618
+
+VertexAttrib3s(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib3sv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 619
+
+VertexAttrib3sv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [3]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4191
+ glsopcode 0x0244
+ offset 620
+
+VertexAttrib4Nbv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int8 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 659
+
+VertexAttrib4Niv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 661
+
+VertexAttrib4Nsv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 660
+
+VertexAttrib4Nub(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x UInt8 in value
+ param y UInt8 in value
+ param z UInt8 in value
+ param w UInt8 in value
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 627
+
+VertexAttrib4Nubv(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt8 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ glxropcode 4201
+ glsopcode 0x024A
+ offset 628
+
+VertexAttrib4Nuiv(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 663
+
+VertexAttrib4Nusv(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt16 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 662
+
+VertexAttrib4bv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int8 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 654
+
+VertexAttrib4d(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib4dv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 621
+
+VertexAttrib4dv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4200
+ glsopcode 0x0249
+ offset 622
+
+VertexAttrib4f(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib4fv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 623
+
+VertexAttrib4fv(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glxropcode 4196
+ glsopcode 0x0248
+ offset 624
+
+VertexAttrib4iv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 655
+
+VertexAttrib4s(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ param w Int16 in value
+ category VERSION_2_0
+ version 2.0
+ vectorequiv VertexAttrib4sv
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 625
+
+VertexAttrib4sv(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ glxropcode 4192
+ glsopcode 0x0247
+ offset 626
+
+VertexAttrib4ubv(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt8 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 656
+
+VertexAttrib4uiv(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 658
+
+VertexAttrib4usv(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt16 in array [4]
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 657
+
+VertexAttribPointer(index, size, type, normalized, stride, pointer)
+ return void
+ param index UInt32 in value
+ param size Int32 in value
+ param type VertexAttribPointerTypeARB in value
+ param normalized Boolean in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ dlflags notlistable
+ category VERSION_2_0
+ version 2.0
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 664
+
+
+###############################################################################
+###############################################################################
+#
+# OpenGL 2.1 commands
+#
+###############################################################################
+###############################################################################
+
+# OpenGL 2.1 (ARB_pixel_buffer_object) commands - none
+
+# OpenGL 2.1 (EXT_texture_sRGB) commands - none
+
+# New commands in OpenGL 2.1
+UniformMatrix2x3fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [6]
+ category VERSION_2_1
+ version 2.1
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix3x2fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [6]
+ category VERSION_2_1
+ version 2.1
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix2x4fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [8]
+ category VERSION_2_1
+ version 2.1
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix4x2fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [8]
+ category VERSION_2_1
+ version 2.1
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix3x4fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [12]
+ category VERSION_2_1
+ version 2.1
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UniformMatrix4x3fv(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [12]
+ category VERSION_2_1
+ version 2.1
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+
+
+###############################################################################
+###############################################################################
+#
+# ARB extensions, in order by ARB extension number
+#
+###############################################################################
+###############################################################################
+
+###############################################################################
+#
+# ARB Extension #1
+# ARB_multitexture commands
+#
+###############################################################################
+
+ActiveTextureARB(texture)
+ return void
+ param texture TextureUnit in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 197
+ alias ActiveTexture
+ glsalias ActiveTexture
+
+ClientActiveTextureARB(texture)
+ return void
+ param texture TextureUnit in value
+ category ARB_multitexture
+ dlflags notlistable
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.2
+ alias ClientActiveTexture
+ glsalias ClientActiveTexture
+
+MultiTexCoord1dARB(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord1dv
+
+MultiTexCoord1dvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [1]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 198
+ alias MultiTexCoord1dv
+ glsalias MultiTexCoord1dv
+
+MultiTexCoord1fARB(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord1fv
+
+MultiTexCoord1fvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [1]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 199
+ alias MultiTexCoord1fv
+ glsalias MultiTexCoord1fv
+
+MultiTexCoord1iARB(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord1iv
+
+MultiTexCoord1ivARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [1]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 200
+ alias MultiTexCoord1iv
+ glsalias MultiTexCoord1iv
+
+MultiTexCoord1sARB(target, s)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord1sv
+
+MultiTexCoord1svARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [1]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 201
+ alias MultiTexCoord1sv
+ glsalias MultiTexCoord1sv
+
+MultiTexCoord2dARB(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ param t CoordD in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord2dv
+
+MultiTexCoord2dvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [2]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 202
+ alias MultiTexCoord2dv
+ glsalias MultiTexCoord2dv
+
+MultiTexCoord2fARB(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ param t CoordF in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord2fv
+
+MultiTexCoord2fvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [2]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 203
+ alias MultiTexCoord2fv
+ glsalias MultiTexCoord2fv
+
+MultiTexCoord2iARB(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ param t CoordI in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord2iv
+
+MultiTexCoord2ivARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [2]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 204
+ alias MultiTexCoord2iv
+ glsalias MultiTexCoord2iv
+
+MultiTexCoord2sARB(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ param t CoordS in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord2sv
+
+MultiTexCoord2svARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [2]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 205
+ alias MultiTexCoord2sv
+ glsalias MultiTexCoord2sv
+
+MultiTexCoord3dARB(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ param t CoordD in value
+ param r CoordD in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord3dv
+
+MultiTexCoord3dvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [3]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 206
+ alias MultiTexCoord3dv
+ glsalias MultiTexCoord3dv
+
+MultiTexCoord3fARB(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ param t CoordF in value
+ param r CoordF in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord3fv
+
+MultiTexCoord3fvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [3]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 207
+ alias MultiTexCoord3fv
+ glsalias MultiTexCoord3fv
+
+MultiTexCoord3iARB(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ param t CoordI in value
+ param r CoordI in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord3iv
+
+MultiTexCoord3ivARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [3]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 208
+ alias MultiTexCoord3iv
+ glsalias MultiTexCoord3iv
+
+MultiTexCoord3sARB(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ param t CoordS in value
+ param r CoordS in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord3sv
+
+MultiTexCoord3svARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [3]
+ category ARB_multitexture
+ version 1.2
+ glxflags ARB
+ glxropcode 209
+ alias MultiTexCoord3sv
+ glsalias MultiTexCoord3sv
+
+MultiTexCoord4dARB(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordD in value
+ param t CoordD in value
+ param r CoordD in value
+ param q CoordD in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord4dv
+
+MultiTexCoord4dvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordD in array [4]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 210
+ alias MultiTexCoord4dv
+ glsalias MultiTexCoord4dv
+
+MultiTexCoord4fARB(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordF in value
+ param t CoordF in value
+ param r CoordF in value
+ param q CoordF in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord4fv
+
+MultiTexCoord4fvARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordF in array [4]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 211
+ alias MultiTexCoord4fv
+ glsalias MultiTexCoord4fv
+
+MultiTexCoord4iARB(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordI in value
+ param t CoordI in value
+ param r CoordI in value
+ param q CoordI in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord4iv
+
+MultiTexCoord4ivARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordI in array [4]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 212
+ alias MultiTexCoord4iv
+ glsalias MultiTexCoord4iv
+
+MultiTexCoord4sARB(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s CoordS in value
+ param t CoordS in value
+ param r CoordS in value
+ param q CoordS in value
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ vectorequiv MultiTexCoord4sv
+
+MultiTexCoord4svARB(target, v)
+ return void
+ param target TextureUnit in value
+ param v CoordS in array [4]
+ category ARB_multitexture
+ glxflags ARB
+ version 1.2
+ glxropcode 213
+ alias MultiTexCoord4sv
+ glsalias MultiTexCoord4sv
+
+################################################################################
+#
+# ARB Extension #2 - GLX_ARB_get_proc_address
+#
+###############################################################################
+
+################################################################################
+#
+# ARB Extension #3
+# ARB_transpose_matrix commands
+#
+###############################################################################
+
+LoadTransposeMatrixfARB(m)
+ return void
+ param m Float32 in array [16]
+ category ARB_transpose_matrix
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.2
+ alias LoadTransposeMatrixf
+ glsalias LoadTransposeMatrixf
+
+LoadTransposeMatrixdARB(m)
+ return void
+ param m Float64 in array [16]
+ category ARB_transpose_matrix
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.2
+ alias LoadTransposeMatrixd
+ glsalias LoadTransposeMatrixd
+
+MultTransposeMatrixfARB(m)
+ return void
+ param m Float32 in array [16]
+ category ARB_transpose_matrix
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.2
+ alias MultTransposeMatrixf
+ glsalias MultTransposeMatrixf
+
+MultTransposeMatrixdARB(m)
+ return void
+ param m Float64 in array [16]
+ category ARB_transpose_matrix
+ glxflags ARB client-handcode client-intercept server-handcode
+ version 1.2
+ alias MultTransposeMatrixd
+ glsalias MultTransposeMatrixd
+
+################################################################################
+#
+# ARB Extension #4 - WGL_ARB_buffer_region
+#
+###############################################################################
+
+################################################################################
+#
+# ARB Extension #5
+# ARB_multisample commands
+#
+###############################################################################
+
+SampleCoverageARB(value, invert)
+ return void
+ param value ClampedFloat32 in value
+ param invert Boolean in value
+ category ARB_multisample
+ glxflags ARB
+ version 1.2
+ alias SampleCoverage
+ glsalias SampleCoverage
+
+################################################################################
+#
+# ARB Extension #6
+# ARB_texture_env_add commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_env_add
+
+################################################################################
+#
+# ARB Extension #7
+# ARB_texture_cube_map commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_cube_map
+
+################################################################################
+#
+# ARB Extension #8 - WGL_ARB_extensions_string
+# ARB Extension #9 - WGL_ARB_pixel_format commands
+# ARB Extension #10 - WGL_ARB_make_current_read commands
+# ARB Extension #11 - WGL_ARB_pbuffer
+#
+###############################################################################
+
+################################################################################
+#
+# ARB Extension #12
+# ARB_texture_compression commands
+#
+###############################################################################
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param border CheckedInt32 in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category ARB_texture_compression
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.2
+ glxropcode 216
+ alias CompressedTexImage3D
+ glsalias CompressedTexImage3D
+ wglflags client-handcode server-handcode
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param border CheckedInt32 in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category ARB_texture_compression
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.2
+ glxropcode 215
+ alias CompressedTexImage2D
+ glsalias CompressedTexImage2D
+ wglflags client-handcode server-handcode
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param border CheckedInt32 in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category ARB_texture_compression
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.2
+ glxropcode 214
+ alias CompressedTexImage1D
+ glsalias CompressedTexImage1D
+ wglflags client-handcode server-handcode
+
+CompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param zoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param format PixelFormat in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category ARB_texture_compression
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.2
+ glxropcode 219
+ alias CompressedTexSubImage3D
+ glsalias CompressedTexSubImage3D
+ wglflags client-handcode server-handcode
+
+CompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category ARB_texture_compression
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.2
+ glxropcode 218
+ alias CompressedTexSubImage2D
+ glsalias CompressedTexSubImage2D
+ wglflags client-handcode server-handcode
+
+CompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param imageSize SizeI in value
+ param data CompressedTextureARB in array [imageSize]
+ category ARB_texture_compression
+ dlflags handcode
+ glxflags ARB client-handcode server-handcode
+ version 1.2
+ glxropcode 217
+ alias CompressedTexSubImage1D
+ glsalias CompressedTexSubImage1D
+ wglflags client-handcode server-handcode
+
+GetCompressedTexImageARB(target, level, img)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param img CompressedTextureARB out array [COMPSIZE(target/level)]
+ category ARB_texture_compression
+ dlflags notlistable
+ glxflags ARB client-handcode server-handcode
+ version 1.2
+ glxsingle 160
+ alias GetCompressedTexImage
+ glsalias GetCompressedTexImage
+ wglflags client-handcode server-handcode
+
+################################################################################
+#
+# ARB Extension #13
+# ARB_texture_border_clamp commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_border_clamp
+
+###############################################################################
+#
+# ARB Extension #14
+# ARB_point_parameters commands
+#
+###############################################################################
+
+PointParameterfARB(pname, param)
+ return void
+ param pname PointParameterNameARB in value
+ param param CheckedFloat32 in value
+ category ARB_point_parameters
+ version 1.0
+ glxflags ARB
+ glxropcode 2065
+ extension
+ alias PointParameterf
+ glsalias PointParameterf
+
+PointParameterfvARB(pname, params)
+ return void
+ param pname PointParameterNameARB in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category ARB_point_parameters
+ version 1.0
+ glxflags ARB
+ glxropcode 2066
+ extension
+ alias PointParameterfv
+ glsalias PointParameterfv
+
+################################################################################
+#
+# ARB Extension #15
+# ARB_vertex_blend commands
+#
+###############################################################################
+
+WeightbvARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights Int8 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 220
+ glxflags ignore
+ glsopcode 0x0206
+ offset ?
+
+WeightsvARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights Int16 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 222
+ glxflags ignore
+ glsopcode 0x0207
+ offset ?
+
+WeightivARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights Int32 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 224
+ glxflags ignore
+ glsopcode 0x0208
+ offset ?
+
+WeightfvARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights Float32 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 227
+ glxflags ignore
+ glsopcode 0x0209
+ offset ?
+
+WeightdvARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights Float64 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 228
+ glxflags ignore
+ glsopcode 0x020A
+ offset ?
+
+WeightubvARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights UInt8 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 221
+ glxflags ignore
+ glsopcode 0x020B
+ offset ?
+
+WeightusvARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights UInt16 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 223
+ glxflags ignore
+ glsopcode 0x020C
+ offset ?
+
+WeightuivARB(size, weights)
+ return void
+ param size Int32 in value
+ param weights UInt32 in array [size]
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 225
+ glxflags ignore
+ glsopcode 0x020D
+ offset ?
+
+WeightPointerARB(size, type, stride, pointer)
+ return void
+ param size Int32 in value
+ param type WeightPointerTypeARB in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ dlflags notlistable
+ glxflags ignore
+ glsflags client
+ glsopcode 0x020E
+ offset ?
+
+VertexBlendARB(count)
+ return void
+ param count Int32 in value
+ category ARB_vertex_blend
+ version 1.1
+ extension
+ glxropcode 226
+ glxflags ignore
+ glsopcode 0x020F
+ offset ?
+
+################################################################################
+#
+# ARB Extension #16
+# ARB_matrix_palette commands
+#
+###############################################################################
+
+CurrentPaletteMatrixARB(index)
+ return void
+ param index Int32 in value
+ category ARB_matrix_palette
+ version 1.1
+ extension
+ glxropcode 4329
+ glxflags ignore
+ glsopcode 0x0210
+ offset ?
+
+MatrixIndexubvARB(size, indices)
+ return void
+ param size Int32 in value
+ param indices UInt8 in array [size]
+ category ARB_matrix_palette
+ version 1.1
+ extension
+ glxropcode 4326
+ glxflags ignore
+ glsopcode 0x0211
+ offset ?
+
+MatrixIndexusvARB(size, indices)
+ return void
+ param size Int32 in value
+ param indices UInt16 in array [size]
+ category ARB_matrix_palette
+ version 1.1
+ extension
+ glxropcode 4327
+ glxflags ignore
+ glsopcode 0x0212
+ offset ?
+
+MatrixIndexuivARB(size, indices)
+ return void
+ param size Int32 in value
+ param indices UInt32 in array [size]
+ category ARB_matrix_palette
+ version 1.1
+ extension
+ glxropcode 4328
+ glxflags ignore
+ glsopcode 0x0213
+ offset ?
+
+MatrixIndexPointerARB(size, type, stride, pointer)
+ return void
+ param size Int32 in value
+ param type MatrixIndexPointerTypeARB in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category ARB_matrix_palette
+ version 1.1
+ extension
+ dlflags notlistable
+ glxflags ignore
+ glsflags client
+ glsopcode 0x0214
+ offset ?
+
+################################################################################
+#
+# ARB Extension #17
+# ARB_texture_env_combine commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_env_combine
+
+################################################################################
+#
+# ARB Extension #18
+# ARB_texture_env_crossbar commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_env_crossbar
+
+################################################################################
+#
+# ARB Extension #19
+# ARB_texture_env_dot3 commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_env_dot3
+
+###############################################################################
+#
+# ARB Extension #20 - WGL_ARB_render_texture
+#
+###############################################################################
+
+###############################################################################
+#
+# ARB Extension #21
+# ARB_texture_mirrored_repeat commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_mirrored_repeat
+
+###############################################################################
+#
+# ARB Extension #22
+# ARB_depth_texture commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_depth_texture
+
+###############################################################################
+#
+# ARB Extension #23
+# ARB_shadow commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_shadow
+
+###############################################################################
+#
+# ARB Extension #24
+# ARB_shadow_ambient commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_shadow_ambient
+
+###############################################################################
+#
+# ARB Extension #25
+# ARB_window_pos commands
+# Note: all entry points use glxropcode ropcode 230, with 3 float parameters
+#
+###############################################################################
+
+WindowPos2dARB(x, y)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ category ARB_window_pos
+ vectorequiv WindowPos2dvARB
+ version 1.0
+ alias WindowPos2d
+ glsalias WindowPos2d
+
+WindowPos2dvARB(v)
+ return void
+ param v CoordD in array [2]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos2dv
+ glsalias WindowPos2dv
+
+WindowPos2fARB(x, y)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ category ARB_window_pos
+ vectorequiv WindowPos2fvARB
+ version 1.0
+ alias WindowPos2f
+ glsalias WindowPos2f
+
+WindowPos2fvARB(v)
+ return void
+ param v CoordF in array [2]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos2fv
+ glsalias WindowPos2fv
+
+WindowPos2iARB(x, y)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ category ARB_window_pos
+ vectorequiv WindowPos2ivARB
+ version 1.0
+ alias WindowPos2i
+ glsalias WindowPos2i
+
+WindowPos2ivARB(v)
+ return void
+ param v CoordI in array [2]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos2iv
+ glsalias WindowPos2iv
+
+WindowPos2sARB(x, y)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ category ARB_window_pos
+ vectorequiv WindowPos2svARB
+ version 1.0
+ alias WindowPos2s
+ glsalias WindowPos2s
+
+WindowPos2svARB(v)
+ return void
+ param v CoordS in array [2]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos2sv
+ glsalias WindowPos2sv
+
+WindowPos3dARB(x, y, z)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ vectorequiv WindowPos3dvARB
+ category ARB_window_pos
+ version 1.0
+ alias WindowPos3d
+ glsalias WindowPos3d
+
+WindowPos3dvARB(v)
+ return void
+ param v CoordD in array [3]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos3dv
+ glsalias WindowPos3dv
+
+WindowPos3fARB(x, y, z)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ category ARB_window_pos
+ vectorequiv WindowPos3fvARB
+ version 1.0
+ alias WindowPos3f
+ glsalias WindowPos3f
+
+WindowPos3fvARB(v)
+ return void
+ param v CoordF in array [3]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos3fv
+ glsalias WindowPos3fv
+
+WindowPos3iARB(x, y, z)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ category ARB_window_pos
+ vectorequiv WindowPos3ivARB
+ version 1.0
+ alias WindowPos3i
+ glsalias WindowPos3i
+
+WindowPos3ivARB(v)
+ return void
+ param v CoordI in array [3]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos3iv
+ glsalias WindowPos3iv
+
+WindowPos3sARB(x, y, z)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ category ARB_window_pos
+ vectorequiv WindowPos3svARB
+ version 1.0
+ alias WindowPos3s
+ glsalias WindowPos3s
+
+WindowPos3svARB(v)
+ return void
+ param v CoordS in array [3]
+ category ARB_window_pos
+ version 1.0
+ glxropcode 230
+ glxflags client-handcode server-handcode
+ alias WindowPos3sv
+ glsalias WindowPos3sv
+
+###############################################################################
+#
+# ARB Extension #26
+# ARB_vertex_program commands
+#
+###############################################################################
+
+VertexAttrib1dARB(index, x)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib1dvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib1d
+ glsalias VertexAttrib1d
+
+VertexAttrib1dvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [1]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4197
+ glsopcode 0x0240
+ alias VertexAttrib1dv
+ glsalias VertexAttrib1dv
+
+VertexAttrib1fARB(index, x)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib1fvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib1f
+ glsalias VertexAttrib1f
+
+VertexAttrib1fvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [1]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4193
+ glsopcode 0x023F
+ alias VertexAttrib1fv
+ glsalias VertexAttrib1fv
+
+VertexAttrib1sARB(index, x)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib1svARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib1s
+ glsalias VertexAttrib1s
+
+VertexAttrib1svARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [1]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4189
+ glsopcode 0x023E
+ alias VertexAttrib1sv
+ glsalias VertexAttrib1sv
+
+VertexAttrib2dARB(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib2dvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib2d
+ glsalias VertexAttrib2d
+
+VertexAttrib2dvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [2]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4198
+ glsopcode 0x0243
+ alias VertexAttrib2dv
+ glsalias VertexAttrib2dv
+
+VertexAttrib2fARB(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib2fvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib2f
+ glsalias VertexAttrib2f
+
+VertexAttrib2fvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [2]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4194
+ glsopcode 0x0242
+ alias VertexAttrib2fv
+ glsalias VertexAttrib2fv
+
+VertexAttrib2sARB(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib2svARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib2s
+ glsalias VertexAttrib2s
+
+VertexAttrib2svARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [2]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4190
+ glsopcode 0x0241
+ alias VertexAttrib2sv
+ glsalias VertexAttrib2sv
+
+VertexAttrib3dARB(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib3dvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib3d
+ glsalias VertexAttrib3d
+
+VertexAttrib3dvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [3]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4199
+ glsopcode 0x0246
+ alias VertexAttrib3dv
+ glsalias VertexAttrib3dv
+
+VertexAttrib3fARB(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib3fvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib3f
+ glsalias VertexAttrib3f
+
+VertexAttrib3fvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [3]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4195
+ glsopcode 0x0245
+ alias VertexAttrib3fv
+ glsalias VertexAttrib3fv
+
+VertexAttrib3sARB(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib3svARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib3s
+ glsalias VertexAttrib3s
+
+VertexAttrib3svARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [3]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4191
+ glsopcode 0x0244
+ alias VertexAttrib3sv
+ glsalias VertexAttrib3sv
+
+VertexAttrib4NbvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int8 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4Nbv
+ glsalias VertexAttrib4Nbv
+
+VertexAttrib4NivARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4Niv
+ glsalias VertexAttrib4Niv
+
+VertexAttrib4NsvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4Nsv
+ glsalias VertexAttrib4Nsv
+
+VertexAttrib4NubARB(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x UInt8 in value
+ param y UInt8 in value
+ param z UInt8 in value
+ param w UInt8 in value
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4Nub
+ glsalias VertexAttrib4Nub
+
+VertexAttrib4NubvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt8 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4201
+ glsopcode 0x024A
+ alias VertexAttrib4Nubv
+ glsalias VertexAttrib4Nubv
+
+VertexAttrib4NuivARB(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4Nuiv
+ glsalias VertexAttrib4Nuiv
+
+VertexAttrib4NusvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt16 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4Nusv
+ glsalias VertexAttrib4Nusv
+
+VertexAttrib4bvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int8 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4bv
+ glsalias VertexAttrib4bv
+
+VertexAttrib4dARB(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib4dvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib4d
+ glsalias VertexAttrib4d
+
+VertexAttrib4dvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4200
+ glsopcode 0x0249
+ alias VertexAttrib4dv
+ glsalias VertexAttrib4dv
+
+VertexAttrib4fARB(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib4fvARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib4f
+ glsalias VertexAttrib4f
+
+VertexAttrib4fvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4196
+ glsopcode 0x0248
+ alias VertexAttrib4fv
+ glsalias VertexAttrib4fv
+
+VertexAttrib4ivARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4iv
+ glsalias VertexAttrib4iv
+
+VertexAttrib4sARB(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ param w Int16 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv VertexAttrib4svARB
+ extension soft WINSOFT NV10
+ alias VertexAttrib4s
+ glsalias VertexAttrib4s
+
+VertexAttrib4svARB(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4192
+ glsopcode 0x0247
+ alias VertexAttrib4sv
+ glsalias VertexAttrib4sv
+
+VertexAttrib4ubvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt8 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4ubv
+ glsalias VertexAttrib4ubv
+
+VertexAttrib4uivARB(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4uiv
+ glsalias VertexAttrib4uiv
+
+VertexAttrib4usvARB(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt16 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttrib4usv
+ glsalias VertexAttrib4usv
+
+VertexAttribPointerARB(index, size, type, normalized, stride, pointer)
+ return void
+ param index UInt32 in value
+ param size Int32 in value
+ param type VertexAttribPointerTypeARB in value
+ param normalized Boolean in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias VertexAttribPointer
+ glsalias VertexAttribPointer
+
+EnableVertexAttribArrayARB(index)
+ return void
+ param index UInt32 in value
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias EnableVertexAttribArray
+ glsalias EnableVertexAttribArray
+
+DisableVertexAttribArrayARB(index)
+ return void
+ param index UInt32 in value
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ alias DisableVertexAttribArray
+ glsalias DisableVertexAttribArray
+
+ProgramStringARB(target, format, len, string)
+ return void
+ param target ProgramTargetARB in value
+ param format ProgramFormatARB in value
+ param len SizeI in value
+ param string Void in array [len]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 667
+
+BindProgramARB(target, program)
+ return void
+ param target ProgramTargetARB in value
+ param program UInt32 in value
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxropcode 4180
+ glsopcode 0x0227
+ offset 579
+
+DeleteProgramsARB(n, programs)
+ return void
+ param n SizeI in value
+ param programs UInt32 in array [n]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxvendorpriv 1294
+ glsopcode 0x0228
+ offset 580
+
+GenProgramsARB(n, programs)
+ return void
+ param n SizeI in value
+ param programs UInt32 out array [n]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxvendorpriv 1295
+ glsopcode 0x022A
+ offset 582
+
+ProgramEnvParameter4dARB(target, index, x, y, z, w)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv ProgramEnvParameter4dvARB
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 668
+
+ProgramEnvParameter4dvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float64 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 669
+
+ProgramEnvParameter4fARB(target, index, x, y, z, w)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv ProgramEnvParameter4fvARB
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 670
+
+ProgramEnvParameter4fvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float32 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 671
+
+ProgramLocalParameter4dARB(target, index, x, y, z, w)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv ProgramLocalParameter4dvARB
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 672
+
+ProgramLocalParameter4dvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float64 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 673
+
+ProgramLocalParameter4fARB(target, index, x, y, z, w)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category ARB_vertex_program
+ version 1.3
+ vectorequiv ProgramLocalParameter4fvARB
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 674
+
+ProgramLocalParameter4fvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float32 in array [4]
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 675
+
+GetProgramEnvParameterdvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float64 out array [4]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 676
+
+GetProgramEnvParameterfvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float32 out array [4]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 677
+
+GetProgramLocalParameterdvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float64 out array [4]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 678
+
+GetProgramLocalParameterfvARB(target, index, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param params Float32 out array [4]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 679
+
+GetProgramivARB(target, pname, params)
+ return void
+ param target ProgramTargetARB in value
+ param pname ProgramPropertyARB in value
+ param params Int32 out array [1]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 680
+
+GetProgramStringARB(target, pname, string)
+ return void
+ param target ProgramTargetARB in value
+ param pname ProgramStringPropertyARB in value
+ param string Void out array [COMPSIZE(target,pname)]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glsflags ignore
+ glxflags ignore
+ offset 681
+
+GetVertexAttribdvARB(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPropertyARB in value
+ param params Float64 out array [4]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxvendorpriv 1301
+ glsflags client get
+ glsopcode 0x0232
+ alias GetVertexAttribdv
+ glsalias GetVertexAttribdv
+
+GetVertexAttribfvARB(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPropertyARB in value
+ param params Float32 out array [4]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxvendorpriv 1302
+ glsflags client get
+ glsopcode 0x0233
+ alias GetVertexAttribfv
+ glsalias GetVertexAttribfv
+
+GetVertexAttribivARB(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPropertyARB in value
+ param params Int32 out array [4]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxvendorpriv 1303
+ glsflags client get
+ glsopcode 0x0234
+ alias GetVertexAttribiv
+ glsalias GetVertexAttribiv
+
+GetVertexAttribPointervARB(index, pname, pointer)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribPointerPropertyARB in value
+ param pointer VoidPointer out array [1]
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags client get
+ glsopcode 0x0235
+ alias GetVertexAttribPointerv
+ glsalias GetVertexAttribPointerv
+
+IsProgramARB(program)
+ return Boolean
+ param program UInt32 in value
+ dlflags notlistable
+ category ARB_vertex_program
+ version 1.3
+ extension soft WINSOFT NV10
+ glxvendorpriv 1304
+ glsflags get
+ alias IsProgram
+ glsalias IsProgram
+
+
+###############################################################################
+#
+# ARB Extension #27
+# ARB_fragment_program commands
+#
+###############################################################################
+
+# All ARB_fragment_program entry points are shared with ARB_vertex_program,
+# and are only included in that #define block, for now.
+newcategory: ARB_fragment_program
+passthru: /* All ARB_fragment_program entry points are shared with ARB_vertex_program. */
+
+###############################################################################
+#
+# ARB Extension #28
+# ARB_vertex_buffer_object commands
+#
+###############################################################################
+
+BindBufferARB(target, buffer)
+ return void
+ param target BufferTargetARB in value
+ param buffer UInt32 in value
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias BindBuffer
+ glsalias BindBuffer
+
+DeleteBuffersARB(n, buffers)
+ return void
+ param n SizeI in value
+ param buffers ConstUInt32 in array [n]
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias DeleteBuffers
+ glsalias DeleteBuffers
+
+GenBuffersARB(n, buffers)
+ return void
+ param n SizeI in value
+ param buffers UInt32 out array [n]
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias GenBuffers
+ glsalias GenBuffers
+
+IsBufferARB(buffer)
+ return Boolean
+ param buffer UInt32 in value
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias IsBuffer
+ glsalias IsBuffer
+
+BufferDataARB(target, size, data, usage)
+ return void
+ param target BufferTargetARB in value
+ param size BufferSizeARB in value
+ param data ConstVoid in array [size]
+ param usage BufferUsageARB in value
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias BufferData
+ glsalias BufferData
+
+BufferSubDataARB(target, offset, size, data)
+ return void
+ param target BufferTargetARB in value
+ param offset BufferOffsetARB in value
+ param size BufferSizeARB in value
+ param data ConstVoid in array [size]
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias BufferSubData
+ glsalias BufferSubData
+
+GetBufferSubDataARB(target, offset, size, data)
+ return void
+ param target BufferTargetARB in value
+ param offset BufferOffsetARB in value
+ param size BufferSizeARB in value
+ param data Void out array [size]
+ category ARB_vertex_buffer_object
+ dlflags notlistable
+ version 1.2
+ extension
+ alias GetBufferSubData
+ glsalias GetBufferSubData
+
+MapBufferARB(target, access)
+ return VoidPointer
+ param target BufferTargetARB in value
+ param access BufferAccessARB in value
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias MapBuffer
+ glsalias MapBuffer
+
+UnmapBufferARB(target)
+ return Boolean
+ param target BufferTargetARB in value
+ category ARB_vertex_buffer_object
+ version 1.2
+ extension
+ alias UnmapBuffer
+ glsalias UnmapBuffer
+
+GetBufferParameterivARB(target, pname, params)
+ return void
+ param target BufferTargetARB in value
+ param pname BufferPNameARB in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category ARB_vertex_buffer_object
+ dlflags notlistable
+ version 1.2
+ extension
+ alias GetBufferParameteriv
+ glsalias GetBufferParameteriv
+
+GetBufferPointervARB(target, pname, params)
+ return void
+ param target BufferTargetARB in value
+ param pname BufferPointerNameARB in value
+ param params VoidPointer out array [1]
+ category ARB_vertex_buffer_object
+ dlflags notlistable
+ version 1.2
+ extension
+ alias GetBufferPointerv
+ glsalias GetBufferPointerv
+
+###############################################################################
+#
+# ARB Extension #29
+# ARB_occlusion_query commands
+#
+###############################################################################
+
+GenQueriesARB(n, ids)
+ return void
+ param n SizeI in value
+ param ids UInt32 out array [n]
+ category ARB_occlusion_query
+ version 1.5
+ extension
+ alias GenQueries
+ glsalias GenQueries
+
+DeleteQueriesARB(n, ids)
+ return void
+ param n SizeI in value
+ param ids UInt32 in array [n]
+ category ARB_occlusion_query
+ version 1.5
+ extension
+ alias DeleteQueries
+ glsalias DeleteQueries
+
+IsQueryARB(id)
+ return Boolean
+ param id UInt32 in value
+ category ARB_occlusion_query
+ version 1.5
+ extension
+ alias IsQuery
+ glsalias IsQuery
+
+BeginQueryARB(target, id)
+ return void
+ param target GLenum in value
+ param id UInt32 in value
+ category ARB_occlusion_query
+ version 1.5
+ extension
+ alias BeginQuery
+ glsalias BeginQuery
+
+EndQueryARB(target)
+ return void
+ param target GLenum in value
+ category ARB_occlusion_query
+ version 1.5
+ extension
+ alias EndQuery
+ glsalias EndQuery
+
+GetQueryivARB(target, pname, params)
+ return void
+ param target GLenum in value
+ param pname GLenum in value
+ param params Int32 out array [pname]
+ category ARB_occlusion_query
+ dlflags notlistable
+ version 1.5
+ extension
+ alias GetQueryiv
+ glsalias GetQueryiv
+
+GetQueryObjectivARB(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname GLenum in value
+ param params Int32 out array [pname]
+ category ARB_occlusion_query
+ dlflags notlistable
+ version 1.5
+ extension
+ alias GetQueryObjectiv
+ glsalias GetQueryObjectiv
+
+GetQueryObjectuivARB(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname GLenum in value
+ param params UInt32 out array [pname]
+ category ARB_occlusion_query
+ dlflags notlistable
+ version 1.5
+ extension
+ alias GetQueryObjectuiv
+ glsalias GetQueryObjectuiv
+
+###############################################################################
+#
+# ARB Extension #30
+# ARB_shader_objects commands
+#
+###############################################################################
+
+DeleteObjectARB(obj)
+ return void
+ param obj handleARB in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+GetHandleARB(pname)
+ return handleARB
+ param pname GLenum in value
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+DetachObjectARB(containerObj, attachedObj)
+ return void
+ param containerObj handleARB in value
+ param attachedObj handleARB in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias DetachShader
+ glsalias DetachShader
+
+CreateShaderObjectARB(shaderType)
+ return handleARB
+ param shaderType GLenum in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias CreateShader
+ glsalias CreateShader
+
+ShaderSourceARB(shaderObj, count, string, length)
+ return void
+ param shaderObj handleARB in value
+ param count SizeI in value
+ param string charPointerARB in array [count]
+ param length Int32 in array [1]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias ShaderSource
+ glsalias ShaderSource
+
+CompileShaderARB(shaderObj)
+ return void
+ param shaderObj handleARB in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias CompileShader
+ glsalias CompileShader
+
+CreateProgramObjectARB()
+ return handleARB
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias CreateProgram
+ glsalias CreateProgram
+
+AttachObjectARB(containerObj, obj)
+ return void
+ param containerObj handleARB in value
+ param obj handleARB in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias AttachShader
+ glsalias AttachShader
+
+LinkProgramARB(programObj)
+ return void
+ param programObj handleARB in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias LinkProgram
+ glsalias LinkProgram
+
+UseProgramObjectARB(programObj)
+ return void
+ param programObj handleARB in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias UseProgram
+ glsalias UseProgram
+
+ValidateProgramARB(programObj)
+ return void
+ param programObj handleARB in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias ValidateProgram
+ glsalias ValidateProgram
+
+Uniform1fARB(location, v0)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform1f
+ glsalias Uniform1f
+
+Uniform2fARB(location, v0, v1)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ param v1 Float32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform2f
+ glsalias Uniform2f
+
+Uniform3fARB(location, v0, v1, v2)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ param v1 Float32 in value
+ param v2 Float32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform3f
+ glsalias Uniform3f
+
+Uniform4fARB(location, v0, v1, v2, v3)
+ return void
+ param location Int32 in value
+ param v0 Float32 in value
+ param v1 Float32 in value
+ param v2 Float32 in value
+ param v3 Float32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform4f
+ glsalias Uniform4f
+
+Uniform1iARB(location, v0)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform1i
+ glsalias Uniform1i
+
+Uniform2iARB(location, v0, v1)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ param v1 Int32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform2i
+ glsalias Uniform2i
+
+Uniform3iARB(location, v0, v1, v2)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ param v1 Int32 in value
+ param v2 Int32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform3i
+ glsalias Uniform3i
+
+Uniform4iARB(location, v0, v1, v2, v3)
+ return void
+ param location Int32 in value
+ param v0 Int32 in value
+ param v1 Int32 in value
+ param v2 Int32 in value
+ param v3 Int32 in value
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform4i
+ glsalias Uniform4i
+
+Uniform1fvARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform1fv
+ glsalias Uniform1fv
+
+Uniform2fvARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform2fv
+ glsalias Uniform2fv
+
+Uniform3fvARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform3fv
+ glsalias Uniform3fv
+
+Uniform4fvARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Float32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform4fv
+ glsalias Uniform4fv
+
+Uniform1ivARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform1iv
+ glsalias Uniform1iv
+
+Uniform2ivARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform2iv
+ glsalias Uniform2iv
+
+Uniform3ivARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform3iv
+ glsalias Uniform3iv
+
+Uniform4ivARB(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value Int32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias Uniform4iv
+ glsalias Uniform4iv
+
+UniformMatrix2fvARB(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias UniformMatrix2fv
+ glsalias UniformMatrix2fv
+
+UniformMatrix3fvARB(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias UniformMatrix3fv
+ glsalias UniformMatrix3fv
+
+UniformMatrix4fvARB(location, count, transpose, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param transpose Boolean in value
+ param value Float32 in array [count]
+ category ARB_shader_objects
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias UniformMatrix4fv
+ glsalias UniformMatrix4fv
+
+GetObjectParameterfvARB(obj, pname, params)
+ return void
+ param obj handleARB in value
+ param pname GLenum in value
+ param params Float32 out array [pname]
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetObjectParameterivARB(obj, pname, params)
+ return void
+ param obj handleARB in value
+ param pname GLenum in value
+ param params Int32 out array [pname]
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetInfoLogARB(obj, maxLength, length, infoLog)
+ return void
+ param obj handleARB in value
+ param maxLength SizeI in value
+ param length SizeI out array [1]
+ param infoLog charARB out array [length]
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetAttachedObjectsARB(containerObj, maxCount, count, obj)
+ return void
+ param containerObj handleARB in value
+ param maxCount SizeI in value
+ param count SizeI out array [1]
+ param obj handleARB out array [count]
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetAttachedShaders
+ glsalias GetAttachedShaders
+
+GetUniformLocationARB(programObj, name)
+ return Int32
+ param programObj handleARB in value
+ param name charARB in array []
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetUniformLocation
+ glsalias GetUniformLocation
+
+GetActiveUniformARB(programObj, index, maxLength, length, size, type, name)
+ return void
+ param programObj handleARB in value
+ param index UInt32 in value
+ param maxLength SizeI in value
+ param length SizeI out array [1]
+ param size Int32 out array [1]
+ param type GLenum out array [1]
+ param name charARB out array []
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetActiveUniform
+ glsalias GetActiveUniform
+
+GetUniformfvARB(programObj, location, params)
+ return void
+ param programObj handleARB in value
+ param location Int32 in value
+ param params Float32 out array [location]
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetUniformfv
+ glsalias GetUniformfv
+
+GetUniformivARB(programObj, location, params)
+ return void
+ param programObj handleARB in value
+ param location Int32 in value
+ param params Int32 out array [location]
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetUniformiv
+ glsalias GetUniformiv
+
+GetShaderSourceARB(obj, maxLength, length, source)
+ return void
+ param obj handleARB in value
+ param maxLength SizeI in value
+ param length SizeI out array [1]
+ param source charARB out array [length]
+ category ARB_shader_objects
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetShaderSource
+ glsalias GetShaderSource
+
+
+###############################################################################
+#
+# ARB Extension #31
+# ARB_vertex_shader commands
+#
+###############################################################################
+
+BindAttribLocationARB(programObj, index, name)
+ return void
+ param programObj handleARB in value
+ param index UInt32 in value
+ param name charARB in array []
+ category ARB_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias BindAttribLocation
+ glsalias BindAttribLocation
+
+GetActiveAttribARB(programObj, index, maxLength, length, size, type, name)
+ return void
+ param programObj handleARB in value
+ param index UInt32 in value
+ param maxLength SizeI in value
+ param length SizeI out array [1]
+ param size Int32 out array [1]
+ param type GLenum out array [1]
+ param name charARB out array []
+ category ARB_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetActiveAttrib
+ glsalias GetActiveAttrib
+
+GetAttribLocationARB(programObj, name)
+ return Int32
+ param programObj handleARB in value
+ param name charARB in array []
+ category ARB_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ alias GetAttribLocation
+ glsalias GetAttribLocation
+
+###############################################################################
+#
+# ARB Extension #32
+# ARB_fragment_shader commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_fragment_shader
+
+###############################################################################
+#
+# ARB Extension #33
+# ARB_shading_language_100 commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_shading_language_100
+
+###############################################################################
+#
+# ARB Extension #34
+# ARB_texture_non_power_of_two commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_non_power_of_two
+
+###############################################################################
+#
+# ARB Extension #35
+# ARB_point_sprite commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_point_sprite
+
+###############################################################################
+#
+# ARB Extension #36
+# ARB_fragment_program_shadow commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_fragment_program_shadow
+
+###############################################################################
+#
+# ARB Extension #37
+# ARB_draw_buffers commands
+#
+###############################################################################
+
+DrawBuffersARB(n, bufs)
+ return void
+ param n SizeI in value
+ param bufs DrawBufferModeATI in array [n]
+ category ARB_draw_buffers
+ version 1.5
+ extension
+ alias DrawBuffers
+ glsalias DrawBuffers
+
+###############################################################################
+#
+# ARB Extension #38
+# ARB_texture_rectangle commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_rectangle
+
+###############################################################################
+#
+# ARB Extension #39
+# ARB_color_buffer_float commands
+#
+###############################################################################
+
+ClampColorARB(target, clamp)
+ return void
+ param target ClampColorTargetARB in value
+ param clamp ClampColorModeARB in value
+ category ARB_color_buffer_float
+ version 1.5
+ extension
+ glxropcode 234
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# ARB Extension #40
+# ARB_half_float_pixel commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_half_float_pixel
+
+###############################################################################
+#
+# ARB Extension #41
+# ARB_texture_float commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_texture_float
+
+###############################################################################
+#
+# ARB Extension #42
+# ARB_pixel_buffer_object commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_pixel_buffer_object
+
+
+###############################################################################
+###############################################################################
+#
+# Non-ARB extensions, in order by registry extension number
+#
+###############################################################################
+###############################################################################
+
+###############################################################################
+#
+# Extension #1
+# EXT_abgr commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_abgr
+
+###############################################################################
+#
+# Extension #2
+# EXT_blend_color commands
+#
+###############################################################################
+
+BlendColorEXT(red, green, blue, alpha)
+ return void
+ param red ClampedColorF in value
+ param green ClampedColorF in value
+ param blue ClampedColorF in value
+ param alpha ClampedColorF in value
+ category EXT_blend_color
+ version 1.0
+ glxropcode 4096
+ glxflags EXT
+ extension soft
+ alias BlendColor
+ glsalias BlendColor
+
+###############################################################################
+#
+# Extension #3
+# EXT_polygon_offset commands
+#
+###############################################################################
+
+PolygonOffsetEXT(factor, bias)
+ return void
+ param factor Float32 in value
+ param bias Float32 in value
+ category EXT_polygon_offset
+ version 1.0
+ glxropcode 4098
+ glxflags EXT
+ extension soft
+ glsopcode 0x0122
+ offset 414
+
+###############################################################################
+#
+# Extension #4
+# EXT_texture commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture
+
+###############################################################################
+#
+# Extension #5 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #6
+# EXT_texture3D commands
+#
+###############################################################################
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+TexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param border CheckedInt32 in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height/depth)]
+ category EXT_texture3D
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4114
+ extension
+ alias TexImage3D
+ glsalias TexImage3D
+
+TexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param zoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height/depth)]
+ category EXT_texture3D
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4115
+ extension
+ alias TexSubImage3D
+ glsalias TexSubImage3D
+
+###############################################################################
+#
+# Extension #7
+# SGIS_texture_filter4 commands
+#
+###############################################################################
+
+GetTexFilterFuncSGIS(target, filter, weights)
+ return void
+ param target TextureTarget in value
+ param filter TextureFilterSGIS in value
+ param weights Float32 out array [COMPSIZE(target/filter)]
+ category SGIS_texture_filter4
+ dlflags notlistable
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4101
+ extension
+ glsflags get
+ glsopcode 0x0175
+ offset 415
+
+TexFilterFuncSGIS(target, filter, n, weights)
+ return void
+ param target TextureTarget in value
+ param filter TextureFilterSGIS in value
+ param n SizeI in value
+ param weights Float32 in array [n]
+ category SGIS_texture_filter4
+ glxflags SGI
+ version 1.0
+ glxropcode 2064
+ extension
+ glsopcode 0x0176
+ offset 416
+
+###############################################################################
+#
+# Extension #8 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #9
+# EXT_subtexture commands
+#
+###############################################################################
+
+TexSubImage1DEXT(target, level, xoffset, width, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width)]
+ category EXT_subtexture
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4099
+ extension
+ alias TexSubImage1D
+ glsalias TexSubImage1D
+
+TexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height)]
+ category EXT_subtexture
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4100
+ extension
+ alias TexSubImage2D
+ glsalias TexSubImage2D
+
+###############################################################################
+#
+# Extension #10
+# EXT_copy_texture commands
+#
+###############################################################################
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CopyTexImage1DEXT(target, level, internalformat, x, y, width, border)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param border CheckedInt32 in value
+ category EXT_copy_texture
+ version 1.0
+ glxflags EXT
+ glxropcode 4119
+ extension
+ alias CopyTexImage1D
+ glsalias CopyTexImage1D
+
+# Arguably TexelInternalFormat, not PixelInternalFormat
+CopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ param border CheckedInt32 in value
+ category EXT_copy_texture
+ version 1.0
+ glxflags EXT
+ glxropcode 4120
+ extension
+ alias CopyTexImage2D
+ glsalias CopyTexImage2D
+
+CopyTexSubImage1DEXT(target, level, xoffset, x, y, width)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category EXT_copy_texture
+ version 1.0
+ glxflags EXT
+ glxropcode 4121
+ extension
+ alias CopyTexSubImage1D
+ glsalias CopyTexSubImage1D
+
+CopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category EXT_copy_texture
+ version 1.0
+ glxflags EXT
+ glxropcode 4122
+ extension
+ alias CopyTexSubImage2D
+ glsalias CopyTexSubImage2D
+
+CopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param zoffset CheckedInt32 in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category EXT_copy_texture
+ version 1.0
+ glxflags EXT
+ glxropcode 4123
+ extension
+ alias CopyTexSubImage3D
+ glsalias CopyTexSubImage3D
+
+###############################################################################
+#
+# Extension #11
+# EXT_histogram commands
+#
+###############################################################################
+
+GetHistogramEXT(target, reset, format, type, values)
+ return void
+ param target HistogramTargetEXT in value
+ param reset Boolean in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param values Void out array [COMPSIZE(target/format/type)]
+ category EXT_histogram
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxvendorpriv 5
+ extension
+ glsflags get pixel-pack
+ glsopcode 0x0132
+ offset 417
+
+GetHistogramParameterfvEXT(target, pname, params)
+ return void
+ param target HistogramTargetEXT in value
+ param pname GetHistogramParameterPNameEXT in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category EXT_histogram
+ dlflags notlistable
+ version 1.0
+ glxvendorpriv 6
+ glxflags EXT
+ extension
+ glsflags get
+ glsopcode 0x0133
+ offset 418
+
+GetHistogramParameterivEXT(target, pname, params)
+ return void
+ param target HistogramTargetEXT in value
+ param pname GetHistogramParameterPNameEXT in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category EXT_histogram
+ dlflags notlistable
+ version 1.0
+ glxvendorpriv 7
+ glxflags EXT
+ extension
+ glsflags get
+ glsopcode 0x0134
+ offset 419
+
+GetMinmaxEXT(target, reset, format, type, values)
+ return void
+ param target MinmaxTargetEXT in value
+ param reset Boolean in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param values Void out array [COMPSIZE(target/format/type)]
+ category EXT_histogram
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxvendorpriv 8
+ extension
+ glsflags get pixel-pack
+ glsopcode 0x0135
+ offset 420
+
+GetMinmaxParameterfvEXT(target, pname, params)
+ return void
+ param target MinmaxTargetEXT in value
+ param pname GetMinmaxParameterPNameEXT in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category EXT_histogram
+ dlflags notlistable
+ version 1.0
+ glxvendorpriv 9
+ glxflags EXT
+ extension
+ glsflags get
+ glsopcode 0x0136
+ offset 421
+
+GetMinmaxParameterivEXT(target, pname, params)
+ return void
+ param target MinmaxTargetEXT in value
+ param pname GetMinmaxParameterPNameEXT in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category EXT_histogram
+ dlflags notlistable
+ version 1.0
+ glxvendorpriv 10
+ glxflags EXT
+ extension
+ glsflags get
+ glsopcode 0x0137
+ offset 422
+
+HistogramEXT(target, width, internalformat, sink)
+ return void
+ param target HistogramTargetEXT in value
+ param width SizeI in value
+ param internalformat PixelInternalFormat in value
+ param sink Boolean in value
+ category EXT_histogram
+ version 1.0
+ glxropcode 4110
+ glxflags EXT
+ extension
+ alias Histogram
+ glsalias Histogram
+
+MinmaxEXT(target, internalformat, sink)
+ return void
+ param target MinmaxTargetEXT in value
+ param internalformat PixelInternalFormat in value
+ param sink Boolean in value
+ category EXT_histogram
+ version 1.0
+ glxropcode 4111
+ glxflags EXT
+ extension
+ alias Minmax
+ glsalias Minmax
+
+ResetHistogramEXT(target)
+ return void
+ param target HistogramTargetEXT in value
+ category EXT_histogram
+ version 1.0
+ glxropcode 4112
+ glxflags EXT
+ extension
+ alias ResetHistogram
+ glsalias ResetHistogram
+
+ResetMinmaxEXT(target)
+ return void
+ param target MinmaxTargetEXT in value
+ category EXT_histogram
+ version 1.0
+ glxropcode 4113
+ glxflags EXT
+ extension
+ alias ResetMinmax
+ glsalias ResetMinmax
+
+###############################################################################
+#
+# Extension #12
+# EXT_convolution commands
+#
+###############################################################################
+
+ConvolutionFilter1DEXT(target, internalformat, width, format, type, image)
+ return void
+ param target ConvolutionTargetEXT in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param image Void in array [COMPSIZE(format/type/width)]
+ category EXT_convolution
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4101
+ extension
+ alias ConvolutionFilter1D
+ glsalias ConvolutionFilter1D
+
+ConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image)
+ return void
+ param target ConvolutionTargetEXT in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param image Void in array [COMPSIZE(format/type/width/height)]
+ category EXT_convolution
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4102
+ extension
+ alias ConvolutionFilter2D
+ glsalias ConvolutionFilter2D
+
+ConvolutionParameterfEXT(target, pname, params)
+ return void
+ param target ConvolutionTargetEXT in value
+ param pname ConvolutionParameterEXT in value
+ param params CheckedFloat32 in value
+ category EXT_convolution
+ version 1.0
+ glxropcode 4103
+ glxflags EXT
+ extension
+ alias ConvolutionParameterf
+ glsalias ConvolutionParameterf
+
+ConvolutionParameterfvEXT(target, pname, params)
+ return void
+ param target ConvolutionTargetEXT in value
+ param pname ConvolutionParameterEXT in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category EXT_convolution
+ version 1.0
+ glxropcode 4104
+ glxflags EXT
+ extension
+ alias ConvolutionParameterfv
+ glsalias ConvolutionParameterfv
+
+ConvolutionParameteriEXT(target, pname, params)
+ return void
+ param target ConvolutionTargetEXT in value
+ param pname ConvolutionParameterEXT in value
+ param params CheckedInt32 in value
+ category EXT_convolution
+ version 1.0
+ glxropcode 4105
+ glxflags EXT
+ extension
+ alias ConvolutionParameteri
+ glsalias ConvolutionParameteri
+
+ConvolutionParameterivEXT(target, pname, params)
+ return void
+ param target ConvolutionTargetEXT in value
+ param pname ConvolutionParameterEXT in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category EXT_convolution
+ version 1.0
+ glxropcode 4106
+ glxflags EXT
+ extension
+ alias ConvolutionParameteriv
+ glsalias ConvolutionParameteriv
+
+CopyConvolutionFilter1DEXT(target, internalformat, x, y, width)
+ return void
+ param target ConvolutionTargetEXT in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category EXT_convolution
+ version 1.0
+ glxropcode 4107
+ glxflags EXT
+ extension
+ alias CopyConvolutionFilter1D
+ glsalias CopyConvolutionFilter1D
+
+CopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height)
+ return void
+ param target ConvolutionTargetEXT in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ param height SizeI in value
+ category EXT_convolution
+ version 1.0
+ glxropcode 4108
+ glxflags EXT
+ extension
+ alias CopyConvolutionFilter2D
+ glsalias CopyConvolutionFilter2D
+
+GetConvolutionFilterEXT(target, format, type, image)
+ return void
+ param target ConvolutionTargetEXT in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param image Void out array [COMPSIZE(target/format/type)]
+ category EXT_convolution
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxvendorpriv 1
+ extension
+ glsflags get pixel-pack
+ glsopcode 0x012D
+ offset 423
+
+GetConvolutionParameterfvEXT(target, pname, params)
+ return void
+ param target ConvolutionTargetEXT in value
+ param pname ConvolutionParameterEXT in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category EXT_convolution
+ dlflags notlistable
+ version 1.0
+ glxvendorpriv 2
+ glxflags EXT
+ extension
+ glsflags get
+ glsopcode 0x012E
+ offset 424
+
+GetConvolutionParameterivEXT(target, pname, params)
+ return void
+ param target ConvolutionTargetEXT in value
+ param pname ConvolutionParameterEXT in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category EXT_convolution
+ dlflags notlistable
+ version 1.0
+ glxvendorpriv 3
+ glxflags EXT
+ extension
+ glsflags get
+ glsopcode 0x012F
+ offset 425
+
+GetSeparableFilterEXT(target, format, type, row, column, span)
+ return void
+ param target SeparableTargetEXT in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param row Void out array [COMPSIZE(target/format/type)]
+ param column Void out array [COMPSIZE(target/format/type)]
+ param span Void out array [COMPSIZE(target/format/type)]
+ category EXT_convolution
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxvendorpriv 4
+ extension
+ glsflags get pixel-pack
+ glsopcode 0x0130
+ offset 426
+
+SeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column)
+ return void
+ param target SeparableTargetEXT in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param row Void in array [COMPSIZE(target/format/type/width)]
+ param column Void in array [COMPSIZE(target/format/type/height)]
+ category EXT_convolution
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4109
+ extension
+ alias SeparableFilter2D
+ glsalias SeparableFilter2D
+
+###############################################################################
+#
+# Extension #13
+# SGI_color_matrix commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGI_color_matrix
+
+###############################################################################
+#
+# Extension #14
+# SGI_color_table commands
+#
+###############################################################################
+
+ColorTableSGI(target, internalformat, width, format, type, table)
+ return void
+ param target ColorTableTargetSGI in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param table Void in array [COMPSIZE(format/type/width)]
+ category SGI_color_table
+ dlflags handcode
+ glxflags client-handcode server-handcode SGI
+ version 1.0
+ glxropcode 2053
+ extension
+ alias ColorTable
+ glsalias ColorTable
+
+ColorTableParameterfvSGI(target, pname, params)
+ return void
+ param target ColorTableTargetSGI in value
+ param pname ColorTableParameterPNameSGI in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category SGI_color_table
+ version 1.0
+ glxropcode 2054
+ glxflags SGI
+ extension
+ alias ColorTableParameterfv
+ glsalias ColorTableParameterfv
+
+ColorTableParameterivSGI(target, pname, params)
+ return void
+ param target ColorTableTargetSGI in value
+ param pname ColorTableParameterPNameSGI in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category SGI_color_table
+ version 1.0
+ glxropcode 2055
+ glxflags SGI
+ extension
+ alias ColorTableParameteriv
+ glsalias ColorTableParameteriv
+
+CopyColorTableSGI(target, internalformat, x, y, width)
+ return void
+ param target ColorTableTargetSGI in value
+ param internalformat PixelInternalFormat in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category SGI_color_table
+ version 1.0
+ glxropcode 2056
+ glxflags SGI
+ extension
+ alias CopyColorTable
+ glsalias CopyColorTable
+
+GetColorTableSGI(target, format, type, table)
+ return void
+ param target ColorTableTargetSGI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param table Void out array [COMPSIZE(target/format/type)]
+ category SGI_color_table
+ dlflags notlistable
+ glxflags client-handcode server-handcode SGI
+ version 1.0
+ glxvendorpriv 4098
+ extension
+ glsflags get pixel-pack
+ glsopcode 0x016B
+ offset 427
+
+GetColorTableParameterfvSGI(target, pname, params)
+ return void
+ param target ColorTableTargetSGI in value
+ param pname GetColorTableParameterPNameSGI in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category SGI_color_table
+ dlflags notlistable
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4099
+ extension
+ glsflags get
+ glsopcode 0x016C
+ offset 428
+
+GetColorTableParameterivSGI(target, pname, params)
+ return void
+ param target ColorTableTargetSGI in value
+ param pname GetColorTableParameterPNameSGI in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category SGI_color_table
+ dlflags notlistable
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4100
+ extension
+ glsflags get
+ glsopcode 0x016D
+ offset 429
+
+###############################################################################
+#
+# Extension #15
+# SGIX_pixel_texture commands
+#
+###############################################################################
+
+PixelTexGenSGIX(mode)
+ return void
+ param mode PixelTexGenModeSGIX in value
+ category SGIX_pixel_texture
+ version 1.0
+ glxflags SGI
+ glxropcode 2059
+ extension
+ glsopcode 0x0170
+ offset 430
+
+###############################################################################
+#
+# Extension #15 (variant)
+# SGIS_pixel_texture commands
+# Both SGIS and SGIX forms have extension #15!
+#
+###############################################################################
+
+PixelTexGenParameteriSGIS(pname, param)
+ return void
+ param pname PixelTexGenParameterNameSGIS in value
+ param param CheckedInt32 in value
+ category SGIS_pixel_texture
+ version 1.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x0192
+ offset 431
+
+PixelTexGenParameterivSGIS(pname, params)
+ return void
+ param pname PixelTexGenParameterNameSGIS in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category SGIS_pixel_texture
+ version 1.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x0193
+ offset 432
+
+PixelTexGenParameterfSGIS(pname, param)
+ return void
+ param pname PixelTexGenParameterNameSGIS in value
+ param param CheckedFloat32 in value
+ category SGIS_pixel_texture
+ version 1.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x0194
+ offset 433
+
+PixelTexGenParameterfvSGIS(pname, params)
+ return void
+ param pname PixelTexGenParameterNameSGIS in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category SGIS_pixel_texture
+ version 1.0
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x0195
+ offset 434
+
+GetPixelTexGenParameterivSGIS(pname, params)
+ return void
+ param pname PixelTexGenParameterNameSGIS in value
+ param params CheckedInt32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category SGIS_pixel_texture
+ version 1.0
+ extension
+ glxvendorpriv ?
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0196
+ offset 435
+
+GetPixelTexGenParameterfvSGIS(pname, params)
+ return void
+ param pname PixelTexGenParameterNameSGIS in value
+ param params CheckedFloat32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category SGIS_pixel_texture
+ version 1.0
+ extension
+ glxvendorpriv ?
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0197
+ offset 436
+
+###############################################################################
+#
+# Extension #16
+# SGIS_texture4D commands
+#
+###############################################################################
+
+TexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param size4d SizeI in value
+ param border CheckedInt32 in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height/depth/size4d)]
+ category SGIS_texture4D
+ dlflags handcode
+ glxflags client-handcode server-handcode SGI
+ version 1.0
+ glxropcode 2057
+ extension
+ glsflags pixel-null pixel-unpack
+ glsopcode 0x016E
+ offset 437
+
+TexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels)
+ return void
+ param target TextureTarget in value
+ param level CheckedInt32 in value
+ param xoffset CheckedInt32 in value
+ param yoffset CheckedInt32 in value
+ param zoffset CheckedInt32 in value
+ param woffset CheckedInt32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param size4d SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param pixels Void in array [COMPSIZE(format/type/width/height/depth/size4d)]
+ category SGIS_texture4D
+ dlflags handcode
+ glxflags client-handcode server-handcode SGI
+ version 1.0
+ glxropcode 2058
+ extension
+ glsflags pixel-unpack
+ glsopcode 0x016F
+ offset 438
+
+###############################################################################
+#
+# Extension #17
+# SGI_texture_color_table commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGI_texture_color_table
+
+###############################################################################
+#
+# Extension #18
+# EXT_cmyka commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_cmyka
+
+###############################################################################
+#
+# Extension #19 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #20
+# EXT_texture_object commands
+#
+###############################################################################
+
+AreTexturesResidentEXT(n, textures, residences)
+ return Boolean
+ param n SizeI in value
+ param textures Texture in array [n]
+ param residences Boolean out array [n]
+ category EXT_texture_object
+ glxflags EXT
+ glxvendorpriv 11
+ dlflags notlistable
+ version 1.0
+ extension
+ glsflags get
+ glsopcode 0x0147
+ offset 439
+
+BindTextureEXT(target, texture)
+ return void
+ param target TextureTarget in value
+ param texture Texture in value
+ category EXT_texture_object
+ version 1.0
+ glxflags EXT
+ glxropcode 4117
+ extension
+ alias BindTexture
+ glsalias BindTexture
+
+DeleteTexturesEXT(n, textures)
+ return void
+ param n SizeI in value
+ param textures Texture in array [n]
+ category EXT_texture_object
+ dlflags notlistable
+ version 1.0
+ glxflags EXT
+ glxvendorpriv 12
+ extension
+ glsopcode 0x0149
+ offset 561
+
+GenTexturesEXT(n, textures)
+ return void
+ param n SizeI in value
+ param textures Texture out array [n]
+ category EXT_texture_object
+ dlflags notlistable
+ version 1.0
+ glxflags EXT
+ glxvendorpriv 13
+ extension
+ glsopcode 0x014A
+ offset 440
+
+IsTextureEXT(texture)
+ return Boolean
+ param texture Texture in value
+ category EXT_texture_object
+ dlflags notlistable
+ version 1.0
+ glxflags EXT
+ glxvendorpriv 14
+ extension
+ glsflags get
+ glsopcode 0x014B
+ offset 441
+
+PrioritizeTexturesEXT(n, textures, priorities)
+ return void
+ param n SizeI in value
+ param textures Texture in array [n]
+ param priorities ClampedFloat32 in array [n]
+ category EXT_texture_object
+ glxflags EXT
+ version 1.0
+ glxropcode 4118
+ extension
+ alias PrioritizeTextures
+ glsalias PrioritizeTextures
+
+###############################################################################
+#
+# Extension #21
+# SGIS_detail_texture commands
+#
+###############################################################################
+
+DetailTexFuncSGIS(target, n, points)
+ return void
+ param target TextureTarget in value
+ param n SizeI in value
+ param points Float32 in array [n*2]
+ category SGIS_detail_texture
+ glxflags SGI
+ version 1.0
+ glxropcode 2051
+ extension
+ glsopcode 0x0163
+ offset 442
+
+GetDetailTexFuncSGIS(target, points)
+ return void
+ param target TextureTarget in value
+ param points Float32 out array [COMPSIZE(target)]
+ category SGIS_detail_texture
+ dlflags notlistable
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4096
+ extension
+ glsflags get
+ glsopcode 0x0164
+ offset 443
+
+###############################################################################
+#
+# Extension #22
+# SGIS_sharpen_texture commands
+#
+###############################################################################
+
+SharpenTexFuncSGIS(target, n, points)
+ return void
+ param target TextureTarget in value
+ param n SizeI in value
+ param points Float32 in array [n*2]
+ category SGIS_sharpen_texture
+ glxflags SGI
+ version 1.0
+ glxropcode 2052
+ extension
+ glsopcode 0x0165
+ offset 444
+
+GetSharpenTexFuncSGIS(target, points)
+ return void
+ param target TextureTarget in value
+ param points Float32 out array [COMPSIZE(target)]
+ category SGIS_sharpen_texture
+ dlflags notlistable
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4097
+ extension
+ glsflags get
+ glsopcode 0x0166
+ offset 445
+
+###############################################################################
+#
+# EXT_packed_pixels commands
+# Extension #23
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_packed_pixels
+
+###############################################################################
+#
+# Extension #24
+# SGIS_texture_lod commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIS_texture_lod
+
+###############################################################################
+#
+# Extension #25
+# SGIS_multisample commands
+#
+###############################################################################
+
+SampleMaskSGIS(value, invert)
+ return void
+ param value ClampedFloat32 in value
+ param invert Boolean in value
+ category SGIS_multisample
+ version 1.1
+ glxropcode 2048
+ glxflags SGI
+ extension
+ alias SampleMaskEXT
+ glsalias SampleMaskEXT
+
+SamplePatternSGIS(pattern)
+ return void
+ param pattern SamplePatternSGIS in value
+ category SGIS_multisample
+ version 1.0
+ glxropcode 2049
+ glxflags SGI
+ extension
+ alias SamplePatternEXT
+ glsalias SamplePatternEXT
+
+###############################################################################
+#
+# Extension #26 - no specification?
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #27
+# EXT_rescale_normal commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_rescale_normal
+
+###############################################################################
+#
+# Extension #28 - GLX_EXT_visual_info
+# Extension #29 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #30
+# EXT_vertex_array commands
+#
+###############################################################################
+
+ArrayElementEXT(i)
+ return void
+ param i Int32 in value
+ category EXT_vertex_array
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ alias ArrayElement
+ glsalias ArrayElement
+
+ColorPointerEXT(size, type, stride, count, pointer)
+ return void
+ param size Int32 in value
+ param type ColorPointerType in value
+ param stride SizeI in value
+ param count SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride/count)] retained
+ category EXT_vertex_array
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ glsflags client
+ glsopcode 0x013F
+ offset 448
+
+DrawArraysEXT(mode, first, count)
+ return void
+ param mode BeginMode in value
+ param first Int32 in value
+ param count SizeI in value
+ category EXT_vertex_array
+ dlflags handcode
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ glxropcode 4116
+ extension
+ alias DrawArrays
+ glsopcode 0x0140
+
+EdgeFlagPointerEXT(stride, count, pointer)
+ return void
+ param stride SizeI in value
+ param count SizeI in value
+ param pointer Boolean in array [COMPSIZE(stride/count)] retained
+ category EXT_vertex_array
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ glsflags client
+ glsopcode 0x0141
+ offset 449
+
+GetPointervEXT(pname, params)
+ return void
+ param pname GetPointervPName in value
+ param params VoidPointer out array [1]
+ category EXT_vertex_array
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ alias GetPointerv
+ glsalias GetPointerv
+
+IndexPointerEXT(type, stride, count, pointer)
+ return void
+ param type IndexPointerType in value
+ param stride SizeI in value
+ param count SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride/count)] retained
+ category EXT_vertex_array
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ glsflags client
+ glsopcode 0x0143
+ offset 450
+
+NormalPointerEXT(type, stride, count, pointer)
+ return void
+ param type NormalPointerType in value
+ param stride SizeI in value
+ param count SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride/count)] retained
+ category EXT_vertex_array
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ glsflags client
+ glsopcode 0x0144
+ offset 451
+
+TexCoordPointerEXT(size, type, stride, count, pointer)
+ return void
+ param size Int32 in value
+ param type TexCoordPointerType in value
+ param stride SizeI in value
+ param count SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride/count)] retained
+ category EXT_vertex_array
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ glsflags client
+ glsopcode 0x0145
+ offset 452
+
+VertexPointerEXT(size, type, stride, count, pointer)
+ return void
+ param size Int32 in value
+ param type VertexPointerType in value
+ param stride SizeI in value
+ param count SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride/count)] retained
+ category EXT_vertex_array
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.0
+ extension
+ glsflags client
+ glsopcode 0x0146
+ offset 453
+
+###############################################################################
+#
+# Extension #31
+# EXT_misc_attribute commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_misc_attribute
+
+###############################################################################
+#
+# Extension #32
+# SGIS_generate_mipmap commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIS_generate_mipmap
+
+###############################################################################
+#
+# Extension #33
+# SGIX_clipmap commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_clipmap
+
+###############################################################################
+#
+# Extension #34
+# SGIX_shadow commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_shadow
+
+###############################################################################
+#
+# Extension #35
+# SGIS_texture_edge_clamp commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIS_texture_edge_clamp
+
+###############################################################################
+#
+# Extension #36
+# SGIS_texture_border_clamp commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIS_texture_border_clamp
+
+###############################################################################
+#
+# Extension #37
+# EXT_blend_minmax commands
+#
+###############################################################################
+
+BlendEquationEXT(mode)
+ return void
+ param mode BlendEquationModeEXT in value
+ category EXT_blend_minmax
+ version 1.0
+ glxropcode 4097
+ glxflags EXT
+ extension soft
+ alias BlendEquation
+ glsalias BlendEquation
+
+###############################################################################
+#
+# Extension #38
+# EXT_blend_subtract commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_blend_subtract
+
+###############################################################################
+#
+# Extension #39
+# EXT_blend_logic_op commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_blend_logic_op
+
+###############################################################################
+#
+# Extension #40 - GLX_SGI_swap_control
+# Extension #41 - GLX_SGI_video_sync
+# Extension #42 - GLX_SGI_make_current_read
+# Extension #43 - GLX_SGIX_video_source
+# Extension #44 - GLX_EXT_visual_rating
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #45
+# SGIX_interlace commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_interlace
+
+###############################################################################
+#
+# Extension #46
+# SGIX_pixel_tiles commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_pixel_tiles
+
+###############################################################################
+#
+# Extension #47 - GLX_EXT_import_context
+# Extension #48 - skipped
+# Extension #49 - GLX_SGIX_fbconfig
+# Extension #50 - GLX_SGIX_pbuffer
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #51
+# SGIX_texture_select commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_texture_select
+
+###############################################################################
+#
+# Extension #52
+# SGIX_sprite commands
+#
+###############################################################################
+
+SpriteParameterfSGIX(pname, param)
+ return void
+ param pname SpriteParameterNameSGIX in value
+ param param CheckedFloat32 in value
+ category SGIX_sprite
+ version 1.0
+ glxflags SGI
+ glxropcode 2060
+ extension
+ glsflags gl-enum
+ glsopcode 0x0171
+ offset 454
+
+SpriteParameterfvSGIX(pname, params)
+ return void
+ param pname SpriteParameterNameSGIX in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category SGIX_sprite
+ version 1.0
+ glxflags SGI
+ glxropcode 2061
+ extension
+ glsflags gl-enum
+ glsopcode 0x0172
+ offset 455
+
+SpriteParameteriSGIX(pname, param)
+ return void
+ param pname SpriteParameterNameSGIX in value
+ param param CheckedInt32 in value
+ category SGIX_sprite
+ version 1.0
+ glxflags SGI
+ glxropcode 2062
+ extension
+ glsflags gl-enum
+ glsopcode 0x0173
+ offset 456
+
+SpriteParameterivSGIX(pname, params)
+ return void
+ param pname SpriteParameterNameSGIX in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category SGIX_sprite
+ version 1.0
+ glxflags SGI
+ glxropcode 2063
+ extension
+ glsflags gl-enum
+ glsopcode 0x0174
+ offset 457
+
+###############################################################################
+#
+# Extension #53
+# SGIX_texture_multi_buffer commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_texture_multi_buffer
+
+###############################################################################
+#
+# Extension #54
+# EXT_point_parameters / SGIS_point_parameters commands
+#
+###############################################################################
+
+PointParameterfEXT(pname, param)
+ return void
+ param pname PointParameterNameARB in value
+ param param CheckedFloat32 in value
+ category EXT_point_parameters
+ version 1.0
+ glxflags SGI
+ extension
+ alias PointParameterfARB
+ glsalias PointParameterfARB
+
+PointParameterfvEXT(pname, params)
+ return void
+ param pname PointParameterNameARB in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category EXT_point_parameters
+ version 1.0
+ glxflags SGI
+ extension
+ alias PointParameterfvARB
+ glsalias PointParameterfvARB
+
+PointParameterfSGIS(pname, param)
+ return void
+ param pname PointParameterNameARB in value
+ param param CheckedFloat32 in value
+ category SGIS_point_parameters
+ version 1.0
+ glxflags SGI
+ extension
+ alias PointParameterfARB
+ glsalias PointParameterfARB
+
+PointParameterfvSGIS(pname, params)
+ return void
+ param pname PointParameterNameARB in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category SGIS_point_parameters
+ version 1.0
+ glxflags SGI
+ extension
+ alias PointParameterfvARB
+ glsalias PointParameterfvARB
+
+###############################################################################
+#
+# Extension #55
+# SGIX_instruments commands
+#
+###############################################################################
+
+GetInstrumentsSGIX()
+ return Int32
+ dlflags notlistable
+ category SGIX_instruments
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4102
+ extension
+ glsflags get
+ glsopcode 0x017A
+ offset 460
+
+InstrumentsBufferSGIX(size, buffer)
+ return void
+ param size SizeI in value
+ param buffer Int32 out array [size] retained
+ dlflags notlistable
+ category SGIX_instruments
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4103
+ extension
+ glsflags client
+ glsopcode 0x017B
+ offset 461
+
+PollInstrumentsSGIX(marker_p)
+ return Int32
+ param marker_p Int32 out array [1]
+ dlflags notlistable
+ category SGIX_instruments
+ version 1.0
+ glxflags SGI
+ glxvendorpriv 4104
+ extension
+ glsflags get
+ glsopcode 0x017C
+ offset 462
+
+ReadInstrumentsSGIX(marker)
+ return void
+ param marker Int32 in value
+ category SGIX_instruments
+ version 1.0
+ glxflags SGI
+ glxropcode 2077
+ extension
+ glsopcode 0x017D
+ offset 463
+
+StartInstrumentsSGIX()
+ return void
+ category SGIX_instruments
+ version 1.0
+ glxflags SGI
+ glxropcode 2069
+ extension
+ glsopcode 0x017E
+ offset 464
+
+StopInstrumentsSGIX(marker)
+ return void
+ param marker Int32 in value
+ category SGIX_instruments
+ version 1.0
+ glxflags SGI
+ glxropcode 2070
+ extension
+ glsopcode 0x017F
+ offset 465
+
+###############################################################################
+#
+# Extension #56
+# SGIX_texture_scale_bias commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_texture_scale_bias
+
+###############################################################################
+#
+# Extension #57
+# SGIX_framezoom commands
+#
+###############################################################################
+
+FrameZoomSGIX(factor)
+ return void
+ param factor CheckedInt32 in value
+ category SGIX_framezoom
+ version 1.0
+ glxflags SGI
+ glxropcode 2072
+ extension
+ glsopcode 0x0182
+ offset 466
+
+###############################################################################
+#
+# Extension #58
+# SGIX_tag_sample_buffer commands
+#
+###############################################################################
+
+TagSampleBufferSGIX()
+ return void
+ category SGIX_tag_sample_buffer
+ version 1.0
+ glxropcode 2050
+ glxflags SGI
+ extension
+ glsopcode 0x0162
+ offset 467
+
+###############################################################################
+#
+# Extension #59
+# SGIX_polynomial_ffd commands
+#
+###############################################################################
+
+DeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points)
+ return void
+ param target FfdTargetSGIX in value
+ param u1 CoordD in value
+ param u2 CoordD in value
+ param ustride Int32 in value
+ param uorder CheckedInt32 in value
+ param v1 CoordD in value
+ param v2 CoordD in value
+ param vstride Int32 in value
+ param vorder CheckedInt32 in value
+ param w1 CoordD in value
+ param w2 CoordD in value
+ param wstride Int32 in value
+ param worder CheckedInt32 in value
+ param points CoordD in array [COMPSIZE(target/ustride/uorder/vstride/vorder/wstride/worder)]
+ dlflags handcode
+ category SGIX_polynomial_ffd
+ version 1.0
+ glxflags SGI ignore
+ glxropcode 2073
+ extension
+ glsflags capture-handcode
+ glsopcode 0x0184
+ offset ?
+
+DeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points)
+ return void
+ param target FfdTargetSGIX in value
+ param u1 CoordF in value
+ param u2 CoordF in value
+ param ustride Int32 in value
+ param uorder CheckedInt32 in value
+ param v1 CoordF in value
+ param v2 CoordF in value
+ param vstride Int32 in value
+ param vorder CheckedInt32 in value
+ param w1 CoordF in value
+ param w2 CoordF in value
+ param wstride Int32 in value
+ param worder CheckedInt32 in value
+ param points CoordF in array [COMPSIZE(target/ustride/uorder/vstride/vorder/wstride/worder)]
+ category SGIX_polynomial_ffd
+ dlflags handcode
+ version 1.0
+ glxflags SGI ignore
+ glxropcode 2074
+ extension
+ glsflags capture-handcode
+ glsopcode 0x0185
+ offset ?
+
+DeformSGIX(mask)
+ return void
+ param mask FfdMaskSGIX in value
+ category SGIX_polynomial_ffd
+ version 1.0
+ glxflags SGI ignore
+ glxropcode 2075
+ extension
+ glsopcode 0x0186
+ offset ?
+
+LoadIdentityDeformationMapSGIX(mask)
+ return void
+ param mask FfdMaskSGIX in value
+ category SGIX_polynomial_ffd
+ version 1.0
+ glxflags SGI ignore
+ glxropcode 2076
+ extension
+ glsopcode 0x0187
+ offset ?
+
+###############################################################################
+#
+# Extension #60
+# SGIX_reference_plane commands
+#
+###############################################################################
+
+ReferencePlaneSGIX(equation)
+ return void
+ param equation Float64 in array [4]
+ category SGIX_reference_plane
+ version 1.0
+ glxflags SGI
+ glxropcode 2071
+ extension
+ glsopcode 0x0181
+ offset 468
+
+###############################################################################
+#
+# Extension #61
+# SGIX_flush_raster commands
+#
+###############################################################################
+
+FlushRasterSGIX()
+ return void
+ category SGIX_flush_raster
+ version 1.0
+ dlflags notlistable
+ glxflags SGI
+ glxvendorpriv 4105
+ extension
+ glsopcode 0x0180
+ offset 469
+
+###############################################################################
+#
+# Extension #62 - GLX_SGIX_cushion
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #63
+# SGIX_depth_texture commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_depth_texture
+
+###############################################################################
+#
+# Extension #64
+# SGIS_fog_function commands
+#
+###############################################################################
+
+FogFuncSGIS(n, points)
+ return void
+ param n SizeI in value
+ param points Float32 in array [n*2]
+ category SGIS_fog_function
+ version 1.1
+ glxflags SGI
+ glxropcode 2067
+ extension
+ glsopcode 0x0179
+ offset
+
+# Need to insert GLX information
+GetFogFuncSGIS(points)
+ return void
+ param points Float32 out array [COMPSIZE()]
+ category SGIS_fog_function
+ version 1.1
+ dlflags notlistable
+ glxflags ignore
+ extension
+ glsflags get
+ glsopcode 0x0191
+ offset
+
+###############################################################################
+#
+# Extension #65
+# SGIX_fog_offset commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_fog_offset
+
+###############################################################################
+#
+# Extension #66
+# HP_image_transform commands
+#
+###############################################################################
+
+ImageTransformParameteriHP(target, pname, param)
+ return void
+ param target ImageTransformTargetHP in value
+ param pname ImageTransformPNameHP in value
+ param param Int32 in value
+ category HP_image_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ImageTransformParameterfHP(target, pname, param)
+ return void
+ param target ImageTransformTargetHP in value
+ param pname ImageTransformPNameHP in value
+ param param Float32 in value
+ category HP_image_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ImageTransformParameterivHP(target, pname, params)
+ return void
+ param target ImageTransformTargetHP in value
+ param pname ImageTransformPNameHP in value
+ param params Int32 in array [COMPSIZE(pname)]
+ category HP_image_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ImageTransformParameterfvHP(target, pname, params)
+ return void
+ param target ImageTransformTargetHP in value
+ param pname ImageTransformPNameHP in value
+ param params Float32 in array [COMPSIZE(pname)]
+ category HP_image_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GetImageTransformParameterivHP(target, pname, params)
+ return void
+ param target ImageTransformTargetHP in value
+ param pname ImageTransformPNameHP in value
+ param params Int32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category HP_image_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GetImageTransformParameterfvHP(target, pname, params)
+ return void
+ param target ImageTransformTargetHP in value
+ param pname ImageTransformPNameHP in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category HP_image_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #67
+# HP_convolution_border_modes commands
+#
+###############################################################################
+
+# (none)
+newcategory: HP_convolution_border_modes
+
+###############################################################################
+#
+# Extension #68
+# INGR_palette_buffer commands
+#
+###############################################################################
+
+#@ (Intergraph hasn't provided a spec)
+
+###############################################################################
+#
+# Extension #69
+# SGIX_texture_add_env commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_texture_add_env
+
+###############################################################################
+#
+# Extension #70 - skipped
+# Extension #71 - skipped
+# Extension #72 - skipped
+# Extension #73 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #74
+# EXT_color_subtable commands
+#
+# This was probably never actually shipped as an EXT - just written up as a
+# reference for OpenGL 1.2 ARB_imaging.
+#
+###############################################################################
+
+ColorSubTableEXT(target, start, count, format, type, data)
+ return void
+ param target ColorTableTarget in value
+ param start SizeI in value
+ param count SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param data Void in array [COMPSIZE(format/type/count)]
+ category EXT_color_subtable
+ version 1.2
+ alias ColorSubTable
+ glsalias ColorSubTable
+
+CopyColorSubTableEXT(target, start, x, y, width)
+ return void
+ param target ColorTableTarget in value
+ param start SizeI in value
+ param x WinCoord in value
+ param y WinCoord in value
+ param width SizeI in value
+ category EXT_color_subtable
+ version 1.2
+ alias CopyColorSubTable
+ glsalias CopyColorSubTable
+
+###############################################################################
+#
+# Extension #75 - GLU_EXT_object_space_tess
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #76
+# PGI_vertex_hints commands
+#
+###############################################################################
+
+# (none)
+newcategory: PGI_vertex_hints
+
+###############################################################################
+#
+# Extension #77
+# PGI_misc_hints commands
+#
+###############################################################################
+
+HintPGI(target, mode)
+ return void
+ param target HintTargetPGI in value
+ param mode Int32 in value
+ category PGI_misc_hints
+ version 1.1
+ offset 544
+ glsopcode 0x01D0
+
+###############################################################################
+#
+# Extension #78
+# EXT_paletted_texture commands
+#
+###############################################################################
+
+ColorTableEXT(target, internalFormat, width, format, type, table)
+ return void
+ param target ColorTableTarget in value
+ param internalFormat PixelInternalFormat in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param table Void in array [COMPSIZE(format/type/width)]
+ category EXT_paletted_texture
+ version 1.1
+ alias ColorTable
+ glsalias ColorTable
+
+GetColorTableEXT(target, format, type, data)
+ return void
+ param target ColorTableTarget in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param data Void out array [COMPSIZE(target/format/type)]
+ category EXT_paletted_texture
+ version 1.1
+ offset 550
+ glsalias GetColorTable
+
+GetColorTableParameterivEXT(target, pname, params)
+ return void
+ param target ColorTableTarget in value
+ param pname GetColorTableParameterPName in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category EXT_paletted_texture
+ version 1.1
+ offset 551
+ glsalias GetColorTableParameteriv
+
+GetColorTableParameterfvEXT(target, pname, params)
+ return void
+ param target ColorTableTarget in value
+ param pname GetColorTableParameterPName in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category EXT_paletted_texture
+ version 1.1
+ offset 552
+ glsalias GetColorTableParameterfv
+
+###############################################################################
+#
+# Extension #79
+# EXT_clip_volume_hint commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_clip_volume_hint
+
+###############################################################################
+#
+# Extension #80
+# SGIX_list_priority commands
+#
+###############################################################################
+
+# @@@ Needs vendorpriv opcodes assigned
+GetListParameterfvSGIX(list, pname, params)
+ return void
+ param list List in value
+ param pname ListParameterName in value
+ param params CheckedFloat32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ glxflags ignore
+ category SGIX_list_priority
+ version 1.0
+ glxvendorpriv ?
+ extension
+ glsopcode 0x0188
+ offset 470
+
+# @@@ Needs vendorpriv opcodes assigned
+GetListParameterivSGIX(list, pname, params)
+ return void
+ param list List in value
+ param pname ListParameterName in value
+ param params CheckedInt32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ glxflags ignore
+ category SGIX_list_priority
+ version 1.0
+ glxvendorpriv ?
+ extension
+ glsopcode 0x0189
+ offset 471
+
+ListParameterfSGIX(list, pname, param)
+ return void
+ param list List in value
+ param pname ListParameterName in value
+ param param CheckedFloat32 in value
+ dlflags notlistable
+ glxflags ignore
+ category SGIX_list_priority
+ version 1.0
+ glxropcode 2078
+ extension
+ glsopcode 0x018A
+ offset 472
+
+ListParameterfvSGIX(list, pname, params)
+ return void
+ param list List in value
+ param pname ListParameterName in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ dlflags notlistable
+ glxflags ignore
+ category SGIX_list_priority
+ version 1.0
+ glxropcode 2079
+ extension
+ glsopcode 0x018B
+ offset 473
+
+ListParameteriSGIX(list, pname, param)
+ return void
+ param list List in value
+ param pname ListParameterName in value
+ param param CheckedInt32 in value
+ dlflags notlistable
+ glxflags ignore
+ category SGIX_list_priority
+ version 1.0
+ glxropcode 2080
+ extension
+ glsopcode 0x018C
+ offset 474
+
+ListParameterivSGIX(list, pname, params)
+ return void
+ param list List in value
+ param pname ListParameterName in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ dlflags notlistable
+ glxflags ignore
+ category SGIX_list_priority
+ version 1.0
+ glxropcode 2081
+ extension
+ glsopcode 0x018D
+ offset 475
+
+###############################################################################
+#
+# Extension #81
+# SGIX_ir_instrument1 commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_ir_instrument1
+
+###############################################################################
+#
+# Extension #82
+# SGIX_calligraphic_fragment commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_calligraphic_fragment
+
+###############################################################################
+#
+# Extension #83 - GLX_SGIX_video_resize
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #84
+# SGIX_texture_lod_bias commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_texture_lod_bias
+
+###############################################################################
+#
+# Extension #85 - skipped
+# Extension #86 - GLX_SGIX_dmbuffer
+# Extension #87 - skipped
+# Extension #88 - skipped
+# Extension #89 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #90
+# SGIX_shadow_ambient commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_shadow_ambient
+
+###############################################################################
+#
+# Extension #91 - GLX_SGIX_swap_group
+# Extension #92 - GLX_SGIX_swap_barrier
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #93
+# EXT_index_texture commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_index_texture
+
+###############################################################################
+#
+# Extension #94
+# EXT_index_material commands
+#
+###############################################################################
+
+IndexMaterialEXT(face, mode)
+ return void
+ param face MaterialFace in value
+ param mode IndexMaterialParameterEXT in value
+ category EXT_index_material
+ version 1.1
+ extension soft
+ glxflags ignore
+ glsopcode 0x01D1
+ offset 538
+
+###############################################################################
+#
+# Extension #95
+# EXT_index_func commands
+#
+###############################################################################
+
+IndexFuncEXT(func, ref)
+ return void
+ param func IndexFunctionEXT in value
+ param ref ClampedFloat32 in value
+ category EXT_index_func
+ version 1.1
+ extension soft
+ glxflags ignore
+ glsopcode 0x01D2
+ offset 539
+
+###############################################################################
+#
+# Extension #96
+# EXT_index_array_formats commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_index_array_formats
+
+###############################################################################
+#
+# Extension #97
+# EXT_compiled_vertex_array commands
+#
+###############################################################################
+
+LockArraysEXT(first, count)
+ return void
+ param first Int32 in value
+ param count SizeI in value
+ category EXT_compiled_vertex_array
+ version 1.1
+ dlflags notlistable
+ extension soft
+ glxflags ignore
+ glsopcode 0x01D3
+ offset 540
+
+UnlockArraysEXT()
+ return void
+ category EXT_compiled_vertex_array
+ version 1.1
+ dlflags notlistable
+ extension soft
+ glxflags ignore
+ glsopcode 0x01D4
+ offset 541
+
+###############################################################################
+#
+# Extension #98
+# EXT_cull_vertex commands
+#
+###############################################################################
+
+CullParameterdvEXT(pname, params)
+ return void
+ param pname CullParameterEXT in value
+ param params Float64 out array [4]
+ category EXT_cull_vertex
+ version 1.1
+ dlflags notlistable
+ extension soft
+ glxflags ignore
+ glsopcode 0x01D5
+ offset 542
+
+CullParameterfvEXT(pname, params)
+ return void
+ param pname CullParameterEXT in value
+ param params Float32 out array [4]
+ category EXT_cull_vertex
+ version 1.1
+ dlflags notlistable
+ extension soft
+ glxflags ignore
+ glsopcode 0x01D6
+ offset 543
+
+###############################################################################
+#
+# Extension #99 - skipped
+# Extension #100 - GLU_EXT_nurbs_tessellator
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #101
+# SGIX_ycrcb commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_ycrcb
+
+###############################################################################
+#
+# Extension #102
+# SGIX_fragment_lighting commands
+#
+###############################################################################
+
+FragmentColorMaterialSGIX(face, mode)
+ return void
+ param face MaterialFace in value
+ param mode MaterialParameter in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x019E
+ offset 476
+
+FragmentLightfSGIX(light, pname, param)
+ return void
+ param light FragmentLightNameSGIX in value
+ param pname FragmentLightParameterSGIX in value
+ param param CheckedFloat32 in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x019F
+ offset 477
+
+FragmentLightfvSGIX(light, pname, params)
+ return void
+ param light FragmentLightNameSGIX in value
+ param pname FragmentLightParameterSGIX in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x01A0
+ offset 478
+
+FragmentLightiSGIX(light, pname, param)
+ return void
+ param light FragmentLightNameSGIX in value
+ param pname FragmentLightParameterSGIX in value
+ param param CheckedInt32 in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x01A1
+ offset 479
+
+FragmentLightivSGIX(light, pname, params)
+ return void
+ param light FragmentLightNameSGIX in value
+ param pname FragmentLightParameterSGIX in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x01A2
+ offset 480
+
+FragmentLightModelfSGIX(pname, param)
+ return void
+ param pname FragmentLightModelParameterSGIX in value
+ param param CheckedFloat32 in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags gl-enum
+ glsopcode 0x01A3
+ offset 481
+
+FragmentLightModelfvSGIX(pname, params)
+ return void
+ param pname FragmentLightModelParameterSGIX in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags gl-enum
+ glsopcode 0x01A4
+ offset 482
+
+FragmentLightModeliSGIX(pname, param)
+ return void
+ param pname FragmentLightModelParameterSGIX in value
+ param param CheckedInt32 in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags gl-enum
+ glsopcode 0x01A5
+ offset 483
+
+FragmentLightModelivSGIX(pname, params)
+ return void
+ param pname FragmentLightModelParameterSGIX in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags gl-enum
+ glsopcode 0x01A6
+ offset 484
+
+FragmentMaterialfSGIX(face, pname, param)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param param CheckedFloat32 in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x01A7
+ offset 485
+
+FragmentMaterialfvSGIX(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x01A8
+ offset 486
+
+FragmentMaterialiSGIX(face, pname, param)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param param CheckedInt32 in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x01A9
+ offset 487
+
+FragmentMaterialivSGIX(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsopcode 0x01AA
+ offset 488
+
+GetFragmentLightfvSGIX(light, pname, params)
+ return void
+ param light FragmentLightNameSGIX in value
+ param pname FragmentLightParameterSGIX in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ dlflags notlistable
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags get
+ glsopcode 0x01AB
+ offset 489
+
+GetFragmentLightivSGIX(light, pname, params)
+ return void
+ param light FragmentLightNameSGIX in value
+ param pname FragmentLightParameterSGIX in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ dlflags notlistable
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags get
+ glsopcode 0x01AC
+ offset 490
+
+GetFragmentMaterialfvSGIX(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ dlflags notlistable
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags get
+ glsopcode 0x01AD
+ offset 491
+
+GetFragmentMaterialivSGIX(face, pname, params)
+ return void
+ param face MaterialFace in value
+ param pname MaterialParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category SGIX_fragment_lighting
+ dlflags notlistable
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags get
+ glsopcode 0x01AE
+ offset 492
+
+LightEnviSGIX(pname, param)
+ return void
+ param pname LightEnvParameterSGIX in value
+ param param CheckedInt32 in value
+ category SGIX_fragment_lighting
+ glxflags ignore
+ version 1.0
+ extension
+ glsflags gl-enum
+ glsopcode 0x01AF
+ offset 493
+
+###############################################################################
+#
+# Extension #103 - skipped
+# Extension #104 - skipped
+# Extension #105 - skipped
+# Extension #106 - skipped
+# Extension #107 - skipped
+# Extension #108 - skipped
+# Extension #109 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #110
+# IBM_rasterpos_clip commands
+#
+###############################################################################
+
+# (none)
+newcategory: IBM_rasterpos_clip
+
+###############################################################################
+#
+# Extension #111
+# HP_texture_lighting commands
+#
+###############################################################################
+
+# (none)
+newcategory: HP_texture_lighting
+
+###############################################################################
+#
+# Extension #112
+# EXT_draw_range_elements commands
+#
+###############################################################################
+
+# Spec entries to be written
+DrawRangeElementsEXT(mode, start, end, count, type, indices)
+ return void
+ param mode BeginMode in value
+ param start UInt32 in value
+ param end UInt32 in value
+ param count SizeI in value
+ param type DrawElementsType in value
+ param indices Void in array [COMPSIZE(count/type)]
+ category EXT_draw_range_elements
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ alias DrawRangeElements
+ glsalias DrawRangeElements
+
+###############################################################################
+#
+# Extension #113
+# WIN_phong_shading commands
+#
+###############################################################################
+
+# (none)
+newcategory: WIN_phong_shading
+
+###############################################################################
+#
+# Extension #114
+# WIN_specular_fog commands
+#
+###############################################################################
+
+# (none)
+newcategory: WIN_specular_fog
+
+###############################################################################
+#
+# Extension #115 - skipped
+# Extension #116 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #117
+# EXT_light_texture commands
+#
+###############################################################################
+
+# Spec entries to be written
+ApplyTextureEXT(mode)
+ return void
+ param mode LightTextureModeEXT in value
+ category EXT_light_texture
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TextureLightEXT(pname)
+ return void
+ param pname LightTexturePNameEXT in value
+ category EXT_light_texture
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TextureMaterialEXT(face, mode)
+ return void
+ param face MaterialFace in value
+ param mode MaterialParameter in value
+ category EXT_light_texture
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #118 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #119
+# SGIX_blend_alpha_minmax commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_blend_alpha_minmax
+
+###############################################################################
+#
+# Extension #120 - skipped
+# Extension #121 - skipped
+# Extension #122 - skipped
+# Extension #123 - skipped
+# Extension #124 - skipped
+# Extension #125 - skipped
+# Extension #126 - skipped
+# Extension #127 - skipped
+# Extension #128 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #129
+# EXT_bgra commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_bgra
+
+###############################################################################
+#
+# Extension #130 - skipped
+# Extension #131 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #132
+# SGIX_async commands
+#
+###############################################################################
+
+AsyncMarkerSGIX(marker)
+ return void
+ param marker UInt32 in value
+ category SGIX_async
+ version 1.0
+ glxflags ignore
+ extension
+ glsopcode 0x0198
+ offset ?
+
+FinishAsyncSGIX(markerp)
+ return Int32
+ param markerp UInt32 out array [1]
+ category SGIX_async
+ version 1.0
+ dlflags notlistable
+ glxflags ignore
+ extension
+ glsopcode 0x0199
+ offset ?
+
+PollAsyncSGIX(markerp)
+ return Int32
+ param markerp UInt32 out array [1]
+ category SGIX_async
+ version 1.0
+ dlflags notlistable
+ glxflags ignore
+ extension
+ glsopcode 0x019A
+ offset ?
+
+GenAsyncMarkersSGIX(range)
+ return UInt32
+ param range SizeI in value
+ category SGIX_async
+ version 1.0
+ dlflags notlistable
+ glxflags ignore
+ extension
+ glsopcode 0x019B
+ offset ?
+
+DeleteAsyncMarkersSGIX(marker, range)
+ return void
+ param marker UInt32 in value
+ param range SizeI in value
+ category SGIX_async
+ version 1.0
+ dlflags notlistable
+ glxflags ignore
+ extension
+ glsopcode 0x019C
+ offset ?
+
+IsAsyncMarkerSGIX(marker)
+ return Boolean
+ param marker UInt32 in value
+ category SGIX_async
+ version 1.0
+ dlflags notlistable
+ glxflags ignore
+ extension
+ glsopcode 0x019D
+ offset ?
+
+###############################################################################
+#
+# Extension #133
+# SGIX_async_pixel commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_async_pixel
+
+###############################################################################
+#
+# Extension #134
+# SGIX_async_histogram commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_async_histogram
+
+###############################################################################
+#
+# Extension #135 - skipped (INTEL_texture_scissor was never implemented)
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #136
+# INTEL_parallel_arrays commands
+#
+###############################################################################
+
+VertexPointervINTEL(size, type, pointer)
+ return void
+ param size Int32 in value
+ param type VertexPointerType in value
+ param pointer VoidPointer in array [4] retained
+ category INTEL_parallel_arrays
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.1
+ glsflags ignore client
+ offset ?
+
+NormalPointervINTEL(type, pointer)
+ return void
+ param type NormalPointerType in value
+ param pointer VoidPointer in array [4] retained
+ category INTEL_parallel_arrays
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.1
+ glsflags ignore client
+ offset ?
+
+ColorPointervINTEL(size, type, pointer)
+ return void
+ param size Int32 in value
+ param type VertexPointerType in value
+ param pointer VoidPointer in array [4] retained
+ category INTEL_parallel_arrays
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.1
+ glsflags ignore client
+ offset ?
+
+TexCoordPointervINTEL(size, type, pointer)
+ return void
+ param size Int32 in value
+ param type VertexPointerType in value
+ param pointer VoidPointer in array [4] retained
+ category INTEL_parallel_arrays
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.1
+ glsflags ignore client
+ offset ?
+
+
+###############################################################################
+#
+# Extension #137
+# HP_occlusion_test commands
+#
+###############################################################################
+
+# (none)
+newcategory: HP_occlusion_test
+
+###############################################################################
+#
+# Extension #138
+# EXT_pixel_transform commands
+#
+###############################################################################
+
+PixelTransformParameteriEXT(target, pname, param)
+ return void
+ param target PixelTransformTargetEXT in value
+ param pname PixelTransformPNameEXT in value
+ param param Int32 in value
+ category EXT_pixel_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+PixelTransformParameterfEXT(target, pname, param)
+ return void
+ param target PixelTransformTargetEXT in value
+ param pname PixelTransformPNameEXT in value
+ param param Float32 in value
+ category EXT_pixel_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+PixelTransformParameterivEXT(target, pname, params)
+ return void
+ param target PixelTransformTargetEXT in value
+ param pname PixelTransformPNameEXT in value
+ param params Int32 in array [1]
+ category EXT_pixel_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+PixelTransformParameterfvEXT(target, pname, params)
+ return void
+ param target PixelTransformTargetEXT in value
+ param pname PixelTransformPNameEXT in value
+ param params Float32 in array [1]
+ category EXT_pixel_transform
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #139
+# EXT_pixel_transform_color_table commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_pixel_transform_color_table
+
+###############################################################################
+#
+# Extension #140 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #141
+# EXT_shared_texture_palette commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_shared_texture_palette
+
+###############################################################################
+#
+# Extension #142 - GLX_SGIS_blended_overlay
+# Extension #143 - GLX_SGIS_shared_multisample
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #144
+# EXT_separate_specular_color commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_separate_specular_color
+
+###############################################################################
+#
+# Extension #145
+# EXT_secondary_color commands
+#
+###############################################################################
+
+SecondaryColor3bEXT(red, green, blue)
+ return void
+ param red ColorB in value
+ param green ColorB in value
+ param blue ColorB in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3bvEXT
+ version 1.1
+ alias SecondaryColor3b
+ glsalias SecondaryColor3b
+
+SecondaryColor3bvEXT(v)
+ return void
+ param v ColorB in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4126
+ alias SecondaryColor3bv
+ glsalias SecondaryColor3bv
+
+SecondaryColor3dEXT(red, green, blue)
+ return void
+ param red ColorD in value
+ param green ColorD in value
+ param blue ColorD in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3dvEXT
+ version 1.1
+ alias SecondaryColor3d
+ glsalias SecondaryColor3d
+
+SecondaryColor3dvEXT(v)
+ return void
+ param v ColorD in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4130
+ alias SecondaryColor3dv
+ glsalias SecondaryColor3dv
+
+SecondaryColor3fEXT(red, green, blue)
+ return void
+ param red ColorF in value
+ param green ColorF in value
+ param blue ColorF in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3fvEXT
+ version 1.1
+ alias SecondaryColor3f
+ glsalias SecondaryColor3f
+
+SecondaryColor3fvEXT(v)
+ return void
+ param v ColorF in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4129
+ alias SecondaryColor3fv
+ glsalias SecondaryColor3fv
+
+SecondaryColor3iEXT(red, green, blue)
+ return void
+ param red ColorI in value
+ param green ColorI in value
+ param blue ColorI in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3ivEXT
+ version 1.1
+ alias SecondaryColor3i
+ glsalias SecondaryColor3i
+
+SecondaryColor3ivEXT(v)
+ return void
+ param v ColorI in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4128
+ glsopcode 0x0200
+ offset 568
+ alias SecondaryColor3iv
+ glsalias SecondaryColor3iv
+
+SecondaryColor3sEXT(red, green, blue)
+ return void
+ param red ColorS in value
+ param green ColorS in value
+ param blue ColorS in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3svEXT
+ version 1.1
+ alias SecondaryColor3s
+ glsalias SecondaryColor3s
+
+SecondaryColor3svEXT(v)
+ return void
+ param v ColorS in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4127
+ alias SecondaryColor3sv
+ glsalias SecondaryColor3sv
+
+SecondaryColor3ubEXT(red, green, blue)
+ return void
+ param red ColorUB in value
+ param green ColorUB in value
+ param blue ColorUB in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3ubvEXT
+ version 1.1
+ alias SecondaryColor3ub
+ glsalias SecondaryColor3ub
+
+SecondaryColor3ubvEXT(v)
+ return void
+ param v ColorUB in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4131
+ alias SecondaryColor3ubv
+ glsalias SecondaryColor3ubv
+
+SecondaryColor3uiEXT(red, green, blue)
+ return void
+ param red ColorUI in value
+ param green ColorUI in value
+ param blue ColorUI in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3uivEXT
+ version 1.1
+ alias SecondaryColor3ui
+ glsalias SecondaryColor3ui
+
+SecondaryColor3uivEXT(v)
+ return void
+ param v ColorUI in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4133
+ alias SecondaryColor3uiv
+ glsalias SecondaryColor3uiv
+
+SecondaryColor3usEXT(red, green, blue)
+ return void
+ param red ColorUS in value
+ param green ColorUS in value
+ param blue ColorUS in value
+ category EXT_secondary_color
+ vectorequiv SecondaryColor3usvEXT
+ version 1.1
+ alias SecondaryColor3us
+ glsalias SecondaryColor3us
+
+SecondaryColor3usvEXT(v)
+ return void
+ param v ColorUS in array [3]
+ category EXT_secondary_color
+ version 1.1
+ glxropcode 4132
+ alias SecondaryColor3usv
+ glsalias SecondaryColor3usv
+
+SecondaryColorPointerEXT(size, type, stride, pointer)
+ return void
+ param size Int32 in value
+ param type ColorPointerType in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ category EXT_secondary_color
+ dlflags notlistable
+ glxflags client-handcode server-handcode EXT
+ version 1.1
+ extension
+ alias SecondaryColorPointer
+ glsalias SecondaryColorPointer
+
+###############################################################################
+#
+# Extension #146
+# EXT_texture_env commands
+#
+###############################################################################
+
+# Dead extension - never implemented (removed from registry!)
+# (none)
+# newcategory: EXT_texture_env
+
+###############################################################################
+#
+# Extension #147
+# EXT_texture_perturb_normal commands
+#
+###############################################################################
+
+TextureNormalEXT(mode)
+ return void
+ param mode TextureNormalModeEXT in value
+ category EXT_texture_perturb_normal
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #148
+# EXT_multi_draw_arrays commands
+#
+###############################################################################
+
+# first and count are really 'in'
+MultiDrawArraysEXT(mode, first, count, primcount)
+ return void
+ param mode BeginMode in value
+ param first Int32 out array [COMPSIZE(primcount)]
+ param count SizeI out array [COMPSIZE(primcount)]
+ param primcount SizeI in value
+ category EXT_multi_draw_arrays
+ version 1.1
+ glxropcode ?
+ alias MultiDrawArrays
+ glsalias MultiDrawArrays
+
+MultiDrawElementsEXT(mode, count, type, indices, primcount)
+ return void
+ param mode BeginMode in value
+ param count SizeI in array [COMPSIZE(primcount)]
+ param type DrawElementsType in value
+ param indices VoidPointer in array [COMPSIZE(primcount)]
+ param primcount SizeI in value
+ category EXT_multi_draw_arrays
+ version 1.1
+ glxropcode ?
+ alias MultiDrawElements
+ glsalias MultiDrawElements
+
+###############################################################################
+#
+# Extension #149
+# EXT_fog_coord commands
+#
+###############################################################################
+
+FogCoordfEXT(coord)
+ return void
+ param coord CoordF in value
+ category EXT_fog_coord
+ vectorequiv FogCoordfvEXT
+ version 1.1
+ alias FogCoordf
+ glsalias FogCoordf
+
+FogCoordfvEXT(coord)
+ return void
+ param coord CoordF in array [1]
+ category EXT_fog_coord
+ version 1.1
+ glxropcode 4124
+ alias FogCoordfv
+ glsalias FogCoordfv
+
+FogCoorddEXT(coord)
+ return void
+ param coord CoordD in value
+ category EXT_fog_coord
+ vectorequiv FogCoorddvEXT
+ version 1.1
+ alias FogCoordd
+ glsalias FogCoordd
+
+FogCoorddvEXT(coord)
+ return void
+ param coord CoordD in array [1]
+ category EXT_fog_coord
+ version 1.1
+ glxropcode 4125
+ alias FogCoorddv
+ glsalias FogCoorddv
+
+FogCoordPointerEXT(type, stride, pointer)
+ return void
+ param type FogPointerTypeEXT in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category EXT_fog_coord
+ dlflags notlistable
+ version 1.1
+ glxflags client-handcode server-handcode EXT
+ alias FogCoordPointer
+ glsalias FogCoordPointer
+
+###############################################################################
+#
+# Extension #150 - skipped
+# Extension #151 - skipped
+# Extension #152 - skipped
+# Extension #153 - skipped
+# Extension #154 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #155
+# REND_screen_coordinates commands
+#
+###############################################################################
+
+# (none)
+newcategory: REND_screen_coordinates
+
+###############################################################################
+#
+# Extension #156
+# EXT_coordinate_frame commands
+#
+###############################################################################
+
+Tangent3bEXT(tx, ty, tz)
+ return void
+ param tx Int8 in value
+ param ty Int8 in value
+ param tz Int8 in value
+ category EXT_coordinate_frame
+ vectorequiv Tangent3bvEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Tangent3bvEXT(v)
+ return void
+ param v Int8 in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Tangent3dEXT(tx, ty, tz)
+ return void
+ param tx CoordD in value
+ param ty CoordD in value
+ param tz CoordD in value
+ category EXT_coordinate_frame
+ vectorequiv Tangent3dvEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Tangent3dvEXT(v)
+ return void
+ param v CoordD in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Tangent3fEXT(tx, ty, tz)
+ return void
+ param tx CoordF in value
+ param ty CoordF in value
+ param tz CoordF in value
+ category EXT_coordinate_frame
+ vectorequiv Tangent3fvEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Tangent3fvEXT(v)
+ return void
+ param v CoordF in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Tangent3iEXT(tx, ty, tz)
+ return void
+ param tx Int32 in value
+ param ty Int32 in value
+ param tz Int32 in value
+ category EXT_coordinate_frame
+ vectorequiv Tangent3ivEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Tangent3ivEXT(v)
+ return void
+ param v Int32 in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Tangent3sEXT(tx, ty, tz)
+ return void
+ param tx Int16 in value
+ param ty Int16 in value
+ param tz Int16 in value
+ category EXT_coordinate_frame
+ vectorequiv Tangent3svEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Tangent3svEXT(v)
+ return void
+ param v Int16 in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Binormal3bEXT(bx, by, bz)
+ return void
+ param bx Int8 in value
+ param by Int8 in value
+ param bz Int8 in value
+ category EXT_coordinate_frame
+ vectorequiv Binormal3bvEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Binormal3bvEXT(v)
+ return void
+ param v Int8 in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Binormal3dEXT(bx, by, bz)
+ return void
+ param bx CoordD in value
+ param by CoordD in value
+ param bz CoordD in value
+ category EXT_coordinate_frame
+ vectorequiv Binormal3dvEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Binormal3dvEXT(v)
+ return void
+ param v CoordD in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Binormal3fEXT(bx, by, bz)
+ return void
+ param bx CoordF in value
+ param by CoordF in value
+ param bz CoordF in value
+ category EXT_coordinate_frame
+ vectorequiv Binormal3fvEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Binormal3fvEXT(v)
+ return void
+ param v CoordF in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Binormal3iEXT(bx, by, bz)
+ return void
+ param bx Int32 in value
+ param by Int32 in value
+ param bz Int32 in value
+ category EXT_coordinate_frame
+ vectorequiv Binormal3ivEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Binormal3ivEXT(v)
+ return void
+ param v Int32 in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Binormal3sEXT(bx, by, bz)
+ return void
+ param bx Int16 in value
+ param by Int16 in value
+ param bz Int16 in value
+ category EXT_coordinate_frame
+ vectorequiv Binormal3svEXT
+ version 1.1
+ glsflags ignore
+ offset ?
+
+Binormal3svEXT(v)
+ return void
+ param v Int16 in array [3]
+ category EXT_coordinate_frame
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TangentPointerEXT(type, stride, pointer)
+ return void
+ param type TangentPointerTypeEXT in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category EXT_coordinate_frame
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags ignore
+ offset ?
+
+BinormalPointerEXT(type, stride, pointer)
+ return void
+ param type BinormalPointerTypeEXT in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category EXT_coordinate_frame
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #157 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #158
+# EXT_texture_env_combine commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_env_combine
+
+###############################################################################
+#
+# Extension #159
+# APPLE_specular_vector commands
+#
+###############################################################################
+
+# (none)
+newcategory: APPLE_specular_vector
+
+###############################################################################
+#
+# Extension #160
+# APPLE_transform_hint commands
+#
+###############################################################################
+
+# (none)
+newcategory: APPLE_transform_hint
+
+###############################################################################
+#
+# Extension #161
+# SGIX_fog_scale commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_fog_scale
+
+###############################################################################
+#
+# Extension #162 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #163
+# SUNX_constant_data commands
+#
+###############################################################################
+
+FinishTextureSUNX()
+ return void
+ category SUNX_constant_data
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #164
+# SUN_global_alpha commands
+#
+###############################################################################
+
+GlobalAlphaFactorbSUN(factor)
+ return void
+ param factor Int8 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GlobalAlphaFactorsSUN(factor)
+ return void
+ param factor Int16 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GlobalAlphaFactoriSUN(factor)
+ return void
+ param factor Int32 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GlobalAlphaFactorfSUN(factor)
+ return void
+ param factor Float32 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GlobalAlphaFactordSUN(factor)
+ return void
+ param factor Float64 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GlobalAlphaFactorubSUN(factor)
+ return void
+ param factor UInt8 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GlobalAlphaFactorusSUN(factor)
+ return void
+ param factor UInt16 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+GlobalAlphaFactoruiSUN(factor)
+ return void
+ param factor UInt32 in value
+ category SUN_global_alpha
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #165
+# SUN_triangle_list commands
+#
+###############################################################################
+
+ReplacementCodeuiSUN(code)
+ return void
+ param code UInt32 in value
+ category SUN_triangle_list
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeusSUN(code)
+ return void
+ param code UInt16 in value
+ category SUN_triangle_list
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeubSUN(code)
+ return void
+ param code UInt8 in value
+ category SUN_triangle_list
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuivSUN(code)
+ return void
+ param code UInt32 in array [COMPSIZE()]
+ category SUN_triangle_list
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeusvSUN(code)
+ return void
+ param code UInt16 in array [COMPSIZE()]
+ category SUN_triangle_list
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeubvSUN(code)
+ return void
+ param code UInt8 in array [COMPSIZE()]
+ category SUN_triangle_list
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodePointerSUN(type, stride, pointer)
+ return void
+ param type ReplacementCodeTypeSUN in value
+ param stride SizeI in value
+ param pointer VoidPointer in array [COMPSIZE(type/stride)] retained
+ category SUN_triangle_list
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #166
+# SUN_vertex commands
+#
+###############################################################################
+
+Color4ubVertex2fSUN(r, g, b, a, x, y)
+ return void
+ param r UInt8 in value
+ param g UInt8 in value
+ param b UInt8 in value
+ param a UInt8 in value
+ param x Float32 in value
+ param y Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Color4ubVertex2fvSUN(c, v)
+ return void
+ param c UInt8 in array [4]
+ param v Float32 in array [2]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Color4ubVertex3fSUN(r, g, b, a, x, y, z)
+ return void
+ param r UInt8 in value
+ param g UInt8 in value
+ param b UInt8 in value
+ param a UInt8 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Color4ubVertex3fvSUN(c, v)
+ return void
+ param c UInt8 in array [4]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Color3fVertex3fSUN(r, g, b, x, y, z)
+ return void
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Color3fVertex3fvSUN(c, v)
+ return void
+ param c Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Normal3fVertex3fSUN(nx, ny, nz, x, y, z)
+ return void
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Normal3fVertex3fvSUN(n, v)
+ return void
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Color4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z)
+ return void
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param a Float32 in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+Color4fNormal3fVertex3fvSUN(c, n, v)
+ return void
+ param c Float32 in array [4]
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fVertex3fSUN(s, t, x, y, z)
+ return void
+ param s Float32 in value
+ param t Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fVertex3fvSUN(tc, v)
+ return void
+ param tc Float32 in array [2]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w)
+ return void
+ param s Float32 in value
+ param t Float32 in value
+ param p Float32 in value
+ param q Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord4fVertex4fvSUN(tc, v)
+ return void
+ param tc Float32 in array [4]
+ param v Float32 in array [4]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z)
+ return void
+ param s Float32 in value
+ param t Float32 in value
+ param r UInt8 in value
+ param g UInt8 in value
+ param b UInt8 in value
+ param a UInt8 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fColor4ubVertex3fvSUN(tc, c, v)
+ return void
+ param tc Float32 in array [2]
+ param c UInt8 in array [4]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z)
+ return void
+ param s Float32 in value
+ param t Float32 in value
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fColor3fVertex3fvSUN(tc, c, v)
+ return void
+ param tc Float32 in array [2]
+ param c Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z)
+ return void
+ param s Float32 in value
+ param t Float32 in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fNormal3fVertex3fvSUN(tc, n, v)
+ return void
+ param tc Float32 in array [2]
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z)
+ return void
+ param s Float32 in value
+ param t Float32 in value
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param a Float32 in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v)
+ return void
+ param tc Float32 in array [2]
+ param c Float32 in array [4]
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w)
+ return void
+ param s Float32 in value
+ param t Float32 in value
+ param p Float32 in value
+ param q Float32 in value
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param a Float32 in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v)
+ return void
+ param tc Float32 in array [4]
+ param c Float32 in array [4]
+ param n Float32 in array [3]
+ param v Float32 in array [4]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiVertex3fSUN(rc, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiVertex3fvSUN(rc, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param r UInt8 in value
+ param g UInt8 in value
+ param b UInt8 in value
+ param a UInt8 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param c UInt8 in array [4]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiColor3fVertex3fvSUN(rc, c, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param c Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param a Float32 in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param c Float32 in array [4]
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param s Float32 in value
+ param t Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param tc Float32 in array [2]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param s Float32 in value
+ param t Float32 in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param tc Float32 in array [2]
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z)
+ return void
+ param rc ReplacementCodeSUN in value
+ param s Float32 in value
+ param t Float32 in value
+ param r Float32 in value
+ param g Float32 in value
+ param b Float32 in value
+ param a Float32 in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v)
+ return void
+ param rc ReplacementCodeSUN in array [1]
+ param tc Float32 in array [2]
+ param c Float32 in array [4]
+ param n Float32 in array [3]
+ param v Float32 in array [3]
+ category SUN_vertex
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #167 - WGL_EXT_display_color_table
+# Extension #168 - WGL_EXT_extensions_string
+# Extension #169 - WGL_EXT_make_current_read
+# Extension #170 - WGL_EXT_pixel_format
+# Extension #171 - WGL_EXT_pbuffer
+# Extension #172 - WGL_EXT_swap_control
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #173
+# EXT_blend_func_separate commands (also INGR_blend_func_separate)
+#
+###############################################################################
+
+BlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)
+ return void
+ param sfactorRGB BlendFuncSeparateParameterEXT in value
+ param dfactorRGB BlendFuncSeparateParameterEXT in value
+ param sfactorAlpha BlendFuncSeparateParameterEXT in value
+ param dfactorAlpha BlendFuncSeparateParameterEXT in value
+ category EXT_blend_func_separate
+ glxropcode 4134
+ version 1.0
+ extension
+ alias BlendFuncSeparate
+ glsalias BlendFuncSeparate
+
+BlendFuncSeparateINGR(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha)
+ return void
+ param sfactorRGB BlendFuncSeparateParameterEXT in value
+ param dfactorRGB BlendFuncSeparateParameterEXT in value
+ param sfactorAlpha BlendFuncSeparateParameterEXT in value
+ param dfactorAlpha BlendFuncSeparateParameterEXT in value
+ category INGR_blend_func_separate
+ glxropcode 4134
+ version 1.0
+ extension
+ alias BlendFuncSeparateEXT
+ glsalias BlendFuncSeparateEXT
+
+###############################################################################
+#
+# Extension #174
+# INGR_color_clamp commands
+#
+###############################################################################
+
+# (none)
+newcategory: INGR_color_clamp
+
+###############################################################################
+#
+# Extension #175
+# INGR_interlace_read commands
+#
+###############################################################################
+
+# (none)
+newcategory: INGR_interlace_read
+
+###############################################################################
+#
+# Extension #176
+# EXT_stencil_wrap commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_stencil_wrap
+
+###############################################################################
+#
+# Extension #177 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #178
+# EXT_422_pixels commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_422_pixels
+
+###############################################################################
+#
+# Extension #179
+# NV_texgen_reflection commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texgen_reflection
+
+###############################################################################
+#
+# Extension #???
+# @ EXT_texture_cube_map commands
+#
+###############################################################################
+
+# (none)
+
+###############################################################################
+#
+# Extension #180 - skipped
+# Extension #181 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #182
+# SUN_convolution_border_modes commands
+#
+###############################################################################
+
+# (none)
+newcategory: SUN_convolution_border_modes
+
+###############################################################################
+#
+# Extension #183 - GLX_SUN_get_transparent_index
+# Extension #184 - skipped
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #185
+# EXT_texture_env_add commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_env_add
+
+###############################################################################
+#
+# Extension #186
+# EXT_texture_lod_bias commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_lod_bias
+
+###############################################################################
+#
+# Extension #187
+# EXT_texture_filter_anisotropic commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_filter_anisotropic
+
+###############################################################################
+#
+# Extension #188
+# EXT_vertex_weighting commands
+#
+###############################################################################
+
+# GLX stuff to be written
+VertexWeightfEXT(weight)
+ return void
+ param weight Float32 in value
+ category EXT_vertex_weighting
+ vectorequiv VertexWeightfvEXT
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ offset 494
+
+VertexWeightfvEXT(weight)
+ return void
+ param weight Float32 in array [1]
+ category EXT_vertex_weighting
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4135
+ glxflags ignore
+ glsopcode 0x01DE
+ offset 495
+
+VertexWeightPointerEXT(size, type, stride, pointer)
+ return void
+ param size SizeI in value
+ param type VertexWeightPointerTypeEXT in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(type/stride)] retained
+ category EXT_vertex_weighting
+ version 1.1
+ extension soft WINSOFT NV10
+ dlflags notlistable
+ glxflags ignore
+ glsflags client
+ glsopcode 0x01DF
+ offset 496
+
+###############################################################################
+#
+# Extension #189
+# NV_light_max_exponent commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_light_max_exponent
+
+###############################################################################
+#
+# Extension #190
+# NV_vertex_array_range commands
+#
+###############################################################################
+
+FlushVertexArrayRangeNV()
+ return void
+ category NV_vertex_array_range
+ version 1.1
+ extension soft WINSOFT NV10
+ dlflags notlistable
+ glxflags client-handcode server-handcode ignore
+ glsflags client
+ glsopcode 0x01E0
+ offset 497
+
+VertexArrayRangeNV(length, pointer)
+ return void
+ param length SizeI in value
+ param pointer Void in array [COMPSIZE(length)] retained
+ category NV_vertex_array_range
+ version 1.1
+ extension soft WINSOFT NV10
+ dlflags notlistable
+ glxflags client-handcode server-handcode ignore
+ glsflags client
+ glsopcode 0x01E1
+ offset 498
+
+###############################################################################
+#
+# Extension #191
+# NV_register_combiners commands
+#
+###############################################################################
+
+CombinerParameterfvNV(pname, params)
+ return void
+ param pname CombinerParameterNV in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4137
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x01E2
+ offset 499
+
+CombinerParameterfNV(pname, param)
+ return void
+ param pname CombinerParameterNV in value
+ param param Float32 in value
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4136
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x01E3
+ offset 500
+
+CombinerParameterivNV(pname, params)
+ return void
+ param pname CombinerParameterNV in value
+ param params CheckedInt32 in array [COMPSIZE(pname)]
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4139
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x01E4
+ offset 501
+
+CombinerParameteriNV(pname, param)
+ return void
+ param pname CombinerParameterNV in value
+ param param Int32 in value
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4138
+ glxflags ignore
+ glsflags gl-enum
+ glsopcode 0x01E5
+ offset 502
+
+CombinerInputNV(stage, portion, variable, input, mapping, componentUsage)
+ return void
+ param stage CombinerStageNV in value
+ param portion CombinerPortionNV in value
+ param variable CombinerVariableNV in value
+ param input CombinerRegisterNV in value
+ param mapping CombinerMappingNV in value
+ param componentUsage CombinerComponentUsageNV in value
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4140
+ glxflags ignore
+ glsopcode 0x01E6
+ offset 503
+
+CombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum)
+ return void
+ param stage CombinerStageNV in value
+ param portion CombinerPortionNV in value
+ param abOutput CombinerRegisterNV in value
+ param cdOutput CombinerRegisterNV in value
+ param sumOutput CombinerRegisterNV in value
+ param scale CombinerScaleNV in value
+ param bias CombinerBiasNV in value
+ param abDotProduct Boolean in value
+ param cdDotProduct Boolean in value
+ param muxSum Boolean in value
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4141
+ glxflags ignore
+ glsopcode 0x01E7
+ offset 504
+
+FinalCombinerInputNV(variable, input, mapping, componentUsage)
+ return void
+ param variable CombinerVariableNV in value
+ param input CombinerRegisterNV in value
+ param mapping CombinerMappingNV in value
+ param componentUsage CombinerComponentUsageNV in value
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxropcode 4142
+ glxflags ignore
+ glsopcode 0x01E8
+ offset 505
+
+GetCombinerInputParameterfvNV(stage, portion, variable, pname, params)
+ return void
+ param stage CombinerStageNV in value
+ param portion CombinerPortionNV in value
+ param variable CombinerVariableNV in value
+ param pname CombinerParameterNV in value
+ param params Float32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxvendorpriv 1270
+ glxflags ignore
+ glsflags get
+ glsopcode 0x01E9
+ offset 506
+
+GetCombinerInputParameterivNV(stage, portion, variable, pname, params)
+ return void
+ param stage CombinerStageNV in value
+ param portion CombinerPortionNV in value
+ param variable CombinerVariableNV in value
+ param pname CombinerParameterNV in value
+ param params Int32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxvendorpriv 1271
+ glxflags ignore
+ glsflags get
+ glsopcode 0x01EA
+ offset 507
+
+GetCombinerOutputParameterfvNV(stage, portion, pname, params)
+ return void
+ param stage CombinerStageNV in value
+ param portion CombinerPortionNV in value
+ param pname CombinerParameterNV in value
+ param params Float32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxvendorpriv 1272
+ glxflags ignore
+ glsflags get
+ glsopcode 0x01EB
+ offset 508
+
+GetCombinerOutputParameterivNV(stage, portion, pname, params)
+ return void
+ param stage CombinerStageNV in value
+ param portion CombinerPortionNV in value
+ param pname CombinerParameterNV in value
+ param params Int32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxvendorpriv 1273
+ glxflags ignore
+ glsflags get
+ glsopcode 0x01EC
+ offset 509
+
+GetFinalCombinerInputParameterfvNV(variable, pname, params)
+ return void
+ param variable CombinerVariableNV in value
+ param pname CombinerParameterNV in value
+ param params Float32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxvendorpriv 1274
+ glxflags ignore
+ glsflags get
+ glsopcode 0x01ED
+ offset 510
+
+GetFinalCombinerInputParameterivNV(variable, pname, params)
+ return void
+ param variable CombinerVariableNV in value
+ param pname CombinerParameterNV in value
+ param params Int32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_register_combiners
+ version 1.1
+ extension soft WINSOFT NV10
+ glxvendorpriv 1275
+ glxflags ignore
+ glsflags get
+ glsopcode 0x01EE
+ offset 511
+
+###############################################################################
+#
+# Extension #192
+# NV_fog_distance commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_fog_distance
+
+###############################################################################
+#
+# Extension #193
+# NV_texgen_emboss commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texgen_emboss
+
+###############################################################################
+#
+# Extension #194
+# NV_blend_square commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_blend_square
+
+###############################################################################
+#
+# Extension #195
+# NV_texture_env_combine4 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texture_env_combine4
+
+###############################################################################
+#
+# Extension #196
+# MESA_resize_buffers commands
+#
+###############################################################################
+
+ResizeBuffersMESA()
+ return void
+ category MESA_resize_buffers
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01EF
+ offset 512
+
+###############################################################################
+#
+# Extension #197
+# MESA_window_pos commands
+#
+# Note that the 2- and 3-component versions are now aliases of ARB
+# entry points.
+#
+###############################################################################
+
+WindowPos2dMESA(x, y)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ category MESA_window_pos
+ vectorequiv WindowPos2dvMESA
+ version 1.0
+ alias WindowPos2dARB
+
+WindowPos2dvMESA(v)
+ return void
+ param v CoordD in array [2]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F0
+ alias WindowPos2dvARB
+
+WindowPos2fMESA(x, y)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ category MESA_window_pos
+ vectorequiv WindowPos2fvMESA
+ version 1.0
+ alias WindowPos2fARB
+
+WindowPos2fvMESA(v)
+ return void
+ param v CoordF in array [2]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F1
+ alias WindowPos2fvARB
+
+WindowPos2iMESA(x, y)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ category MESA_window_pos
+ vectorequiv WindowPos2ivMESA
+ version 1.0
+ alias WindowPos2iARB
+
+WindowPos2ivMESA(v)
+ return void
+ param v CoordI in array [2]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F2
+ alias WindowPos2ivARB
+
+WindowPos2sMESA(x, y)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ category MESA_window_pos
+ vectorequiv WindowPos2svMESA
+ version 1.0
+ alias WindowPos2sARB
+
+WindowPos2svMESA(v)
+ return void
+ param v CoordS in array [2]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F3
+ alias WindowPos2svARB
+
+WindowPos3dMESA(x, y, z)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ vectorequiv WindowPos3dvMESA
+ category MESA_window_pos
+ version 1.0
+ alias WindowPos3dARB
+
+WindowPos3dvMESA(v)
+ return void
+ param v CoordD in array [3]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F4
+ alias WindowPos3dvARB
+
+WindowPos3fMESA(x, y, z)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ category MESA_window_pos
+ vectorequiv WindowPos3fvMESA
+ version 1.0
+ alias WindowPos3fARB
+
+WindowPos3fvMESA(v)
+ return void
+ param v CoordF in array [3]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F5
+ alias WindowPos3fvARB
+
+WindowPos3iMESA(x, y, z)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ category MESA_window_pos
+ vectorequiv WindowPos3ivMESA
+ version 1.0
+ alias WindowPos3iARB
+
+WindowPos3ivMESA(v)
+ return void
+ param v CoordI in array [3]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F6
+ alias WindowPos3ivARB
+
+WindowPos3sMESA(x, y, z)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ category MESA_window_pos
+ vectorequiv WindowPos3svMESA
+ version 1.0
+ alias WindowPos3sARB
+
+WindowPos3svMESA(v)
+ return void
+ param v CoordS in array [3]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F7
+ alias WindowPos3svARB
+
+WindowPos4dMESA(x, y, z, w)
+ return void
+ param x CoordD in value
+ param y CoordD in value
+ param z CoordD in value
+ param w CoordD in value
+ vectorequiv WindowPos4dvMESA
+ category MESA_window_pos
+ version 1.0
+ offset 529
+
+WindowPos4dvMESA(v)
+ return void
+ param v CoordD in array [4]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F8
+ offset 530
+
+WindowPos4fMESA(x, y, z, w)
+ return void
+ param x CoordF in value
+ param y CoordF in value
+ param z CoordF in value
+ param w CoordF in value
+ category MESA_window_pos
+ vectorequiv WindowPos4fvMESA
+ version 1.0
+ offset 531
+
+WindowPos4fvMESA(v)
+ return void
+ param v CoordF in array [4]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01F9
+ offset 532
+
+WindowPos4iMESA(x, y, z, w)
+ return void
+ param x CoordI in value
+ param y CoordI in value
+ param z CoordI in value
+ param w CoordI in value
+ category MESA_window_pos
+ vectorequiv WindowPos4ivMESA
+ version 1.0
+ offset 533
+
+WindowPos4ivMESA(v)
+ return void
+ param v CoordI in array [4]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01FA
+ offset 534
+
+WindowPos4sMESA(x, y, z, w)
+ return void
+ param x CoordS in value
+ param y CoordS in value
+ param z CoordS in value
+ param w CoordS in value
+ category MESA_window_pos
+ vectorequiv WindowPos4svMESA
+ version 1.0
+ offset 535
+
+WindowPos4svMESA(v)
+ return void
+ param v CoordS in array [4]
+ category MESA_window_pos
+ version 1.0
+ glxropcode ?
+ glsopcode 0x01FB
+ offset 536
+
+###############################################################################
+#
+# Extension #198
+# EXT_texture_compression_s3tc commands
+#
+###############################################################################
+
+#@@ (none yet)
+
+###############################################################################
+#
+# Extension #199
+# IBM_cull_vertex commands
+#
+###############################################################################
+
+# (none)
+newcategory: IBM_cull_vertex
+
+###############################################################################
+#
+# Extension #200
+# IBM_multimode_draw_arrays commands
+#
+###############################################################################
+
+MultiModeDrawArraysIBM(mode, first, count, primcount, modestride)
+ return void
+ param mode BeginMode in array [COMPSIZE(primcount)]
+ param first Int32 in array [COMPSIZE(primcount)]
+ param count SizeI in array [COMPSIZE(primcount)]
+ param primcount SizeI in value
+ param modestride Int32 in value
+ category IBM_multimode_draw_arrays
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset 708
+
+
+MultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride)
+ return void
+ param mode BeginMode in array [COMPSIZE(primcount)]
+ param count SizeI in array [COMPSIZE(primcount)]
+ param type DrawElementsType in value
+ param indices ConstVoidPointer in array [COMPSIZE(primcount)]
+ param primcount SizeI in value
+ param modestride Int32 in value
+ category IBM_multimode_draw_arrays
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset 709
+
+###############################################################################
+#
+# Extension #201
+# IBM_vertex_array_lists commands
+#
+###############################################################################
+
+ColorPointerListIBM(size, type, stride, pointer, ptrstride)
+ return void
+ param size Int32 in value
+ param type ColorPointerType in value
+ param stride Int32 in value
+ param pointer VoidPointer in array [COMPSIZE(size/type/stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+SecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride)
+ return void
+ param size Int32 in value
+ param type SecondaryColorPointerTypeIBM in value
+ param stride Int32 in value
+ param pointer VoidPointer in array [COMPSIZE(size/type/stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+EdgeFlagPointerListIBM(stride, pointer, ptrstride)
+ return void
+ param stride Int32 in value
+ param pointer BooleanPointer in array [COMPSIZE(stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+FogCoordPointerListIBM(type, stride, pointer, ptrstride)
+ return void
+ param type FogPointerTypeIBM in value
+ param stride Int32 in value
+ param pointer VoidPointer in array [COMPSIZE(type/stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+IndexPointerListIBM(type, stride, pointer, ptrstride)
+ return void
+ param type IndexPointerType in value
+ param stride Int32 in value
+ param pointer VoidPointer in array [COMPSIZE(type/stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+NormalPointerListIBM(type, stride, pointer, ptrstride)
+ return void
+ param type NormalPointerType in value
+ param stride Int32 in value
+ param pointer VoidPointer in array [COMPSIZE(type/stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+TexCoordPointerListIBM(size, type, stride, pointer, ptrstride)
+ return void
+ param size Int32 in value
+ param type TexCoordPointerType in value
+ param stride Int32 in value
+ param pointer VoidPointer in array [COMPSIZE(size/type/stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+VertexPointerListIBM(size, type, stride, pointer, ptrstride)
+ return void
+ param size Int32 in value
+ param type VertexPointerType in value
+ param stride Int32 in value
+ param pointer VoidPointer in array [COMPSIZE(size/type/stride)] retained
+ param ptrstride Int32 in value
+ category IBM_vertex_array_lists
+ version 1.1
+ glxropcode ?
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #202
+# SGIX_subsample commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_subsample
+
+###############################################################################
+#
+# Extension #203
+# SGIX_ycrcba commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_ycrcba
+
+###############################################################################
+#
+# Extension #204
+# SGIX_ycrcb_subsample commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_ycrcb_subsample
+
+###############################################################################
+#
+# Extension #205
+# SGIX_depth_pass_instrument commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_depth_pass_instrument
+
+###############################################################################
+#
+# Extension #206
+# 3DFX_texture_compression_FXT1 commands
+#
+###############################################################################
+
+# (none)
+newcategory: 3DFX_texture_compression_FXT1
+
+###############################################################################
+#
+# Extension #207
+# 3DFX_multisample commands
+#
+###############################################################################
+
+# (none)
+newcategory: 3DFX_multisample
+
+###############################################################################
+#
+# Extension #208
+# 3DFX_tbuffer commands
+#
+###############################################################################
+
+TbufferMask3DFX(mask)
+ return void
+ param mask UInt32 in value
+ category 3DFX_tbuffer
+ version 1.2
+ glxropcode ?
+ glsflags ignore
+ glsopcode 0x01FC
+ offset 553
+
+###############################################################################
+#
+# Extension #209
+# EXT_multisample commands
+#
+###############################################################################
+
+SampleMaskEXT(value, invert)
+ return void
+ param value ClampedFloat32 in value
+ param invert Boolean in value
+ category EXT_multisample
+ version 1.0
+ glxropcode ?
+ extension
+ glsopcode 0x0160
+ offset 446
+
+SamplePatternEXT(pattern)
+ return void
+ param pattern SamplePatternEXT in value
+ category EXT_multisample
+ version 1.0
+ glxropcode ?
+ glxflags
+ extension
+ glsopcode 0x0161
+ offset 447
+
+###############################################################################
+#
+# Extension #210
+# SGIX_vertex_preclip commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_vertex_preclip
+
+###############################################################################
+#
+# Extension #211
+# SGIX_convolution_accuracy commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_convolution_accuracy
+
+###############################################################################
+#
+# Extension #212
+# SGIX_resample commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_resample
+
+###############################################################################
+#
+# Extension #213
+# SGIS_point_line_texgen commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIS_point_line_texgen
+
+###############################################################################
+#
+# Extension #214
+# SGIS_texture_color_mask commands
+#
+###############################################################################
+
+TextureColorMaskSGIS(red, green, blue, alpha)
+ return void
+ param red Boolean in value
+ param green Boolean in value
+ param blue Boolean in value
+ param alpha Boolean in value
+ category SGIS_texture_color_mask
+ version 1.1
+ glxropcode 2082
+ extension
+ glsopcode 0x01B0
+ offset ?
+
+###############################################################################
+#
+# Extension #215 - GLX_MESA_copy_sub_buffer
+# Extension #216 - GLX_MESA_pixmap_colormap
+# Extension #217 - GLX_MESA_release_buffers
+# Extension #218 - GLX_MESA_set_3dfx_mode
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #219
+# SGIX_igloo_interface commands
+#
+###############################################################################
+
+IglooInterfaceSGIX(pname, params)
+ return void
+ dlflags notlistable
+ param pname IglooFunctionSelectSGIX in value
+ param params IglooParameterSGIX in array [COMPSIZE(pname)]
+ category SGIX_igloo_interface
+ version 1.0
+ glxflags SGI ignore
+ extension
+ glxropcode 200
+ glsopcode 0x0183
+ offset ?
+
+###############################################################################
+#
+# Extension #220
+# EXT_texture_env_dot3 commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_env_dot3
+
+###############################################################################
+#
+# Extension #221
+# ATI_texture_mirror_once commands
+#
+###############################################################################
+# (none)
+newcategory: ATI_texture_mirror_once
+
+###############################################################################
+#
+# Extension #222
+# NV_fence commands
+#
+###############################################################################
+
+DeleteFencesNV(n, fences)
+ return void
+ param n SizeI in value
+ param fences FenceNV in array [n]
+ category NV_fence
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1276
+ glxflags ignore
+ glsopcode 0x0216
+ offset 647
+
+GenFencesNV(n, fences)
+ return void
+ param n SizeI in value
+ param fences FenceNV out array [n]
+ category NV_fence
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1277
+ glxflags ignore
+ glsopcode 0x0215
+ offset 648
+
+IsFenceNV(fence)
+ return Boolean
+ param fence FenceNV in value
+ category NV_fence
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1278
+ glxflags ignore
+ glsflags get
+ glsopcode 0x021A
+ offset 649
+
+TestFenceNV(fence)
+ return Boolean
+ param fence FenceNV in value
+ category NV_fence
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1279
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0218
+ offset 650
+
+GetFenceivNV(fence, pname, params)
+ return void
+ param fence FenceNV in value
+ param pname FenceParameterNameNV in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category NV_fence
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1280
+ glxflags ignore
+ glsflags get
+ glsopcode 0x021B
+ offset 651
+
+FinishFenceNV(fence)
+ return void
+ param fence FenceNV in value
+ category NV_fence
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1312
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0219
+ offset 652
+
+SetFenceNV(fence, condition)
+ return void
+ param fence FenceNV in value
+ param condition FenceConditionNV in value
+ category NV_fence
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsopcode 0x0217
+ offset 653
+
+###############################################################################
+#
+# Extension #225
+# NV_evaluators commands
+#
+###############################################################################
+
+MapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points)
+ return void
+ param target EvalTargetNV in value
+ param index UInt32 in value
+ param type MapTypeNV in value
+ param ustride SizeI in value
+ param vstride SizeI in value
+ param uorder CheckedInt32 in value
+ param vorder CheckedInt32 in value
+ param packed Boolean in value
+ param points Void in array [COMPSIZE(target/uorder/vorder)]
+ category NV_evaluators
+ dlflags handcode
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags ignore
+ glsopcode 0x021C
+ offset ?
+
+MapParameterivNV(target, pname, params)
+ return void
+ param target EvalTargetNV in value
+ param pname MapParameterNV in value
+ param params CheckedInt32 in array [COMPSIZE(target/pname)]
+ category NV_evaluators
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags ignore
+ glsopcode 0x021D
+ offset ?
+
+MapParameterfvNV(target, pname, params)
+ return void
+ param target EvalTargetNV in value
+ param pname MapParameterNV in value
+ param params CheckedFloat32 in array [COMPSIZE(target/pname)]
+ category NV_evaluators
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags ignore
+ glsopcode 0x021E
+ offset ?
+
+GetMapControlPointsNV(target, index, type, ustride, vstride, packed, points)
+ return void
+ param target EvalTargetNV in value
+ param index UInt32 in value
+ param type MapTypeNV in value
+ param ustride SizeI in value
+ param vstride SizeI in value
+ param packed Boolean in value
+ param points Void out array [COMPSIZE(target)]
+ category NV_evaluators
+ dlflags notlistable
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags get
+ glsopcode 0x021F
+ offset ?
+
+GetMapParameterivNV(target, pname, params)
+ return void
+ param target EvalTargetNV in value
+ param pname MapParameterNV in value
+ param params Int32 out array [COMPSIZE(target/pname)]
+ category NV_evaluators
+ dlflags notlistable
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0220
+ offset ?
+
+GetMapParameterfvNV(target, pname, params)
+ return void
+ param target EvalTargetNV in value
+ param pname MapParameterNV in value
+ param params Float32 out array [COMPSIZE(target/pname)]
+ category NV_evaluators
+ dlflags notlistable
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0221
+ offset ?
+
+GetMapAttribParameterivNV(target, index, pname, params)
+ return void
+ param target EvalTargetNV in value
+ param index UInt32 in value
+ param pname MapAttribParameterNV in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category NV_evaluators
+ dlflags notlistable
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0222
+ offset ?
+
+GetMapAttribParameterfvNV(target, index, pname, params)
+ return void
+ param target EvalTargetNV in value
+ param index UInt32 in value
+ param pname MapAttribParameterNV in value
+ param params Float32 out array [COMPSIZE(pname)]
+ category NV_evaluators
+ dlflags notlistable
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0223
+ offset ?
+
+EvalMapsNV(target, mode)
+ return void
+ param target EvalTargetNV in value
+ param mode EvalMapsModeNV in value
+ category NV_evaluators
+ version 1.1
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsopcode 0x0224
+ offset ?
+
+###############################################################################
+#
+# Extension #226
+# NV_packed_depth_stencil commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_packed_depth_stencil
+
+###############################################################################
+#
+# Extension #227
+# NV_register_combiners2 commands
+#
+###############################################################################
+
+CombinerStageParameterfvNV(stage, pname, params)
+ return void
+ param stage CombinerStageNV in value
+ param pname CombinerParameterNV in value
+ param params CheckedFloat32 in array [COMPSIZE(pname)]
+ category NV_register_combiners2
+ version 1.1
+ extension
+ glxflags ignore
+ glsopcode 0x0225
+ offset ?
+
+GetCombinerStageParameterfvNV(stage, pname, params)
+ return void
+ param stage CombinerStageNV in value
+ param pname CombinerParameterNV in value
+ param params Float32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_register_combiners2
+ version 1.1
+ extension
+ glxflags ignore
+ glsflags get
+ glsopcode 0x0226
+ offset ?
+
+###############################################################################
+#
+# Extension #228
+# NV_texture_compression_vtc commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texture_compression_vtc
+
+###############################################################################
+#
+# Extension #229
+# NV_texture_rectangle commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texture_rectangle
+
+###############################################################################
+#
+# Extension #230
+# NV_texture_shader commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texture_shader
+
+###############################################################################
+#
+# Extension #231
+# NV_texture_shader2 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texture_shader2
+
+###############################################################################
+#
+# Extension #232
+# NV_vertex_array_range2 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_vertex_array_range2
+
+###############################################################################
+#
+# Extension #233
+# NV_vertex_program commands
+#
+###############################################################################
+
+AreProgramsResidentNV(n, programs, residences)
+ return Boolean
+ param n SizeI in value
+ param programs UInt32 in array [n]
+ param residences Boolean out array [n]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glxvendorpriv 1293
+ glsflags get
+ glsopcode 0x022B
+ offset 578
+
+BindProgramNV(target, id)
+ return void
+ param target VertexAttribEnumNV in value
+ param id UInt32 in value
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4180
+ glsopcode 0x0227
+ alias BindProgramARB
+ glsalias BindProgramARB
+
+DeleteProgramsNV(n, programs)
+ return void
+ param n SizeI in value
+ param programs UInt32 in array [n]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1294
+ glsopcode 0x0228
+ alias DeleteProgramsARB
+ glsalias DeleteProgramsARB
+
+ExecuteProgramNV(target, id, params)
+ return void
+ param target VertexAttribEnumNV in value
+ param id UInt32 in value
+ param params Float32 in array [4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glxropcode 4181
+ glsopcode 0x0229
+ offset 581
+
+GenProgramsNV(n, programs)
+ return void
+ param n SizeI in value
+ param programs UInt32 out array [n]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1295
+ glsopcode 0x022A
+ alias GenProgramsARB
+ glsalias GenProgramsARB
+
+GetProgramParameterdvNV(target, index, pname, params)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param params Float64 out array [4]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glxvendorpriv 1297
+ glsflags get
+ glsopcode 0x022E
+ offset 583
+
+GetProgramParameterfvNV(target, index, pname, params)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param params Float32 out array [4]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glxvendorpriv 1296
+ glsflags get
+ glsopcode 0x022D
+ offset 584
+
+# GetProgramParameterSigneddvNV(target, index, pname, params)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param pname VertexAttribEnumNV in value
+# param params Float64 out array [4]
+# category NV_vertex_program1_1_dcc
+# dlflags notlistable
+# version 1.2
+# extension soft WINSOFT NV20
+# glsflags ignore
+# glxflags ignore
+# offset ?
+#
+# GetProgramParameterSignedfvNV(target, index, pname, params)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param pname VertexAttribEnumNV in value
+# param params Float32 out array [4]
+# category NV_vertex_program1_1_dcc
+# dlflags notlistable
+# version 1.2
+# extension soft WINSOFT NV20
+# glsflags ignore
+# glxflags ignore
+# offset ?
+
+GetProgramivNV(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param params Int32 out array [4]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glxvendorpriv 1298
+ glsflags get
+ glsopcode 0x022F
+ offset 585
+
+GetProgramStringNV(id, pname, program)
+ return void
+ param id UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param program ProgramCharacterNV out array [COMPSIZE(id/pname)]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glxvendorpriv 1299
+ glsflags get
+ glsopcode 0x0230
+ offset 586
+
+GetTrackMatrixivNV(target, address, pname, params)
+ return void
+ param target VertexAttribEnumNV in value
+ param address UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param params Int32 out array [1]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glxvendorpriv 1300
+ glsflags get
+ glsopcode 0x0231
+ offset 587
+
+GetVertexAttribdvNV(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param params Float64 out array [1]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1301
+ glsflags client get
+ glsopcode 0x0232
+ alias GetVertexAttribdv
+ glsalias GetVertexAttribdv
+
+GetVertexAttribfvNV(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param params Float32 out array [1]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1302
+ glsflags client get
+ glsopcode 0x0233
+ alias GetVertexAttribfv
+ glsalias GetVertexAttribfv
+
+GetVertexAttribivNV(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param params Int32 out array [1]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1303
+ glsflags client get
+ glsopcode 0x0234
+ alias GetVertexAttribiv
+ glsalias GetVertexAttribiv
+
+GetVertexAttribPointervNV(index, pname, pointer)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribEnumNV in value
+ param pointer VoidPointer out array [1]
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags client get
+ glsopcode 0x0235
+ alias GetVertexAttribPointerv
+ glsalias GetVertexAttribPointerv
+
+IsProgramNV(id)
+ return Boolean
+ param id UInt32 in value
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxvendorpriv 1304
+ glsflags get
+ glsopcode 0x0236
+ alias IsProgram
+ glsalias IsProgram
+
+LoadProgramNV(target, id, len, program)
+ return void
+ param target VertexAttribEnumNV in value
+ param id UInt32 in value
+ param len SizeI in value
+ param program UInt8 in array [len]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4183
+ glsopcode 0x0237
+ offset 593
+
+ProgramParameter4dNV(target, index, x, y, z, w)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv ProgramParameter4dvNV
+ extension soft WINSOFT NV10
+ offset 594
+
+ProgramParameter4dvNV(target, index, v)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param v Float64 in array [4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4185
+ glsopcode 0x0238
+ offset 595
+
+ProgramParameter4fNV(target, index, x, y, z, w)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv ProgramParameter4fvNV
+ extension soft WINSOFT NV10
+ offset 596
+
+ProgramParameter4fvNV(target, index, v)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param v Float32 in array [4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4184
+ glsopcode 0x0239
+ offset 597
+
+#??? 'count' was SizeI in the latest NVIDIA gl.spec, but UInt32 in the
+#??? extension specification in the registry.
+ProgramParameters4dvNV(target, index, count, v)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param count UInt32 in value
+ param v Float64 in array [count*4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4187
+ glsopcode 0x023A
+ offset 598
+
+#??? 'count' was SizeI in the latest NVIDIA gl.spec, but UInt32 in the
+#??? extension specification in the registry.
+ProgramParameters4fvNV(target, index, count, v)
+ return void
+ param target VertexAttribEnumNV in value
+ param index UInt32 in value
+ param count UInt32 in value
+ param v Float32 in array [count*4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4186
+ glsopcode 0x023B
+ offset 599
+
+# ProgramParameterSigned4dNV(target, index, x, y, z, w)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param x Float64 in value
+# param y Float64 in value
+# param z Float64 in value
+# param w Float64 in value
+# category NV_vertex_program1_1_dcc
+# version 1.2
+# vectorequiv ProgramParameterSigned4dvNV
+# extension soft WINSOFT NV20
+# offset ?
+#
+# ProgramParameterSigned4dvNV(target, index, v)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param v Float64 in array [4]
+# category NV_vertex_program1_1_dcc
+# version 1.2
+# extension soft WINSOFT NV20
+# glsflags ignore
+# glxflags ignore
+# offset ?
+#
+# ProgramParameterSigned4fNV(target, index, x, y, z, w)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param x Float32 in value
+# param y Float32 in value
+# param z Float32 in value
+# param w Float32 in value
+# category NV_vertex_program1_1_dcc
+# version 1.2
+# vectorequiv ProgramParameterSigned4fvNV
+# extension soft WINSOFT NV20
+# offset ?
+#
+# ProgramParameterSigned4fvNV(target, index, v)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param v Float32 in array [4]
+# category NV_vertex_program1_1_dcc
+# version 1.2
+# extension soft WINSOFT NV20
+# glsflags ignore
+# glxflags ignore
+# offset ?
+#
+# ProgramParametersSigned4dvNV(target, index, count, v)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param count SizeI in value
+# param v Float64 in array [count*4]
+# category NV_vertex_program1_1_dcc
+# version 1.2
+# extension soft WINSOFT NV20
+# glsflags ignore
+# glxflags ignore
+# offset ?
+#
+# ProgramParametersSigned4fvNV(target, index, count, v)
+# return void
+# param target VertexAttribEnumNV in value
+# param index Int32 in value
+# param count SizeI in value
+# param v Float32 in array [count*4]
+# category NV_vertex_program1_1_dcc
+# version 1.2
+# extension soft WINSOFT NV20
+# glsflags ignore
+# glxflags ignore
+# offset ?
+
+RequestResidentProgramsNV(n, programs)
+ return void
+ param n SizeI in value
+ param programs UInt32 in array [n]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4182
+ glsopcode 0x022C
+ offset 600
+
+TrackMatrixNV(target, address, matrix, transform)
+ return void
+ param target VertexAttribEnumNV in value
+ param address UInt32 in value
+ param matrix VertexAttribEnumNV in value
+ param transform VertexAttribEnumNV in value
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4188
+ glsopcode 0x023C
+ offset 601
+
+VertexAttribPointerNV(index, fsize, type, stride, pointer)
+ return void
+ param index UInt32 in value
+ param fsize Int32 in value
+ param type VertexAttribEnumNV in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(fsize/type/stride)] retained
+ category NV_vertex_program
+ dlflags notlistable
+ version 1.2
+ extension soft WINSOFT NV10
+ glxflags ignore
+ glsflags client
+ glsopcode 0x023D
+ offset 602
+
+VertexAttrib1dNV(index, x)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib1dvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib1d
+ glsalias VertexAttrib1d
+
+VertexAttrib1dvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [1]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4197
+ glsopcode 0x0240
+ alias VertexAttrib1dv
+ glsalias VertexAttrib1dv
+
+VertexAttrib1fNV(index, x)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib1fvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib1f
+ glsalias VertexAttrib1f
+
+VertexAttrib1fvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [1]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4193
+ glsopcode 0x023F
+ alias VertexAttrib1fv
+ glsalias VertexAttrib1fv
+
+VertexAttrib1sNV(index, x)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib1svNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib1s
+ glsalias VertexAttrib1s
+
+VertexAttrib1svNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [1]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4189
+ glsopcode 0x023E
+ alias VertexAttrib1sv
+ glsalias VertexAttrib1sv
+
+VertexAttrib2dNV(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib2dvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib2d
+ glsalias VertexAttrib2d
+
+VertexAttrib2dvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [2]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4198
+ glsopcode 0x0243
+ alias VertexAttrib2dv
+ glsalias VertexAttrib2dv
+
+VertexAttrib2fNV(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib2fvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib2f
+ glsalias VertexAttrib2f
+
+VertexAttrib2fvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [2]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4194
+ glsopcode 0x0242
+ alias VertexAttrib2fv
+ glsalias VertexAttrib2fv
+
+VertexAttrib2sNV(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib2svNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib2s
+ glsalias VertexAttrib2s
+
+VertexAttrib2svNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [2]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4190
+ glsopcode 0x0241
+ alias VertexAttrib2sv
+ glsalias VertexAttrib2sv
+
+VertexAttrib3dNV(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib3dvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib3d
+ glsalias VertexAttrib3d
+
+VertexAttrib3dvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [3]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4199
+ glsopcode 0x0246
+ alias VertexAttrib3dv
+ glsalias VertexAttrib3dv
+
+VertexAttrib3fNV(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib3fvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib3f
+ glsalias VertexAttrib3f
+
+VertexAttrib3fvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [3]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4195
+ glsopcode 0x0245
+ alias VertexAttrib3fv
+ glsalias VertexAttrib3fv
+
+VertexAttrib3sNV(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib3svNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib3s
+ glsalias VertexAttrib3s
+
+VertexAttrib3svNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [3]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4191
+ glsopcode 0x0244
+ alias VertexAttrib3sv
+ glsalias VertexAttrib3sv
+
+VertexAttrib4dNV(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib4dvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib4d
+ glsalias VertexAttrib4d
+
+VertexAttrib4dvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float64 in array [4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4200
+ glsopcode 0x0249
+ alias VertexAttrib4dv
+ glsalias VertexAttrib4dv
+
+VertexAttrib4fNV(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib4fvNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib4f
+ glsalias VertexAttrib4f
+
+VertexAttrib4fvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Float32 in array [4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4196
+ glsopcode 0x0248
+ alias VertexAttrib4fv
+ glsalias VertexAttrib4fv
+
+VertexAttrib4sNV(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ param w Int16 in value
+ category NV_vertex_program
+ version 1.2
+ vectorequiv VertexAttrib4svNV
+ extension soft WINSOFT NV10
+ alias VertexAttrib4s
+ glsalias VertexAttrib4s
+
+VertexAttrib4svNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4192
+ glsopcode 0x0247
+ alias VertexAttrib4sv
+ glsalias VertexAttrib4sv
+
+VertexAttrib4ubNV(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x ColorUB in value
+ param y ColorUB in value
+ param z ColorUB in value
+ param w ColorUB in value
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ vectorequiv VertexAttrib4ubvNV
+ alias VertexAttrib4Nub
+ glsalias VertexAttrib4Nub
+
+VertexAttrib4ubvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v ColorUB in array [4]
+ category NV_vertex_program
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4201
+ glsopcode 0x024A
+ alias VertexAttrib4Nubv
+ glsalias VertexAttrib4Nubv
+
+VertexAttribs1dvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float64 in array [count]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4210
+ glsopcode 0x024D
+ offset 629
+
+VertexAttribs1fvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float32 in array [count]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4206
+ glsopcode 0x024C
+ offset 630
+
+VertexAttribs1svNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Int16 in array [count]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4202
+ glsopcode 0x024B
+ offset 631
+
+VertexAttribs2dvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float64 in array [count*2]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4211
+ glsopcode 0x0250
+ offset 632
+
+VertexAttribs2fvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float32 in array [count*2]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4207
+ glsopcode 0x024F
+ offset 633
+
+VertexAttribs2svNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Int16 in array [count*2]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4203
+ glsopcode 0x024E
+ offset 634
+
+VertexAttribs3dvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float64 in array [count*3]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4212
+ glsopcode 0x0253
+ offset 635
+
+VertexAttribs3fvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float32 in array [count*3]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4208
+ glsopcode 0x0252
+ offset 636
+
+VertexAttribs3svNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Int16 in array [count*3]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4204
+ glsopcode 0x0251
+ offset 637
+
+VertexAttribs4dvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float64 in array [count*4]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4213
+ glsopcode 0x0256
+ offset 638
+
+VertexAttribs4fvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Float32 in array [count*4]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4209
+ glsopcode 0x0255
+ offset 639
+
+VertexAttribs4svNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v Int16 in array [count*4]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4205
+ glsopcode 0x0254
+ offset 640
+
+VertexAttribs4ubvNV(index, count, v)
+ return void
+ param index UInt32 in value
+ param count SizeI in value
+ param v ColorUB in array [count*4]
+ category NV_vertex_program
+ dlflags handcode
+ version 1.2
+ extension soft WINSOFT NV10
+ glxropcode 4214
+ glsopcode 0x0257
+ offset 641
+
+
+###############################################################################
+#
+# Extension #234 - GLX_SGIX_visual_select_group
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #235
+# SGIX_texture_coordinate_clamp commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_texture_coordinate_clamp
+
+###############################################################################
+#
+# Extension #236
+# SGIX_scalebias_hint commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_scalebias_hint
+
+###############################################################################
+#
+# Extension #237 - GLX_OML_swap_method commands
+# Extension #238 - GLX_OML_sync_control commands
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #239
+# OML_interlace commands
+#
+###############################################################################
+
+# (none)
+newcategory: OML_interlace
+
+###############################################################################
+#
+# Extension #240
+# OML_subsample commands
+#
+###############################################################################
+
+# (none)
+newcategory: OML_subsample
+
+###############################################################################
+#
+# Extension #241
+# OML_resample commands
+#
+###############################################################################
+
+# (none)
+newcategory: OML_resample
+
+###############################################################################
+#
+# Extension #242 - WGL_OML_sync_control commands
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #243
+# NV_copy_depth_to_color commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_copy_depth_to_color
+
+###############################################################################
+#
+# Extension #244
+# ATI_envmap_bumpmap commands
+#
+###############################################################################
+
+TexBumpParameterivATI(pname, param)
+ return void
+ param pname TexBumpParameterATI in value
+ param param Int32 in array [COMPSIZE(pname)]
+ category ATI_envmap_bumpmap
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+TexBumpParameterfvATI(pname, param)
+ return void
+ param pname TexBumpParameterATI in value
+ param param Float32 in array [COMPSIZE(pname)]
+ category ATI_envmap_bumpmap
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+GetTexBumpParameterivATI(pname, param)
+ return void
+ param pname GetTexBumpParameterATI in value
+ param param Int32 out array [COMPSIZE(pname)]
+ category ATI_envmap_bumpmap
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetTexBumpParameterfvATI(pname, param)
+ return void
+ param pname GetTexBumpParameterATI in value
+ param param Float32 out array [COMPSIZE(pname)]
+ category ATI_envmap_bumpmap
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+###############################################################################
+#
+# Extension #245
+# ATI_fragment_shader commands
+#
+###############################################################################
+
+GenFragmentShadersATI(range)
+ return UInt32
+ param range UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BindFragmentShaderATI(id)
+ return void
+ param id UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+DeleteFragmentShaderATI(id)
+ return void
+ param id UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BeginFragmentShaderATI()
+ return void
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+EndFragmentShaderATI()
+ return void
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+PassTexCoordATI(dst, coord, swizzle)
+ return void
+ param dst UInt32 in value
+ param coord UInt32 in value
+ param swizzle SwizzleOpATI in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+SampleMapATI(dst, interp, swizzle)
+ return void
+ param dst UInt32 in value
+ param interp UInt32 in value
+ param swizzle SwizzleOpATI in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod)
+ return void
+ param op FragmentOpATI in value
+ param dst UInt32 in value
+ param dstMask UInt32 in value
+ param dstMod UInt32 in value
+ param arg1 UInt32 in value
+ param arg1Rep UInt32 in value
+ param arg1Mod UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod)
+ return void
+ param op FragmentOpATI in value
+ param dst UInt32 in value
+ param dstMask UInt32 in value
+ param dstMod UInt32 in value
+ param arg1 UInt32 in value
+ param arg1Rep UInt32 in value
+ param arg1Mod UInt32 in value
+ param arg2 UInt32 in value
+ param arg2Rep UInt32 in value
+ param arg2Mod UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod)
+ return void
+ param op FragmentOpATI in value
+ param dst UInt32 in value
+ param dstMask UInt32 in value
+ param dstMod UInt32 in value
+ param arg1 UInt32 in value
+ param arg1Rep UInt32 in value
+ param arg1Mod UInt32 in value
+ param arg2 UInt32 in value
+ param arg2Rep UInt32 in value
+ param arg2Mod UInt32 in value
+ param arg3 UInt32 in value
+ param arg3Rep UInt32 in value
+ param arg3Mod UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+AlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod)
+ return void
+ param op FragmentOpATI in value
+ param dst UInt32 in value
+ param dstMod UInt32 in value
+ param arg1 UInt32 in value
+ param arg1Rep UInt32 in value
+ param arg1Mod UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+AlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod)
+ return void
+ param op FragmentOpATI in value
+ param dst UInt32 in value
+ param dstMod UInt32 in value
+ param arg1 UInt32 in value
+ param arg1Rep UInt32 in value
+ param arg1Mod UInt32 in value
+ param arg2 UInt32 in value
+ param arg2Rep UInt32 in value
+ param arg2Mod UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+AlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod)
+ return void
+ param op FragmentOpATI in value
+ param dst UInt32 in value
+ param dstMod UInt32 in value
+ param arg1 UInt32 in value
+ param arg1Rep UInt32 in value
+ param arg1Mod UInt32 in value
+ param arg2 UInt32 in value
+ param arg2Rep UInt32 in value
+ param arg2Mod UInt32 in value
+ param arg3 UInt32 in value
+ param arg3Rep UInt32 in value
+ param arg3Mod UInt32 in value
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+SetFragmentShaderConstantATI(dst, value)
+ return void
+ param dst UInt32 in value
+ param value ConstFloat32 in array [4]
+ category ATI_fragment_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #246
+# ATI_pn_triangles commands
+#
+###############################################################################
+
+PNTrianglesiATI(pname, param)
+ return void
+ param pname PNTrianglesPNameATI in value
+ param param Int32 in value
+ category ATI_pn_triangles
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+PNTrianglesfATI(pname, param)
+ return void
+ param pname PNTrianglesPNameATI in value
+ param param Float32 in value
+ category ATI_pn_triangles
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #247
+# ATI_vertex_array_object commands
+#
+###############################################################################
+
+NewObjectBufferATI(size, pointer, usage)
+ return UInt32
+ param size SizeI in value
+ param pointer ConstVoid in array [size]
+ param usage ArrayObjectUsageATI in value
+ category ATI_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+IsObjectBufferATI(buffer)
+ return Boolean
+ param buffer UInt32 in value
+ category ATI_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+UpdateObjectBufferATI(buffer, offset, size, pointer, preserve)
+ return void
+ param buffer UInt32 in value
+ param offset UInt32 in value
+ param size SizeI in value
+ param pointer ConstVoid in array [size]
+ param preserve PreserveModeATI in value
+ category ATI_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+GetObjectBufferfvATI(buffer, pname, params)
+ return void
+ param buffer UInt32 in value
+ param pname ArrayObjectPNameATI in value
+ param params Float32 out array [1]
+ category ATI_vertex_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetObjectBufferivATI(buffer, pname, params)
+ return void
+ param buffer UInt32 in value
+ param pname ArrayObjectPNameATI in value
+ param params Int32 out array [1]
+ category ATI_vertex_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+FreeObjectBufferATI(buffer)
+ return void
+ param buffer UInt32 in value
+ category ATI_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ArrayObjectATI(array, size, type, stride, buffer, offset)
+ return void
+ param array EnableCap in value
+ param size Int32 in value
+ param type ScalarType in value
+ param stride SizeI in value
+ param buffer UInt32 in value
+ param offset UInt32 in value
+ category ATI_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+GetArrayObjectfvATI(array, pname, params)
+ return void
+ param array EnableCap in value
+ param pname ArrayObjectPNameATI in value
+ param params Float32 out array [1]
+ category ATI_vertex_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetArrayObjectivATI(array, pname, params)
+ return void
+ param array EnableCap in value
+ param pname ArrayObjectPNameATI in value
+ param params Int32 out array [1]
+ category ATI_vertex_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+VariantArrayObjectATI(id, type, stride, buffer, offset)
+ return void
+ param id UInt32 in value
+ param type ScalarType in value
+ param stride SizeI in value
+ param buffer UInt32 in value
+ param offset UInt32 in value
+ category ATI_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+GetVariantArrayObjectfvATI(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname ArrayObjectPNameATI in value
+ param params Float32 out array [1]
+ category ATI_vertex_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetVariantArrayObjectivATI(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname ArrayObjectPNameATI in value
+ param params Int32 out array [1]
+ category ATI_vertex_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+###############################################################################
+#
+# Extension #248
+# EXT_vertex_shader commands
+#
+###############################################################################
+
+BeginVertexShaderEXT()
+ return void
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+EndVertexShaderEXT()
+ return void
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BindVertexShaderEXT(id)
+ return void
+ param id UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+GenVertexShadersEXT(range)
+ return UInt32
+ param range UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+DeleteVertexShaderEXT(id)
+ return void
+ param id UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ShaderOp1EXT(op, res, arg1)
+ return void
+ param op VertexShaderOpEXT in value
+ param res UInt32 in value
+ param arg1 UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ShaderOp2EXT(op, res, arg1, arg2)
+ return void
+ param op VertexShaderOpEXT in value
+ param res UInt32 in value
+ param arg1 UInt32 in value
+ param arg2 UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ShaderOp3EXT(op, res, arg1, arg2, arg3)
+ return void
+ param op VertexShaderOpEXT in value
+ param res UInt32 in value
+ param arg1 UInt32 in value
+ param arg2 UInt32 in value
+ param arg3 UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+SwizzleEXT(res, in, outX, outY, outZ, outW)
+ return void
+ param res UInt32 in value
+ param in UInt32 in value
+ param outX VertexShaderCoordOutEXT in value
+ param outY VertexShaderCoordOutEXT in value
+ param outZ VertexShaderCoordOutEXT in value
+ param outW VertexShaderCoordOutEXT in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+WriteMaskEXT(res, in, outX, outY, outZ, outW)
+ return void
+ param res UInt32 in value
+ param in UInt32 in value
+ param outX VertexShaderWriteMaskEXT in value
+ param outY VertexShaderWriteMaskEXT in value
+ param outZ VertexShaderWriteMaskEXT in value
+ param outW VertexShaderWriteMaskEXT in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+InsertComponentEXT(res, src, num)
+ return void
+ param res UInt32 in value
+ param src UInt32 in value
+ param num UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ExtractComponentEXT(res, src, num)
+ return void
+ param res UInt32 in value
+ param src UInt32 in value
+ param num UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+GenSymbolsEXT(datatype, storagetype, range, components)
+ return UInt32
+ param datatype DataTypeEXT in value
+ param storagetype VertexShaderStorageTypeEXT in value
+ param range ParameterRangeEXT in value
+ param components UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+SetInvariantEXT(id, type, addr)
+ return void
+ param id UInt32 in value
+ param type ScalarType in value
+ param addr Void in array [COMPSIZE(id/type)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+SetLocalConstantEXT(id, type, addr)
+ return void
+ param id UInt32 in value
+ param type ScalarType in value
+ param addr Void in array [COMPSIZE(id/type)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantbvEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr Int8 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantsvEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr Int16 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantivEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr Int32 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantfvEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr Float32 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantdvEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr Float64 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantubvEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr UInt8 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantusvEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr UInt16 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantuivEXT(id, addr)
+ return void
+ param id UInt32 in value
+ param addr UInt32 in array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VariantPointerEXT(id, type, stride, addr)
+ return void
+ param id UInt32 in value
+ param type ScalarType in value
+ param stride UInt32 in value
+ param addr Void in array [COMPSIZE(id/type/stride)]
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+EnableVariantClientStateEXT(id)
+ return void
+ param id UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+DisableVariantClientStateEXT(id)
+ return void
+ param id UInt32 in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BindLightParameterEXT(light, value)
+ return UInt32
+ param light LightName in value
+ param value LightParameter in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BindMaterialParameterEXT(face, value)
+ return UInt32
+ param face MaterialFace in value
+ param value MaterialParameter in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BindTexGenParameterEXT(unit, coord, value)
+ return UInt32
+ param unit TextureUnit in value
+ param coord TextureCoordName in value
+ param value TextureGenParameter in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BindTextureUnitParameterEXT(unit, value)
+ return UInt32
+ param unit TextureUnit in value
+ param value VertexShaderTextureUnitParameter in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+BindParameterEXT(value)
+ return UInt32
+ param value VertexShaderParameterEXT in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+IsVariantEnabledEXT(id, cap)
+ return Boolean
+ param id UInt32 in value
+ param cap VariantCapEXT in value
+ category EXT_vertex_shader
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+GetVariantBooleanvEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Boolean out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetVariantIntegervEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Int32 out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetVariantFloatvEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Float32 out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetVariantPointervEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data VoidPointer out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetInvariantBooleanvEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Boolean out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetInvariantIntegervEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Int32 out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetInvariantFloatvEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Float32 out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetLocalConstantBooleanvEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Boolean out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetLocalConstantIntegervEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Int32 out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+GetLocalConstantFloatvEXT(id, value, data)
+ return void
+ param id UInt32 in value
+ param value GetVariantValueEXT in value
+ param data Float32 out array [COMPSIZE(id)]
+ category EXT_vertex_shader
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags ignore get
+ offset ?
+
+###############################################################################
+#
+# Extension #249
+# ATI_vertex_streams commands
+#
+###############################################################################
+
+VertexStream1sATI(stream, x)
+ return void
+ param stream VertexStreamATI in value
+ param x Int16 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream1svATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int16 in array [1]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream1iATI(stream, x)
+ return void
+ param stream VertexStreamATI in value
+ param x Int32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream1ivATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int32 in array [1]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream1fATI(stream, x)
+ return void
+ param stream VertexStreamATI in value
+ param x Float32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream1fvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float32 in array [1]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream1dATI(stream, x)
+ return void
+ param stream VertexStreamATI in value
+ param x Float64 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream1dvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float64 in array [1]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2sATI(stream, x, y)
+ return void
+ param stream VertexStreamATI in value
+ param x Int16 in value
+ param y Int16 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2svATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int16 in array [2]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2iATI(stream, x, y)
+ return void
+ param stream VertexStreamATI in value
+ param x Int32 in value
+ param y Int32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2ivATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int32 in array [2]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2fATI(stream, x, y)
+ return void
+ param stream VertexStreamATI in value
+ param x Float32 in value
+ param y Float32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2fvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float32 in array [2]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2dATI(stream, x, y)
+ return void
+ param stream VertexStreamATI in value
+ param x Float64 in value
+ param y Float64 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream2dvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float64 in array [2]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3sATI(stream, x, y, z)
+ return void
+ param stream VertexStreamATI in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3svATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int16 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3iATI(stream, x, y, z)
+ return void
+ param stream VertexStreamATI in value
+ param x Int32 in value
+ param y Int32 in value
+ param z Int32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3ivATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int32 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3fATI(stream, x, y, z)
+ return void
+ param stream VertexStreamATI in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3fvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float32 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3dATI(stream, x, y, z)
+ return void
+ param stream VertexStreamATI in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream3dvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float64 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4sATI(stream, x, y, z, w)
+ return void
+ param stream VertexStreamATI in value
+ param x Int16 in value
+ param y Int16 in value
+ param z Int16 in value
+ param w Int16 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4svATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int16 in array [4]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4iATI(stream, x, y, z, w)
+ return void
+ param stream VertexStreamATI in value
+ param x Int32 in value
+ param y Int32 in value
+ param z Int32 in value
+ param w Int32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4ivATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int32 in array [4]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4fATI(stream, x, y, z, w)
+ return void
+ param stream VertexStreamATI in value
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4fvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float32 in array [4]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4dATI(stream, x, y, z, w)
+ return void
+ param stream VertexStreamATI in value
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexStream4dvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float64 in array [4]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3bATI(stream, nx, ny, nz)
+ return void
+ param stream VertexStreamATI in value
+ param nx Int8 in value
+ param ny Int8 in value
+ param nz Int8 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3bvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int8 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3sATI(stream, nx, ny, nz)
+ return void
+ param stream VertexStreamATI in value
+ param nx Int16 in value
+ param ny Int16 in value
+ param nz Int16 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3svATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int16 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3iATI(stream, nx, ny, nz)
+ return void
+ param stream VertexStreamATI in value
+ param nx Int32 in value
+ param ny Int32 in value
+ param nz Int32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3ivATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Int32 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3fATI(stream, nx, ny, nz)
+ return void
+ param stream VertexStreamATI in value
+ param nx Float32 in value
+ param ny Float32 in value
+ param nz Float32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3fvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float32 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3dATI(stream, nx, ny, nz)
+ return void
+ param stream VertexStreamATI in value
+ param nx Float64 in value
+ param ny Float64 in value
+ param nz Float64 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+NormalStream3dvATI(stream, coords)
+ return void
+ param stream VertexStreamATI in value
+ param coords Float64 in array [3]
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+ClientActiveVertexStreamATI(stream)
+ return void
+ param stream VertexStreamATI in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexBlendEnviATI(pname, param)
+ return void
+ param pname VertexStreamATI in value
+ param param Int32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+VertexBlendEnvfATI(pname, param)
+ return void
+ param pname VertexStreamATI in value
+ param param Float32 in value
+ category ATI_vertex_streams
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #250 - WGL_I3D_digital_video_control
+# Extension #251 - WGL_I3D_gamma
+# Extension #252 - WGL_I3D_genlock
+# Extension #253 - WGL_I3D_image_buffer
+# Extension #254 - WGL_I3D_swap_frame_lock
+# Extension #255 - WGL_I3D_swap_frame_usage
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #256
+# ATI_element_array commands
+#
+###############################################################################
+
+ElementPointerATI(type, pointer)
+ return void
+ param type ElementPointerTypeATI in value
+ param pointer Void in array [COMPSIZE(type)] retained
+ category ATI_element_array
+ dlflags notlistable
+ glxflags client-handcode client-intercept server-handcode
+ version 1.2
+ glsflags ignore
+ offset ?
+
+DrawElementArrayATI(mode, count)
+ return void
+ param mode BeginMode in value
+ param count SizeI in value
+ category ATI_element_array
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.2
+ glsopcode ?
+ offset ?
+
+DrawRangeElementArrayATI(mode, start, end, count)
+ return void
+ param mode BeginMode in value
+ param start UInt32 in value
+ param end UInt32 in value
+ param count SizeI in value
+ category ATI_element_array
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.2
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #257
+# SUN_mesh_array commands
+#
+###############################################################################
+
+DrawMeshArraysSUN(mode, first, count, width)
+ return void
+ param mode BeginMode in value
+ param first Int32 in value
+ param count SizeI in value
+ param width SizeI in value
+ category SUN_mesh_array
+ dlflags handcode
+ glxflags client-handcode client-intercept server-handcode
+ version 1.1
+ glxropcode ?
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #258
+# SUN_slice_accum commands
+#
+###############################################################################
+
+# (none)
+newcategory: SUN_slice_accum
+
+###############################################################################
+#
+# Extension #259
+# NV_multisample_filter_hint commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_multisample_filter_hint
+
+###############################################################################
+#
+# Extension #260
+# NV_depth_clamp commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_depth_clamp
+
+###############################################################################
+#
+# Extension #261
+# NV_occlusion_query commands
+#
+###############################################################################
+
+GenOcclusionQueriesNV(n, ids)
+ return void
+ param n SizeI in value
+ param ids UInt32 out array [n]
+ dlflags notlistable
+ category NV_occlusion_query
+ version 1.2
+ extension soft WINSOFT NV20
+ glsflags ignore
+ glxflags ignore
+
+DeleteOcclusionQueriesNV(n, ids)
+ return void
+ param n SizeI in value
+ param ids UInt32 in array [n]
+ dlflags notlistable
+ category NV_occlusion_query
+ version 1.2
+ extension soft WINSOFT NV20
+ glsflags ignore
+ glxflags ignore
+
+IsOcclusionQueryNV(id)
+ return Boolean
+ param id UInt32 in value
+ dlflags notlistable
+ category NV_occlusion_query
+ version 1.2
+ extension soft WINSOFT NV20
+ glsflags ignore
+ glxflags ignore
+
+BeginOcclusionQueryNV(id)
+ return void
+ param id UInt32 in value
+ category NV_occlusion_query
+ version 1.2
+ extension soft WINSOFT NV20
+ glsflags ignore
+ glxflags ignore
+
+EndOcclusionQueryNV()
+ return void
+ category NV_occlusion_query
+ version 1.2
+ extension soft WINSOFT NV20
+ glsflags ignore
+ glxflags ignore
+
+GetOcclusionQueryivNV(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname OcclusionQueryParameterNameNV in value
+ param params Int32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_occlusion_query
+ version 1.2
+ extension soft WINSOFT NV20
+ glsflags ignore
+ glxflags ignore
+
+GetOcclusionQueryuivNV(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname OcclusionQueryParameterNameNV in value
+ param params UInt32 out array [COMPSIZE(pname)]
+ dlflags notlistable
+ category NV_occlusion_query
+ version 1.2
+ extension soft WINSOFT NV20
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #262
+# NV_point_sprite commands
+#
+###############################################################################
+
+PointParameteriNV(pname, param)
+ return void
+ param pname PointParameterNameARB in value
+ param param Int32 in value
+ category NV_point_sprite
+ version 1.2
+ extension soft WINSOFT NV20
+ glxropcode 4221
+ alias PointParameteri
+ glsalias PointParameteri
+
+PointParameterivNV(pname, params)
+ return void
+ param pname PointParameterNameARB in value
+ param params Int32 in array [COMPSIZE(pname)]
+ category NV_point_sprite
+ version 1.2
+ extension soft WINSOFT NV20
+ glxropcode 4222
+ alias PointParameteriv
+ glsalias PointParameteriv
+
+###############################################################################
+#
+# Extension #263 - WGL_NV_render_depth_texture
+# Extension #264 - WGL_NV_render_texture_rectangle
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #265
+# NV_texture_shader3 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texture_shader3
+
+###############################################################################
+#
+# Extension #266
+# NV_vertex_program1_1 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_vertex_program1_1
+
+###############################################################################
+#
+# Extension #267
+# EXT_shadow_funcs commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_shadow_funcs
+
+###############################################################################
+#
+# Extension #268
+# EXT_stencil_two_side commands
+#
+###############################################################################
+
+ActiveStencilFaceEXT(face)
+ return void
+ param face StencilFaceDirection in value
+ category EXT_stencil_two_side
+ version 1.3
+ glxropcode 4220
+ glsopcode ?
+ offset 646
+
+###############################################################################
+#
+# Extension #269
+# ATI_text_fragment_shader commands
+#
+###############################################################################
+
+# Uses ARB_vertex_program entry points
+newcategory: ATI_text_fragment_shader
+
+###############################################################################
+#
+# Extension #270
+# APPLE_client_storage commands
+#
+###############################################################################
+
+# (none)
+newcategory: APPLE_client_storage
+
+###############################################################################
+#
+# Extension #271
+# APPLE_element_array commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+# @@@ like #256 ATI_element_array
+ElementPointerAPPLE(type, pointer)
+ return void
+ param type ElementPointerTypeATI in value
+ param pointer Void in array [type]
+ category APPLE_element_array
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DrawElementArrayAPPLE(mode, first, count)
+ return void
+ param mode BeginMode in value
+ param first Int32 in value
+ param count SizeI in value
+ category APPLE_element_array
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DrawRangeElementArrayAPPLE(mode, start, end, first, count)
+ return void
+ param mode BeginMode in value
+ param start UInt32 in value
+ param end UInt32 in value
+ param first Int32 in value
+ param count SizeI in value
+ category APPLE_element_array
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiDrawElementArrayAPPLE(mode, first, count, primcount)
+ return void
+ param mode BeginMode in value
+ param first Int32 in array [primcount]
+ param count SizeI in array [primcount]
+ param primcount SizeI in value
+ category APPLE_element_array
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount)
+ return void
+ param mode BeginMode in value
+ param start UInt32 in value
+ param end UInt32 in value
+ param first Int32 in array [primcount]
+ param count SizeI in array [primcount]
+ param primcount SizeI in value
+ category APPLE_element_array
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #272
+# APPLE_fence commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+# @@@ like #222 NV_fence
+GenFencesAPPLE(n, fences)
+ return void
+ param n SizeI in value
+ param fences FenceNV out array [n]
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DeleteFencesAPPLE(n, fences)
+ return void
+ param n SizeI in value
+ param fences FenceNV in array [n]
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+SetFenceAPPLE(fence)
+ return void
+ param fence FenceNV in value
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+IsFenceAPPLE(fence)
+ return Boolean
+ param fence FenceNV in value
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TestFenceAPPLE(fence)
+ return Boolean
+ param fence FenceNV in value
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FinishFenceAPPLE(fence)
+ return void
+ param fence FenceNV in value
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TestObjectAPPLE(object, name)
+ return Boolean
+ param object ObjectTypeAPPLE in value
+ param name UInt32 in value
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FinishObjectAPPLE(object, name)
+ return void
+ param object ObjectTypeAPPLE in value
+ param name Int32 in value
+ category APPLE_fence
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #273
+# APPLE_vertex_array_object commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+# @@@ loosely derived from incomplete SGIX_vertex_array_object
+BindVertexArrayAPPLE(array)
+ return void
+ param array UInt32 in value
+ category APPLE_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DeleteVertexArraysAPPLE(n, arrays)
+ return void
+ param n SizeI in value
+ param arrays UInt32 in array [n]
+ category APPLE_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+GenVertexArraysAPPLE(n, arrays)
+ return void
+ param n SizeI in value
+ param arrays UInt32 out array [n]
+ category APPLE_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+IsVertexArrayAPPLE(array)
+ return Boolean
+ param array UInt32 in value
+ category APPLE_vertex_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #274
+# APPLE_vertex_array_range commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+# @@@ like #190 NV_vertex_array_range,
+VertexArrayRangeAPPLE(length, pointer)
+ return void
+ param length SizeI in value
+ param pointer Void out array [length]
+ category APPLE_vertex_array_range
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FlushVertexArrayRangeAPPLE(length, pointer)
+ return void
+ param length SizeI in value
+ param pointer Void out array [length]
+ category APPLE_vertex_array_range
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexArrayParameteriAPPLE(pname, param)
+ return void
+ param pname VertexArrayPNameAPPLE in value
+ param param Int32 in value
+ category APPLE_vertex_array_range
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #275
+# APPLE_ycbcr_422 commands
+#
+###############################################################################
+
+# (none)
+newcategory: APPLE_ycbcr_422
+
+###############################################################################
+#
+# Extension #276
+# S3_s3tc commands
+#
+###############################################################################
+
+# (none)
+newcategory: S3_s3tc
+
+###############################################################################
+#
+# Extension #277
+# ATI_draw_buffers commands
+#
+###############################################################################
+
+DrawBuffersATI(n, bufs)
+ return void
+ param n SizeI in value
+ param bufs DrawBufferModeATI in array [n]
+ category ATI_draw_buffers
+ version 1.2
+ extension
+ glxropcode 233
+ alias DrawBuffers
+ glsalias DrawBuffers
+
+###############################################################################
+#
+# Extension #278 - WGL_ATI_pixel_format_float
+#
+###############################################################################
+newcategory: ATI_pixel_format_float
+passthru: /* This is really a WGL extension, but defines some associated GL enums.
+passthru: * ATI does not export "GL_ATI_pixel_format_float" in the GL_EXTENSIONS string.
+passthru: */
+
+###############################################################################
+#
+# Extension #279
+# ATI_texture_env_combine3 commands
+#
+###############################################################################
+
+# (none)
+newcategory: ATI_texture_env_combine3
+
+###############################################################################
+#
+# Extension #280
+# ATI_texture_float commands
+#
+###############################################################################
+
+# (none)
+newcategory: ATI_texture_float
+
+###############################################################################
+#
+# Extension #281 (also WGL_NV_float_buffer)
+# NV_float_buffer commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_float_buffer
+
+###############################################################################
+#
+# Extension #282
+# NV_fragment_program commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+# Some NV_fragment_program entry points are shared with ARB_vertex_program,
+# and are only included in that #define block, for now.
+newcategory: NV_fragment_program
+passthru: /* Some NV_fragment_program entry points are shared with ARB_vertex_program. */
+
+ProgramNamedParameter4fNV(id, len, name, x, y, z, w)
+ return void
+ param id UInt32 in value
+ param len SizeI in value
+ param name UInt8 in array [1]
+ param x Float32 in value
+ param y Float32 in value
+ param z Float32 in value
+ param w Float32 in value
+ category NV_fragment_program
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 682
+
+ProgramNamedParameter4dNV(id, len, name, x, y, z, w)
+ return void
+ param id UInt32 in value
+ param len SizeI in value
+ param name UInt8 in array [1]
+ param x Float64 in value
+ param y Float64 in value
+ param z Float64 in value
+ param w Float64 in value
+ category NV_fragment_program
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 683
+
+ProgramNamedParameter4fvNV(id, len, name, v)
+ return void
+ param id UInt32 in value
+ param len SizeI in value
+ param name UInt8 in array [1]
+ param v Float32 in array [4]
+ category NV_fragment_program
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 684
+
+ProgramNamedParameter4dvNV(id, len, name, v)
+ return void
+ param id UInt32 in value
+ param len SizeI in value
+ param name UInt8 in array [1]
+ param v Float64 in array [4]
+ category NV_fragment_program
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset 685
+
+GetProgramNamedParameterfvNV(id, len, name, params)
+ return void
+ param id UInt32 in value
+ param len SizeI in value
+ param name UInt8 in array [1]
+ param params Float32 out array [4]
+ category NV_fragment_program
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 686
+
+GetProgramNamedParameterdvNV(id, len, name, params)
+ return void
+ param id UInt32 in value
+ param len SizeI in value
+ param name UInt8 in array [1]
+ param params Float64 out array [4]
+ category NV_fragment_program
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset 687
+
+###############################################################################
+#
+# Extension #283
+# NV_half_float commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+Vertex2hNV(x, y)
+ return void
+ param x Half16NV in value
+ param y Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Vertex2hvNV(v)
+ return void
+ param v Half16NV in array [2]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Vertex3hNV(x, y, z)
+ return void
+ param x Half16NV in value
+ param y Half16NV in value
+ param z Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Vertex3hvNV(v)
+ return void
+ param v Half16NV in array [3]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Vertex4hNV(x, y, z, w)
+ return void
+ param x Half16NV in value
+ param y Half16NV in value
+ param z Half16NV in value
+ param w Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Vertex4hvNV(v)
+ return void
+ param v Half16NV in array [4]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Normal3hNV(nx, ny, nz)
+ return void
+ param nx Half16NV in value
+ param ny Half16NV in value
+ param nz Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Normal3hvNV(v)
+ return void
+ param v Half16NV in array [3]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Color3hNV(red, green, blue)
+ return void
+ param red Half16NV in value
+ param green Half16NV in value
+ param blue Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Color3hvNV(v)
+ return void
+ param v Half16NV in array [3]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Color4hNV(red, green, blue, alpha)
+ return void
+ param red Half16NV in value
+ param green Half16NV in value
+ param blue Half16NV in value
+ param alpha Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+Color4hvNV(v)
+ return void
+ param v Half16NV in array [4]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord1hNV(s)
+ return void
+ param s Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord1hvNV(v)
+ return void
+ param v Half16NV in array [1]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord2hNV(s, t)
+ return void
+ param s Half16NV in value
+ param t Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord2hvNV(v)
+ return void
+ param v Half16NV in array [2]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord3hNV(s, t, r)
+ return void
+ param s Half16NV in value
+ param t Half16NV in value
+ param r Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord3hvNV(v)
+ return void
+ param v Half16NV in array [3]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord4hNV(s, t, r, q)
+ return void
+ param s Half16NV in value
+ param t Half16NV in value
+ param r Half16NV in value
+ param q Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+TexCoord4hvNV(v)
+ return void
+ param v Half16NV in array [4]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord1hNV(target, s)
+ return void
+ param target TextureUnit in value
+ param s Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord1hvNV(target, v)
+ return void
+ param target TextureUnit in value
+ param v Half16NV in array [1]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord2hNV(target, s, t)
+ return void
+ param target TextureUnit in value
+ param s Half16NV in value
+ param t Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord2hvNV(target, v)
+ return void
+ param target TextureUnit in value
+ param v Half16NV in array [2]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord3hNV(target, s, t, r)
+ return void
+ param target TextureUnit in value
+ param s Half16NV in value
+ param t Half16NV in value
+ param r Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord3hvNV(target, v)
+ return void
+ param target TextureUnit in value
+ param v Half16NV in array [3]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord4hNV(target, s, t, r, q)
+ return void
+ param target TextureUnit in value
+ param s Half16NV in value
+ param t Half16NV in value
+ param r Half16NV in value
+ param q Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+MultiTexCoord4hvNV(target, v)
+ return void
+ param target TextureUnit in value
+ param v Half16NV in array [4]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FogCoordhNV(fog)
+ return void
+ param fog Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FogCoordhvNV(fog)
+ return void
+ param fog Half16NV in array [1]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+SecondaryColor3hNV(red, green, blue)
+ return void
+ param red Half16NV in value
+ param green Half16NV in value
+ param blue Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+SecondaryColor3hvNV(v)
+ return void
+ param v Half16NV in array [3]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexWeighthNV(weight)
+ return void
+ param weight Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexWeighthvNV(weight)
+ return void
+ param weight Half16NV in array [1]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib1hNV(index, x)
+ return void
+ param index UInt32 in value
+ param x Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib1hvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Half16NV in array [1]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib2hNV(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Half16NV in value
+ param y Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib2hvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Half16NV in array [2]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib3hNV(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Half16NV in value
+ param y Half16NV in value
+ param z Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib3hvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Half16NV in array [3]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib4hNV(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Half16NV in value
+ param y Half16NV in value
+ param z Half16NV in value
+ param w Half16NV in value
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttrib4hvNV(index, v)
+ return void
+ param index UInt32 in value
+ param v Half16NV in array [4]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttribs1hvNV(index, n, v)
+ return void
+ param index UInt32 in value
+ param n SizeI in value
+ param v Half16NV in array [n]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttribs2hvNV(index, n, v)
+ return void
+ param index UInt32 in value
+ param n SizeI in value
+ param v Half16NV in array [n]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttribs3hvNV(index, n, v)
+ return void
+ param index UInt32 in value
+ param n SizeI in value
+ param v Half16NV in array [n]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+VertexAttribs4hvNV(index, n, v)
+ return void
+ param index UInt32 in value
+ param n SizeI in value
+ param v Half16NV in array [n]
+ category NV_half_float
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #284
+# NV_pixel_data_range commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+PixelDataRangeNV(target, length, pointer)
+ return void
+ param target PixelDataRangeTargetNV in value
+ param length SizeI in value
+ param pointer Void out array [length]
+ category NV_pixel_data_range
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FlushPixelDataRangeNV(target)
+ return void
+ param target PixelDataRangeTargetNV in value
+ category NV_pixel_data_range
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #285
+# NV_primitive_restart commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+PrimitiveRestartNV()
+ return void
+ category NV_primitive_restart
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+PrimitiveRestartIndexNV(index)
+ return void
+ param index UInt32 in value
+ category NV_primitive_restart
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+
+###############################################################################
+#
+# Extension #286
+# NV_texture_expand_normal commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_texture_expand_normal
+
+###############################################################################
+#
+# Extension #287
+# NV_vertex_program2 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_vertex_program2
+
+###############################################################################
+#
+# Extension #288
+# ATI_map_object_buffer commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+MapObjectBufferATI(buffer)
+ return VoidPointer
+ param buffer UInt32 in value
+ category ATI_map_object_buffer
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+UnmapObjectBufferATI(buffer)
+ return void
+ param buffer UInt32 in value
+ category ATI_map_object_buffer
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #289
+# ATI_separate_stencil commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+StencilOpSeparateATI(face, sfail, dpfail, dppass)
+ return void
+ param face StencilFaceDirection in value
+ param sfail StencilOp in value
+ param dpfail StencilOp in value
+ param dppass StencilOp in value
+ category ATI_separate_stencil
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias StencilOpSeparate
+ glsalias StencilOpSeparate
+
+StencilFuncSeparateATI(frontfunc, backfunc, ref, mask)
+ return void
+ param frontfunc StencilFunction in value
+ param backfunc StencilFunction in value
+ param ref ClampedStencilValue in value
+ param mask MaskedStencilValue in value
+ category ATI_separate_stencil
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ alias StencilFuncSeparate
+ glsalias StencilFuncSeparate
+
+###############################################################################
+#
+# Extension #290
+# ATI_vertex_attrib_array_object commands
+#
+###############################################################################
+
+# @@ Need to verify/add GLX protocol
+
+VertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset)
+ return void
+ param index UInt32 in value
+ param size Int32 in value
+ param type VertexAttribPointerTypeARB in value
+ param normalized Boolean in value
+ param stride SizeI in value
+ param buffer UInt32 in value
+ param offset UInt32 in value
+ category ATI_vertex_attrib_array_object
+ version 1.2
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+GetVertexAttribArrayObjectfvATI(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname ArrayObjectPNameATI in value
+ param params Float32 out array [pname]
+ category ATI_vertex_attrib_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetVertexAttribArrayObjectivATI(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname ArrayObjectPNameATI in value
+ param params Int32 out array [pname]
+ category ATI_vertex_attrib_array_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxsingle ?
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #291 - OpenGL ES only, not in glext.h
+# OES_byte_coordinates commands
+#
+###############################################################################
+
+# void Vertex{234}bOES(T coords)
+# void Vertex{234}bvOES(T *coords)
+# void TexCoord{1234}bOES(T coords)
+# void TexCoord{1234}bvOES(T *coords)
+# void MultiTexCoord{1234}bOES(enum texture, T coords)
+# void MultiTexCoord{1234}bvOES(enum texture, T *coords)
+# All are handcode - mapped to non-byte GLX protocol on client side
+
+# newcategory: OES_byte_coordinates
+
+###############################################################################
+#
+# Extension #292 - OpenGL ES only, not in glext.h
+# OES_fixed_point commands
+#
+###############################################################################
+
+# Too many to list in just a comment - see spec in the extension registry
+# All are handcode - mapped to non-byte GLX protocol on client side
+
+# newcategory: OES_fixed_point
+
+###############################################################################
+#
+# Extension #293 - OpenGL ES only, not in glext.h
+# OES_single_precision commands
+#
+###############################################################################
+
+# void DepthRangefOES(clampf n, clampf f)
+# void FrustumfOES(float l, float r, float b, float t, float n, float f)
+# void OrthofOES(float l, float r, float b, float t, float n, float f)
+# void ClipPlanefOES(enum plane, const float* equation)
+# void glClearDepthfOES(clampd depth)
+# GLX ropcodes 4308-4312 (not respectively, see extension spec)
+# void GetClipPlanefOES(enum plane, float* equation)
+# GLX vendor private 1421
+
+# newcategory: OES_single_precision
+
+###############################################################################
+#
+# Extension #294 - OpenGL ES only, not in glext.h
+# OES_compressed_paletted_texture commands
+#
+###############################################################################
+
+# (none)
+# newcategory: OES_compressed_paletted_texture
+
+###############################################################################
+#
+# Extension #295 - This is an OpenGL ES extension, but also implemented in Mesa
+# OES_read_format commands
+#
+###############################################################################
+
+# (none)
+newcategory: OES_read_format
+
+###############################################################################
+#
+# Extension #296 - OpenGL ES only, not in glext.h
+# OES_query_matrix commands
+#
+###############################################################################
+
+# bitfield queryMatrixxOES(fixed mantissa[16], int exponent[16])
+# All are handcode - mapped to non-byte GLX protocol on client side
+
+# newcategory: OES_query_matrix
+
+###############################################################################
+#
+# Extension #297
+# EXT_depth_bounds_test commands
+#
+###############################################################################
+
+DepthBoundsEXT(zmin, zmax)
+ return void
+ param zmin ClampedFloat64 in value
+ param zmax ClampedFloat64 in value
+ category EXT_depth_bounds_test
+ version 1.2
+ extension
+ glxropcode 4229
+ glsopcode ?
+ offset 699
+
+###############################################################################
+#
+# Extension #298
+# EXT_texture_mirror_clamp commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_mirror_clamp
+
+###############################################################################
+#
+# Extension #299
+# EXT_blend_equation_separate commands
+#
+###############################################################################
+
+BlendEquationSeparateEXT(modeRGB, modeAlpha)
+ return void
+ param modeRGB BlendEquationModeEXT in value
+ param modeAlpha BlendEquationModeEXT in value
+ category EXT_blend_equation_separate
+ version 1.2
+ extension
+ glxropcode 4228
+ alias BlendEquationSeparate
+ glsalias BlendEquationSeparate
+
+###############################################################################
+#
+# Extension #300
+# MESA_pack_invert commands
+#
+###############################################################################
+
+# (none)
+newcategory: MESA_pack_invert
+
+###############################################################################
+#
+# Extension #301
+# MESA_ycbcr_texture commands
+#
+###############################################################################
+
+# (none)
+newcategory: MESA_ycbcr_texture
+
+###############################################################################
+#
+# Extension #301
+# MESA_ycbcr_texture commands
+#
+###############################################################################
+
+# (none)
+newcategory: MESA_ycbcr_texture
+
+###############################################################################
+#
+# Extension #302
+# EXT_pixel_buffer_object commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_pixel_buffer_object
+
+###############################################################################
+#
+# Extension #303
+# NV_fragment_program_option commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_fragment_program_option
+
+###############################################################################
+#
+# Extension #304
+# NV_fragment_program2 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_fragment_program2
+
+###############################################################################
+#
+# Extension #305
+# NV_vertex_program2_option commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_vertex_program2_option
+
+###############################################################################
+#
+# Extension #306
+# NV_vertex_program3 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_vertex_program3
+
+###############################################################################
+#
+# Extension #307 - GLX_SGIX_hyperpipe commands
+# Extension #308 - GLX_MESA_agp_offset commands
+# Extension #309 - GL_EXT_texture_compression_dxt1 (OpenGL ES only, subset of _st3c version)
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #310
+# EXT_framebuffer_object commands
+#
+###############################################################################
+
+IsRenderbufferEXT(renderbuffer)
+ return Boolean
+ param renderbuffer UInt32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxvendorpriv 1422
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+BindRenderbufferEXT(target, renderbuffer)
+ return void
+ param target RenderbufferTarget in value
+ param renderbuffer UInt32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4316
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DeleteRenderbuffersEXT(n, renderbuffers)
+ return void
+ param n SizeI in value
+ param renderbuffers UInt32 in array [n]
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4317
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+GenRenderbuffersEXT(n, renderbuffers)
+ return void
+ param n SizeI in value
+ param renderbuffers UInt32 out array [n]
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxvendorpriv 1423
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+RenderbufferStorageEXT(target, internalformat, width, height)
+ return void
+ param target RenderbufferTarget in value
+ param internalformat GLenum in value
+ param width SizeI in value
+ param height SizeI in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4318
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+GetRenderbufferParameterivEXT(target, pname, params)
+ return void
+ param target RenderbufferTarget in value
+ param pname GLenum in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category EXT_framebuffer_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxvendorpriv 1424
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+IsFramebufferEXT(framebuffer)
+ return Boolean
+ param framebuffer UInt32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxvendorpriv 1425
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+BindFramebufferEXT(target, framebuffer)
+ return void
+ param target FramebufferTarget in value
+ param framebuffer UInt32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4319
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+DeleteFramebuffersEXT(n, framebuffers)
+ return void
+ param n SizeI in value
+ param framebuffers UInt32 in array [n]
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4320
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+GenFramebuffersEXT(n, framebuffers)
+ return void
+ param n SizeI in value
+ param framebuffers UInt32 out array [n]
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxvendorpriv 1426
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+CheckFramebufferStatusEXT(target)
+ return GLenum
+ param target FramebufferTarget in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxvendorpriv 1427
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FramebufferTexture1DEXT(target, attachment, textarget, texture, level)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param textarget GLenum in value
+ param texture UInt32 in value
+ param level Int32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4321
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FramebufferTexture2DEXT(target, attachment, textarget, texture, level)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param textarget GLenum in value
+ param texture UInt32 in value
+ param level Int32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4322
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param textarget GLenum in value
+ param texture UInt32 in value
+ param level Int32 in value
+ param zoffset Int32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4323
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param renderbuffertarget RenderbufferTarget in value
+ param renderbuffer UInt32 in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4324
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+GetFramebufferAttachmentParameterivEXT(target, attachment, pname, params)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param pname GLenum in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category EXT_framebuffer_object
+ dlflags notlistable
+ version 1.2
+ extension
+ glxvendorpriv 1428
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GenerateMipmapEXT(target)
+ return void
+ param target GLenum in value
+ category EXT_framebuffer_object
+ version 1.2
+ extension
+ glxropcode 4325
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+
+###############################################################################
+#
+# Extension #311
+# GREMEDY_string_marker commands
+#
+###############################################################################
+
+StringMarkerGREMEDY(len, string)
+ return void
+ param len SizeI in value
+ param string Void in array [len]
+ category GREMEDY_string_marker
+ version 1.0
+ extension
+ glsflags ignore
+ glxflags ignore
+ offset ?
+
+###############################################################################
+#
+# Extension #312
+# EXT_packed_depth_stencil commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_packed_depth_stencil
+
+###############################################################################
+#
+# Extension #313 - WGL_3DL_stereo_control
+#
+###############################################################################
+
+###############################################################################
+#
+# Extension #314
+# EXT_stencil_clear_tag commands
+#
+###############################################################################
+
+StencilClearTagEXT(stencilTagBits, stencilClearTag)
+ return void
+ param stencilTagBits SizeI in value
+ param stencilClearTag UInt32 in value
+ category EXT_stencil_clear_tag
+ version 1.5
+ extension
+ glxropcode 4223
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #315
+# EXT_texture_sRGB commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_sRGB
+
+###############################################################################
+#
+# Extension #316
+# EXT_framebuffer_blit commands
+#
+###############################################################################
+
+BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)
+ return void
+ param srcX0 Int32 in value
+ param srcY0 Int32 in value
+ param srcX1 Int32 in value
+ param srcY1 Int32 in value
+ param dstX0 Int32 in value
+ param dstY0 Int32 in value
+ param dstX1 Int32 in value
+ param dstY1 Int32 in value
+ param mask ClearBufferMask in value
+ param filter GLenum in value
+ category EXT_framebuffer_blit
+ version 1.5
+ glxropcode 4330
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #317
+# EXT_framebuffer_multisample commands
+#
+###############################################################################
+
+RenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height)
+ return void
+ param target GLenum in value
+ param samples SizeI in value
+ param internalformat GLenum in value
+ param width SizeI in value
+ param height SizeI in value
+ category EXT_framebuffer_multisample
+ version 1.5
+ glxropcode 4331
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #318
+# MESAX_texture_stack commands
+#
+###############################################################################
+
+# (none)
+newcategory: MESAX_texture_stack
+
+###############################################################################
+#
+# Extension #319
+# EXT_timer_query commands
+#
+###############################################################################
+
+GetQueryObjecti64vEXT(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname GLenum in value
+ param params Int64EXT out array [pname]
+ category EXT_timer_query
+ dlflags notlistable
+ version 1.5
+ glxvendorpriv 1328
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+GetQueryObjectui64vEXT(id, pname, params)
+ return void
+ param id UInt32 in value
+ param pname GLenum in value
+ param params UInt64EXT out array [pname]
+ category EXT_timer_query
+ dlflags notlistable
+ version 1.5
+ glxvendorpriv 1329
+ glxflags ignore
+ glsflags get
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #320
+# EXT_gpu_program_parameters commands
+#
+###############################################################################
+
+ProgramEnvParameters4fvEXT(target, index, count, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params Float32 in array [count*4]
+ category EXT_gpu_program_parameters
+ version 1.2
+ glxropcode 4281
+ glsopcode ?
+ offset ?
+
+ProgramLocalParameters4fvEXT(target, index, count, params)
+ return void
+ param target ProgramTargetARB in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params Float32 in array [count*4]
+ category EXT_gpu_program_parameters
+ version 1.2
+ glxropcode 4282
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #321
+# APPLE_flush_buffer_range commands
+#
+###############################################################################
+
+BufferParameteriAPPLE(target, pname, param)
+ return void
+ param target GLenum in value
+ param pname GLenum in value
+ param param Int32 in value
+ category APPLE_flush_buffer_range
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+FlushMappedBufferRangeAPPLE(target, offset, size)
+ return void
+ param target GLenum in value
+ param offset BufferOffset in value
+ param size BufferSize in value
+ category APPLE_flush_buffer_range
+ version 1.5
+ extension
+ glxropcode ?
+ glxflags ignore
+ glsopcode ?
+ offset ?
+
+###############################################################################
+#
+# Extension #322
+# NV_gpu_program4 commands
+#
+###############################################################################
+
+ProgramLocalParameterI4iNV(target, index, x, y, z, w)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param x Int32 in value
+ param y Int32 in value
+ param z Int32 in value
+ param w Int32 in value
+ category NV_gpu_program4
+ version 1.3
+ vectorequiv ProgramLocalParameterI4ivNV
+ glxvectorequiv ProgramLocalParameterI4ivNV
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramLocalParameterI4ivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params Int32 in array [4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramLocalParametersI4ivNV(target, index, count, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params Int32 in array [count*4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramLocalParameterI4uiNV(target, index, x, y, z, w)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param x UInt32 in value
+ param y UInt32 in value
+ param z UInt32 in value
+ param w UInt32 in value
+ category NV_gpu_program4
+ version 1.3
+ vectorequiv ProgramLocalParameterI4uivNV
+ glxvectorequiv ProgramLocalParameterI4uivNV
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramLocalParameterI4uivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params UInt32 in array [4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramLocalParametersI4uivNV(target, index, count, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params UInt32 in array [count*4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramEnvParameterI4iNV(target, index, x, y, z, w)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param x Int32 in value
+ param y Int32 in value
+ param z Int32 in value
+ param w Int32 in value
+ category NV_gpu_program4
+ version 1.3
+ vectorequiv ProgramEnvParameterI4ivNV
+ glxvectorequiv ProgramEnvParameterI4ivNV
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramEnvParameterI4ivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params Int32 in array [4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramEnvParametersI4ivNV(target, index, count, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params Int32 in array [count*4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramEnvParameterI4uiNV(target, index, x, y, z, w)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param x UInt32 in value
+ param y UInt32 in value
+ param z UInt32 in value
+ param w UInt32 in value
+ category NV_gpu_program4
+ version 1.3
+ vectorequiv ProgramEnvParameterI4uivNV
+ glxvectorequiv ProgramEnvParameterI4uivNV
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramEnvParameterI4uivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params UInt32 in array [4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramEnvParametersI4uivNV(target, index, count, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params UInt32 in array [count*4]
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetProgramLocalParameterIivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params Int32 out array [4]
+ dlflags notlistable
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetProgramLocalParameterIuivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params UInt32 out array [4]
+ dlflags notlistable
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetProgramEnvParameterIivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params Int32 out array [4]
+ dlflags notlistable
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetProgramEnvParameterIuivNV(target, index, params)
+ return void
+ param target ProgramTarget in value
+ param index UInt32 in value
+ param params UInt32 out array [4]
+ dlflags notlistable
+ category NV_gpu_program4
+ version 1.3
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #323
+# NV_geometry_program4 commands
+#
+###############################################################################
+
+ProgramVertexLimitNV(target, limit)
+ return void
+ param target ProgramTarget in value
+ param limit Int32 in value
+ category NV_geometry_program4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+FramebufferTextureEXT(target, attachment, texture, level)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param texture Texture in value
+ param level CheckedInt32 in value
+ category NV_geometry_program4
+ version 2.0
+ extension soft WINSOFT
+ dlflags notlistable
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+FramebufferTextureLayerEXT(target, attachment, texture, level, layer)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param texture Texture in value
+ param level CheckedInt32 in value
+ param layer CheckedInt32 in value
+ category NV_geometry_program4
+ version 2.0
+ extension soft WINSOFT
+ dlflags notlistable
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+FramebufferTextureFaceEXT(target, attachment, texture, level, face)
+ return void
+ param target FramebufferTarget in value
+ param attachment FramebufferAttachment in value
+ param texture Texture in value
+ param level CheckedInt32 in value
+ param face TextureTarget in value
+ category NV_geometry_program4
+ version 2.0
+ extension soft WINSOFT
+ dlflags notlistable
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #324
+# EXT_geometry_shader4 commands
+#
+###############################################################################
+
+ProgramParameteriEXT(program, pname, value)
+ return void
+ param program UInt32 in value
+ param pname ProgramParameterPName in value
+ param value Int32 in value
+ category EXT_geometry_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #325
+# NV_vertex_program4 commands
+#
+###############################################################################
+
+VertexAttribI1iEXT(index, x)
+ return void
+ param index UInt32 in value
+ param x Int32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI1ivEXT
+ glxvectorequiv VertexAttribI1ivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI2iEXT(index, x, y)
+ return void
+ param index UInt32 in value
+ param x Int32 in value
+ param y Int32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI2ivEXT
+ glxvectorequiv VertexAttribI2ivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI3iEXT(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x Int32 in value
+ param y Int32 in value
+ param z Int32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI3ivEXT
+ glxvectorequiv VertexAttribI3ivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4iEXT(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x Int32 in value
+ param y Int32 in value
+ param z Int32 in value
+ param w Int32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI4ivEXT
+ glxvectorequiv VertexAttribI4ivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI1uiEXT(index, x)
+ return void
+ param index UInt32 in value
+ param x UInt32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI1uivEXT
+ glxvectorequiv VertexAttribI1uivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI2uiEXT(index, x, y)
+ return void
+ param index UInt32 in value
+ param x UInt32 in value
+ param y UInt32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI2uivEXT
+ glxvectorequiv VertexAttribI2uivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI3uiEXT(index, x, y, z)
+ return void
+ param index UInt32 in value
+ param x UInt32 in value
+ param y UInt32 in value
+ param z UInt32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI3uivEXT
+ glxvectorequiv VertexAttribI3uivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4uiEXT(index, x, y, z, w)
+ return void
+ param index UInt32 in value
+ param x UInt32 in value
+ param y UInt32 in value
+ param z UInt32 in value
+ param w UInt32 in value
+ category NV_vertex_program4
+ beginend allow-inside
+ vectorequiv VertexAttribI4uivEXT
+ glxvectorequiv VertexAttribI4uivEXT
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI1ivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [1]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI2ivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [2]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI3ivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [3]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4ivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v Int32 in array [4]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI1uivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [1]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI2uivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [2]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI3uivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [3]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4uivEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt32 in array [4]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4bvEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v Int8 in array [4]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4svEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v Int16 in array [4]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4ubvEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt8 in array [4]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribI4usvEXT(index, v)
+ return void
+ param index UInt32 in value
+ param v UInt16 in array [4]
+ category NV_vertex_program4
+ beginend allow-inside
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+VertexAttribIPointerEXT(index, size, type, stride, pointer)
+ return void
+ param index UInt32 in value
+ param size Int32 in value
+ param type VertexAttribEnum in value
+ param stride SizeI in value
+ param pointer Void in array [COMPSIZE(size/type/stride)] retained
+ category NV_vertex_program4
+ dlflags notlistable
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetVertexAttribIivEXT(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribEnum in value
+ param params Int32 out array [1]
+ category NV_vertex_program4
+ dlflags notlistable
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetVertexAttribIuivEXT(index, pname, params)
+ return void
+ param index UInt32 in value
+ param pname VertexAttribEnum in value
+ param params UInt32 out array [1]
+ category NV_vertex_program4
+ dlflags notlistable
+ extension soft WINSOFT NV10
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #326
+# EXT_gpu_shader4 commands
+#
+###############################################################################
+
+GetUniformuivEXT(program, location, params)
+ return void
+ param program UInt32 in value
+ param location Int32 in value
+ param params UInt32 out array [COMPSIZE(program/location)]
+ category EXT_gpu_shader4
+ dlflags notlistable
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+BindFragDataLocationEXT(program, color, name)
+ return void
+ param program UInt32 in value
+ param color UInt32 in value
+ param name Char in array [COMPSIZE(name)]
+ category EXT_gpu_shader4
+ dlflags notlistable
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetFragDataLocationEXT(program, name)
+ return Int32
+ param program UInt32 in value
+ param name Char in array [COMPSIZE(name)]
+ category EXT_gpu_shader4
+ dlflags notlistable
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform1uiEXT(location, v0)
+ return void
+ param location Int32 in value
+ param v0 UInt32 in value
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform2uiEXT(location, v0, v1)
+ return void
+ param location Int32 in value
+ param v0 UInt32 in value
+ param v1 UInt32 in value
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform3uiEXT(location, v0, v1, v2)
+ return void
+ param location Int32 in value
+ param v0 UInt32 in value
+ param v1 UInt32 in value
+ param v2 UInt32 in value
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform4uiEXT(location, v0, v1, v2, v3)
+ return void
+ param location Int32 in value
+ param v0 UInt32 in value
+ param v1 UInt32 in value
+ param v2 UInt32 in value
+ param v3 UInt32 in value
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform1uivEXT(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value UInt32 in array [count]
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform2uivEXT(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value UInt32 in array [count*2]
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform3uivEXT(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value UInt32 in array [count*3]
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+Uniform4uivEXT(location, count, value)
+ return void
+ param location Int32 in value
+ param count SizeI in value
+ param value UInt32 in array [count*4]
+ category EXT_gpu_shader4
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #327
+# EXT_draw_instanced commands
+#
+###############################################################################
+
+DrawArraysInstancedEXT(mode, start, count, primcount)
+ return void
+ param mode BeginMode in value
+ param start Int32 in value
+ param count SizeI in value
+ param primcount SizeI in value
+ category EXT_draw_instanced
+ version 2.0
+ extension soft WINSOFT
+ dlflags notlistable
+ vectorequiv ArrayElement
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+DrawElementsInstancedEXT(mode, count, type, indices, primcount)
+ return void
+ param mode BeginMode in value
+ param count SizeI in value
+ param type DrawElementsType in value
+ param indices Void in array [COMPSIZE(count/type)]
+ param primcount SizeI in value
+ category EXT_draw_instanced
+ version 2.0
+ extension soft WINSOFT
+ dlflags notlistable
+ vectorequiv ArrayElement
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+
+###############################################################################
+#
+# Extension #328
+# EXT_packed_float commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_packed_float
+
+###############################################################################
+#
+# Extension #329
+# EXT_texture_array commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_array
+
+###############################################################################
+#
+# Extension #330
+# EXT_texture_buffer_object commands
+#
+###############################################################################
+
+TexBufferEXT(target, internalformat, buffer)
+ return void
+ param target TextureTarget in value
+ param internalformat GLenum in value
+ param buffer UInt32 in value
+ category EXT_texture_buffer_object
+ version 2.0
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #331
+# EXT_texture_compression_latc commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_compression_latc
+
+###############################################################################
+#
+# Extension #332
+# EXT_texture_compression_rgtc commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_compression_rgtc
+
+###############################################################################
+#
+# Extension #333
+# EXT_texture_shared_exponent commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_texture_shared_exponent
+
+###############################################################################
+#
+# Extension #334
+# NV_depth_buffer_float commands
+#
+###############################################################################
+
+DepthRangedNV(zNear, zFar)
+ return void
+ param zNear Float64 in value
+ param zFar Float64 in value
+ category NV_depth_buffer_float
+ extension soft WINSOFT NV50
+ version 2.0
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ClearDepthdNV(depth)
+ return void
+ param depth Float64 in value
+ category NV_depth_buffer_float
+ extension soft WINSOFT NV50
+ version 2.0
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+DepthBoundsdNV(zmin, zmax)
+ return void
+ param zmin Float64 in value
+ param zmax Float64 in value
+ category NV_depth_buffer_float
+ extension soft WINSOFT NV50
+ version 2.0
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #335
+# NV_fragment_program4 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_fragment_program4
+
+###############################################################################
+#
+# Extension #336
+# NV_framebuffer_multisample_coverage commands
+#
+###############################################################################
+
+RenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height)
+ return void
+ param target RenderbufferTarget in value
+ param coverageSamples SizeI in value
+ param colorSamples SizeI in value
+ param internalformat PixelInternalFormat in value
+ param width SizeI in value
+ param height SizeI in value
+ category NV_framebuffer_multisample_coverage
+ version 1.5
+ extension soft WINSOFT
+ dlflags notlistable
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #337
+# EXT_framebuffer_sRGB commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_framebuffer_sRGB
+
+###############################################################################
+#
+# Extension #338
+# NV_geometry_shader4 commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_geometry_shader4
+
+###############################################################################
+#
+# Extension #339
+# NV_parameter_buffer_object commands
+#
+###############################################################################
+
+ProgramBufferParametersfvNV(target, buffer, index, count, params)
+ return void
+ param target ProgramTarget in value
+ param buffer UInt32 in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params Float32 in array [count]
+ category NV_parameter_buffer_object
+ version 1.2
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramBufferParametersIivNV(target, buffer, index, count, params)
+ return void
+ param target ProgramTarget in value
+ param buffer UInt32 in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params Int32 in array [count]
+ category NV_parameter_buffer_object
+ version 1.2
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ProgramBufferParametersIuivNV(target, buffer, index, count, params)
+ return void
+ param target ProgramTarget in value
+ param buffer UInt32 in value
+ param index UInt32 in value
+ param count SizeI in value
+ param params UInt32 in array [count]
+ category NV_parameter_buffer_object
+ version 1.2
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #340
+# EXT_draw_buffers2 commands
+#
+###############################################################################
+
+ColorMaskIndexedEXT(index, r, g, b, a)
+ return void
+ param index UInt32 in value
+ param r Boolean in value
+ param g Boolean in value
+ param b Boolean in value
+ param a Boolean in value
+ category EXT_draw_buffers2
+ version 2.0
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+GetBooleanIndexedvEXT(target, index, data)
+ return void
+ param target GLenum in value
+ param index UInt32 in value
+ param data Boolean out array [COMPSIZE(target)]
+ category EXT_draw_buffers2
+ version 2.0
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+GetIntegerIndexedvEXT(target, index, data)
+ return void
+ param target GLenum in value
+ param index UInt32 in value
+ param data Int32 out array [COMPSIZE(target)]
+ category EXT_draw_buffers2
+ version 2.0
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+EnableIndexedEXT(target, index)
+ return void
+ param target GLenum in value
+ param index UInt32 in value
+ category EXT_draw_buffers2
+ version 2.0
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+DisableIndexedEXT(target, index)
+ return void
+ param target GLenum in value
+ param index UInt32 in value
+ category EXT_draw_buffers2
+ version 2.0
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+IsEnabledIndexedEXT(target, index)
+ return Boolean
+ param target GLenum in value
+ param index UInt32 in value
+ category EXT_draw_buffers2
+ version 2.0
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+###############################################################################
+#
+# Extension #341
+# NV_transform_feedback commands
+#
+###############################################################################
+
+BeginTransformFeedbackNV(primitiveMode)
+ return void
+ param primitiveMode GLenum in value
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+EndTransformFeedbackNV()
+ return void
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+TransformFeedbackAttribsNV(count, attribs, bufferMode)
+ return void
+ param count UInt32 in value
+ param attribs Int32 in array [COMPSIZE(count)]
+ param bufferMode GLenum in value
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+BindBufferRangeNV(target, index, buffer, offset, size)
+ return void
+ param target GLenum in value
+ param index UInt32 in value
+ param buffer UInt32 in value
+ param offset BufferOffset in value
+ param size BufferSize in value
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+BindBufferOffsetNV(target, index, buffer, offset)
+ return void
+ param target GLenum in value
+ param index UInt32 in value
+ param buffer UInt32 in value
+ param offset BufferOffset in value
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+BindBufferBaseNV(target, index, buffer)
+ return void
+ param target GLenum in value
+ param index UInt32 in value
+ param buffer UInt32 in value
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+TransformFeedbackVaryingsNV(program, count, locations, bufferMode)
+ return void
+ param program UInt32 in value
+ param count SizeI in value
+ param locations Int32 in array [COMPSIZE(count)]
+ param bufferMode GLenum in value
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+ActiveVaryingNV(program, name)
+ return void
+ param program UInt32 in value
+ param name Char in array [COMPSIZE(name)]
+ category NV_transform_feedback
+ version 1.5
+ dlflags notlistable
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+ extension soft WINSOFT
+
+GetVaryingLocationNV(program, name)
+ return Int32
+ param program UInt32 in value
+ param name Char in array [COMPSIZE(name)]
+ category NV_transform_feedback
+ dlflags notlistable
+ version 1.5
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+ extension soft WINSOFT
+
+GetActiveVaryingNV(program, index, bufSize, length, size, type, name)
+ return void
+ param program UInt32 in value
+ param index UInt32 in value
+ param bufSize SizeI in value
+ param length SizeI out array [1]
+ param size SizeI out array [1]
+ param type GLenum out array [1]
+ param name Char out array [COMPSIZE(program/index/bufSize)]
+ category NV_transform_feedback
+ dlflags notlistable
+ version 1.5
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetTransformFeedbackVaryingNV(program, index, location)
+ return void
+ param program UInt32 in value
+ param index UInt32 in value
+ param location Int32 out array [1]
+ category NV_transform_feedback
+ dlflags notlistable
+ version 1.5
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #342
+# EXT_bindable_uniform commands
+#
+###############################################################################
+
+UniformBufferEXT(program, location, buffer)
+ return void
+ param program UInt32 in value
+ param location Int32 in value
+ param buffer UInt32 in value
+ category EXT_bindable_uniform
+ version 2.0
+ extension soft WINSOFT
+ glxflags ignore
+ glfflags ignore
+ glsflags ignore
+
+GetUniformBufferSizeEXT(program, location)
+ return Int32
+ param program UInt32 in value
+ param location Int32 in value
+ category EXT_bindable_uniform
+ dlflags notlistable
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetUniformOffsetEXT(program, location)
+ return BufferOffset
+ param program UInt32 in value
+ param location Int32 in value
+ category EXT_bindable_uniform
+ dlflags notlistable
+ version 2.0
+ extension soft WINSOFT
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #343
+# EXT_texture_integer extension commands
+#
+###############################################################################
+
+TexParameterIivEXT(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname TextureParameterName in value
+ param params Int32 in array [COMPSIZE(pname)]
+ category EXT_texture_integer
+ version 2.0
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+TexParameterIuivEXT(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname TextureParameterName in value
+ param params UInt32 in array [COMPSIZE(pname)]
+ category EXT_texture_integer
+ version 2.0
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetTexParameterIivEXT(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname GetTextureParameter in value
+ param params Int32 out array [COMPSIZE(pname)]
+ category EXT_texture_integer
+ dlflags notlistable
+ version 1.0
+ version 2.0
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+GetTexParameterIuivEXT(target, pname, params)
+ return void
+ param target TextureTarget in value
+ param pname GetTextureParameter in value
+ param params UInt32 out array [COMPSIZE(pname)]
+ category EXT_texture_integer
+ dlflags notlistable
+ version 1.0
+ version 2.0
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ClearColorIiEXT(red, green, blue, alpha)
+ return void
+ param red Int32 in value
+ param green Int32 in value
+ param blue Int32 in value
+ param alpha Int32 in value
+ category EXT_texture_integer
+ version 2.0
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+ClearColorIuiEXT(red, green, blue, alpha)
+ return void
+ param red UInt32 in value
+ param green UInt32 in value
+ param blue UInt32 in value
+ param alpha UInt32 in value
+ category EXT_texture_integer
+ version 2.0
+ extension soft WINSOFT NV50
+ glfflags ignore
+ glsflags ignore
+ glxflags ignore
+
+###############################################################################
+#
+# Extension #344 - GLX_EXT_texture_from_pixmap
+#
+###############################################################################
+
diff --git a/Source/Bind/Specifications/gl.tm b/Source/Bind/Specifications/gl.tm
new file mode 100644
index 00000000..0bcac25f
--- /dev/null
+++ b/Source/Bind/Specifications/gl.tm
@@ -0,0 +1,291 @@
+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,*,*
+FramebufferAttachment,*,*, GLenum,*,*
+FramebufferTarget,*,*, 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,*,*
+ProgramParameterPName,*,*, GLenum,*,*
+QuadricCallback,*,*, GLenum,*,*
+QuadricDrawStyle,*,*, GLenum,*,*
+QuadricNormal,*,*, GLenum,*,*
+QuadricObj,*,*, GLUquadric*,*,*
+QuadricOrientation,*,*, GLenum,*,*
+ReadBufferMode,*,*, GLenum,*,*
+RenderbufferTarget,*,*, 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,*,*
+VertexAttribEnum,*,*, GLenum,*,*
+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,*,*
+ProgramTarget,*,*, 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
+BufferOffset,*,*, GLintptr,*,*
+BufferSize,*,*, GLsizeiptr,*,*
+BufferAccessARB,*,*, GLenum,*,*
+BufferOffsetARB,*,*, GLintptrARB,*,*
+BufferPNameARB,*,*, GLenum,*,*
+BufferPointerNameARB,*,*, GLenum,*,*
+BufferSizeARB,*,*, GLsizeiptrARB,*,*
+BufferTargetARB,*,*, GLenum,*,*
+BufferUsageARB,*,*, 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*,*,*
+# EXT_timer_query
+Int64EXT,*,*, GLint64EXT,*,*
+UInt64EXT,*,*, GLuint64EXT,*,*
diff --git a/Source/Bind/Specifications/glu.spec b/Source/Bind/Specifications/glu.spec
new file mode 100644
index 00000000..a38a74b0
--- /dev/null
+++ b/Source/Bind/Specifications/glu.spec
@@ -0,0 +1,438 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2002 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+
+param: retval retained
+version: 1.0
+
+BeginCurve(nurb)
+ return void
+ param nurb NurbsObj in value
+
+BeginPolygon(tess)
+ return void
+ param tess TesselatorObj in value
+
+BeginSurface(nurb)
+ return void
+ param nurb NurbsObj in value
+
+BeginTrim(nurb)
+ return void
+ param nurb NurbsObj in value
+
+Build1DMipmapLevels(target, internalFormat, width, format, type, level, base, max, data);
+ return Int32
+ param target TextureTarget in value
+ param internalFormat Int32 in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param level Int32 in value
+ param base Int32 in value
+ param max Int32 in value
+ param data void in reference
+
+Build1DMipmaps(target, internalFormat, width, format, type, data);
+ return Int32
+ param target TextureTarget in value
+ param internalFormat Int32 in value
+ param width SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param data void in reference
+
+Build2DMipmapLevels(target, internalFormat, width, height, format, type, level, base, max, data);
+ return Int32
+ param target TextureTarget in value
+ param internalFormat Int32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param level Int32 in value
+ param base Int32 in value
+ param max Int32 in value
+ param data void in reference
+
+Build2DMipmaps(target, internalFormat, width, height, format, type, data);
+ return Int32
+ param target TextureTarget in value
+ param internalFormat Int32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param data void in reference
+
+Build3DMipmapLevels(target, internalFormat, width, height, depth, format, type, level, base, max, data);
+ return Int32
+ param target TextureTarget in value
+ param internalFormat Int32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param level Int32 in value
+ param base Int32 in value
+ param max Int32 in value
+ param data void in reference
+
+Build3DMipmaps(target, internalFormat, width, height, depth, format, type, data);
+ return Int32
+ param target TextureTarget in value
+ param internalFormat Int32 in value
+ param width SizeI in value
+ param height SizeI in value
+ param depth SizeI in value
+ param format PixelFormat in value
+ param type PixelType in value
+ param data void in reference
+
+CheckExtension(extName, extString)
+ return Boolean
+ param extName UInt8 in array [COMPSIZE()]
+ param extString UInt8 in array [COMPSIZE()]
+
+Cylinder(quad, base, top, height, slices, stacks);
+ return void
+ param quad QuadricObj in value
+ param base Float64 in value
+ param top Float64 in value
+ param height Float64 in value
+ param slices Int32 in value
+ param stacks Int32 in value
+
+DeleteNurbsRenderer(nurb)
+ return void
+ param nurb NurbsObj in value
+
+DeleteQuadric(quad)
+ return void
+ param quad QuadricObj in value
+
+DeleteTess(tess)
+ return void
+ param tess TesselatorObj in value
+
+Disk(quad, inner, outer, slices, loops)
+ return void
+ param quad QuadricObj in value
+ param inner Float64 in value
+ param outer Float64 in value
+ param slices Int32 in value
+ param loops Int32 in value
+
+EndCurve(nurb)
+ return void
+ param nurb NurbsObj in value
+
+EndPolygon(tess)
+ return void
+ param tess TesselatorObj in value
+
+EndSurface(nurb)
+ return void
+ param nurb NurbsObj in value
+
+EndTrim(nurb)
+ return void
+ param nurb NurbsObj in value
+
+ErrorString(error)
+ return String
+ param error ErrorCode in value
+
+GetString(name)
+ return String
+ param name StringName in value
+
+GetNurbsProperty(nurb, property, data)
+ return void
+ param nurb NurbsObj in value
+ param property NurbsProperty in value
+ param data Float32Pointer out value
+
+GetTessProperty(tess, which, data)
+ return void
+ param tess TesselatorObj in value
+ param which TessProperty in value
+ param data Float64Pointer out value
+
+LoadSamplingMatrices(nurb, model, perspective, view)
+ return void
+ param nurb NurbsObj in value
+ param model Float32 in array [16]
+ param perspective Float32 in array [16]
+ param view Int32 in array [4]
+
+LookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ)
+ return void
+ param eyeX Float64 in value
+ param eyeY Float64 in value
+ param eyeZ Float64 in value
+ param centerX Float64 in value
+ param centerY Float64 in value
+ param centerZ Float64 in value
+ param upX Float64 in value
+ param upY Float64 in value
+ param upZ Float64 in value
+
+NewNurbsRenderer()
+ return NurbsObj
+
+NewQuadric()
+ return QuadricObj
+
+NewTess()
+ return TesselatorObj
+
+NextContour(tess, type)
+ return void
+ param tess TesselatorObj in value
+ param type TessContour in value
+
+NurbsCallback(nurb, which, CallBackFunc)
+ return void
+ param nurb NurbsObj in value
+ param which NurbsCallback in value
+ param CallBackFunc FunctionPointer in value
+
+NurbsCallbackData(nurb, userData)
+ return void
+ param nurb NurbsObj in value
+ param userData VoidPointer in value
+
+NurbsCallbackDataEXT(nurb, userData)
+ return void
+ param nurb NurbsObj in value
+ param userData VoidPointer in value
+
+NurbsCurve(nurb, knotCount, knots, stride, control, order, type)
+ return void
+ param nurb NurbsObj in value
+ param knotCount Int32 in value
+ param knots Float32 out reference
+ param stride Int32 in value
+ param control Float32 out reference
+ param order Int32 in value
+ param type MapTarget in value
+
+NurbsProperty(nurb, property, value)
+ return void
+ param nurb NurbsObj in value
+ param property NurbsProperty in value
+ param value Float32 in value
+
+NurbsSurface(nurb, sKnotCount, sKnots, tKnotCount, tKnots, sStride, tStride, control, sOrder, tOrder, type)
+ return void
+ param nurb NurbsObj in value
+ param sKnotCount Int32 in value
+ param sKnots Float32Pointer in value
+ param tKnotCount Int32 in value
+ param tKnots Float32Pointer in value
+ param sStride Int32 in value
+ param tStride Int32 in value
+ param control Float32Pointer in value
+ param sOrder Int32 in value
+ param tOrder Int32 in value
+ param type MapTarget in value
+
+Ortho2D(left, right, bottom, top)
+ return void
+ param left Float64 in value
+ param right Float64 in value
+ param bottom Float64 in value
+ param top Float64 in value
+
+PartialDisk(quad, inner, outer, slices, loops, start, sweep)
+ return void
+ param quad QuadricObj in value
+ param inner Float64 in value
+ param outer Float64 in value
+ param slices Int32 in value
+ param loops Int32 in value
+ param start Float64 in value
+ param sweep Float64 in value
+
+Perspective(fovy, aspect, zNear, zFar)
+ return void
+ param fovy Float64 in value
+ param aspect Float64 in value
+ param zNear Float64 in value
+ param zFar Float64 in value
+
+PickMatrix(x, y, delX, delY, viewport)
+ return void
+ param x Float64 in value
+ param y Float64 in value
+ param delX Float64 in value
+ param delY Float64 in value
+ param viewport Int32 out array [4]
+
+Project(objX, objY, objZ, model, proj, view, winX, winY, winZ)
+ return Int32
+ param objX Float64 in value
+ param objY Float64 in value
+ param objZ Float64 in value
+ param model Float64 in array [16]
+ param proj Float64 in array [16]
+ param view Int32 in array [4]
+ param winX Float64Pointer in value
+ param winY Float64Pointer in value
+ param winZ Float64Pointer in value
+
+PwlCurve(nurb, count, data, stride, type)
+ return void
+ param nurb NurbsObj in value
+ param count Int32 in value
+ param data Float32Pointer in value
+ param stride Int32 in value
+ param type NurbsTrim in value
+
+QuadricCallback(quad, which, CallBackFunc)
+ return void
+ param quad QuadricObj in value
+ param which QuadricCallback in value
+ param CallBackFunc FunctionPointer in value
+
+QuadricDrawStyle(quad, draw)
+ return void
+ param quad QuadricObj in value
+ param draw QuadricDrawStyle in value
+
+QuadricNormals(quad, normal)
+ return void
+ param quad QuadricObj in value
+ param normal QuadricNormal in value
+
+QuadricOrientation(quad, orientation)
+ return void
+ param quad QuadricObj in value
+ param orientation QuadricOrientation in value
+
+QuadricTexture(quad, texture)
+ return void
+ param quad QuadricObj in value
+ param texture Boolean in value
+
+ScaleImage(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut)
+ return Int32
+ param format PixelFormat in value
+ param wIn SizeI in value
+ param hIn SizeI in value
+ param typeIn PixelType in value
+ param dataIn void in reference
+ param wOut SizeI in value
+ param hOut SizeI in value
+ param typeOut PixelType in value
+ param dataOut VoidPointer out value
+
+Sphere(quad, radius, slices, stacks)
+ return void
+ param quad QuadricObj in value
+ param radius Float64 in value
+ param slices Int32 in value
+ param stacks Int32 in value
+
+TessBeginContour(tess)
+ return void
+ param tess TesselatorObj in value
+
+TessBeginPolygon(tess, data)
+ return void
+ param tess TesselatorObj in value
+ param data VoidPointer in value
+
+TessCallback(tess, which, CallBackFunc)
+ return void
+ param tess TesselatorObj in value
+ param which TessCallback in value
+ param CallBackFunc FunctionPointer in value
+
+TessEndContour(tess)
+ return void
+ param tess TesselatorObj in value
+
+TessEndPolygon(tess)
+ return void
+ param tess TesselatorObj in value
+
+TessNormal(tess, valueX, valueY, valueZ)
+ return void
+ param tess TesselatorObj in value
+ param valueX Float64 in value
+ param valueY Float64 in value
+ param valueZ Float64 in value
+
+TessProperty(tess, which, data)
+ return void
+ param tess TesselatorObj in value
+ param which TessProperty in value
+ param data Float64 in value
+
+TessVertex(tess, location, data)
+ return void
+ param tess TesselatorObj in value
+ param location Float64 out array [3]
+ param data VoidPointer in value
+
+TexFilterFuncSGI(target, filtertype, parms, n, weights)
+ return Int32 out value
+ param target TextureTarget in value
+ param filtertype Filter4TypeSGIS in value
+ param parms Float32 in array [2]
+ param n Int32 in value
+ param weights Float32Pointer out value
+
+UnProject(winX, winY, winZ, model, proj, view, objX, objY, objZ)
+ return Int32
+ param winX Float64 in value
+ param winY Float64 in value
+ param winZ Float64 in value
+ param model Float64 in array [16]
+ param proj Float64 in array [16]
+ param view Int32 in array [4]
+ param objX Float64Pointer in value
+ param objY Float64Pointer in value
+ param objZ Float64Pointer in value
+
+UnProject4(winX, winY, winZ, clipW, model, proj, view, near, far, objX, objY, objZ, objW)
+ return Int32
+ param winX Float64 in value
+ param winY Float64 in value
+ param winZ Float64 in value
+ param clipW Float64 in value
+ param model Float64 in array [16]
+ param proj Float64 in array [16]
+ param view Int32 in array [4]
+ param near Float64 in value
+ param far Float64 in value
+ param objX Float64Pointer in value
+ param objY Float64Pointer in value
+ param objZ Float64Pointer in value
+ param objW Float64Pointer in value
diff --git a/Source/Bind/Specifications/glx.spec b/Source/Bind/Specifications/glx.spec
new file mode 100644
index 00000000..c497578f
--- /dev/null
+++ b/Source/Bind/Specifications/glx.spec
@@ -0,0 +1,621 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2005 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+
+required-props:
+param: retval retained
+dlflags: notlistable handcode nop
+glxflags: client-handcode server-handcode
+glxvendorglx: *
+vectorequiv: *
+category: pixel-rw bgn-end display-list drawing drawing-control feedback framebuf misc modeling pixel-op pixel-rw state-req xform glx glxopcode
+glxopcode: *
+
+###############################################################################
+#
+# GLX1.0 commands
+#
+###############################################################################
+Render()
+ return void
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 1
+
+
+RenderLarge()
+ return void
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 2
+
+
+CreateContext(gc_id, screen, visual, share_list)
+ return void
+ param gc_id Int32 in value
+ param screen Int32 in value
+ param visual Int32 in value
+ param share_list Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 3
+
+
+DestroyContext(context)
+ return void
+ param context Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 4
+
+
+MakeCurrent(drawable, context)
+ return void
+ param drawable Int32 in value
+ param context Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 5
+
+
+IsDirect(dpy, context)
+ return void
+ param dpy Int32 in value
+ param context Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 6
+
+
+QueryVersion(major, minor)
+ return void
+ param major Int32 out reference
+ param minor Int32 out reference
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 7
+
+
+WaitGL(context)
+ return void
+ param context Int32 in value
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 8
+
+
+WaitX()
+ return void
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 9
+
+
+CopyContext(source, dest, mask)
+ return void
+ param source Int32 in value
+ param dest Int32 in value
+ param mask Int32 in value
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 10
+
+
+SwapBuffers(drawable)
+ return void
+ param drawable Int32 in value
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 11
+
+
+UseXFont(font, first, count, list_base)
+ return void
+ param font Int32 in value
+ param first Int32 in value
+ param count Int32 in value
+ param list_base Int32 in value
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 12
+
+
+CreateGLXPixmap(visual, pixmap, glxpixmap)
+ return void
+ param visual Int32 in value
+ param pixmap Int32 in value
+ param glxpixmap Int32 in value
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 13
+
+GetVisualConfigs()
+ return void
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 14
+
+
+DestroyGLXPixmap(pixmap)
+ return void
+ param pixmap Int32 in value
+ glxflags client-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 15
+
+
+VendorPrivate()
+ return void
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 16
+
+
+VendorPrivateWithReply()
+ return void
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 17
+
+###############################################################################
+#
+# GLX1.1 commands
+#
+###############################################################################
+QueryExtensionsString(screen)
+ return void
+ param screen Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 18
+
+QueryServerString(screen, name)
+ return void
+ param screen Int32 in value
+ param name Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 19
+
+ClientInfo()
+ return void
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxopcode 20
+
+###############################################################################
+#
+# GLX1.3 commands
+#
+###############################################################################
+GetFBConfigs()
+ return void
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxopcode 21
+
+CreatePixmap(config, pixmap, glxpixmap)
+ return void
+ param config Int32 in value
+ param pixmap Int32 in value
+ param glxpixmap Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 22
+
+DestroyPixmap(glxpixmap)
+ return void
+ param glxpixmap Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 23
+
+CreateNewContext(config, render_type, share_list, direct)
+ return void
+ param config Int32 in value
+ param render_type Int32 in value
+ param share_list Int32 in value
+ param direct Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 24
+
+QueryContext()
+ return void
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 25
+
+MakeContextCurrent(drawable, readdrawable, context)
+ return void
+ param drawable Int32 in value
+ param readdrawable Int32 in value
+ param context Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 26
+
+CreatePbuffer(config, pbuffer)
+ return void
+ param config Int32 in value
+ param pbuffer Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 27
+
+DestroyPbuffer(pbuffer)
+ return void
+ param pbuffer Int32 in value
+ dlflags notlistable
+ glxflags client-handcode
+ category glx
+ glxopcode 28
+
+GetDrawableAttributes(drawable)
+ return void
+ param drawable Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 29
+
+ChangeDrawableAttributes(drawable)
+ return void
+ param drawable Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 30
+
+CreateWindow(config, window, glxwindow)
+ return void
+ param config Int32 in value
+ param window Int32 in value
+ param glxwindow Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 31
+
+DestroyWindow(glxwindow)
+ return void
+ param glxwindow Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxopcode 32
+
+###############################################################################
+#
+# IRIX5.3 extension commands
+#
+###############################################################################
+
+###############################################################################
+#
+# SGI_swap_control extension commands
+#
+###############################################################################
+SwapIntervalSGI()
+ return void
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65536
+
+###############################################################################
+#
+# IRIX5.3-PATCH154 extension commands
+#
+###############################################################################
+
+###############################################################################
+#
+# SGI_make_current_read extension commands
+#
+###############################################################################
+MakeCurrentReadSGI(drawable, readdrawable, context)
+ return void
+ param drawable Int32 in value
+ param readdrawable Int32 in value
+ param context Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65537
+
+###############################################################################
+#
+# SGIX_video_source extension commands
+#
+###############################################################################
+CreateGLXVideoSourceSGIX(dpy, screen, server, path, class, node)
+ return void
+ param dpy Int32 in value
+ param screen Int32 in value
+ param server Int32 in value
+ param path Int32 in value
+ param class Int32 in value
+ param node Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65538
+
+DestroyGLXVideoSourceSGIX(dpy, glxvideosource)
+ return void
+ param dpy Int32 in value
+ param glxvideosource Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65539
+
+###############################################################################
+#
+# IRIX6.2 extension commands
+#
+###############################################################################
+
+###############################################################################
+#
+# EXT_import_context extension commands
+#
+###############################################################################
+QueryContextInfoEXT()
+ return void
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxvendorglx 1024
+
+###############################################################################
+#
+# SGIX_fbconfig extension commands
+#
+###############################################################################
+GetFBConfigsSGIX()
+ return void
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxvendorglx 65540
+
+CreateContextWithConfigSGIX(gc_id, screen, config, share_list)
+ return void
+ param gc_id Int32 in value
+ param screen Int32 in value
+ param config Int32 in value
+ param share_list Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65541
+
+CreateGLXPixmapWithConfigSGIX(config, pixmap, glxpixmap)
+ return void
+ param config Int32 in value
+ param pixmap Int32 in value
+ param glxpixmap Int32 in value
+ category glx
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ glxvendorglx 65542
+
+###############################################################################
+#
+# SGIX_pbuffer extension commands
+#
+###############################################################################
+
+CreateGLXPbufferSGIX(config, pbuffer)
+ return void
+ param config Int32 in value
+ param pbuffer Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxvendorglx 65543
+
+DestroyGLXPbufferSGIX(pbuffer)
+ return void
+ param pbuffer Int32 in value
+ dlflags notlistable
+ glxflags client-handcode
+ category glx
+ glxvendorglx 65544
+
+ChangeDrawableAttributesSGIX(drawable)
+ return void
+ param drawable Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxvendorglx 65545
+
+GetDrawableAttributesSGIX(drawable)
+ return void
+ param drawable Int32 in value
+ dlflags notlistable
+ glxflags client-handcode server-handcode
+ category glx
+ glxvendorglx 65546
+
+###############################################################################
+#
+# SGIX_swap_group extension commands
+#
+###############################################################################
+
+JoinSwapGroupSGIX(window,group)
+ return void
+ param window Int32 in value
+ param group Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65547
+
+###############################################################################
+#
+# SGIX_swap_barrier extension commands
+#
+###############################################################################
+
+BindSwapBarrierSGIX(window,barrier)
+ return void
+ param window Int32 in value
+ param barrier Int32 in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65548
+
+QueryMaxSwapBarriersSGIX()
+ return void
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65549
+
+###############################################################################
+#
+# SGIX_hyperpipe extension commands
+#
+###############################################################################
+
+QueryHyperpipeNetworkSGIX(dpy, npipes)
+ return GLXHyperpipeNetworkPointer
+ param dpy Display out reference
+ param npipes int out reference
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65550
+
+HyperpipeConfigSGIX(dpy, networkId, npipes, cfg, hpId)
+ return int
+ param dpy Display out reference
+ param networkId int in value
+ param npipes int in value
+ param cfg GLXHyperpipeConfig in array[npipes]
+ param hpId int out reference
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65552
+
+QueryHyperpipeConfigSGIX(dpy, hpId, npipes)
+ return GLXHyperpipeConfigPointer
+ param dpy Display out reference
+ param hpId int in value
+ param npipes int out reference
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65551
+
+DestroyHyperpipeConfigSGIX(dpy, hpId)
+ return int
+ param dpy Display out reference
+ param hpId int in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx 65553
+
+BindHyperpipeSGIX(dpy, hpId)
+ return int
+ param dpy Display out reference
+ param hpId int in value
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx ???
+
+QueryHyperpipeBestAttribSGIX(dpy, timeSlice, attrib, size, attribList, returnAttribList)
+ return int
+ param dpy Display out reference
+ param timeSlice int in value
+ param attrib int in value
+ param size int in value
+ param attribList Void in array[size]
+ param returnAttribList Void out array[size]
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx ???
+
+HyperpipeAttribSGIX(dpy, timeSlice, attrib, size, attribList)
+ return int
+ param dpy Display out reference
+ param timeSlice int in value
+ param attrib int in value
+ param size int in value
+ param attribList void in array[size]
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx ???
+
+QueryHyperpipeAttribSGIX(dpy, timeSlice, attrib, size, returnAttribList)
+ return int
+ param dpy Display out reference
+ param timeSlice int in value
+ param attrib int in value
+ param size int in value
+ param returnAttribList void in array[size]
+ glxflags client-handcode server-handcode
+ category glx
+ dlflags notlistable
+ glxvendorglx ???
diff --git a/Source/Bind/Specifications/glx.tm b/Source/Bind/Specifications/glx.tm
new file mode 100644
index 00000000..ca2b4506
--- /dev/null
+++ b/Source/Bind/Specifications/glx.tm
@@ -0,0 +1,43 @@
+Bool,*,*, Bool,*,*
+Colormap,*,*, Colormap,*,*
+DMbuffer,*,*, DMbuffer,*,*
+DMparams,*,*, DMparams,*,*
+Display,*,*, Display,*,*
+DisplayPointer,*,*, Display *,*,*
+FunctionPointer,*,*, __GLXextFuncPtr,*,*
+GLXContext,*,*, GLXContext,*,*
+constGLXContext,*,*, const GLXContext,*,*
+GLXContextID,*,*, GLXContextID,*,*
+GLXDrawable,*,*, GLXDrawable,*,*
+GLXFBConfig,*,*, GLXFBConfig,*,*
+GLXFBConfigPointer,*,*, GLXFBConfig *,*,*
+GLXFBConfigSGIX,*,*, GLXFBConfigSGIX,*,*
+GLXFBConfigSGIXPointer,*,*, GLXFBConfigSGIX *,*,*
+GLXHyperpipeNetworkSGIXPointer,*,*, GLXHyperpipeNetworkSGIX *,*,*
+GLXHyperpipeConfigSGIX,*,*, GLXHyperpipeConfigSGIX,*,*
+GLXHyperpipeConfigSGIXPointer,*,*, GLXHyperpipeConfigSGIX *,*,*
+GLXPbuffer,*,*, GLXPbuffer,*,*
+GLXPbufferSGIX,*,*, GLXPbufferSGIX,*,*
+GLXPixmap,*,*, GLXPixmap,*,*
+GLXVideoSourceSGIX,*,*, GLXVideoSourceSGIX,*,*
+GLXWindow,*,*, GLXWindow,*,*
+GLenum,*,*, GLenum,*,*
+GLfunction,*,*, GLfunction,*,*
+GLubyte,*,*, GLubyte,*,*
+Pixmap,*,*, Pixmap,*,*
+Status,*,*, Status,*,*
+Uint,*,*, unsigned int,*,*
+VLNode,*,*, VLNode,*,*
+VLPath,*,*, VLPath,*,*
+VLServer,*,*, VLServer,*,*
+Window,*,*, Window,*,*
+XVisualInfo,*,*, XVisualInfo,*,*
+XVisualInfoPointer,*,*, XVisualInfo *,*,*
+float,*,*, float,*,*
+int,*,*, int,*,*
+uint,*,*, unsigned int,*,*
+int32_t,*,*, int32_t,*,*
+int64_t,*,*, int64_t,*,*
+long,*,*, long,*,*
+ulong,*,*, unsigned long,*,*
+void,*,*, void,*,*
diff --git a/Source/Bind/Specifications/glxenum.spec b/Source/Bind/Specifications/glxenum.spec
new file mode 100644
index 00000000..9f7b15a7
--- /dev/null
+++ b/Source/Bind/Specifications/glxenum.spec
@@ -0,0 +1,324 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2005 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+#
+# $Date: 2005/01/20 08:44:12 $ $Revision: 1.6 $
+# $Header: /oss/CVS/cvs/projects/ogl-sample/main/doc/registry/specs/glxenum.spec,v 1.6 2005/01/20 08:44:12 ljp Exp $
+
+# This is the GLX enumerant registry.
+#
+# It is an extremely important file. Do not mess with it unless
+# you know what you're doing and have permission to do so.
+#
+# Rules for modification are the same as the rules for the OpenGL
+# enumerant registry (gl.spec). Basically, don't modify this
+# file unless you're SGI's ARB Representative.
+
+Extensions define:
+ VERSION_1_1 = 1
+ VERSION_1_2 = 1
+ VERSION_1_3 = 1
+ VERSION_1_4 = 1
+ SGIS_multisample = 1
+ EXT_visual_info = 1
+ SGI_swap_control = 1
+ SGI_video_sync = 1
+ SGI_make_current_read = 1
+ SGIX_video_source = 1
+ EXT_visual_rating = 1
+ EXT_import_context = 1
+ SGIX_fbconfig = 1
+ SGIX_pbuffer = 1
+ SGI_cushion = 1
+ SGIX_video_resize = 1
+ SGIX_dmbuffer = 1
+ SGIX_swap_group = 1
+ SGIX_swap_barrier = 1
+ SGIS_blended_overlay = 1
+ SGIS_shared_multisample = 1
+ SUN_get_transparent_index = 1
+ 3DFX_multisample = 1
+ MESA_copy_sub_buffer = 1
+ MESA_pixmap_colormap = 1
+ MESA_release_buffers = 1
+ MESA_set_3dfx_mode = 1
+ SGIX_visual_select_group = 1
+ SGIX_hyperpipe = 1
+
+GLXStringName enum:
+ VENDOR = 0x1
+ VERSION = 0x2
+ EXTENSIONS = 0x3
+
+GLXErrorCode enum:
+ BAD_SCREEN = 1
+ BAD_ATTRIBUTE = 2
+ NO_EXTENSION = 3
+ BAD_VISUAL = 4
+ BAD_CONTEXT = 5
+ BAD_VALUE = 6
+ BAD_ENUM = 7
+ BAD_HYPERPIPE_CONFIG_SGIX = 91 # SGIX_hyperpipe
+ BAD_HYPERPIPE_SGIX = 92 # "
+
+GLXDrawableTypeMask enum:
+ WINDOW_BIT = 0x00000001 # DRAWABLE_TYPE value
+ PIXMAP_BIT = 0x00000002 # "
+ PBUFFER_BIT = 0x00000004 # "
+ WINDOW_BIT_SGIX = 0x00000001 # DRAWABLE_TYPE_SGIX value
+ PIXMAP_BIT_SGIX = 0x00000002 # "
+ PBUFFER_BIT_SGIX = 0x00000004 # "
+
+GLXRenderTypeMask enum:
+ RGBA_BIT = 0x00000001 # RENDER_TYPE value
+ COLOR_INDEX_BIT = 0x00000002 # "
+ RGBA_BIT_SGIX = 0x00000001 # RENDER_TYPE_SGIX value
+ COLOR_INDEX_BIT_SGIX = 0x00000002 # "
+ RGBA_FLOAT_BIT_ARB = 0x00000004 # RENDER_TYPE value (from ARB_fbconfig_float)
+
+GLXSyncType enum:
+ SYNC_FRAME_SGIX = 0x00000000 # ChannelRectSyncSGIX synctype
+ SYNC_SWAP_SGIX = 0x00000001 # "
+
+GLXEventMask enum:
+ PBUFFER_CLOBBER_MASK = 0x08000000 # SelectEvent mask
+ BUFFER_CLOBBER_MASK_SGIX = 0x08000000 # SelectEventSGIX mask
+
+GLXPbufferClobberMask enum:
+ FRONT_LEFT_BUFFER_BIT = 0x00000001 # PbufferClobberEvent mask
+ FRONT_RIGHT_BUFFER_BIT = 0x00000002 # "
+ BACK_LEFT_BUFFER_BIT = 0x00000004 # "
+ BACK_RIGHT_BUFFER_BIT = 0x00000008 # "
+ AUX_BUFFERS_BIT = 0x00000010 # "
+ DEPTH_BUFFER_BIT = 0x00000020 # "
+ STENCIL_BUFFER_BIT = 0x00000040 # "
+ ACCUM_BUFFER_BIT = 0x00000080 # "
+ FRONT_LEFT_BUFFER_BIT_SGIX = 0x00000001 # BufferClobberEventSGIX mask
+ FRONT_RIGHT_BUFFER_BIT_SGIX = 0x00000002 # "
+ BACK_LEFT_BUFFER_BIT_SGIX = 0x00000004 # "
+ BACK_RIGHT_BUFFER_BIT_SGIX = 0x00000008 # "
+ AUX_BUFFERS_BIT_SGIX = 0x00000010 # "
+ DEPTH_BUFFER_BIT_SGIX = 0x00000020 # "
+ STENCIL_BUFFER_BIT_SGIX = 0x00000040 # "
+ ACCUM_BUFFER_BIT_SGIX = 0x00000080 # "
+ SAMPLE_BUFFERS_BIT_SGIX = 0x00000100 # "
+
+GLXHyperpipeTypeMask enum:
+ HYPERPIPE_DISPLAY_PIPE_SGIX = 0x00000001 # SGIX_hyperpipe
+ HYPERPIPE_RENDER_PIPE_SGIX = 0x00000002 # "
+
+GLXHyperpipeAttrib enum:
+ PIPE_RECT_SGIX = 0x00000001 # SGIX_hyperpipe
+ PIPE_RECT_LIMITS_SGIX = 0x00000002 # "
+ HYPERPIPE_STEREO_SGIX = 0x00000003 # "
+ HYPERPIPE_PIXEL_AVERAGE_SGIX = 0x00000004 # "
+
+GLXHyperpipeMisc enum:
+ HYPERPIPE_PIPE_NAME_LENGTH_SGIX = 80 # SGIX_hyperpipe
+
+GLXAttribute enum:
+ USE_GL = 1 # Visual attributes
+ BUFFER_SIZE = 2 # "
+ LEVEL = 3 # "
+ RGBA = 4 # "
+ DOUBLEBUFFER = 5 # "
+ STEREO = 6 # "
+ AUX_BUFFERS = 7 # "
+ RED_SIZE = 8 # "
+ GREEN_SIZE = 9 # "
+ BLUE_SIZE = 10 # "
+ ALPHA_SIZE = 11 # "
+ DEPTH_SIZE = 12 # "
+ STENCIL_SIZE = 13 # "
+ ACCUM_RED_SIZE = 14 # "
+ ACCUM_GREEN_SIZE = 15 # "
+ ACCUM_BLUE_SIZE = 16 # "
+ ACCUM_ALPHA_SIZE = 17 # "
+ CONFIG_CAVEAT = 0x20 # "
+ X_VISUAL_TYPE = 0x22 # "
+ TRANSPARENT_TYPE = 0x23 # "
+ TRANSPARENT_INDEX_VALUE = 0x24 # "
+ TRANSPARENT_RED_VALUE = 0x25 # "
+ TRANSPARENT_GREEN_VALUE = 0x26 # "
+ TRANSPARENT_BLUE_VALUE = 0x27 # "
+ TRANSPARENT_ALPHA_VALUE = 0x28 # "
+ DONT_CARE = 0xFFFFFFFF # may be specified for ChooseFBConfig attributes
+ NONE = 0x8000 # several attribute values
+ SLOW_CONFIG = 0x8001 # CONFIG_CAVEAT attribute value
+ TRUE_COLOR = 0x8002 # X_VISUAL_TYPE attribute value
+ DIRECT_COLOR = 0x8003 # "
+ PSEUDO_COLOR = 0x8004 # "
+ STATIC_COLOR = 0x8005 # "
+ GRAY_SCALE = 0x8006 # "
+ STATIC_GRAY = 0x8007 # "
+ TRANSPARENT_RGB = 0x8008 # TRANSPARENT_TYPE attribute value
+ TRANSPARENT_INDEX = 0x8009 # "
+ VISUAL_ID = 0x800B # Context attribute
+ SCREEN = 0x800C # "
+ NON_CONFORMANT_CONFIG = 0x800D # CONFIG_CAVEAT attribute value
+ DRAWABLE_TYPE = 0x8010 # FBConfig attribute
+ RENDER_TYPE = 0x8011 # "
+ X_RENDERABLE = 0x8012 # "
+ FBCONFIG_ID = 0x8013 # "
+ RGBA_TYPE = 0x8014 # CreateNewContext render_type value
+ COLOR_INDEX_TYPE = 0x8015 # "
+ MAX_PBUFFER_WIDTH = 0x8016 # FBConfig attribute
+ MAX_PBUFFER_HEIGHT = 0x8017 # "
+ MAX_PBUFFER_PIXELS = 0x8018 # "
+ PRESERVED_CONTENTS = 0x801B # CreateGLXPbuffer attribute
+ LARGEST_PBUFFER = 0x801C # "
+ WIDTH = 0x801D # Drawable attribute
+ HEIGHT = 0x801E # "
+ EVENT_MASK = 0x801F # "
+ DAMAGED = 0x8020 # PbufferClobber event_type value
+ SAVED = 0x8021 # "
+ WINDOW = 0x8022 # PbufferClobber draw_type value
+ PBUFFER = 0x8023 # "
+ PBUFFER_HEIGHT = 0x8040 # CreateGLXPbuffer attribute
+ PBUFFER_WIDTH = 0x8041 # "
+ VISUAL_CAVEAT_EXT = 0x20 # Visual attribute
+ X_VISUAL_TYPE_EXT = 0x22 # "
+ TRANSPARENT_TYPE_EXT = 0x23 # "
+ TRANSPARENT_INDEX_VALUE_EXT = 0x24 # "
+ TRANSPARENT_RED_VALUE_EXT = 0x25 # "
+ TRANSPARENT_GREEN_VALUE_EXT = 0x26 # "
+ TRANSPARENT_BLUE_VALUE_EXT = 0x27 # "
+ TRANSPARENT_ALPHA_VALUE_EXT = 0x28 # "
+ NONE_EXT = 0x8000 # several EXT attribute values
+ SLOW_VISUAL_EXT = 0x8001 # VISUAL_CAVEAT_EXT attribute value
+ TRUE_COLOR_EXT = 0x8002 # X_VISUAL_TYPE_EXT attribute value
+ DIRECT_COLOR_EXT = 0x8003 # "
+ PSEUDO_COLOR_EXT = 0x8004 # "
+ STATIC_COLOR_EXT = 0x8005 # "
+ GRAY_SCALE_EXT = 0x8006 # "
+ STATIC_GRAY_EXT = 0x8007 # "
+ TRANSPARENT_RGB_EXT = 0x8008 # TRANSPARENT_TYPE_EXT attribute value
+ TRANSPARENT_INDEX_EXT = 0x8009 # "
+ SHARE_CONTEXT_EXT = 0x800A # QueryContextInfoEXT attribute
+ VISUAL_ID_EXT = 0x800B # "
+ SCREEN_EXT = 0x800C # "
+ NON_CONFORMANT_VISUAL_EXT = 0x800D # VISUAL_CAVEAT_EXT attribute value
+ DRAWABLE_TYPE_SGIX = 0x8010 # FBConfigSGIX attribute
+ RENDER_TYPE_SGIX = 0x8011 # "
+ X_RENDERABLE_SGIX = 0x8012 # "
+ FBCONFIG_ID_SGIX = 0x8013 # "
+ RGBA_TYPE_SGIX = 0x8014 # CreateContextWithConfigSGIX render_type value
+ COLOR_INDEX_TYPE_SGIX = 0x8015 # "
+ MAX_PBUFFER_WIDTH_SGIX = 0x8016 # FBConfigSGIX attribute
+ MAX_PBUFFER_HEIGHT_SGIX = 0x8017 # "
+ MAX_PBUFFER_PIXELS_SGIX = 0x8018 # "
+ OPTIMAL_PBUFFER_WIDTH_SGIX = 0x8019 # "
+ OPTIMAL_PBUFFER_HEIGHT_SGIX = 0x801A # "
+ PRESERVED_CONTENTS_SGIX = 0x801B # PbufferSGIX attribute
+ LARGEST_PBUFFER_SGIX = 0x801C # "
+ WIDTH_SGIX = 0x801D # "
+ HEIGHT_SGIX = 0x801E # "
+ EVENT_MASK_SGIX = 0x801F # "
+ DAMAGED_SGIX = 0x8020 # BufferClobberSGIX event_type value
+ SAVED_SGIX = 0x8021 # "
+ WINDOW_SGIX = 0x8022 # BufferClobberSGIX draw_type value
+ PBUFFER_SGIX = 0x8023 # "
+ DIGITAL_MEDIA_PBUFFER_SGIX = 0x8024 # PbufferSGIX attribute
+ BLENDED_RGBA_SGIS = 0x8025 # TRANSPARENT_TYPE_EXT attribute value
+ MULTISAMPLE_SUB_RECT_WIDTH_SGIS = 0x8026 # Visual attribute (shared_multisample)
+ MULTISAMPLE_SUB_RECT_HEIGHT_SGIS = 0x8027 # "
+ VISUAL_SELECT_GROUP_SGIX = 0x8028 # Visual attribute (visual_select_group)
+ HYPERPIPE_ID_SGIX = 0x8030 # Associated hyperpipe ID (SGIX_hyperpipe)
+ SAMPLE_BUFFERS_SGIS = 100000 # Visual attribute (SGIS_multisample)
+ SAMPLES_SGIS = 100001 # "
+ SAMPLE_BUFFERS_ARB = 100000 # Visual attribute (ARB_multisample - alias of SGIS_multisample)
+ SAMPLES_ARB = 100001 # "
+ SAMPLE_BUFFERS = 100000 # Visual attribute (GLX 1.4 core - alias of SGIS_multisample)
+ SAMPLES = 100001 # "
+
+###############################################################################
+
+# NVIDIA: 0x20A0 - 0x219F
+
+# NV_float_buffer enum:
+ FLOAT_COMPONENTS_NV = 0x20B0
+# NV_future_use: 0x20B1-0x20B8
+# ARB_fbconfig_float enum:
+ RGBA_FLOAT_TYPE_ARB = 0x20B9
+# NV_future_use: 0x20BA-0x219F
+
+###############################################################################
+
+# MESA (not in a reserved block)
+
+# MESA_set_3dfx_mode enum:
+# 3DFX_WINDOW_MODE_MESA = 0x1
+# 3DFX_FULLSCREEN_MODE_MESA = 0x2
+
+###############################################################################
+
+# SGI_future_use: 0x8029-0x802F
+# SGIX_hyperpipe adds attribute name HYPERPIPE_ID_SGIX = 0x8030
+# SGI_future_use: 0x8031-0x803F
+
+###############################################################################
+
+# ARB_future_use: 0x8042-0x804F
+
+###############################################################################
+
+# 3DFX: 0x8050-0x805F
+
+# 3DFX_multisample enum:
+# SAMPLE_BUFFERS_3DFX = 0x8050
+# SAMPLES_3DFX = 0x8051
+
+###############################################################################
+
+# OML: 0x8060-0x806F
+
+# OML_swap_method enum:
+# SWAP_METHOD_OML = 0x8060
+# SWAP_EXCHANGE_OML = 0x8061
+# SWAP_COPY_OML = 0x8062
+# SWAP_UNDEFINED_OML = 0x8063
+
+# OML_future_use: 0x8064-0x806F
+
+###############################################################################
+
+# NVIDIA: 0x8070 - 0x816F
+
+###############################################################################
+
+# SUN: 0x8170 - 0x817F
+
+###############################################################################
+### PLEASE REMEMBER THAT NEW ENUMERANT ALLOCATIONS MUST BE OBTAINED BY
+### REQUEST TO SGI'S ARB REPRESENTATIVE (see comments at the top of this file)
+###############################################################################
+
+# Any_vendor_future_use: 0x8180-0xFFFF
+#
+# This range must be the last range in the file. To generate a new
+# range, allocate multiples of 16 from the beginning of the
+# Any_vendor_future_use range and update glxenum.spec, glxenumext.spec,
+# and extensions.reserved.
diff --git a/Source/Bind/Specifications/glxenumext.spec b/Source/Bind/Specifications/glxenumext.spec
new file mode 100644
index 00000000..e52c7e05
--- /dev/null
+++ b/Source/Bind/Specifications/glxenumext.spec
@@ -0,0 +1,412 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2005 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+#
+# $Date: 2005/01/20 08:44:12 $ $Revision: 1.6 $
+# $Header: /oss/CVS/cvs/projects/ogl-sample/main/doc/registry/specs/glxenumext.spec,v 1.6 2005/01/20 08:44:12 ljp Exp $
+
+# List of GLX enumerants for glxext.h header
+#
+# This is NOT the master GLX enumerant registry (glxenum.spec).
+#
+# Unlike glxenum.spec, glxenumext.spec is
+# (1) In order by extension number.
+# (2) Includes only GLX extensions and GLX 1.3/1.4 core enumerants,
+# since it's assumed all today support at least GLX 1.2.
+# (3) Has no 'Extensions' section, since enums are always
+# conditionally protected against multiple definition
+# by glextenum.pl.
+# (4) Is processed by glextenum.pl, which has evolved
+# from enum.pl - should merge back into one script.
+
+# glxext.h version number - this should be automatically updated,
+# when changing either enum or template spec files.
+
+passthru:
+passthru: /* Header file version number, required by OpenGL ABI for Linux */
+passthru: /* glxext.h last updated 2005/01/20 */
+passthru: /* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+passthru: #define GLX_GLXEXT_VERSION 10
+
+###############################################################################
+#
+# GLX 1.3 enums
+#
+###############################################################################
+
+VERSION_1_3 enum:
+ WINDOW_BIT = 0x00000001 # DRAWABLE_TYPE value
+ PIXMAP_BIT = 0x00000002 # "
+ PBUFFER_BIT = 0x00000004 # "
+ RGBA_BIT = 0x00000001 # RENDER_TYPE value
+ COLOR_INDEX_BIT = 0x00000002 # "
+ PBUFFER_CLOBBER_MASK = 0x08000000 # SelectEvent mask
+ FRONT_LEFT_BUFFER_BIT = 0x00000001 # PbufferClobberEvent mask
+ FRONT_RIGHT_BUFFER_BIT = 0x00000002 # "
+ BACK_LEFT_BUFFER_BIT = 0x00000004 # "
+ BACK_RIGHT_BUFFER_BIT = 0x00000008 # "
+ AUX_BUFFERS_BIT = 0x00000010 # "
+ DEPTH_BUFFER_BIT = 0x00000020 # "
+ STENCIL_BUFFER_BIT = 0x00000040 # "
+ ACCUM_BUFFER_BIT = 0x00000080 # "
+ CONFIG_CAVEAT = 0x20 # "
+ X_VISUAL_TYPE = 0x22 # "
+ TRANSPARENT_TYPE = 0x23 # "
+ TRANSPARENT_INDEX_VALUE = 0x24 # "
+ TRANSPARENT_RED_VALUE = 0x25 # "
+ TRANSPARENT_GREEN_VALUE = 0x26 # "
+ TRANSPARENT_BLUE_VALUE = 0x27 # "
+ TRANSPARENT_ALPHA_VALUE = 0x28 # "
+ DONT_CARE = 0xFFFFFFFF # may be specified for ChooseFBConfig attributes
+ NONE = 0x8000 # several attribute values
+ SLOW_CONFIG = 0x8001 # CONFIG_CAVEAT attribute value
+ TRUE_COLOR = 0x8002 # X_VISUAL_TYPE attribute value
+ DIRECT_COLOR = 0x8003 # "
+ PSEUDO_COLOR = 0x8004 # "
+ STATIC_COLOR = 0x8005 # "
+ GRAY_SCALE = 0x8006 # "
+ STATIC_GRAY = 0x8007 # "
+ TRANSPARENT_RGB = 0x8008 # TRANSPARENT_TYPE attribute value
+ TRANSPARENT_INDEX = 0x8009 # "
+ VISUAL_ID = 0x800B # Context attribute
+ SCREEN = 0x800C # "
+ NON_CONFORMANT_CONFIG = 0x800D # CONFIG_CAVEAT attribute value
+ DRAWABLE_TYPE = 0x8010 # FBConfig attribute
+ RENDER_TYPE = 0x8011 # "
+ X_RENDERABLE = 0x8012 # "
+ FBCONFIG_ID = 0x8013 # "
+ RGBA_TYPE = 0x8014 # CreateNewContext render_type value
+ COLOR_INDEX_TYPE = 0x8015 # "
+ MAX_PBUFFER_WIDTH = 0x8016 # FBConfig attribute
+ MAX_PBUFFER_HEIGHT = 0x8017 # "
+ MAX_PBUFFER_PIXELS = 0x8018 # "
+ PRESERVED_CONTENTS = 0x801B # CreateGLXPbuffer attribute
+ LARGEST_PBUFFER = 0x801C # "
+ WIDTH = 0x801D # Drawable attribute
+ HEIGHT = 0x801E # "
+ EVENT_MASK = 0x801F # "
+ DAMAGED = 0x8020 # PbufferClobber event_type value
+ SAVED = 0x8021 # "
+ WINDOW = 0x8022 # PbufferClobber draw_type value
+ PBUFFER = 0x8023 # "
+ PBUFFER_HEIGHT = 0x8040 # CreateGLXPbuffer attribute
+ PBUFFER_WIDTH = 0x8041 # "
+
+###############################################################################
+#
+# GLX 1.4 enums
+#
+###############################################################################
+
+VERSION_1_4 enum:
+ SAMPLE_BUFFERS = 100000
+ SAMPLES = 100001
+
+###############################################################################
+#
+# ARB GLX extensions, in ARB extension order
+#
+###############################################################################
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #2
+ARB_get_proc_address enum:
+
+###############################################################################
+
+# ARB Extension #5
+ARB_multisample enum:
+ SAMPLE_BUFFERS_ARB = 100000
+ SAMPLES_ARB = 100001
+
+###############################################################################
+
+# ARB Extension #39
+ARB_fbconfig_float enum:
+ RGBA_FLOAT_TYPE_ARB = 0x20B9
+ RGBA_FLOAT_BIT_ARB = 0x00000004
+
+
+###############################################################################
+#
+# non-ARB GLX extensions, in registry order
+#
+###############################################################################
+
+###############################################################################
+
+# Unfortunately, the SGIS_multisample specification and the IRIX
+# implementation are inconsistent; the spec assigns enums as follows.
+# ARB_multisample reuses these enums with ARB suffixes, and it can't
+# be changed at this point. So in the interest of supporting both
+# extensions on non-IRIX platforms, the SGIS enums will be defined
+# here as originally specified.
+
+# Extension #25
+SGIS_multisample enum:
+ SAMPLE_BUFFERS_SGIS = 100000
+ SAMPLES_SGIS = 100001
+
+###############################################################################
+
+# Extension #28
+EXT_visual_info enum:
+ X_VISUAL_TYPE_EXT = 0x22
+ TRANSPARENT_TYPE_EXT = 0x23
+ TRANSPARENT_INDEX_VALUE_EXT = 0x24
+ TRANSPARENT_RED_VALUE_EXT = 0x25
+ TRANSPARENT_GREEN_VALUE_EXT = 0x26
+ TRANSPARENT_BLUE_VALUE_EXT = 0x27
+ TRANSPARENT_ALPHA_VALUE_EXT = 0x28
+ NONE_EXT = 0x8000
+ TRUE_COLOR_EXT = 0x8002
+ DIRECT_COLOR_EXT = 0x8003
+ PSEUDO_COLOR_EXT = 0x8004
+ STATIC_COLOR_EXT = 0x8005
+ GRAY_SCALE_EXT = 0x8006
+ STATIC_GRAY_EXT = 0x8007
+ TRANSPARENT_RGB_EXT = 0x8008
+ TRANSPARENT_INDEX_EXT = 0x8009
+
+###############################################################################
+
+# No new tokens
+# Extension #40
+SGI_swap_control enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #41
+SGI_video_sync enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #42
+SGI_make_current_read enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #43
+SGIX_video_source enum:
+
+###############################################################################
+
+# Extension #44
+EXT_visual_rating enum:
+ VISUAL_CAVEAT_EXT = 0x20
+ SLOW_VISUAL_EXT = 0x8001
+ NON_CONFORMANT_VISUAL_EXT = 0x800D
+ use EXT_visual_info NONE_EXT
+
+###############################################################################
+
+# Extension #47
+EXT_import_context enum:
+ SHARE_CONTEXT_EXT = 0x800A
+ VISUAL_ID_EXT = 0x800B
+ SCREEN_EXT = 0x800C
+
+###############################################################################
+
+# Extension #49
+SGIX_fbconfig enum:
+ WINDOW_BIT_SGIX = 0x00000001
+ PIXMAP_BIT_SGIX = 0x00000002
+ RGBA_BIT_SGIX = 0x00000001
+ COLOR_INDEX_BIT_SGIX = 0x00000002
+ DRAWABLE_TYPE_SGIX = 0x8010
+ RENDER_TYPE_SGIX = 0x8011
+ X_RENDERABLE_SGIX = 0x8012
+ FBCONFIG_ID_SGIX = 0x8013
+ RGBA_TYPE_SGIX = 0x8014
+ COLOR_INDEX_TYPE_SGIX = 0x8015
+ use EXT_import_context SCREEN_EXT
+
+###############################################################################
+
+# Extension #50
+SGIX_pbuffer enum:
+ PBUFFER_BIT_SGIX = 0x00000004
+ BUFFER_CLOBBER_MASK_SGIX = 0x08000000
+ FRONT_LEFT_BUFFER_BIT_SGIX = 0x00000001
+ FRONT_RIGHT_BUFFER_BIT_SGIX = 0x00000002
+ BACK_LEFT_BUFFER_BIT_SGIX = 0x00000004
+ BACK_RIGHT_BUFFER_BIT_SGIX = 0x00000008
+ AUX_BUFFERS_BIT_SGIX = 0x00000010
+ DEPTH_BUFFER_BIT_SGIX = 0x00000020
+ STENCIL_BUFFER_BIT_SGIX = 0x00000040
+ ACCUM_BUFFER_BIT_SGIX = 0x00000080
+ SAMPLE_BUFFERS_BIT_SGIX = 0x00000100
+ MAX_PBUFFER_WIDTH_SGIX = 0x8016
+ MAX_PBUFFER_HEIGHT_SGIX = 0x8017
+ MAX_PBUFFER_PIXELS_SGIX = 0x8018
+ OPTIMAL_PBUFFER_WIDTH_SGIX = 0x8019
+ OPTIMAL_PBUFFER_HEIGHT_SGIX = 0x801A
+ PRESERVED_CONTENTS_SGIX = 0x801B
+ LARGEST_PBUFFER_SGIX = 0x801C
+ WIDTH_SGIX = 0x801D
+ HEIGHT_SGIX = 0x801E
+ EVENT_MASK_SGIX = 0x801F
+ DAMAGED_SGIX = 0x8020
+ SAVED_SGIX = 0x8021
+ WINDOW_SGIX = 0x8022
+ PBUFFER_SGIX = 0x8023
+
+###############################################################################
+
+# Extension #62
+SGI_cushion enum:
+# CUSHION_BUFFERS_SGI ????
+
+###############################################################################
+
+# Extension #83
+SGIX_video_resize enum:
+ SYNC_FRAME_SGIX = 0x00000000
+ SYNC_SWAP_SGIX = 0x00000001
+
+###############################################################################
+
+# Extension #86
+SGIX_dmbuffer enum:
+ DIGITAL_MEDIA_PBUFFER_SGIX = 0x8024
+
+###############################################################################
+
+# No new tokens
+# Extension #91
+SGIX_swap_group enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #92
+SGIX_swap_barrier enum:
+
+###############################################################################
+
+# Extension #142
+SGIS_blended_overlay enum:
+ BLENDED_RGBA_SGIS = 0x8025
+
+###############################################################################
+
+# Extension #143
+SGIS_shared_multisample enum:
+ MULTISAMPLE_SUB_RECT_WIDTH_SGIS = 0x8026
+ MULTISAMPLE_SUB_RECT_HEIGHT_SGIS = 0x8027
+
+###############################################################################
+
+# No new tokens
+# Extension #183
+SUN_get_transparent_index enum:
+
+###############################################################################
+
+# Extension #207
+3DFX_multisample enum:
+ SAMPLE_BUFFERS_3DFX = 0x8050
+ SAMPLES_3DFX = 0x8051
+
+###############################################################################
+
+# No new tokens
+# Extension #215
+MESA_copy_sub_buffer enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #216
+MESA_pixmap_colormap enum:
+
+###############################################################################
+
+# No new tokens
+# Extension #217
+MESA_release_buffers enum:
+
+###############################################################################
+
+# Extension #218
+MESA_set_3dfx_mode enum:
+ 3DFX_WINDOW_MODE_MESA = 0x1
+ 3DFX_FULLSCREEN_MODE_MESA = 0x2
+
+###############################################################################
+
+# Extension #234
+SGIX_visual_select_group enum:
+ VISUAL_SELECT_GROUP_SGIX = 0x8028
+
+###############################################################################
+
+# Extension #237
+OML_swap_method enum:
+ SWAP_METHOD_OML = 0x8060
+ SWAP_EXCHANGE_OML = 0x8061
+ SWAP_COPY_OML = 0x8062
+ SWAP_UNDEFINED_OML = 0x8063
+
+###############################################################################
+
+# No new tokens
+# Extension #238
+OML_sync_control enum:
+
+###############################################################################
+
+# Extension #281
+NV_float_buffer enum:
+ FLOAT_COMPONENTS_NV = 0x20B0
+
+###############################################################################
+
+# Extension #307
+SGIX_hyperpipe enum:
+ HYPERPIPE_PIPE_NAME_LENGTH_SGIX = 80
+ BAD_HYPERPIPE_CONFIG_SGIX = 91
+ BAD_HYPERPIPE_SGIX = 92
+ HYPERPIPE_DISPLAY_PIPE_SGIX = 0x00000001
+ HYPERPIPE_RENDER_PIPE_SGIX = 0x00000002
+ PIPE_RECT_SGIX = 0x00000001
+ PIPE_RECT_LIMITS_SGIX = 0x00000002
+ HYPERPIPE_STEREO_SGIX = 0x00000003
+ HYPERPIPE_PIXEL_AVERAGE_SGIX = 0x00000004
+ HYPERPIPE_ID_SGIX = 0x8030
+
+###############################################################################
+
+# No new tokens
+# Extension #308
+MESA_agp_offset enum:
+
diff --git a/Source/Bind/Specifications/glxext.spec b/Source/Bind/Specifications/glxext.spec
new file mode 100644
index 00000000..bdeb796a
--- /dev/null
+++ b/Source/Bind/Specifications/glxext.spec
@@ -0,0 +1,1003 @@
+# glxext.spec file
+# DON'T REMOVE PREVIOUS LINE!!! libspec depends on it!
+#
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2005 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+
+required-props:
+param: retval retained
+glxflags: client-handcode client-intercept server-handcode
+glxvendorglx: *
+vectorequiv: *
+category: VERSION_1_3 VERSION_1_4 ARB_get_proc_address ARB_multisample ARB_fbconfig_float EXT_import_context SGIX_dmbuffer SGIX_fbconfig SGIX_pbuffer SGIX_swap_barrier SGIX_swap_group SGIX_video_resize SGIX_video_source SGI_cushion SGI_make_current_read SGI_swap_control SGI_video_sync SUN_get_transparent_index MESA_agp_offset MESA_copy_sub_buffer MESA_pixmap_colormap MESA_release_buffers MESA_set_3dfx_mode SGIX_visual_select_group OML_sync_control SGIX_hyperpipe
+glxopcode: *
+
+#
+# Boilerplate to define types used by some extensions. This is done
+# up front, since it involves some complexities in protecting
+# the declarations whether or not the -protect flag is given to
+# the generator scripts.
+#
+
+passthru: #ifndef GLX_ARB_get_proc_address
+passthru: typedef void (*__GLXextFuncPtr)(void);
+passthru: #endif
+passthru:
+passthru: #ifndef GLX_SGIX_video_source
+passthru: typedef XID GLXVideoSourceSGIX;
+passthru: #endif
+passthru:
+passthru: #ifndef GLX_SGIX_fbconfig
+passthru: typedef XID GLXFBConfigIDSGIX;
+passthru: typedef struct __GLXFBConfigRec *GLXFBConfigSGIX;
+passthru: #endif
+passthru:
+passthru: #ifndef GLX_SGIX_pbuffer
+passthru: typedef XID GLXPbufferSGIX;
+passthru: typedef struct {
+passthru: int type;
+passthru: unsigned long serial; /* # of last request processed by server */
+passthru: Bool send_event; /* true if this came for SendEvent request */
+passthru: Display *display; /* display the event was read from */
+passthru: GLXDrawable drawable; /* i.d. of Drawable */
+passthru: int event_type; /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */
+passthru: int draw_type; /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */
+passthru: unsigned int mask; /* mask indicating which buffers are affected*/
+passthru: int x, y;
+passthru: int width, height;
+passthru: int count; /* if nonzero, at least this many more */
+passthru: } GLXBufferClobberEventSGIX;
+passthru: #endif
+passthru:
+passthru: /* Define int32_t and int64_t types for UST/MSC */
+passthru: /* (as used in the GLX_OML_sync_control extension). */
+passthru: #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+passthru: #include
+passthru: #elif defined( __VMS )
+passthru: #include
+passthru: #elif defined(__SCO__) || defined(__USLC__)
+passthru: #include
+passthru: #elif defined(__UNIXOS2__) || defined(__SOL64__)
+passthru: typedef long int int32_t;
+passthru: typedef long long int int64_t;
+passthru: #else
+passthru: #warn "int32_t and int64_t are undefined!"
+passthru: #endif
+passthru:
+
+###############################################################################
+#
+# GLX 1.3 commands
+#
+###############################################################################
+
+GetFBConfigs(dpy, screen, nelements)
+ return GLXFBConfigPointer
+ param dpy Display out reference
+ param screen int in value
+ param nelements int out reference
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 21
+
+ChooseFBConfig(dpy, screen, attrib_list, nelements)
+ return GLXFBConfigPointer
+ param dpy Display out reference
+ param screen int in value
+ param attrib_list int in reference
+ param nelements int out reference
+ category VERSION_1_3
+ glxflags client-handcode client-intercept server-handcode
+
+GetFBConfigAttrib(dpy, config, attribute, value)
+ return int
+ param dpy Display out reference
+ param config GLXFBConfig in value
+ param attribute int in value
+ param value int out reference
+ category VERSION_1_3
+ glxflags client-handcode client-intercept server-handcode
+
+GetVisualFromFBConfig(dpy, config)
+ return XVisualInfoPointer
+ param dpy Display out reference
+ param config GLXFBConfig in value
+ category VERSION_1_3
+ glxflags client-handcode client-intercept server-handcode
+
+CreateWindow(dpy, config, win, attrib_list)
+ return GLXWindow
+ param dpy Display out reference
+ param config GLXFBConfig in value
+ param win Window in value
+ param attrib_list int in reference
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 31
+
+DestroyWindow(dpy, win)
+ return void
+ param dpy Display out reference
+ param win GLXWindow in value
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 32
+
+CreatePixmap(dpy, config, pixmap, attrib_list)
+ return GLXPixmap
+ param dpy Display out reference
+ param config GLXFBConfig in value
+ param pixmap Pixmap in value
+ param attrib_list int in reference
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 22
+
+DestroyPixmap(dpy, pixmap)
+ return void
+ param dpy Display out reference
+ param pixmap GLXPixmap in value
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 23
+
+CreatePbuffer(dpy, config, attrib_list)
+ return GLXPbuffer
+ param dpy Display out reference
+ param config GLXFBConfig in value
+ param attrib_list int in reference
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 27
+
+DestroyPbuffer(dpy, pbuf)
+ return void
+ param dpy Display out reference
+ param pbuf GLXPbuffer in value
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 28
+
+# glXGetDrawableAttributes -> GLX opcode 29
+# glXChangeDrawableAttributes -> GLX opcode 30
+
+# Uses glXGetDrawableAttributes protocol
+QueryDrawable(dpy, draw, attribute, value)
+ return void
+ param dpy Display out reference
+ param draw GLXDrawable in value
+ param attribute int in value
+ param value Uint out reference
+ category VERSION_1_3
+ glxflags client-handcode client-intercept server-handcode
+
+CreateNewContext(dpy, config, render_type, share_list, direct)
+ return GLXContext
+ param dpy Display out reference
+ param config GLXFBConfig in value
+ param render_type int in value
+ param share_list GLXContext in value
+ param direct Bool in value
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 24
+
+MakeContextCurrent(dpy, draw, read, ctx)
+ return Bool
+ param dpy Display out reference
+ param draw GLXDrawable in value
+ param read GLXDrawable in value
+ param ctx GLXContext in value
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 26
+
+GetCurrentReadDrawable()
+ return GLXDrawable
+ category VERSION_1_3
+ glxflags client-handcode client-intercept server-handcode
+
+GetCurrentDisplay()
+ return DisplayPointer
+ category VERSION_1_3
+ glxflags client-handcode client-intercept server-handcode
+
+QueryContext(dpy, ctx, attribute, value)
+ return int
+ param dpy Display out reference
+ param ctx GLXContext in value
+ param attribute int in value
+ param value int out reference
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+ glxopcode 25
+
+# Uses glXChangeDrawableAttributes protocol
+SelectEvent(dpy, draw, event_mask)
+ return void
+ param dpy Display out reference
+ param draw GLXDrawable in value
+ param event_mask ulong in value
+ category VERSION_1_3
+ glxflags client-handcode server-handcode
+
+# Uses glXGetDrawableAttributes protocol
+GetSelectedEvent(dpy, draw, event_mask)
+ return void
+ param dpy Display out reference
+ param draw GLXDrawable in value
+ param event_mask ulong out reference
+ category VERSION_1_3
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# GLX 1.4 commands
+#
+###############################################################################
+
+GetProcAddress(procName)
+ return FunctionPointer
+ param procName GLubyte in reference
+ category VERSION_1_4
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# ARB Extension #2
+# ARB_get_proc_address commands
+# @promoted to core in GLX 1.4, but there's no provision for aliasing
+# @in GLX spec files, yet
+#
+###############################################################################
+
+GetProcAddressARB(procName)
+ return FunctionPointer
+ param procName GLubyte in reference
+ category ARB_get_proc_address
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# ARB Extension #5
+# ARB_multisample commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_multisample
+
+###############################################################################
+#
+# ARB Extension #39
+# ARB_fbconfig_float commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_fbconfig_float
+
+###############################################################################
+#
+# Extension #25
+# SGIS_multisample commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIS_multisample
+
+###############################################################################
+#
+# Extension #28
+# EXT_visual_info commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_visual_info
+
+###############################################################################
+#
+# Extension #40
+# SGI_swap_control commands
+#
+###############################################################################
+
+SwapIntervalSGI(interval)
+ return int
+ param interval int in value
+ category SGI_swap_control
+ glxflags client-handcode server-handcode
+ glxvendorglx 65536
+
+###############################################################################
+#
+# Extension #41
+# SGI_video_sync commands
+#
+###############################################################################
+
+GetVideoSyncSGI(count)
+ return int
+ param count Uint out reference
+ category SGI_video_sync
+ glxflags client-handcode client-intercept server-handcode
+
+WaitVideoSyncSGI(divisor, remainder, count)
+ return int
+ param divisor int in value
+ param remainder int in value
+ param count Uint out reference
+ category SGI_video_sync
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #42
+# SGI_make_current_read commands
+#
+###############################################################################
+
+MakeCurrentReadSGI(dpy, draw, read, ctx)
+ return Bool
+ param dpy Display out reference
+ param draw GLXDrawable in value
+ param read GLXDrawable in value
+ param ctx GLXContext in value
+ category SGI_make_current_read
+ glxflags client-handcode server-handcode
+ glxvendorglx 65537
+
+GetCurrentReadDrawableSGI()
+ return GLXDrawable
+ category SGI_make_current_read
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #43
+# SGIX_video_source commands
+#
+###############################################################################
+
+newcategory: SGIX_video_source
+passthru: #ifdef _VL_H
+
+CreateGLXVideoSourceSGIX(display, screen, server, path, nodeClass, drainNode)
+ return GLXVideoSourceSGIX
+ param display Display out reference
+ param screen int in value
+ param server VLServer in value
+ param path VLPath in value
+ param nodeClass int in value
+ param drainNode VLNode in value
+ category SGIX_video_source
+ glxflags client-handcode server-handcode
+ glxvendorglx 65538
+
+DestroyGLXVideoSourceSGIX(dpy, glxvideosource)
+ return void
+ param dpy Display out reference
+ param glxvideosource GLXVideoSourceSGIX in value
+ category SGIX_video_source
+ glxflags client-handcode server-handcode
+ glxvendorglx 65539
+
+passend: #endif /* _VL_H */
+endcategory:
+
+###############################################################################
+#
+# Extension #44
+# EXT_visual_rating commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_visual_rating
+
+###############################################################################
+#
+# Extension #47
+# EXT_import_context commands
+#
+###############################################################################
+
+GetCurrentDisplayEXT()
+ return DisplayPointer
+ category EXT_import_context
+ glxflags client-handcode client-intercept server-handcode
+
+QueryContextInfoEXT(dpy, context, attribute, value)
+ return int
+ param dpy Display out reference
+ param context GLXContext in value
+ param attribute int in value
+ param value int out reference
+ category EXT_import_context
+ glxflags client-handcode server-handcode
+ glxvendorglx 1024
+
+# 'constGLXContext' is a hack; the extension specification and glx.h
+# should be fixed instead.
+GetContextIDEXT(context)
+ return GLXContextID
+ param context constGLXContext in value
+ category EXT_import_context
+ glxflags client-handcode client-intercept server-handcode
+
+ImportContextEXT(dpy, contextID)
+ return GLXContext
+ param dpy Display out reference
+ param contextID GLXContextID in value
+ category EXT_import_context
+ glxflags client-handcode client-intercept server-handcode
+
+FreeContextEXT(dpy, context)
+ return void
+ param dpy Display out reference
+ param context GLXContext in value
+ category EXT_import_context
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #49
+# SGIX_fbconfig commands
+#
+###############################################################################
+
+# GetFBConfigsSGIX protocol -> VendorPrivate opcode 65540
+
+GetFBConfigAttribSGIX(dpy, config, attribute, value)
+ return int
+ param dpy Display out reference
+ param config GLXFBConfigSGIX in value
+ param attribute int in value
+ param value int out reference
+ category SGIX_fbconfig
+ glxflags client-handcode client-intercept server-handcode
+
+ChooseFBConfigSGIX(dpy, screen, attrib_list, nelements)
+ return GLXFBConfigSGIXPointer
+ param dpy Display out reference
+ param screen int in value
+ param attrib_list int out reference
+ param nelements int out reference
+ category SGIX_fbconfig
+ glxflags client-handcode client-intercept server-handcode
+
+CreateGLXPixmapWithConfigSGIX(dpy, config, pixmap)
+ return GLXPixmap
+ param dpy Display out reference
+ param config GLXFBConfigSGIX in value
+ param pixmap Pixmap in value
+ category SGIX_fbconfig
+ glxflags client-handcode server-handcode
+ glxvendorglx 65542
+
+CreateContextWithConfigSGIX(dpy, config, render_type, share_list, direct)
+ return GLXContext
+ param dpy Display out reference
+ param config GLXFBConfigSGIX in value
+ param render_type int in value
+ param share_list GLXContext in value
+ param direct Bool in value
+ category SGIX_fbconfig
+ glxflags client-handcode server-handcode
+ glxvendorglx 65541
+
+GetVisualFromFBConfigSGIX(dpy, config)
+ return XVisualInfoPointer
+ param dpy Display out reference
+ param config GLXFBConfigSGIX in value
+ category SGIX_fbconfig
+ glxflags client-handcode client-intercept server-handcode
+
+GetFBConfigFromVisualSGIX(dpy, vis)
+ return GLXFBConfigSGIX
+ param dpy Display out reference
+ param vis XVisualInfo out reference
+ category SGIX_fbconfig
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #50
+# SGIX_pbuffer commands
+#
+###############################################################################
+
+# ChangeDrawableAttributesSGIX protocol -> VendorPrivate opcode 65545
+# GetDrawableAttributesSGIX protocol -> VendorPrivate opcode 65546
+
+CreateGLXPbufferSGIX(dpy, config, width, height, attrib_list)
+ return GLXPbufferSGIX
+ param dpy Display out reference
+ param config GLXFBConfigSGIX in value
+ param width Uint in value
+ param height Uint in value
+ param attrib_list int out reference
+ category SGIX_pbuffer
+ glxflags client-handcode server-handcode
+ glxvendorglx 65543
+
+DestroyGLXPbufferSGIX(dpy, pbuf)
+ return void
+ param dpy Display out reference
+ param pbuf GLXPbufferSGIX in value
+ category SGIX_pbuffer
+ glxflags client-handcode
+ glxvendorglx 65544
+
+QueryGLXPbufferSGIX(dpy, pbuf, attribute, value)
+ return int
+ param dpy Display out reference
+ param pbuf GLXPbufferSGIX in value
+ param attribute int in value
+ param value Uint out reference
+ category SGIX_pbuffer
+
+SelectEventSGIX(dpy, drawable, mask)
+ return void
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param mask ulong in value
+ category SGIX_pbuffer
+
+GetSelectedEventSGIX(dpy, drawable, mask)
+ return void
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param mask ulong out reference
+ category SGIX_pbuffer
+
+###############################################################################
+#
+# Extension #62
+# SGI_cushion commands
+#
+###############################################################################
+
+CushionSGI(dpy, window, cushion)
+ return void
+ param dpy Display out reference
+ param window Window in value
+ param cushion float in value
+ category SGI_cushion
+
+###############################################################################
+#
+# Extension #83
+# SGIX_video_resize commands
+#
+###############################################################################
+
+BindChannelToWindowSGIX(display, screen, channel, window)
+ return int
+ param display Display out reference
+ param screen int in value
+ param channel int in value
+ param window Window in value
+ category SGIX_video_resize
+
+ChannelRectSGIX(display, screen, channel, x, y, w, h)
+ return int
+ param display Display out reference
+ param screen int in value
+ param channel int in value
+ param x int in value
+ param y int in value
+ param w int in value
+ param h int in value
+ category SGIX_video_resize
+
+QueryChannelRectSGIX(display, screen, channel, dx, dy, dw, dh)
+ return int
+ param display Display out reference
+ param screen int in value
+ param channel int in value
+ param dx int out reference
+ param dy int out reference
+ param dw int out reference
+ param dh int out reference
+ category SGIX_video_resize
+
+QueryChannelDeltasSGIX(display, screen, channel, x, y, w, h)
+ return int
+ param display Display out reference
+ param screen int in value
+ param channel int in value
+ param x int out reference
+ param y int out reference
+ param w int out reference
+ param h int out reference
+ category SGIX_video_resize
+
+# @@@ Not in man page - this entry point may not be shipping?
+ChannelRectSyncSGIX(display, screen, channel, synctype)
+ return int
+ param display Display out reference
+ param screen int in value
+ param channel int in value
+ param synctype GLenum in value
+ category SGIX_video_resize
+
+###############################################################################
+#
+# Extension #86
+# SGIX_dmbuffer commands
+#
+###############################################################################
+
+newcategory: SGIX_dmbuffer
+passthru: #ifdef _DM_BUFFER_H_
+
+AssociateDMPbufferSGIX(dpy, pbuffer, params, dmbuffer)
+ return Bool
+ param dpy Display out reference
+ param pbuffer GLXPbufferSGIX in value
+ param params DMparams out reference
+ param dmbuffer DMbuffer in value
+ category SGIX_dmbuffer
+
+passend: #endif /* _DM_BUFFER_H_ */
+endcategory:
+
+###############################################################################
+#
+# Extension #91
+# SGIX_swap_group commands
+#
+###############################################################################
+
+JoinSwapGroupSGIX(dpy, drawable, member)
+ return void
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param member GLXDrawable in value
+ category SGIX_swap_group
+ glxflags client-handcode server-handcode
+ glxvendorglx 65547
+
+###############################################################################
+#
+# Extension #92
+# SGIX_swap_barrier commands
+#
+###############################################################################
+
+BindSwapBarrierSGIX(dpy, drawable, barrier)
+ return void
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param barrier int in value
+ category SGIX_swap_barrier
+ glxflags client-handcode server-handcode
+ glxvendorglx 65548
+
+QueryMaxSwapBarriersSGIX(dpy, screen, max)
+ return Bool
+ param dpy Display out reference
+ param screen int in value
+ param max int out reference
+ category SGIX_swap_barrier
+ glxflags client-handcode server-handcode
+ glxvendorglx 65549
+
+###############################################################################
+#
+# Extension #183
+# SUN_get_transparent_index commands
+#
+###############################################################################
+
+GetTransparentIndexSUN(dpy, overlay, underlay, pTransparentIndex)
+ return Status
+ param dpy Display out reference
+ param overlay Window in value
+ param underlay Window in value
+ param pTransparentIndex long out reference
+ category SUN_get_transparent_index
+
+###############################################################################
+#
+# Extension #215
+# MESA_copy_sub_buffer commands
+#
+###############################################################################
+
+CopySubBufferMESA(dpy, drawable, x, y, width, height)
+ return void
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param x int in value
+ param y int in value
+ param width int in value
+ param height int in value
+ category MESA_copy_sub_buffer
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #216
+# MESA_pixmap_colormap commands
+#
+###############################################################################
+
+CreateGLXPixmapMESA(dpy, visual, pixmap, cmap)
+ return GLXPixmap
+ param dpy Display out reference
+ param visual XVisualInfo out reference
+ param pixmap Pixmap in value
+ param cmap Colormap in value
+ category MESA_pixmap_colormap
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #217
+# MESA_release_buffers commands
+#
+###############################################################################
+
+ReleaseBuffersMESA(dpy, drawable)
+ return Bool
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ category MESA_release_buffers
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #218
+# MESA_set_3dfx_mode commands
+#
+###############################################################################
+
+# Brian's spec has this as returning 'GLboolean' and taking 'GLint mode'
+Set3DfxModeMESA(mode)
+ return Bool
+ param mode int in value
+ category MESA_set_3dfx_mode
+ glxflags client-handcode client-intercept server-handcode
+
+###############################################################################
+#
+# Extension #234
+# SGIX_visual_select_group commands
+#
+###############################################################################
+
+# (none)
+newcategory: SGIX_visual_select_group
+
+###############################################################################
+#
+# Extension #237
+# OML_swap_method commands
+#
+###############################################################################
+
+# (none)
+newcategory: OML_swap_method
+
+###############################################################################
+#
+# Extension #238
+# OML_sync_control commands
+#
+###############################################################################
+
+GetSyncValuesOML(dpy, drawable, ust, msc, sbc)
+ return Bool
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param ust int64_t out reference
+ param msc int64_t out reference
+ param sbc int64_t out reference
+ category OML_sync_control
+ glxflags client-handcode server-handcode
+
+GetMscRateOML(dpy, drawable, numerator, denominator)
+ return Bool
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param numerator int32_t out reference
+ param denominator int32_t out reference
+ category OML_sync_control
+ glxflags client-handcode server-handcode
+
+SwapBuffersMscOML(dpy, drawable, target_msc, divisor, remainder)
+ return int64_t
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param target_msc int64_t in value
+ param divisor int64_t in value
+ param remainder int64_t in value
+ category OML_sync_control
+ glxflags client-handcode server-handcode
+
+WaitForMscOML(dpy, drawable, target_msc, divisor, remainder, ust, msc, sbc)
+ return Bool
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param target_msc int64_t in value
+ param divisor int64_t in value
+ param remainder int64_t in value
+ param ust int64_t out reference
+ param msc int64_t out reference
+ param sbc int64_t out reference
+ category OML_sync_control
+ glxflags client-handcode server-handcode
+
+WaitForSbcOML(dpy, drawable, target_sbc, ust, msc, sbc)
+ return Bool
+ param dpy Display out reference
+ param drawable GLXDrawable in value
+ param target_sbc int64_t in value
+ param ust int64_t out reference
+ param msc int64_t out reference
+ param sbc int64_t out reference
+ category OML_sync_control
+ glxflags client-handcode server-handcode
+
+###############################################################################
+#
+# Extension #281
+# NV_float_buffer commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_float_buffer
+
+###############################################################################
+#
+# Extension #307
+# SGIX_hyperpipe commands
+#
+###############################################################################
+
+newcategory: SGIX_hyperpipe
+passthru:
+passthru: typedef struct {
+passthru: char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+passthru: int networkId;
+passthru: } GLXHyperpipeNetworkSGIX;
+passthru:
+passthru: typedef struct {
+passthru: char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+passthru: int channel;
+passthru: unsigned int
+passthru: participationType;
+passthru: int timeSlice;
+passthru: } GLXHyperpipeConfigSGIX;
+passthru:
+passthru: typedef struct {
+passthru: char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+passthru: int srcXOrigin, srcYOrigin, srcWidth, srcHeight;
+passthru: int destXOrigin, destYOrigin, destWidth, destHeight;
+passthru: } GLXPipeRect;
+passthru:
+passthru: typedef struct {
+passthru: char pipeName[GLX_HYPERPIPE_PIPE_NAME_LENGTH_SGIX];
+passthru: int XOrigin, YOrigin, maxHeight, maxWidth;
+passthru: } GLXPipeRectLimits;
+passthru:
+
+QueryHyperpipeNetworkSGIX(dpy, npipes)
+ return GLXHyperpipeNetworkSGIXPointer
+ param dpy Display out reference
+ param npipes int out reference
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx 65550
+
+HyperpipeConfigSGIX(dpy, networkId, npipes, cfg, hpId)
+ return int
+ param dpy Display out reference
+ param networkId int in value
+ param npipes int in value
+ param cfg GLXHyperpipeConfigSGIX out array [COMPSIZE(npipes)]
+ param hpId int out reference
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx 65552
+
+QueryHyperpipeConfigSGIX(dpy, hpId, npipes)
+ return GLXHyperpipeConfigSGIXPointer
+ param dpy Display out reference
+ param hpId int in value
+ param npipes int out reference
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx 65551
+
+DestroyHyperpipeConfigSGIX(dpy, hpId)
+ return int
+ param dpy Display out reference
+ param hpId int in value
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx 65553
+
+BindHyperpipeSGIX(dpy, hpId)
+ return int
+ param dpy Display out reference
+ param hpId int in value
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx ???
+
+QueryHyperpipeBestAttribSGIX(dpy, timeSlice, attrib, size, attribList, returnAttribList)
+ return int
+ param dpy Display out reference
+ param timeSlice int in value
+ param attrib int in value
+ param size int in value
+ param attribList void out array [COMPSIZE(size)]
+ param returnAttribList void out array [COMPSIZE(size)]
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx ???
+
+HyperpipeAttribSGIX(dpy, timeSlice, attrib, size, attribList)
+ return int
+ param dpy Display out reference
+ param timeSlice int in value
+ param attrib int in value
+ param size int in value
+ param attribList void out array [COMPSIZE(size)]
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx ???
+
+QueryHyperpipeAttribSGIX(dpy, timeSlice, attrib, size, returnAttribList)
+ return int
+ param dpy Display out reference
+ param timeSlice int in value
+ param attrib int in value
+ param size int in value
+ param returnAttribList void out array [COMPSIZE(size)]
+ glxflags client-handcode server-handcode
+ category SGIX_hyperpipe
+ glxvendorglx ???
+
+###############################################################################
+#
+# Extension #308
+# MESA_agp_offset commands
+#
+###############################################################################
+
+GetAGPOffsetMESA(pointer)
+ return uint
+ param pointer void in reference
+ glxflags client-handcode client-intercept server-handcode
+ category MESA_agp_offset
diff --git a/Source/Bind/Specifications/wgl.spec b/Source/Bind/Specifications/wgl.spec
new file mode 100644
index 00000000..28ab0352
--- /dev/null
+++ b/Source/Bind/Specifications/wgl.spec
@@ -0,0 +1,187 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2002 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+
+required-props:
+param: retval retained
+dlflags: notlistable handcode nop
+wglflags: client-handcode server-handcode non-dispatch
+vectorequiv: *
+category: wgl
+
+CreateContext( hDc )
+ return HGLRC
+ param hDc HDC in value
+ category wgl
+ dlflags notlistable handcode
+ wglflags non-dispatch
+
+DeleteContext( oldContext )
+ return BOOL
+ param oldContext HGLRC in value
+ category wgl
+ dlflags notlistable handcode
+ wglflags non-dispatch
+
+GetCurrentContext( )
+ return HGLRC
+ category wgl
+ dlflags notlistable handcode
+ wglflags non-dispatch
+
+MakeCurrent( hDc, newContext )
+ return BOOL
+ param hDc HDC in value
+ param newContext HGLRC in value
+ category wgl
+ dlflags notlistable
+ wglflags non-dispatch
+
+CopyContext( hglrcSrc, hglrcDst, mask )
+ return BOOL
+ param hglrcSrc HGLRC in value
+ param hglrcDst HGLRC in value
+ param mask UINT in value
+ category wgl
+ dlflags notlistable
+ wglflags non-dispatch
+
+ChoosePixelFormat( hDc, pPfd )
+ return int
+ param hDc HDC in value
+ param pPfd PIXELFORMATDESCRIPTOR in reference
+ category wgl
+ dlflags notlistable
+ wglflags non-dispatch
+
+DescribePixelFormat( hdc, ipfd, cjpfd, ppfd )
+ return int
+ param hdc HDC in value
+ param ipfd int in value
+ param cjpfd UINT in value
+ param ppfd PIXELFORMATDESCRIPTOR in reference
+
+GetCurrentDC( )
+ return HDC
+ category wgl
+
+GetDefaultProcAddress( lpszProc)
+ return PROC
+ param lpszProc LPCSTR in value
+ category wgl
+
+GetProcAddress( lpszProc)
+ return PROC
+ param lpszProc LPCSTR in value
+ category wgl
+
+GetPixelFormat( hdc )
+ return int
+ param hdc HDC in value
+ category wgl
+
+SetPixelFormat( hdc, ipfd, ppfd )
+ return BOOL
+ param hdc HDC in value
+ param ipfd int in value
+ param ppfd PIXELFORMATDESCRIPTOR in reference
+ category wgl
+
+SwapBuffers( hdc )
+ return BOOL
+ param hdc HDC in value
+ category wgl
+
+ShareLists( hrcSrvShare, hrcSrvSource)
+ return BOOL
+ param hrcSrvShare HGLRC in value
+ param hrcSrvSource HGLRC in value
+ category wgl
+
+CreateLayerContext( hDc, level )
+ return HGLRC
+ param hDc HDC in value
+ param level int in value
+ category wgl
+
+DescribeLayerPlane( hDc, pixelFormat, layerPlane, nBytes, plpd )
+ return BOOL
+ param hDc HDC in value
+ param pixelFormat int in value
+ param layerPlane int in value
+ param nBytes UINT in value
+ param plpd LAYERPLANEDESCRIPTOR in reference
+ category wgl
+
+SetLayerPaletteEntries( hdc, iLayerPlane, iStart, cEntries, pcr )
+ return int
+ param hdc HDC in value
+ param iLayerPlane int in value
+ param iStart int in value
+ param cEntries int in value
+ param pcr COLORREF in reference
+ category wgl
+
+GetLayerPaletteEntries( hdc, iLayerPlane, iStart, cEntries, pcr )
+ return int
+ param hdc HDC in value
+ param iLayerPlane int in value
+ param iStart int in value
+ param cEntries int in value
+ param pcr COLORREF in reference
+ category wgl
+
+RealizeLayerPalette( hdc, iLayerPlane, bRealize )
+ return BOOL
+ param hdc HDC in value
+ param iLayerPlane int in value
+ param bRealize BOOL in value
+ category wgl
+
+SwapLayerBuffers( hdc, fuFlags )
+ return BOOL
+ param hdc HDC in value
+ param fuFlags UINT in value
+ category wgl
+
+UseFontBitmapsA( hDC, first, count, listBase )
+ return BOOL
+ param hDC HDC in value
+ param first DWORD in value
+ param count DWORD in value
+ param listBase DWORD in value
+ category wgl
+ dlflags notlistable
+
+UseFontBitmapsW( hDC, first, count, listBase )
+ return BOOL
+ param hDC HDC in value
+ param first DWORD in value
+ param count DWORD in value
+ param listBase DWORD in value
+ category wgl
+ dlflags notlistable
+
diff --git a/Source/Bind/Specifications/wgl.tm b/Source/Bind/Specifications/wgl.tm
new file mode 100644
index 00000000..e486d983
--- /dev/null
+++ b/Source/Bind/Specifications/wgl.tm
@@ -0,0 +1,24 @@
+BOOL,*,*, BOOL,*,*
+DWORD,*,*, DWORD,*,*
+FLOAT,*,*, FLOAT,*,*
+GLboolean,*,*, GLboolean,*,*
+GLfloat,*,*, GLfloat,*,*
+GLsizei,*,*, GLsizei,*,*
+GLuint,*,*, GLuint,*,*
+GLushort,*,*, GLushort,*,*
+HANDLE,*,*, HANDLE,*,*
+HDC,*,*, HDC,*,*
+HGLRC,*,*, HGLRC,*,*
+HPBUFFERARB,*,*, HPBUFFERARB,*,*
+HPBUFFEREXT,*,*, HPBUFFEREXT,*,*
+INT32,*,*, INT32,*,*
+INT64,*,*, INT64,*,*
+LPVOID,*,*, LPVOID,*,*
+String,*,*, const char *,*,*
+UINT,*,*, UINT,*,*
+USHORT,*,*, USHORT,*,*
+VOID,*,*, VOID,*,*
+VoidPointer,*,*, void*,*,*
+float,*,*, float,*,*
+int,*,*, int,*,*
+void,*,*, *,*,*
diff --git a/Source/Bind/Specifications/wglenum.spec b/Source/Bind/Specifications/wglenum.spec
new file mode 100644
index 00000000..c2b28eff
--- /dev/null
+++ b/Source/Bind/Specifications/wglenum.spec
@@ -0,0 +1,359 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2005 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+#
+# $Date: 2005/01/20 08:44:12 $ $Revision: 1.6 $
+# $Header: /oss/CVS/cvs/projects/ogl-sample/main/doc/registry/specs/wglenum.spec,v 1.6 2005/01/20 08:44:12 ljp Exp $
+
+# This is the master WGL enumerant registry.
+#
+# It is an extremely important file. Do not mess with it unless
+# you know what you're doing and have permission to do so.
+#
+# Rules for modification are similar to the rules for the OpenGL
+# enumerant registry (gl.spec). Basically, don't modify this file
+# unless you're SGI's ARB Representative. In principle Microsoft
+# owns the WGL registry, but they have for practical purposes
+# ceded administration of it to SGI.
+#
+# Finally, note that this registry does not currently include
+# any core WGL enumerants - only enumerants defined by WGL
+# extensions.
+
+###############################################################################
+
+# Bitmasks - not consumed by the registry
+WGL_ARB_buffer_region enum:
+ WGL_FRONT_COLOR_BUFFER_BIT_ARB = 0x00000001
+ WGL_BACK_COLOR_BUFFER_BIT_ARB = 0x00000002
+ WGL_DEPTH_BUFFER_BIT_ARB = 0x00000004
+ WGL_STENCIL_BUFFER_BIT_ARB = 0x00000008
+
+###############################################################################
+
+# SGI: 0x2000-0x203F
+
+WGL_EXT_pixel_format enum:
+ WGL_NUMBER_PIXEL_FORMATS_EXT = 0x2000
+ WGL_DRAW_TO_WINDOW_EXT = 0x2001
+ WGL_DRAW_TO_BITMAP_EXT = 0x2002
+ WGL_ACCELERATION_EXT = 0x2003
+ WGL_NEED_PALETTE_EXT = 0x2004
+ WGL_NEED_SYSTEM_PALETTE_EXT = 0x2005
+ WGL_SWAP_LAYER_BUFFERS_EXT = 0x2006
+ WGL_SWAP_METHOD_EXT = 0x2007
+ WGL_NUMBER_OVERLAYS_EXT = 0x2008
+ WGL_NUMBER_UNDERLAYS_EXT = 0x2009
+ WGL_TRANSPARENT_EXT = 0x200A
+ WGL_TRANSPARENT_VALUE_EXT = 0x200B
+ WGL_SHARE_DEPTH_EXT = 0x200C
+ WGL_SHARE_STENCIL_EXT = 0x200D
+ WGL_SHARE_ACCUM_EXT = 0x200E
+ WGL_SUPPORT_GDI_EXT = 0x200F
+ WGL_SUPPORT_OPENGL_EXT = 0x2010
+ WGL_DOUBLE_BUFFER_EXT = 0x2011
+ WGL_STEREO_EXT = 0x2012
+ WGL_PIXEL_TYPE_EXT = 0x2013
+ WGL_COLOR_BITS_EXT = 0x2014
+ WGL_RED_BITS_EXT = 0x2015
+ WGL_RED_SHIFT_EXT = 0x2016
+ WGL_GREEN_BITS_EXT = 0x2017
+ WGL_GREEN_SHIFT_EXT = 0x2018
+ WGL_BLUE_BITS_EXT = 0x2019
+ WGL_BLUE_SHIFT_EXT = 0x201A
+ WGL_ALPHA_BITS_EXT = 0x201B
+ WGL_ALPHA_SHIFT_EXT = 0x201C
+ WGL_ACCUM_BITS_EXT = 0x201D
+ WGL_ACCUM_RED_BITS_EXT = 0x201E
+ WGL_ACCUM_GREEN_BITS_EXT = 0x201F
+ WGL_ACCUM_BLUE_BITS_EXT = 0x2020
+ WGL_ACCUM_ALPHA_BITS_EXT = 0x2021
+ WGL_DEPTH_BITS_EXT = 0x2022
+ WGL_STENCIL_BITS_EXT = 0x2023
+ WGL_AUX_BUFFERS_EXT = 0x2024
+ WGL_NO_ACCELERATION_EXT = 0x2025
+ WGL_GENERIC_ACCELERATION_EXT = 0x2026
+ WGL_FULL_ACCELERATION_EXT = 0x2027
+ WGL_SWAP_EXCHANGE_EXT = 0x2028
+ WGL_SWAP_COPY_EXT = 0x2029
+ WGL_SWAP_UNDEFINED_EXT = 0x202A
+ WGL_TYPE_RGBA_EXT = 0x202B
+ WGL_TYPE_COLORINDEX_EXT = 0x202C
+
+WGL_ARB_pixel_format enum:
+ WGL_NUMBER_PIXEL_FORMATS_ARB = 0x2000
+ WGL_DRAW_TO_WINDOW_ARB = 0x2001
+ WGL_DRAW_TO_BITMAP_ARB = 0x2002
+ WGL_ACCELERATION_ARB = 0x2003
+ WGL_NEED_PALETTE_ARB = 0x2004
+ WGL_NEED_SYSTEM_PALETTE_ARB = 0x2005
+ WGL_SWAP_LAYER_BUFFERS_ARB = 0x2006
+ WGL_SWAP_METHOD_ARB = 0x2007
+ WGL_NUMBER_OVERLAYS_ARB = 0x2008
+ WGL_NUMBER_UNDERLAYS_ARB = 0x2009
+ WGL_TRANSPARENT_ARB = 0x200A
+ WGL_SHARE_DEPTH_ARB = 0x200C
+ WGL_SHARE_STENCIL_ARB = 0x200D
+ WGL_SHARE_ACCUM_ARB = 0x200E
+ WGL_SUPPORT_GDI_ARB = 0x200F
+ WGL_SUPPORT_OPENGL_ARB = 0x2010
+ WGL_DOUBLE_BUFFER_ARB = 0x2011
+ WGL_STEREO_ARB = 0x2012
+ WGL_PIXEL_TYPE_ARB = 0x2013
+ WGL_COLOR_BITS_ARB = 0x2014
+ WGL_RED_BITS_ARB = 0x2015
+ WGL_RED_SHIFT_ARB = 0x2016
+ WGL_GREEN_BITS_ARB = 0x2017
+ WGL_GREEN_SHIFT_ARB = 0x2018
+ WGL_BLUE_BITS_ARB = 0x2019
+ WGL_BLUE_SHIFT_ARB = 0x201A
+ WGL_ALPHA_BITS_ARB = 0x201B
+ WGL_ALPHA_SHIFT_ARB = 0x201C
+ WGL_ACCUM_BITS_ARB = 0x201D
+ WGL_ACCUM_RED_BITS_ARB = 0x201E
+ WGL_ACCUM_GREEN_BITS_ARB = 0x201F
+ WGL_ACCUM_BLUE_BITS_ARB = 0x2020
+ WGL_ACCUM_ALPHA_BITS_ARB = 0x2021
+ WGL_DEPTH_BITS_ARB = 0x2022
+ WGL_STENCIL_BITS_ARB = 0x2023
+ WGL_AUX_BUFFERS_ARB = 0x2024
+ WGL_NO_ACCELERATION_ARB = 0x2025
+ WGL_GENERIC_ACCELERATION_ARB = 0x2026
+ WGL_FULL_ACCELERATION_ARB = 0x2027
+ WGL_SWAP_EXCHANGE_ARB = 0x2028
+ WGL_SWAP_COPY_ARB = 0x2029
+ WGL_SWAP_UNDEFINED_ARB = 0x202A
+ WGL_TYPE_RGBA_ARB = 0x202B
+ WGL_TYPE_COLORINDEX_ARB = 0x202C
+ WGL_DRAW_TO_PBUFFER_ARB = 0x202D
+ WGL_MAX_PBUFFER_PIXELS_ARB = 0x202E
+ WGL_MAX_PBUFFER_WIDTH_ARB = 0x202F
+ WGL_MAX_PBUFFER_HEIGHT_ARB = 0x2030
+ WGL_PBUFFER_LARGEST_ARB = 0x2033
+ WGL_PBUFFER_WIDTH_ARB = 0x2034
+ WGL_PBUFFER_HEIGHT_ARB = 0x2035
+ WGL_TRANSPARENT_RED_VALUE_ARB = 0x2037
+ WGL_TRANSPARENT_GREEN_VALUE_ARB = 0x2038
+ WGL_TRANSPARENT_BLUE_VALUE_ARB = 0x2039
+ WGL_TRANSPARENT_ALPHA_VALUE_ARB = 0x203A
+ WGL_TRANSPARENT_INDEX_VALUE_ARB = 0x203B
+
+###############################################################################
+
+WGL_EXT_pbuffer enum:
+ WGL_DRAW_TO_PBUFFER_EXT = 0x202D
+ WGL_MAX_PBUFFER_PIXELS_EXT = 0x202E
+ WGL_MAX_PBUFFER_WIDTH_EXT = 0x202F
+ WGL_MAX_PBUFFER_HEIGHT_EXT = 0x2030
+ WGL_OPTIMAL_PBUFFER_WIDTH_EXT = 0x2031
+ WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = 0x2032
+ WGL_PBUFFER_LARGEST_EXT = 0x2033
+ WGL_PBUFFER_WIDTH_EXT = 0x2034
+ WGL_PBUFFER_HEIGHT_EXT = 0x2035
+
+WGL_ARB_pbuffer enum:
+ WGL_DRAW_TO_PBUFFER_ARB = 0x202D
+ WGL_MAX_PBUFFER_PIXELS_ARB = 0x202E
+ WGL_MAX_PBUFFER_WIDTH_ARB = 0x202F
+ WGL_MAX_PBUFFER_HEIGHT_ARB = 0x2030
+ WGL_PBUFFER_LARGEST_ARB = 0x2033
+ WGL_PBUFFER_WIDTH_ARB = 0x2034
+ WGL_PBUFFER_HEIGHT_ARB = 0x2035
+ WGL_PBUFFER_LOST_ARB = 0x2036
+ use WGL_ARB_pixel_format WGL_TRANSPARENT_RED_VALUE_ARB
+ use WGL_ARB_pixel_format WGL_TRANSPARENT_GREEN_VALUE_ARB
+ use WGL_ARB_pixel_format WGL_TRANSPARENT_BLUE_VALUE_ARB
+ use WGL_ARB_pixel_format WGL_TRANSPARENT_ALPHA_VALUE_ARB
+ use WGL_ARB_pixel_format WGL_TRANSPARENT_INDEX_VALUE_ARB
+
+###############################################################################
+
+# SGI_future_use: 0x203C-0x203F
+
+###############################################################################
+
+# Intense3D: 0x2040-0x205F
+
+WGL_EXT_depth_float enum:
+ WGL_DEPTH_FLOAT_EXT = 0x2040
+
+###############################################################################
+
+WGL_EXT_multisample enum:
+ WGL_SAMPLE_BUFFERS_EXT = 0x2041
+ WGL_SAMPLES_EXT = 0x2042
+
+WGL_ARB_multisample enum:
+ WGL_SAMPLE_BUFFERS_ARB = 0x2041
+ WGL_SAMPLES_ARB = 0x2042
+
+###############################################################################
+
+WGL_EXT_make_current_read enum:
+ ERROR_INVALID_PIXEL_TYPE_EXT = 0x2043
+
+WGL_ARB_make_current_read enum:
+ ERROR_INVALID_PIXEL_TYPE_ARB = 0x2043
+ ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = 0x2054
+
+###############################################################################
+
+WGL_I3D_genlock enum:
+ WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = 0x2044
+ WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = 0x2045
+ WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = 0x2046
+ WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = 0x2047
+ WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = 0x2048
+ WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = 0x2049
+ WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = 0x204A
+ WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = 0x204B
+ WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = 0x204C
+
+###############################################################################
+
+# Intense3D_future_use: 0x204D
+
+###############################################################################
+
+WGL_I3D_gamma enum:
+ WGL_GAMMA_TABLE_SIZE_I3D = 0x204E
+ WGL_GAMMA_EXCLUDE_DESKTOP_I3D = 0x204F
+
+###############################################################################
+
+# Intense3D hasn't spec'ed this extension, but it's in the enum registry
+WGL_I3D_digital_video_control enum:
+ WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = 0x2050
+ WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = 0x2051
+ WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = 0x2052
+ WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = 0x2053
+
+###############################################################################
+
+# WGL_ARB_make_current_read (additional; see above): 0x2054
+
+###############################################################################
+
+# Intense3D_future_use: 0x2055-0x205F
+
+###############################################################################
+
+# 3DFX: 0x2060-0x206F
+
+WGL_3DFX_multisample enum:
+ WGL_SAMPLE_BUFFERS_3DFX = 0x2060
+ WGL_SAMPLES_3DFX = 0x2061
+
+###############################################################################
+
+# ARB: 0x2070-0x209F
+
+WGL_ARB_render_texture enum:
+ WGL_BIND_TO_TEXTURE_RGB_ARB = 0x2070
+ WGL_BIND_TO_TEXTURE_RGBA_ARB = 0x2071
+ WGL_TEXTURE_FORMAT_ARB = 0x2072
+ WGL_TEXTURE_TARGET_ARB = 0x2073
+ WGL_MIPMAP_TEXTURE_ARB = 0x2074
+ WGL_TEXTURE_RGB_ARB = 0x2075
+ WGL_TEXTURE_RGBA_ARB = 0x2076
+ WGL_NO_TEXTURE_ARB = 0x2077
+ WGL_TEXTURE_CUBE_MAP_ARB = 0x2078
+ WGL_TEXTURE_1D_ARB = 0x2079
+ WGL_TEXTURE_2D_ARB = 0x207A
+ WGL_MIPMAP_LEVEL_ARB = 0x207B
+ WGL_CUBE_MAP_FACE_ARB = 0x207C
+ WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x207D
+ WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x207E
+ WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x207F
+ WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x2080
+ WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x2081
+ WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x2082
+ WGL_FRONT_LEFT_ARB = 0x2083
+ WGL_FRONT_RIGHT_ARB = 0x2084
+ WGL_BACK_LEFT_ARB = 0x2085
+ WGL_BACK_RIGHT_ARB = 0x2086
+ WGL_AUX0_ARB = 0x2087
+ WGL_AUX1_ARB = 0x2088
+ WGL_AUX2_ARB = 0x2089
+ WGL_AUX3_ARB = 0x208A
+ WGL_AUX4_ARB = 0x208B
+ WGL_AUX5_ARB = 0x208C
+ WGL_AUX6_ARB = 0x208D
+ WGL_AUX7_ARB = 0x208E
+ WGL_AUX8_ARB = 0x208F
+ WGL_AUX9_ARB = 0x2090
+
+# ARB_future_use: 0x2091-0x209F
+
+###############################################################################
+
+# NVIDIA: 0x20A0-0x219F
+
+WGL_NV_render_texture_rectangle enum:
+ WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = 0x20A0
+ WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 0x20A1
+ WGL_TEXTURE_RECTANGLE_NV = 0x20A2
+
+WGL_NV_render_depth_texture enum:
+ WGL_BIND_TO_TEXTURE_DEPTH_NV = 0x20A3
+ WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 0x20A4
+ WGL_DEPTH_TEXTURE_FORMAT_NV = 0x20A5
+ WGL_TEXTURE_DEPTH_COMPONENT_NV = 0x20A6
+ WGL_DEPTH_COMPONENT_NV = 0x20A7
+
+# NV_future_use: 0x20A8-0x20AF
+
+WGL_NV_float_buffer enum:
+ WGL_FLOAT_COMPONENTS_NV = 0x20B0
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = 0x20B1
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = 0x20B2
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = 0x20B3
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 0x20B4
+ WGL_TEXTURE_FLOAT_R_NV = 0x20B5
+ WGL_TEXTURE_FLOAT_RG_NV = 0x20B6
+ WGL_TEXTURE_FLOAT_RGB_NV = 0x20B7
+ WGL_TEXTURE_FLOAT_RGBA_NV = 0x20B8
+
+# NV_future_use: 0x20B9-0x219F
+
+###############################################################################
+
+# ATI: 0x21A0-0x21AF
+WGL_ARB_pixel_format_float enum:
+ WGL_TYPE_RGBA_FLOAT_ARB = 0x21A0
+
+WGL_ATI_pixel_format_float enum:
+ WGL_TYPE_RGBA_FLOAT_ATI = 0x21A0
+
+# ATI_future_use: 0x21A1-0x21AF
+
+###############################################################################
+
+# Matrox: 0x21B0-0x21BF (tentative, RFC sent to ARB 2002/10/3)
+
+###############################################################################
+
+# Any_vendor_future_use: 0x21C0-0xFFFF
diff --git a/Source/Bind/Specifications/wglenumext.spec b/Source/Bind/Specifications/wglenumext.spec
new file mode 100644
index 00000000..e1240fef
--- /dev/null
+++ b/Source/Bind/Specifications/wglenumext.spec
@@ -0,0 +1,382 @@
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2005 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+#
+# $Date: 2005/01/20 08:44:12 $ $Revision: 1.8 $
+# $Header: /oss/CVS/cvs/projects/ogl-sample/main/doc/registry/specs/wglenumext.spec,v 1.8 2005/01/20 08:44:12 ljp Exp $
+
+# List of WGL enumerants for wglext.h header
+#
+# This is NOT the master WGL enumerant registry. Microsoft used
+# to maintain that, but given their limited interest in OpenGL,
+# SGI now maintains the registry in wglenum.spec.
+#
+# Unlike wglenum.spec, wglenumext.spec is
+# (1) In order by extension number
+# (2) Includes only WGL extensions.
+# (3) Has no 'Extensions' section, since enums are always
+# conditionally protected against multiple definition
+# by glextenum.pl.
+# (4) Is processed by glextenum.pl, which has evolved
+# from enum.pl - should merge back into one script.
+
+# wglext.h version number - this should be automatically updated,
+# when changing either enum or template spec files.
+
+passthru:
+passthru: /* Header file version number */
+passthru: /* wglext.h last updated 2005/01/07 */
+passthru: /* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */
+passthru: #define WGL_WGLEXT_VERSION 6
+
+###############################################################################
+#
+# ARB WGL extensions, in ARB extension order
+#
+###############################################################################
+
+###############################################################################
+
+# ARB Extension #4
+WGL_ARB_buffer_region enum:
+ WGL_FRONT_COLOR_BUFFER_BIT_ARB = 0x00000001
+ WGL_BACK_COLOR_BUFFER_BIT_ARB = 0x00000002
+ WGL_DEPTH_BUFFER_BIT_ARB = 0x00000004
+ WGL_STENCIL_BUFFER_BIT_ARB = 0x00000008
+
+###############################################################################
+
+# ARB Extension #5
+WGL_ARB_multisample enum:
+ WGL_SAMPLE_BUFFERS_ARB = 0x2041
+ WGL_SAMPLES_ARB = 0x2042
+
+###############################################################################
+
+# No new tokens
+# ARB Extension #8
+WGL_ARB_extensions_string enum:
+
+###############################################################################
+
+# ARB Extension #9
+WGL_ARB_pixel_format enum:
+ WGL_NUMBER_PIXEL_FORMATS_ARB = 0x2000
+ WGL_DRAW_TO_WINDOW_ARB = 0x2001
+ WGL_DRAW_TO_BITMAP_ARB = 0x2002
+ WGL_ACCELERATION_ARB = 0x2003
+ WGL_NEED_PALETTE_ARB = 0x2004
+ WGL_NEED_SYSTEM_PALETTE_ARB = 0x2005
+ WGL_SWAP_LAYER_BUFFERS_ARB = 0x2006
+ WGL_SWAP_METHOD_ARB = 0x2007
+ WGL_NUMBER_OVERLAYS_ARB = 0x2008
+ WGL_NUMBER_UNDERLAYS_ARB = 0x2009
+ WGL_TRANSPARENT_ARB = 0x200A
+ WGL_TRANSPARENT_RED_VALUE_ARB = 0x2037
+ WGL_TRANSPARENT_GREEN_VALUE_ARB = 0x2038
+ WGL_TRANSPARENT_BLUE_VALUE_ARB = 0x2039
+ WGL_TRANSPARENT_ALPHA_VALUE_ARB = 0x203A
+ WGL_TRANSPARENT_INDEX_VALUE_ARB = 0x203B
+ WGL_SHARE_DEPTH_ARB = 0x200C
+ WGL_SHARE_STENCIL_ARB = 0x200D
+ WGL_SHARE_ACCUM_ARB = 0x200E
+ WGL_SUPPORT_GDI_ARB = 0x200F
+ WGL_SUPPORT_OPENGL_ARB = 0x2010
+ WGL_DOUBLE_BUFFER_ARB = 0x2011
+ WGL_STEREO_ARB = 0x2012
+ WGL_PIXEL_TYPE_ARB = 0x2013
+ WGL_COLOR_BITS_ARB = 0x2014
+ WGL_RED_BITS_ARB = 0x2015
+ WGL_RED_SHIFT_ARB = 0x2016
+ WGL_GREEN_BITS_ARB = 0x2017
+ WGL_GREEN_SHIFT_ARB = 0x2018
+ WGL_BLUE_BITS_ARB = 0x2019
+ WGL_BLUE_SHIFT_ARB = 0x201A
+ WGL_ALPHA_BITS_ARB = 0x201B
+ WGL_ALPHA_SHIFT_ARB = 0x201C
+ WGL_ACCUM_BITS_ARB = 0x201D
+ WGL_ACCUM_RED_BITS_ARB = 0x201E
+ WGL_ACCUM_GREEN_BITS_ARB = 0x201F
+ WGL_ACCUM_BLUE_BITS_ARB = 0x2020
+ WGL_ACCUM_ALPHA_BITS_ARB = 0x2021
+ WGL_DEPTH_BITS_ARB = 0x2022
+ WGL_STENCIL_BITS_ARB = 0x2023
+ WGL_AUX_BUFFERS_ARB = 0x2024
+ WGL_NO_ACCELERATION_ARB = 0x2025
+ WGL_GENERIC_ACCELERATION_ARB = 0x2026
+ WGL_FULL_ACCELERATION_ARB = 0x2027
+ WGL_SWAP_EXCHANGE_ARB = 0x2028
+ WGL_SWAP_COPY_ARB = 0x2029
+ WGL_SWAP_UNDEFINED_ARB = 0x202A
+ WGL_TYPE_RGBA_ARB = 0x202B
+ WGL_TYPE_COLORINDEX_ARB = 0x202C
+
+###############################################################################
+
+# ARB Extension #10
+WGL_ARB_make_current_read enum:
+ ERROR_INVALID_PIXEL_TYPE_ARB = 0x2043
+ ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = 0x2054
+
+###############################################################################
+
+# ARB Extension #11
+WGL_ARB_pbuffer enum:
+ WGL_DRAW_TO_PBUFFER_ARB = 0x202D
+ WGL_MAX_PBUFFER_PIXELS_ARB = 0x202E
+ WGL_MAX_PBUFFER_WIDTH_ARB = 0x202F
+ WGL_MAX_PBUFFER_HEIGHT_ARB = 0x2030
+ WGL_PBUFFER_LARGEST_ARB = 0x2033
+ WGL_PBUFFER_WIDTH_ARB = 0x2034
+ WGL_PBUFFER_HEIGHT_ARB = 0x2035
+ WGL_PBUFFER_LOST_ARB = 0x2036
+ WGL_TRANSPARENT_RED_VALUE_ARB = 0x2037
+ WGL_TRANSPARENT_GREEN_VALUE_ARB = 0x2038
+ WGL_TRANSPARENT_BLUE_VALUE_ARB = 0x2039
+ WGL_TRANSPARENT_ALPHA_VALUE_ARB = 0x203A
+ WGL_TRANSPARENT_INDEX_VALUE_ARB = 0x203B
+
+###############################################################################
+
+# ARB Extension #20
+WGL_ARB_render_texture enum:
+ WGL_BIND_TO_TEXTURE_RGB_ARB = 0x2070
+ WGL_BIND_TO_TEXTURE_RGBA_ARB = 0x2071
+ WGL_TEXTURE_FORMAT_ARB = 0x2072
+ WGL_TEXTURE_TARGET_ARB = 0x2073
+ WGL_MIPMAP_TEXTURE_ARB = 0x2074
+ WGL_TEXTURE_RGB_ARB = 0x2075
+ WGL_TEXTURE_RGBA_ARB = 0x2076
+ WGL_NO_TEXTURE_ARB = 0x2077
+ WGL_TEXTURE_CUBE_MAP_ARB = 0x2078
+ WGL_TEXTURE_1D_ARB = 0x2079
+ WGL_TEXTURE_2D_ARB = 0x207A
+ WGL_MIPMAP_LEVEL_ARB = 0x207B
+ WGL_CUBE_MAP_FACE_ARB = 0x207C
+ WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x207D
+ WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x207E
+ WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x207F
+ WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x2080
+ WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x2081
+ WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x2082
+ WGL_FRONT_LEFT_ARB = 0x2083
+ WGL_FRONT_RIGHT_ARB = 0x2084
+ WGL_BACK_LEFT_ARB = 0x2085
+ WGL_BACK_RIGHT_ARB = 0x2086
+ WGL_AUX0_ARB = 0x2087
+ WGL_AUX1_ARB = 0x2088
+ WGL_AUX2_ARB = 0x2089
+ WGL_AUX3_ARB = 0x208A
+ WGL_AUX4_ARB = 0x208B
+ WGL_AUX5_ARB = 0x208C
+ WGL_AUX6_ARB = 0x208D
+ WGL_AUX7_ARB = 0x208E
+ WGL_AUX8_ARB = 0x208F
+ WGL_AUX9_ARB = 0x2090
+
+###############################################################################
+
+# ARB Extension #39
+WGL_ARB_pixel_format_float enum:
+ WGL_TYPE_RGBA_FLOAT_ARB = 0x21A0
+
+
+###############################################################################
+#
+# non-ARB extensions follow, in registry order
+#
+###############################################################################
+
+###############################################################################
+
+# Extension #169
+WGL_EXT_make_current_read enum:
+ ERROR_INVALID_PIXEL_TYPE_EXT = 0x2043
+
+###############################################################################
+
+# Extension #170
+WGL_EXT_pixel_format enum:
+ WGL_NUMBER_PIXEL_FORMATS_EXT = 0x2000
+ WGL_DRAW_TO_WINDOW_EXT = 0x2001
+ WGL_DRAW_TO_BITMAP_EXT = 0x2002
+ WGL_ACCELERATION_EXT = 0x2003
+ WGL_NEED_PALETTE_EXT = 0x2004
+ WGL_NEED_SYSTEM_PALETTE_EXT = 0x2005
+ WGL_SWAP_LAYER_BUFFERS_EXT = 0x2006
+ WGL_SWAP_METHOD_EXT = 0x2007
+ WGL_NUMBER_OVERLAYS_EXT = 0x2008
+ WGL_NUMBER_UNDERLAYS_EXT = 0x2009
+ WGL_TRANSPARENT_EXT = 0x200A
+ WGL_TRANSPARENT_VALUE_EXT = 0x200B
+ WGL_SHARE_DEPTH_EXT = 0x200C
+ WGL_SHARE_STENCIL_EXT = 0x200D
+ WGL_SHARE_ACCUM_EXT = 0x200E
+ WGL_SUPPORT_GDI_EXT = 0x200F
+ WGL_SUPPORT_OPENGL_EXT = 0x2010
+ WGL_DOUBLE_BUFFER_EXT = 0x2011
+ WGL_STEREO_EXT = 0x2012
+ WGL_PIXEL_TYPE_EXT = 0x2013
+ WGL_COLOR_BITS_EXT = 0x2014
+ WGL_RED_BITS_EXT = 0x2015
+ WGL_RED_SHIFT_EXT = 0x2016
+ WGL_GREEN_BITS_EXT = 0x2017
+ WGL_GREEN_SHIFT_EXT = 0x2018
+ WGL_BLUE_BITS_EXT = 0x2019
+ WGL_BLUE_SHIFT_EXT = 0x201A
+ WGL_ALPHA_BITS_EXT = 0x201B
+ WGL_ALPHA_SHIFT_EXT = 0x201C
+ WGL_ACCUM_BITS_EXT = 0x201D
+ WGL_ACCUM_RED_BITS_EXT = 0x201E
+ WGL_ACCUM_GREEN_BITS_EXT = 0x201F
+ WGL_ACCUM_BLUE_BITS_EXT = 0x2020
+ WGL_ACCUM_ALPHA_BITS_EXT = 0x2021
+ WGL_DEPTH_BITS_EXT = 0x2022
+ WGL_STENCIL_BITS_EXT = 0x2023
+ WGL_AUX_BUFFERS_EXT = 0x2024
+ WGL_NO_ACCELERATION_EXT = 0x2025
+ WGL_GENERIC_ACCELERATION_EXT = 0x2026
+ WGL_FULL_ACCELERATION_EXT = 0x2027
+ WGL_SWAP_EXCHANGE_EXT = 0x2028
+ WGL_SWAP_COPY_EXT = 0x2029
+ WGL_SWAP_UNDEFINED_EXT = 0x202A
+ WGL_TYPE_RGBA_EXT = 0x202B
+ WGL_TYPE_COLORINDEX_EXT = 0x202C
+
+###############################################################################
+
+# Extension #171
+WGL_EXT_pbuffer enum:
+ WGL_DRAW_TO_PBUFFER_EXT = 0x202D
+ WGL_MAX_PBUFFER_PIXELS_EXT = 0x202E
+ WGL_MAX_PBUFFER_WIDTH_EXT = 0x202F
+ WGL_MAX_PBUFFER_HEIGHT_EXT = 0x2030
+ WGL_OPTIMAL_PBUFFER_WIDTH_EXT = 0x2031
+ WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = 0x2032
+ WGL_PBUFFER_LARGEST_EXT = 0x2033
+ WGL_PBUFFER_WIDTH_EXT = 0x2034
+ WGL_PBUFFER_HEIGHT_EXT = 0x2035
+
+###############################################################################
+
+# Extension #177
+WGL_EXT_depth_float enum:
+ WGL_DEPTH_FLOAT_EXT = 0x2040
+
+###############################################################################
+
+# Extension #207
+WGL_3DFX_multisample enum:
+ WGL_SAMPLE_BUFFERS_3DFX = 0x2060
+ WGL_SAMPLES_3DFX = 0x2061
+
+###############################################################################
+
+# Extension #209
+WGL_EXT_multisample enum:
+ WGL_SAMPLE_BUFFERS_EXT = 0x2041
+ WGL_SAMPLES_EXT = 0x2042
+
+###############################################################################
+
+# Extension #250
+WGL_I3D_digital_video_control enum:
+ WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = 0x2050
+ WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = 0x2051
+ WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = 0x2052
+ WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = 0x2053
+
+###############################################################################
+
+# Extension #251
+WGL_I3D_gamma enum:
+ WGL_GAMMA_TABLE_SIZE_I3D = 0x204E
+ WGL_GAMMA_EXCLUDE_DESKTOP_I3D = 0x204F
+
+###############################################################################
+
+# Extension #252
+WGL_I3D_genlock enum:
+ WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = 0x2044
+ WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = 0x2045
+ WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = 0x2046
+ WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = 0x2047
+ WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = 0x2048
+ WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = 0x2049
+ WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = 0x204A
+ WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = 0x204B
+ WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = 0x204C
+
+###############################################################################
+
+# Extension #253
+WGL_I3D_image_buffer enum:
+ WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = 0x00000001
+ WGL_IMAGE_BUFFER_LOCK_I3D = 0x00000002
+
+###############################################################################
+
+# No new tokens
+# Extension #254
+WGL_I3D_swap_frame_lock enum:
+
+###############################################################################
+
+# Extension #263
+WGL_NV_render_depth_texture enum:
+ WGL_BIND_TO_TEXTURE_DEPTH_NV = 0x20A3
+ WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 0x20A4
+ WGL_DEPTH_TEXTURE_FORMAT_NV = 0x20A5
+ WGL_TEXTURE_DEPTH_COMPONENT_NV = 0x20A6
+ WGL_DEPTH_COMPONENT_NV = 0x20A7
+
+###############################################################################
+
+# Extension #264
+WGL_NV_render_texture_rectangle enum:
+ WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = 0x20A0
+ WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 0x20A1
+ WGL_TEXTURE_RECTANGLE_NV = 0x20A2
+
+###############################################################################
+
+# Extension #278
+WGL_ATI_pixel_format_float enum:
+ WGL_TYPE_RGBA_FLOAT_ATI = 0x21A0
+
+###############################################################################
+
+# Extension #281
+WGL_NV_float_buffer enum:
+ WGL_FLOAT_COMPONENTS_NV = 0x20B0
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = 0x20B1
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = 0x20B2
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = 0x20B3
+ WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = 0x20B4
+ WGL_TEXTURE_FLOAT_R_NV = 0x20B5
+ WGL_TEXTURE_FLOAT_RG_NV = 0x20B6
+ WGL_TEXTURE_FLOAT_RGB_NV = 0x20B7
+ WGL_TEXTURE_FLOAT_RGBA_NV = 0x20B8
diff --git a/Source/Bind/Specifications/wglext.spec b/Source/Bind/Specifications/wglext.spec
new file mode 100644
index 00000000..571701bf
--- /dev/null
+++ b/Source/Bind/Specifications/wglext.spec
@@ -0,0 +1,746 @@
+# wglext.spec file
+# DON'T REMOVE PREVIOUS LINE!!! libspec depends on it!
+#
+# License Applicability. Except to the extent portions of this file are
+# made subject to an alternative license as permitted in the SGI Free
+# Software License B, Version 1.1 (the "License"), the contents of this
+# file are subject only to the provisions of the License. You may not use
+# this file except in compliance with the License. You may obtain a copy
+# of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+# Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+#
+# http://oss.sgi.com/projects/FreeB
+#
+# Note that, as provided in the License, the Software is distributed on an
+# "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+# DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+# CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+# PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+#
+# Original Code. The Original Code is: OpenGL Sample Implementation,
+# Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+# Inc. The Original Code is Copyright (c) 1991-2002 Silicon Graphics, Inc.
+# Copyright in any portions created by third parties is as indicated
+# elsewhere herein. All Rights Reserved.
+#
+# Additional Notice Provisions: This software was created using the
+# OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+# not been independently verified as being compliant with the OpenGL(R)
+# version 1.2.1 Specification.
+
+required-props:
+param: retval retained
+category: wgl ARB_buffer_region ARB_extensions_string ARB_pixel_format ARB_make_current_read ARB_pbuffer ARB_render_texture ARB_pixel_format_float EXT_display_color_table EXT_extensions_string EXT_make_current_read EXT_pbuffer EXT_pixel_format EXT_swap_control OML_sync_control I3D_digital_video_control I3D_gamma I3D_genlock I3D_image_buffer I3D_swap_frame_lock I3D_swap_frame_usage NV_vertex_array_range
+
+# required-props in wgl.spec (which is not used for anything):
+# dlflags: notlistable handcode
+# wglflags: client-handcode server-handcode non-dispatch
+
+#
+# Boilerplate to define types used by some extensions. This is done
+# up front, since it involves some complexities in protecting
+# the declarations whether or not the -protect flag is given to
+# the generator scripts.
+#
+
+passthru: #ifndef WGL_ARB_pbuffer
+passthru: DECLARE_HANDLE(HPBUFFERARB);
+passthru: #endif
+passthru: #ifndef WGL_EXT_pbuffer
+passthru: DECLARE_HANDLE(HPBUFFEREXT);
+passthru: #endif
+passthru:
+
+###############################################################################
+#
+# ARB Extension #4
+# ARB_buffer_region commands
+#
+###############################################################################
+
+CreateBufferRegionARB(hDC, iLayerPlane, uType)
+ return HANDLE
+ param hDC HDC in value
+ param iLayerPlane int in value
+ param uType UINT in value
+ category ARB_buffer_region
+
+DeleteBufferRegionARB(hRegion)
+ return VOID
+ param hRegion HANDLE in value
+ category ARB_buffer_region
+
+SaveBufferRegionARB(hRegion, x, y, width, height)
+ return BOOL
+ param hRegion HANDLE in value
+ param x int in value
+ param y int in value
+ param width int in value
+ param height int in value
+ category ARB_buffer_region
+
+RestoreBufferRegionARB(hRegion, x, y, width, height, xSrc, ySrc)
+ return BOOL
+ param hRegion HANDLE in value
+ param x int in value
+ param y int in value
+ param width int in value
+ param height int in value
+ param xSrc int in value
+ param ySrc int in value
+ category ARB_buffer_region
+
+###############################################################################
+#
+# ARB Extension #5
+# ARB_multisample commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_multisample
+
+###############################################################################
+#
+# ARB Extension #8
+# ARB_extensions_string commands
+#
+###############################################################################
+
+GetExtensionsStringARB(hdc)
+ return String
+ param hdc HDC in value
+ category ARB_extensions_string
+
+###############################################################################
+#
+# ARB Extension #9
+# ARB_pixel_format commands
+#
+###############################################################################
+
+GetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues)
+ return BOOL
+ param hdc HDC in value
+ param iPixelFormat int in value
+ param iLayerPlane int in value
+ param nAttributes UINT in value
+ param piAttributes int in array [nAttributes]
+ param piValues int out array [nAttributes]
+ category ARB_pixel_format
+
+GetPixelFormatAttribfvARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues)
+ return BOOL
+ param hdc HDC in value
+ param iPixelFormat int in value
+ param iLayerPlane int in value
+ param nAttributes UINT in value
+ param piAttributes int in array [nAttributes]
+ param pfValues FLOAT out array [nAttributes]
+ category ARB_pixel_format
+
+ChoosePixelFormatARB(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats)
+ return BOOL
+ param hdc HDC in value
+ param piAttribIList int in array [COMPSIZE()]
+ param pfAttribFList FLOAT in array [COMPSIZE()]
+ param nMaxFormats UINT in value
+ param piFormats int out array [COMPSIZE(nNumFormats)]
+ param nNumFormats UINT out reference
+ category ARB_pixel_format
+
+###############################################################################
+#
+# ARB Extension #10
+# ARB_make_current_read commands
+#
+###############################################################################
+
+MakeContextCurrentARB(hDrawDC, hReadDC, hglrc)
+ return BOOL
+ param hDrawDC HDC in value
+ param hReadDC HDC in value
+ param hglrc HGLRC in value
+ category ARB_make_current_read
+
+GetCurrentReadDCARB()
+ return HDC
+ category ARB_make_current_read
+
+###############################################################################
+#
+# ARB Extension #11
+# ARB_pbuffer commands
+#
+###############################################################################
+
+CreatePbufferARB(hDC, iPixelFormat, iWidth, iHeight, piAttribList)
+ return HPBUFFERARB
+ param hDC HDC in value
+ param iPixelFormat int in value
+ param iWidth int in value
+ param iHeight int in value
+ param piAttribList int in array [COMPSIZE()]
+ category ARB_pbuffer
+
+GetPbufferDCARB(hPbuffer)
+ return HDC
+ param hPbuffer HPBUFFERARB in value
+ category ARB_pbuffer
+
+ReleasePbufferDCARB(hPbuffer, hDC)
+ return int
+ param hPbuffer HPBUFFERARB in value
+ param hDC HDC in value
+ category ARB_pbuffer
+
+DestroyPbufferARB(hPbuffer)
+ return BOOL
+ param hPbuffer HPBUFFERARB in value
+ category ARB_pbuffer
+
+QueryPbufferARB(hPbuffer, iAttribute, piValue)
+ return BOOL
+ param hPbuffer HPBUFFERARB in value
+ param iAttribute int in value
+ param piValue int out reference
+ category ARB_pbuffer
+
+###############################################################################
+#
+# ARB Extension #20
+# ARB_render_texture commands
+#
+###############################################################################
+
+BindTexImageARB(hPbuffer, iBuffer)
+ return BOOL
+ param hPbuffer HPBUFFERARB in value
+ param iBuffer int in value
+ category ARB_render_texture
+
+ReleaseTexImageARB(hPbuffer, iBuffer)
+ return BOOL
+ param hPbuffer HPBUFFERARB in value
+ param iBuffer int in value
+ category ARB_render_texture
+
+SetPbufferAttribARB(hPbuffer, piAttribList)
+ return BOOL
+ param hPbuffer HPBUFFERARB in value
+ param piAttribList int in array [COMPSIZE()]
+ category ARB_render_texture
+
+###############################################################################
+#
+# ARB Extension #39
+# ARB_pixel_format_float commands
+#
+###############################################################################
+
+# (none)
+newcategory: ARB_pixel_format_float
+
+###############################################################################
+#
+# Extension #167
+# EXT_display_color_table commands
+#
+###############################################################################
+
+CreateDisplayColorTableEXT(id)
+ return GLboolean
+ param id GLushort in value
+ category EXT_display_color_table
+
+LoadDisplayColorTableEXT(table, length)
+ return GLboolean
+ param table GLushort in array [length]
+ param length GLuint in value
+ category EXT_display_color_table
+
+BindDisplayColorTableEXT(id)
+ return GLboolean
+ param id GLushort in value
+ category EXT_display_color_table
+
+DestroyDisplayColorTableEXT(id)
+ return VOID
+ param id GLushort in value
+ category EXT_display_color_table
+
+###############################################################################
+#
+# Extension #168
+# EXT_extensions_string commands
+#
+###############################################################################
+
+GetExtensionsStringEXT()
+ return String
+ category EXT_extensions_string
+
+###############################################################################
+#
+# Extension #169
+# EXT_make_current_read commands
+#
+###############################################################################
+
+MakeContextCurrentEXT(hDrawDC, hReadDC, hglrc)
+ return BOOL
+ param hDrawDC HDC in value
+ param hReadDC HDC in value
+ param hglrc HGLRC in value
+ category EXT_make_current_read
+
+GetCurrentReadDCEXT()
+ return HDC
+ category EXT_make_current_read
+
+###############################################################################
+#
+# Extension #171
+# EXT_pbuffer commands
+#
+###############################################################################
+
+CreatePbufferEXT(hDC, iPixelFormat, iWidth, iHeight, piAttribList)
+ return HPBUFFEREXT
+ param hDC HDC in value
+ param iPixelFormat int in value
+ param iWidth int in value
+ param iHeight int in value
+ param piAttribList int in array [COMPSIZE()]
+ category EXT_pbuffer
+
+GetPbufferDCEXT(hPbuffer)
+ return HDC
+ param hPbuffer HPBUFFEREXT in value
+ category EXT_pbuffer
+
+ReleasePbufferDCEXT(hPbuffer, hDC)
+ return int
+ param hPbuffer HPBUFFEREXT in value
+ param hDC HDC in value
+ category EXT_pbuffer
+
+DestroyPbufferEXT(hPbuffer)
+ return BOOL
+ param hPbuffer HPBUFFEREXT in value
+ category EXT_pbuffer
+
+QueryPbufferEXT(hPbuffer, iAttribute, piValue)
+ return BOOL
+ param hPbuffer HPBUFFEREXT in value
+ param iAttribute int in value
+ param piValue int out reference
+ category EXT_pbuffer
+
+###############################################################################
+#
+# Extension #170
+# EXT_pixel_format commands
+#
+###############################################################################
+
+GetPixelFormatAttribivEXT(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues)
+ return BOOL
+ param hdc HDC in value
+ param iPixelFormat int in value
+ param iLayerPlane int in value
+ param nAttributes UINT in value
+ param piAttributes int out array [nAttributes]
+ param piValues int out array [nAttributes]
+ category EXT_pixel_format
+
+GetPixelFormatAttribfvEXT(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues)
+ return BOOL
+ param hdc HDC in value
+ param iPixelFormat int in value
+ param iLayerPlane int in value
+ param nAttributes UINT in value
+ param piAttributes int out array [nAttributes]
+ param pfValues FLOAT out array [nAttributes]
+ category EXT_pixel_format
+
+ChoosePixelFormatEXT(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats)
+ return BOOL
+ param hdc HDC in value
+ param piAttribIList int in array [COMPSIZE()]
+ param pfAttribFList FLOAT in array [COMPSIZE()]
+ param nMaxFormats UINT in value
+ param piFormats int out array [COMPSIZE(nNumFormats)]
+ param nNumFormats UINT out reference
+ category EXT_pixel_format
+
+###############################################################################
+#
+# Extension #172
+# EXT_swap_control commands
+#
+###############################################################################
+
+SwapIntervalEXT(interval)
+ return BOOL
+ param interval int in value
+ category EXT_swap_control
+
+GetSwapIntervalEXT()
+ return int
+ category EXT_swap_control
+
+###############################################################################
+#
+# Extension #177
+# EXT_depth_float commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_depth_float
+
+###############################################################################
+#
+# Extension #190
+# NV_vertex_array_range commands
+#
+###############################################################################
+
+AllocateMemoryNV(size, readfreq, writefreq, priority)
+ return VoidPointer
+ param size GLsizei in value
+ param readfreq GLfloat in value
+ param writefreq GLfloat in value
+ param priority GLfloat in value
+ category NV_vertex_array_range
+
+FreeMemoryNV(pointer)
+ return void
+ param pointer void out array [1]
+ category NV_vertex_array_range
+
+###############################################################################
+#
+# Extension #207
+# 3DFX_multisample commands
+#
+###############################################################################
+
+# (none)
+newcategory: 3DFX_multisample
+
+###############################################################################
+#
+# Extension #209
+# EXT_multisample commands
+#
+###############################################################################
+
+# (none)
+newcategory: EXT_multisample
+
+###############################################################################
+#
+# Extension #242
+# OML_sync_control commands
+#
+###############################################################################
+
+GetSyncValuesOML(hdc, ust, msc, sbc)
+ return BOOL
+ param hdc HDC in value
+ param ust INT64 out array [1]
+ param msc INT64 out array [1]
+ param sbc INT64 out array [1]
+ category OML_sync_control
+
+GetMscRateOML(hdc, numerator, denominator)
+ return BOOL
+ param hdc HDC in value
+ param numerator INT32 out array [1]
+ param denominator INT32 out array [1]
+ category OML_sync_control
+
+SwapBuffersMscOML(hdc, target_msc, divisor, remainder)
+ return INT64
+ param hdc HDC in value
+ param target_msc INT64 in value
+ param divisor INT64 in value
+ param remainder INT64 in value
+ category OML_sync_control
+
+SwapLayerBuffersMscOML(hdc, fuPlanes, target_msc, divisor, remainder)
+ return INT64
+ param hdc HDC in value
+ param fuPlanes int in value
+ param target_msc INT64 in value
+ param divisor INT64 in value
+ param remainder INT64 in value
+ category OML_sync_control
+
+WaitForMscOML(hdc, target_msc, divisor, remainder , ust, msc, sbc)
+ return BOOL
+ param hdc HDC in value
+ param target_msc INT64 in value
+ param divisor INT64 in value
+ param remainder INT64 in value
+ param ust INT64 out array [1]
+ param msc INT64 out array [1]
+ param sbc INT64 out array [1]
+ category OML_sync_control
+
+WaitForSbcOML(hdc, target_sbc, ust, msc, sbc)
+ return BOOL
+ param hdc HDC in value
+ param target_sbc INT64 in value
+ param ust INT64 out array [1]
+ param msc INT64 out array [1]
+ param sbc INT64 out array [1]
+ category OML_sync_control
+
+###############################################################################
+#
+# Extension #250
+# I3D_digital_video_control commands
+#
+###############################################################################
+
+GetDigitalVideoParametersI3D(hDC, iAttribute, piValue)
+ return BOOL
+ param hDC HDC in value
+ param iAttribute int in value
+ param piValue int out array [COMPSIZE(iAttribute)]
+ category I3D_digital_video_control
+
+SetDigitalVideoParametersI3D(hDC, iAttribute, piValue)
+ return BOOL
+ param hDC HDC in value
+ param iAttribute int in value
+ param piValue int in array [COMPSIZE(iAttribute)]
+ category I3D_digital_video_control
+
+###############################################################################
+#
+# Extension #251
+# I3D_gamma commands
+#
+###############################################################################
+
+GetGammaTableParametersI3D(hDC, iAttribute, piValue)
+ return BOOL
+ param hDC HDC in value
+ param iAttribute int in value
+ param piValue int out array [COMPSIZE(iAttribute)]
+ category I3D_gamma
+
+SetGammaTableParametersI3D(hDC, iAttribute, piValue)
+ return BOOL
+ param hDC HDC in value
+ param iAttribute int in value
+ param piValue int in array [COMPSIZE(iAttribute)]
+ category I3D_gamma
+
+GetGammaTableI3D(hDC, iEntries, puRed, puGreen, puBlue)
+ return BOOL
+ param hDC HDC in value
+ param iEntries int in value
+ param puRed USHORT out array [iEntries]
+ param puGreen USHORT out array [iEntries]
+ param puBlue USHORT out array [iEntries]
+ category I3D_gamma
+
+SetGammaTableI3D(hDC, iEntries, puRed, puGreen, puBlue)
+ return BOOL
+ param hDC HDC in value
+ param iEntries int in value
+ param puRed USHORT in array [iEntries]
+ param puGreen USHORT in array [iEntries]
+ param puBlue USHORT in array [iEntries]
+ category I3D_gamma
+
+###############################################################################
+#
+# Extension #252
+# I3D_genlock commands
+#
+###############################################################################
+
+EnableGenlockI3D(hDC)
+ return BOOL
+ param hDC HDC in value
+ category I3D_genlock
+
+DisableGenlockI3D(hDC)
+ return BOOL
+ param hDC HDC in value
+ category I3D_genlock
+
+IsEnabledGenlockI3D(hDC, pFlag)
+ return BOOL
+ param hDC HDC in value
+ param pFlag BOOL out reference
+ category I3D_genlock
+
+GenlockSourceI3D(hDC, uSource)
+ return BOOL
+ param hDC HDC in value
+ param uSource UINT in value
+ category I3D_genlock
+
+GetGenlockSourceI3D(hDC, uSource)
+ return BOOL
+ param hDC HDC in value
+ param uSource UINT out reference
+ category I3D_genlock
+
+GenlockSourceEdgeI3D(hDC, uEdge)
+ return BOOL
+ param hDC HDC in value
+ param uEdge UINT in value
+ category I3D_genlock
+
+GetGenlockSourceEdgeI3D(hDC, uEdge)
+ return BOOL
+ param hDC HDC in value
+ param uEdge UINT out reference
+ category I3D_genlock
+
+GenlockSampleRateI3D(hDC, uRate)
+ return BOOL
+ param hDC HDC in value
+ param uRate UINT in value
+ category I3D_genlock
+
+GetGenlockSampleRateI3D(hDC, uRate)
+ return BOOL
+ param hDC HDC in value
+ param uRate UINT out reference
+ category I3D_genlock
+
+GenlockSourceDelayI3D(hDC, uDelay)
+ return BOOL
+ param hDC HDC in value
+ param uDelay UINT in value
+ category I3D_genlock
+
+GetGenlockSourceDelayI3D(hDC, uDelay)
+ return BOOL
+ param hDC HDC in value
+ param uDelay UINT out reference
+ category I3D_genlock
+
+QueryGenlockMaxSourceDelayI3D(hDC, uMaxLineDelay, uMaxPixelDelay)
+ return BOOL
+ param hDC HDC in value
+ param uMaxLineDelay UINT out reference
+ param uMaxPixelDelay UINT out reference
+ category I3D_genlock
+
+###############################################################################
+#
+# Extension #253
+# I3D_image_buffer commands
+#
+###############################################################################
+
+CreateImageBufferI3D(hDC, dwSize, uFlags)
+ return LPVOID
+ param hDC HDC in value
+ param dwSize DWORD in value
+ param uFlags UINT in value
+ category I3D_image_buffer
+
+DestroyImageBufferI3D(hDC, pAddress)
+ return BOOL
+ param hDC HDC in value
+ param pAddress LPVOID in value
+ category I3D_image_buffer
+
+AssociateImageBufferEventsI3D(hDC, pEvent, pAddress, pSize, count)
+ return BOOL
+ param hDC HDC in value
+ param pEvent HANDLE in array [count]
+ param pAddress LPVOID in array [count]
+ param pSize DWORD in array [count]
+ param count UINT in value
+ category I3D_image_buffer
+
+ReleaseImageBufferEventsI3D(hDC, pAddress, count)
+ return BOOL
+ param hDC HDC in value
+ param pAddress LPVOID in array [count]
+ param count UINT in value
+ category I3D_image_buffer
+
+###############################################################################
+#
+# Extension #254
+# I3D_swap_frame_lock commands
+#
+###############################################################################
+
+EnableFrameLockI3D()
+ return BOOL
+ category I3D_swap_frame_lock
+
+DisableFrameLockI3D()
+ return BOOL
+ category I3D_swap_frame_lock
+
+IsEnabledFrameLockI3D(pFlag)
+ return BOOL
+ param pFlag BOOL out reference
+ category I3D_swap_frame_lock
+
+QueryFrameLockMasterI3D(pFlag)
+ return BOOL
+ param pFlag BOOL out reference
+ category I3D_swap_frame_lock
+
+###############################################################################
+#
+# Extension #255
+# I3D_swap_frame_usage commands
+#
+###############################################################################
+
+GetFrameUsageI3D(pUsage)
+ return BOOL
+ param pUsage float out reference
+ category I3D_swap_frame_usage
+
+BeginFrameTrackingI3D()
+ return BOOL
+ category I3D_swap_frame_usage
+
+EndFrameTrackingI3D()
+ return BOOL
+ category I3D_swap_frame_usage
+
+QueryFrameTrackingI3D(pFrameCount, pMissedFrames, pLastMissedUsage)
+ return BOOL
+ param pFrameCount DWORD out reference
+ param pMissedFrames DWORD out reference
+ param pLastMissedUsage float out reference
+ category I3D_swap_frame_usage
+
+###############################################################################
+#
+# Extension #278
+# ATI_pixel_format_float commands
+#
+###############################################################################
+
+# (none)
+newcategory: ATI_pixel_format_float
+
+###############################################################################
+#
+# Extension #281
+# NV_float_buffer commands
+#
+###############################################################################
+
+# (none)
+newcategory: NV_float_buffer
diff --git a/Source/Bind/Structures/Constant.cs b/Source/Bind/Structures/Constant.cs
new file mode 100644
index 00000000..9d4813d2
--- /dev/null
+++ b/Source/Bind/Structures/Constant.cs
@@ -0,0 +1,97 @@
+#region License
+//Copyright (c) 2006 Stefanos Apostolopoulos
+//See license.txt for license info
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.OpenGL.Bind
+{
+ #region Constant class
+
+ ///
+ /// Represents an opengl constant in C# format. Both the constant name and value
+ /// can be retrieved or set. The value can be either a number, another constant
+ /// or an alias to a constant
+ ///
+ 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 public string ToString()
+
+ ///
+ /// Returns a string that represents the full constant declaration without decorations
+ /// (eg const uint GL_XXX_YYY = 0xDEADBEEF).
+ ///
+ ///
+ override public string ToString()
+ {
+ return Name + " = " + Value;
+ }
+
+ #endregion
+ }
+
+ #endregion
+}
diff --git a/Source/Bind/Structures/Enum.cs b/Source/Bind/Structures/Enum.cs
new file mode 100644
index 00000000..be48a3f6
--- /dev/null
+++ b/Source/Bind/Structures/Enum.cs
@@ -0,0 +1,49 @@
+#region License
+//Copyright (c) 2006 Stefanos Apostolopoulos
+//See license.txt for license info
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.OpenGL.Bind
+{
+ #region class Enum
+
+ 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();
+ }
+ }
+
+ #endregion
+}
diff --git a/Source/Bind/Structures/Function.cs b/Source/Bind/Structures/Function.cs
new file mode 100644
index 00000000..74fe247c
--- /dev/null
+++ b/Source/Bind/Structures/Function.cs
@@ -0,0 +1,266 @@
+#region License
+//Copyright (c) 2006 Stefanos Apostolopoulos
+//See license.txt for license info
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.OpenGL.Bind
+{
+ #region class Function
+
+ ///
+ /// Represents an opengl function.
+ /// The return value, function name, function parameters and opengl version can be retrieved or set.
+ ///
+ public class Function
+ {
+ #region Constructors
+
+ public Function()
+ {
+ Parameters = new ParameterCollection();
+ Body = new FunctionBody();
+ }
+
+ public Function(Function f)
+ {
+ this.Body = new FunctionBody(f.Body);
+ this.Category = new string(f.Category.ToCharArray());
+ this.Extension = f.Extension;
+ this.Name = new string(f.Name.ToCharArray());
+ this.NeedsWrapper = f.NeedsWrapper;
+ this.Parameters = new ParameterCollection(f.Parameters);
+ this.ReturnValue = new string(f.ReturnValue.ToCharArray());
+ this.Version = new string(f.Version.ToCharArray());
+ this.WrapperType = f.WrapperType;
+ }
+
+ #endregion
+
+ #region Function body
+
+ FunctionBody _body;
+
+ public FunctionBody Body
+ {
+ get { return _body; }
+ set { _body = value; }
+ }
+
+ #endregion
+
+ #region Category property
+
+ private string _category;
+
+ public string Category
+ {
+ get { return _category; }
+ set { _category = value; }
+ }
+
+ #endregion
+
+ #region Wrapper type property
+
+ private WrapperTypes _wrapper_type = WrapperTypes.None;
+
+ public WrapperTypes WrapperType
+ {
+ get { return _wrapper_type; }
+ set { _wrapper_type = value; }
+ }
+
+ #endregion
+
+ #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;
+
+ 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 Call function string
+
+ public string CallString()
+ {
+ StringBuilder sb = new StringBuilder();
+ sb.Append(Name);
+ sb.Append("(");
+ foreach (Parameter p in Parameters)
+ {
+ if (p.Unchecked)
+ sb.Append("unchecked((" + p.Type + ")");
+
+ sb.Append(p.Name);
+
+ if (p.Unchecked)
+ sb.Append(")");
+
+ sb.Append(", ");
+ }
+ sb.Replace(", ", ")", sb.Length - 2, 2);
+
+ return sb.ToString();
+ }
+
+ #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()
+ {
+ return ToString("");
+ }
+
+ public string ToString(string indentation)
+ {
+ StringBuilder sb = new StringBuilder();
+
+ sb.Append(indentation + ReturnValue + " " + Name + Parameters.ToString());
+ if (Body.Count > 0)
+ {
+ sb.AppendLine();
+ sb.Append(Body.ToString(indentation));
+ }
+
+ return sb.ToString();
+ }
+
+ #endregion
+
+ }
+
+ #endregion
+
+ #region class FunctionBody : List
+
+ public class FunctionBody : List
+ {
+ public FunctionBody()
+ {
+ }
+
+ public FunctionBody(FunctionBody fb)
+ {
+ foreach (string s in fb)
+ {
+ this.Add(s);
+ }
+ }
+
+ public override string ToString()
+ {
+ return ToString("");
+ }
+
+ public string ToString(string indentation)
+ {
+ if (this.Count == 0)
+ return String.Empty;
+
+ StringBuilder sb = new StringBuilder(this.Count);
+
+ sb.AppendLine(indentation + "{");
+ foreach (string s in this)
+ {
+ sb.AppendLine(indentation + " " + s);
+ }
+ sb.AppendLine(indentation + "}");
+
+ return sb.ToString();
+ }
+ }
+
+ #endregion
+}
diff --git a/Source/Bind/Structures/Parameter.cs b/Source/Bind/Structures/Parameter.cs
new file mode 100644
index 00000000..2a1c471e
--- /dev/null
+++ b/Source/Bind/Structures/Parameter.cs
@@ -0,0 +1,352 @@
+#region License
+//Copyright (c) 2006 Stefanos Apostolopoulos
+//See license.txt for license info
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace OpenTK.OpenGL.Bind
+{
+ #region Parameter class
+
+ ///
+ /// Represents a single parameter of an opengl function.
+ ///
+ public class Parameter
+ {
+ #region Constructors
+
+ ///
+ /// Creates a new Parameter without type and name.
+ ///
+ public Parameter()
+ {
+ }
+
+ ///
+ /// Creates a new parameter from the parameters passed (deep copy).
+ ///
+ /// The parameter to copy from.
+ public Parameter(Parameter p)
+ {
+ if (p == null)
+ return;
+
+ this.Array = p.Array;
+ this.Flow = p.Flow;
+ this.Name = new string(p.Name.ToCharArray());
+ this.NeedsWrapper = p.NeedsWrapper;
+ this.PreviousType = new string(p.PreviousType.ToCharArray());
+ this.Type = new string(p.Type.ToCharArray());
+ this.Unchecked = p.Unchecked;
+ this.UnmanagedType = p.UnmanagedType;
+ this.WrapperType = p.WrapperType;
+ }
+
+ #endregion
+
+ #region Name property
+
+ string _name;
+ ///
+ /// Gets or sets the name of the parameter.
+ ///
+ public string Name
+ {
+ get { return _name; }
+ set { _name = value; }
+ }
+
+ #endregion
+
+ #region UnmanagedType 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
+ {
+ if (_type != null)
+ PreviousType = _type;
+ _type = value;
+ }
+ }
+
+ #endregion
+
+ #region Previous type property
+
+ private string _previous_type;
+
+ public string PreviousType
+ {
+ get { return _previous_type; }
+ set { _previous_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 Unchecked property
+
+ private bool _unchecked;
+
+ public bool Unchecked
+ {
+ get { return _unchecked; }
+ set { _unchecked = value; }
+ }
+
+ #endregion
+
+ #region NeedsWrapper property
+
+ private bool _needs_wrapper;
+
+ public bool NeedsWrapper
+ {
+ get { return _needs_wrapper; }
+ set { _needs_wrapper = value; }
+ }
+
+ #endregion
+
+ #region WrapperType property
+
+ private WrapperTypes _wrapper_type = WrapperTypes.None;
+
+ public WrapperTypes WrapperType
+ {
+ get { return _wrapper_type; }
+ set { _wrapper_type = value; }
+ }
+
+ #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 && !(Type == "IntPtr"))
+ // sb.Append("out ");
+
+ sb.Append(Type);
+ if (Array)
+ sb.Append("[]");
+
+ sb.Append(" ");
+ sb.Append(Name);
+
+ return sb.ToString();
+ }
+ #endregion
+ }
+
+ #endregion
+
+ #region ParameterCollection class
+
+ ///
+ /// Holds the parameter list of an opengl function.
+ ///
+ public class ParameterCollection : List
+ {
+ #region Constructors
+
+ public ParameterCollection()
+ {
+ }
+
+ public ParameterCollection(ParameterCollection pc)
+ {
+ foreach (Parameter p in pc)
+ {
+ this.Add(new Parameter(p));
+ }
+ }
+
+ #endregion
+
+ #region override public string ToString()
+
+ ///
+ ///
+ ///
+ /// The parameter list of an opengl function in the form ( [parameters] )
+ 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;
+ }
+
+ #endregion
+
+ #region public ParameterCollection ReplaceAll(Parameter, Parameter)
+
+ ///
+ /// Replaces all parameters that match the old_param with the new_param.
+ ///
+ ///
+ ///
+ ///
+ /// The PreviousType property is ignored in parameter matching, and is set to the previous type in case of replacement.
+ public ParameterCollection ReplaceAll(Parameter old_param, Parameter new_param)
+ {
+ if (old_param == null || new_param == null)
+ return null;
+
+ ParameterCollection pc = new ParameterCollection(this);
+
+ foreach (Parameter p in pc)
+ {
+ if (p.Array == old_param.Array &&
+ p.Flow == old_param.Flow &&
+ p.Name == old_param.Name &&
+ //p.PreviousType == old_param.PreviousType &&
+ p.Type == old_param.Type &&
+ p.UnmanagedType == old_param.UnmanagedType)
+ {
+ p.Array = new_param.Array;
+ p.Flow = new_param.Flow;
+ p.Name = new_param.Name;
+ p.PreviousType = p.Type;
+ p.Type = new_param.Type;
+ p.UnmanagedType = new_param.UnmanagedType;
+ }
+ }
+
+ return pc;
+ }
+
+ #endregion
+
+ #region public ParameterCollection Replace(Parameter, Parameter)
+
+ ///
+ /// Replaces the first parameter that matches old_param with new_param.
+ ///
+ ///
+ ///
+ ///
+ /// The PreviousType property is ignored in parameter matching, and is set to the previous type in case of replacement.
+ public ParameterCollection Replace(Parameter old_param, Parameter new_param)
+ {
+ if (old_param == null || new_param == null)
+ return null;
+
+ ParameterCollection pc = new ParameterCollection(this);
+
+ foreach (Parameter p in pc)
+ {
+ if (p.Array == old_param.Array &&
+ p.Flow == old_param.Flow &&
+ p.Name == old_param.Name &&
+ //p.PreviousType == old_param.PreviousType &&
+ p.Type == old_param.Type &&
+ p.UnmanagedType == old_param.UnmanagedType)
+ {
+ p.Array = new_param.Array;
+ p.Flow = new_param.Flow;
+ p.Name = new_param.Name;
+ p.PreviousType = p.Type;
+ p.Type = new_param.Type;
+ p.UnmanagedType = new_param.UnmanagedType;
+ return pc;
+ }
+ }
+
+ return pc;
+ }
+
+ #endregion
+ }
+
+ #endregion
+}
diff --git a/Source/Build/Build.cs b/Source/Build/Build.cs
new file mode 100644
index 00000000..4fcdf3f4
--- /dev/null
+++ b/Source/Build/Build.cs
@@ -0,0 +1,358 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.IO;
+using System.Diagnostics;
+
+#endregion
+
+namespace OpenTK.Build
+{
+ class Project
+ {
+ static string RootPath;
+ static string SourcePath;
+ static string ToolPath = "Build";
+ static string PrebuildPath = Path.Combine(ToolPath, "Prebuild.exe");
+ static string BinPath = "Binaries";
+ static string ExePath = Path.Combine(BinPath, "Exe");
+ static string LibPath = Path.Combine(BinPath, "Libraries");
+ static string ExamplePath = Path.Combine(BinPath, "Examples");
+
+ static string PrebuildXml = Path.Combine(ToolPath, "Prebuild.xml");
+
+ enum BuildMode
+ {
+ Default = 0,
+ Release = 0,
+ Debug
+ }
+
+ enum BuildTarget
+ {
+ Default = 0,
+ Net = 0,
+ Mono,
+ VS2005,
+ SharpDevelop,
+ MonoDevelop,
+ Clean,
+ DistClean,
+ SVNClean
+ }
+
+ static BuildMode mode = BuildMode.Default;
+ static BuildTarget target = BuildTarget.Default;
+
+ static void PrintUsage()
+ {
+ Console.WriteLine("Usage: Build.exe BuildMode BuildTarget");
+ Console.WriteLine("\tBuildMode: debug/release");
+ Console.WriteLine("\tBuildTarget: mono/net/monodev/sharpdev/vs2005 or clean/distclean/svnclean");
+ }
+
+ static void Main(string[] args)
+ {
+ RootPath = Directory.GetCurrentDirectory();
+ RootPath = RootPath.Substring(
+ 0,
+ Directory.GetCurrentDirectory().LastIndexOf("Build"));
+ Directory.SetCurrentDirectory(RootPath);
+ SourcePath = Path.Combine(RootPath, "Source");
+
+ // Workaroung for nant on x64 windows (safe for other platforms too, as this affects
+ // only the current process).
+ Environment.SetEnvironmentVariable("CommonProgramFiles(x86)", String.Empty, EnvironmentVariableTarget.Process);
+ Environment.SetEnvironmentVariable("ProgramFiles(x86)", String.Empty, EnvironmentVariableTarget.Process);
+
+ if (args.Length == 0)
+ {
+ PrintUsage();
+ }
+ else
+ {
+ foreach (string s in args)
+ {
+ string arg = s.ToLower();
+ switch (arg)
+ {
+ case "debug":
+ case "d":
+ mode = BuildMode.Debug;
+ break;
+
+ case "release":
+ case "r":
+ mode = BuildMode.Release;
+ break;
+
+ case "mono":
+ target = BuildTarget.Mono;
+ break;
+
+ case "net":
+ target = BuildTarget.Net;
+ break;
+
+ case "monodev":
+ case "monodevelop":
+ case "md":
+ target = BuildTarget.MonoDevelop;
+ break;
+
+ case "sharpdev":
+ case "sharpdevelop":
+ case "sd":
+ target = BuildTarget.SharpDevelop;
+ break;
+
+ case "vs2005":
+ case "vs":
+ target = BuildTarget.VS2005;
+ break;
+
+ case "clean":
+ target = BuildTarget.Clean;
+ break;
+
+ case "svnclean":
+ target = BuildTarget.SVNClean;
+ break;
+
+ case "distclean":
+ target = BuildTarget.DistClean;
+ break;
+
+ default:
+ Console.WriteLine("Unknown command: {0}", s);
+ PrintUsage();
+ return;
+ }
+ }
+
+ ExePath = Path.Combine(
+ BinPath,
+ Path.Combine(mode == BuildMode.Debug ? "Debug" : "Release", "Exe"));
+ LibPath = Path.Combine(
+ BinPath,
+ Path.Combine(mode == BuildMode.Debug ? "Debug" : "Release", "Libraries"));
+ ExamplePath = Path.Combine(
+ BinPath,
+ Path.Combine(mode == BuildMode.Debug ? "Debug" : "Release", "Examples"));
+
+ switch (target)
+ {
+ case BuildTarget.Mono:
+ Console.WriteLine("Building OpenTK using Mono.");
+ ExecuteProcess(PrebuildPath, "/target nant /file " + PrebuildXml);
+ Console.WriteLine();
+ ExecuteProcess(
+ "nant",
+ "-buildfile:./Build/OpenTK.build -t:mono-2.0 " + (mode == BuildMode.Debug ? "build-debug" : "build-release"));
+ CopyBinaries();
+ break;
+
+ case BuildTarget.Net:
+ Console.WriteLine("Building OpenTK using .Net");
+ ExecuteProcess(PrebuildPath, "/target nant /file " + PrebuildXml);
+ Console.WriteLine();
+ ExecuteProcess(
+ "nant",
+ "-buildfile:./Build/OpenTK.build -t:net-2.0 " + (mode == BuildMode.Debug ? "build-debug" : "build-release"));
+ CopyBinaries();
+ break;
+
+ case BuildTarget.MonoDevelop:
+ Console.WriteLine("Creating MonoDevelop project files");
+ ExecuteProcess(PrebuildPath, "/target monodev /file " + PrebuildXml);
+ break;
+
+ case BuildTarget.SharpDevelop:
+ Console.WriteLine("Creating SharpDevelop project files");
+ ExecuteProcess(PrebuildPath, "/target monodev /file " + PrebuildXml);
+ break;
+
+ case BuildTarget.VS2005:
+ Console.WriteLine("Creating VS2005 project files");
+ ExecuteProcess(PrebuildPath, "/target vs2005 /file " + PrebuildXml);
+ break;
+
+ case BuildTarget.Clean:
+ Console.WriteLine("Cleaning intermediate object files.");
+ ExecuteProcess(PrebuildPath, "/clean /yes /file " + PrebuildXml);
+ DeleteDirectories(RootPath, "obj");
+ break;
+
+ case BuildTarget.DistClean:
+ Console.WriteLine("Cleaning intermediate and final object files.");
+ ExecuteProcess(PrebuildPath, "/clean /yes /file " + PrebuildXml);
+ DeleteDirectories(RootPath, "obj");
+ DeleteDirectories(RootPath, "bin");
+ if (Directory.Exists(RootPath + "Binaries"))
+ Directory.Delete(RootPath + "Binaries", true);
+ break;
+
+ case BuildTarget.SVNClean:
+ Console.WriteLine("Deleting svn directories.");
+ DeleteDirectories(RootPath, ".svn");
+ break;
+
+ default:
+ Console.WriteLine("Unknown target: {0}", target);
+ PrintUsage();
+ return;
+ }
+
+ //Console.WriteLine("Press any key to continue...");
+ //Console.ReadKey(true);
+ }
+ }
+
+ static void DeleteDirectories(string root_path, string search)
+ {
+ Console.WriteLine("Deleting {0} directories", search);
+ List matches = new List();
+ FindDirectories(root_path, search, matches);
+ foreach (string m in matches)
+ {
+ Directory.Delete(m, true);
+ }
+ }
+
+ static void CopyBinaries()
+ {
+ List example_matches = new List();
+ List exe_matches = new List();
+ List dll_matches = new List();
+ List dll_config_matches = new List();
+
+ Directory.CreateDirectory(BinPath);
+ Directory.CreateDirectory(ExePath);
+ Directory.CreateDirectory(LibPath);
+ Directory.CreateDirectory(ExamplePath);
+
+ // Move the libraries and the config files.
+ FindFiles(SourcePath, "*.dll", dll_matches);
+ foreach (string m in dll_matches)
+ {
+ File.Delete(Path.Combine(LibPath, Path.GetFileName(m)));
+ File.Copy(m, Path.Combine(LibPath, Path.GetFileName(m)));
+ File.Delete(Path.Combine(ExamplePath, Path.GetFileName(m)));
+ File.Copy(m, Path.Combine(ExamplePath, Path.GetFileName(m)));
+ }
+
+ FindFiles(SourcePath, "*.dll.config", dll_config_matches);
+ foreach (string m in dll_config_matches)
+ {
+ File.Delete(Path.Combine(LibPath, Path.GetFileName(m)));
+ File.Copy(m, Path.Combine(LibPath, Path.GetFileName(m)));
+ File.Delete(Path.Combine(ExamplePath, Path.GetFileName(m)));
+ File.Copy(m, Path.Combine(ExamplePath, Path.GetFileName(m)));
+ }
+
+ // Then the examples.
+ FindFiles(Path.Combine(SourcePath, "Examples"), "*.exe", example_matches);
+ foreach (string m in example_matches)
+ {
+ File.Delete(Path.Combine(ExamplePath, Path.GetFileName(m)));
+ File.Move(m, Path.Combine(ExamplePath, Path.GetFileName(m)));
+ }
+
+ // Then the rest of the exes.
+ FindFiles(SourcePath, "*.exe", exe_matches);
+ foreach (string m in exe_matches)
+ {
+ File.Delete(Path.Combine(ExePath, Path.GetFileName(m)));
+ File.Move(m, Path.Combine(ExePath, Path.GetFileName(m)));
+ }
+ }
+
+ static void FindDirectories(string directory, string search, List matches)
+ {
+ try
+ {
+ foreach (string d in Directory.GetDirectories(directory))
+ {
+ foreach (string f in Directory.GetDirectories(d, search))
+ {
+ matches.Add(f);
+ }
+ FindDirectories(d, search, matches);
+ }
+ }
+ catch (System.Exception e)
+ {
+ Console.WriteLine(e.Message);
+ }
+ }
+
+ static void FindFiles(string directory, string search, List matches)
+ {
+ try
+ {
+ foreach (string f in Directory.GetFiles(directory, search, SearchOption.AllDirectories))
+ {
+ matches.Add(f);
+ }
+ //FindFiles(d, search, matches);
+ }
+ catch (System.Exception e)
+ {
+ Console.WriteLine(e.Message);
+ }
+ }
+
+ static void ExecuteProcess(string path, string args)
+ {
+ using (Process p = new Process())
+ {
+ ProcessStartInfo sinfo = new ProcessStartInfo();
+ if (Environment.OSVersion.Platform == PlatformID.Unix && !path.ToLower().Contains("nant"))
+ {
+ sinfo.FileName = "mono";
+ sinfo.Arguments = path + " " + args;
+ }
+ else
+ {
+ sinfo.FileName = path;
+ sinfo.Arguments = args;
+ }
+
+ sinfo.WorkingDirectory = RootPath;
+ sinfo.CreateNoWindow = true;
+ sinfo.RedirectStandardOutput = true;
+ sinfo.UseShellExecute = false;
+ p.StartInfo = sinfo;
+ p.OutputDataReceived += new DataReceivedEventHandler(p_OutputDataReceived);
+ p.Start();
+ p.BeginOutputReadLine();
+ //StreamReader sr = p.StandardOutput;
+ //while (!p.HasExited)
+ //{
+ // Console.WriteLine(sr.ReadLine());
+ // Console.Out.Flush();
+ //}
+
+ p.WaitForExit();
+ }
+ }
+
+ static void p_OutputDataReceived(object sender, DataReceivedEventArgs e)
+ {
+ if (!String.IsNullOrEmpty(e.Data))
+ {
+ // Eat the last \n, we use WriteLine instead. This way we get the same result
+ // in both windows and linux (linux would interpret both \n and WriteLine).
+ Console.WriteLine(e.Data.TrimEnd('\n'));
+ }
+ }
+ }
+}
diff --git a/Source/Examples/ExampleLauncher.Designer.cs b/Source/Examples/ExampleLauncher.Designer.cs
new file mode 100644
index 00000000..ee0f4a99
--- /dev/null
+++ b/Source/Examples/ExampleLauncher.Designer.cs
@@ -0,0 +1,62 @@
+namespace Examples
+{
+ partial class ExampleLauncher
+ {
+ ///
+ /// Required designer variable.
+ ///
+ private System.ComponentModel.IContainer components = null;
+
+ ///
+ /// Clean up any resources being used.
+ ///
+ /// true if managed resources should be disposed; otherwise, false.
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && (components != null))
+ {
+ components.Dispose();
+ }
+ base.Dispose(disposing);
+ }
+
+ #region Windows Form Designer generated code
+
+ ///
+ /// Required method for Designer support - do not modify
+ /// the contents of this method with the code editor.
+ ///
+ private void InitializeComponent()
+ {
+ this.components = new System.ComponentModel.Container();
+ this.listBox1 = new System.Windows.Forms.ListBox();
+ this.SuspendLayout();
+ //
+ // listBox1
+ //
+ this.listBox1.Dock = System.Windows.Forms.DockStyle.Fill;
+ this.listBox1.FormattingEnabled = true;
+ this.listBox1.Location = new System.Drawing.Point(0, 0);
+ this.listBox1.Name = "listBox1";
+ this.listBox1.Size = new System.Drawing.Size(284, 264);
+ this.listBox1.TabIndex = 0;
+ this.listBox1.DoubleClick += new System.EventHandler(this.listBox1_DoubleClick);
+ //
+ // ExampleLauncher
+ //
+ this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+ this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+ this.ClientSize = new System.Drawing.Size(284, 264);
+ this.Controls.Add(this.listBox1);
+ this.Name = "ExampleLauncher";
+ this.Text = "OpenTK Example Launcher";
+ this.Load += new System.EventHandler(this.ExampleLauncher_Load);
+ this.ResumeLayout(false);
+
+ }
+
+ #endregion
+
+ private System.Windows.Forms.ListBox listBox1;
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/ExampleLauncher.cs b/Source/Examples/ExampleLauncher.cs
new file mode 100644
index 00000000..56c93f8a
--- /dev/null
+++ b/Source/Examples/ExampleLauncher.cs
@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+using System.Reflection;
+using System.Threading;
+using OpenTK;
+
+namespace Examples
+{
+ public partial class ExampleLauncher : Form
+ {
+ ///
+ /// The main entry point for the application.
+ ///
+ [STAThread]
+ static void Main()
+ {
+ using (Form exampleLauncher = new ExampleLauncher())
+ {
+ Application.EnableVisualStyles();
+ Application.Run(exampleLauncher);
+ }
+ }
+
+ public ExampleLauncher()
+ {
+ InitializeComponent();
+ }
+
+ private void listBox1_DoubleClick(object sender, EventArgs e)
+ {
+ if (listBox1.SelectedItem != null)
+ {
+ Type example =
+ Assembly.GetExecutingAssembly().GetType(
+ "Examples." + listBox1.SelectedItem.ToString().Replace(": ", ".").Replace(' ', '_'),
+ true,
+ true
+ );
+
+ if (example.BaseType == typeof(GameWindow))
+ {
+ // Start the GameWindow in a new thread - it runs its own message loop, and it would
+ // interfere with the message loop of the ExampleLauncher.
+ new Thread(Launch).Start(example);
+ }
+ else if (example.BaseType == typeof(Form))
+ {
+ try
+ {
+ // In this we do not want a different thread: these examples rely on the Application.Idle
+ // event, which would then be raised by both the ExampleLauncher thread *and* the new one!
+ this.AddOwnedForm((Form)example.GetConstructor(Type.EmptyTypes).Invoke(null));
+ }
+ catch (Exception expt)
+ {
+ MessageBox.Show(
+ String.Format(
+ "Stacktrace:{0}{1}{0}{0}Inner exception:{0}{2}",
+ System.Environment.NewLine,
+ expt.StackTrace,
+ expt.InnerException
+ ),
+ expt.Message
+ );
+ }
+ }
+ }
+ }
+
+ void Launch(object example)
+ {
+ try
+ {
+ (example as Type).InvokeMember("Launch", BindingFlags.InvokeMethod, null, null, null);
+ }
+ catch (Exception expt)
+ {
+ MessageBox.Show(
+ String.Format(
+ "Stacktrace:{0}{1}{0}{0}Inner exception:{0}{2}",
+ System.Environment.NewLine,
+ expt.StackTrace,
+ expt.InnerException
+ ),
+ expt.Message
+ );
+ }
+ }
+
+ public void ExampleLauncher_Load(object sender, EventArgs e)
+ {
+ SortedList sl = new SortedList();
+
+ // Get all examples
+ Type[] types = Assembly.GetExecutingAssembly().GetTypes();
+ foreach (Type type in types)
+ {
+ if (type.GetInterface("IExample") != null)
+ {
+ sl.Add(
+ (type.Namespace.Replace("Examples.", String.Empty) + ": " + type.Name).Replace('_', ' '),
+ null
+ );
+ }
+ }
+
+ foreach (string s in sl.Keys)
+ listBox1.Items.Add(s);
+
+ // Select first item
+ if (listBox1.Items.Count > 0)
+ {
+ this.listBox1.SelectedIndex = 0;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/ExampleLauncher.resx b/Source/Examples/ExampleLauncher.resx
new file mode 100644
index 00000000..0841fd36
--- /dev/null
+++ b/Source/Examples/ExampleLauncher.resx
@@ -0,0 +1,126 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ 17, 17
+
+
+ 243, 17
+
+
\ No newline at end of file
diff --git a/Source/Examples/IExample.cs b/Source/Examples/IExample.cs
new file mode 100644
index 00000000..9f148cfb
--- /dev/null
+++ b/Source/Examples/IExample.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Examples
+{
+ ///
+ /// Examples should implement this (empty) interface, so that the ExampleLauncher
+ /// can identify them.
+ ///
+ interface IExample
+ {
+ }
+}
diff --git a/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.Designer.cs b/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.Designer.cs
new file mode 100644
index 00000000..caf8f12b
--- /dev/null
+++ b/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.Designer.cs
@@ -0,0 +1,183 @@
+namespace Examples.Windowing
+{
+ partial class W02_Multiple_GLControls
+ {
+ ///
+ /// Required designer variable.
+ ///
+ private System.ComponentModel.IContainer components = null;
+
+ ///
+ /// Clean up any resources being used.
+ ///
+ /// true if managed resources should be disposed; otherwise, false.
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && (components != null))
+ {
+ components.Dispose();
+ }
+ base.Dispose(disposing);
+ }
+
+ #region Windows Form Designer generated code
+
+ ///
+ /// Required method for Designer support - do not modify
+ /// the contents of this method with the code editor.
+ ///
+ private void InitializeComponent()
+ {
+ this.components = new System.ComponentModel.Container();
+ this.panel1 = new System.Windows.Forms.Panel();
+ this.timer1 = new System.Windows.Forms.Timer(this.components);
+ this.panel2 = new System.Windows.Forms.Panel();
+ this.create1 = new System.Windows.Forms.Button();
+ this.dispose1 = new System.Windows.Forms.Button();
+ this.groupBox1 = new System.Windows.Forms.GroupBox();
+ this.groupBox2 = new System.Windows.Forms.GroupBox();
+ this.create2 = new System.Windows.Forms.Button();
+ this.dispose2 = new System.Windows.Forms.Button();
+ this.label1 = new System.Windows.Forms.Label();
+ this.groupBox1.SuspendLayout();
+ this.groupBox2.SuspendLayout();
+ this.SuspendLayout();
+ //
+ // panel1
+ //
+ this.panel1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+ | System.Windows.Forms.AnchorStyles.Right)));
+ this.panel1.Location = new System.Drawing.Point(12, 12);
+ this.panel1.Name = "panel1";
+ this.panel1.Size = new System.Drawing.Size(283, 131);
+ this.panel1.TabIndex = 0;
+ //
+ // timer1
+ //
+ this.timer1.Interval = 40;
+ this.timer1.Tick += new System.EventHandler(this.timer1_Tick);
+ //
+ // panel2
+ //
+ this.panel2.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+ | System.Windows.Forms.AnchorStyles.Left)
+ | System.Windows.Forms.AnchorStyles.Right)));
+ this.panel2.Location = new System.Drawing.Point(12, 149);
+ this.panel2.Name = "panel2";
+ this.panel2.Size = new System.Drawing.Size(283, 130);
+ this.panel2.TabIndex = 0;
+ //
+ // create1
+ //
+ this.create1.Location = new System.Drawing.Point(6, 19);
+ this.create1.Name = "create1";
+ this.create1.Size = new System.Drawing.Size(63, 23);
+ this.create1.TabIndex = 0;
+ this.create1.Text = "Create";
+ this.create1.UseVisualStyleBackColor = true;
+ this.create1.Click += new System.EventHandler(this.create1_Click);
+ //
+ // dispose1
+ //
+ this.dispose1.Enabled = false;
+ this.dispose1.Location = new System.Drawing.Point(6, 48);
+ this.dispose1.Name = "dispose1";
+ this.dispose1.Size = new System.Drawing.Size(63, 23);
+ this.dispose1.TabIndex = 0;
+ this.dispose1.Text = "Dispose";
+ this.dispose1.UseVisualStyleBackColor = true;
+ this.dispose1.Click += new System.EventHandler(this.dispose1_Click);
+ //
+ // groupBox1
+ //
+ this.groupBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+ this.groupBox1.Controls.Add(this.create1);
+ this.groupBox1.Controls.Add(this.dispose1);
+ this.groupBox1.Location = new System.Drawing.Point(301, 12);
+ this.groupBox1.Name = "groupBox1";
+ this.groupBox1.Size = new System.Drawing.Size(75, 77);
+ this.groupBox1.TabIndex = 1;
+ this.groupBox1.TabStop = false;
+ this.groupBox1.Text = "Context";
+ //
+ // groupBox2
+ //
+ this.groupBox2.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+ this.groupBox2.Controls.Add(this.create2);
+ this.groupBox2.Controls.Add(this.dispose2);
+ this.groupBox2.Location = new System.Drawing.Point(301, 149);
+ this.groupBox2.Name = "groupBox2";
+ this.groupBox2.Size = new System.Drawing.Size(75, 77);
+ this.groupBox2.TabIndex = 2;
+ this.groupBox2.TabStop = false;
+ this.groupBox2.Text = "Context";
+ //
+ // create2
+ //
+ this.create2.Location = new System.Drawing.Point(6, 19);
+ this.create2.Name = "create2";
+ this.create2.Size = new System.Drawing.Size(63, 23);
+ this.create2.TabIndex = 0;
+ this.create2.Text = "Create";
+ this.create2.UseVisualStyleBackColor = true;
+ this.create2.Click += new System.EventHandler(this.create2_Click);
+ //
+ // dispose2
+ //
+ this.dispose2.Enabled = false;
+ this.dispose2.Location = new System.Drawing.Point(6, 48);
+ this.dispose2.Name = "dispose2";
+ this.dispose2.Size = new System.Drawing.Size(63, 23);
+ this.dispose2.TabIndex = 0;
+ this.dispose2.Text = "Dispose";
+ this.dispose2.UseVisualStyleBackColor = true;
+ this.dispose2.Click += new System.EventHandler(this.dispose2_Click);
+ //
+ // label1
+ //
+ this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
+ this.label1.AutoSize = true;
+ this.label1.Location = new System.Drawing.Point(9, 287);
+ this.label1.Name = "label1";
+ this.label1.Size = new System.Drawing.Size(210, 13);
+ this.label1.TabIndex = 3;
+ this.label1.Text = "Press F1 to toggle FullScreen / Windowed.";
+ //
+ // Form1
+ //
+ this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+ this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+ this.ClientSize = new System.Drawing.Size(388, 310);
+ this.Controls.Add(this.label1);
+ this.Controls.Add(this.groupBox2);
+ this.Controls.Add(this.groupBox1);
+ this.Controls.Add(this.panel2);
+ this.Controls.Add(this.panel1);
+ this.KeyPreview = true;
+ this.Name = "Form1";
+ this.SizeGripStyle = System.Windows.Forms.SizeGripStyle.Show;
+ this.Text = "Form1";
+ this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.Form1_KeyDown);
+ this.Load += new System.EventHandler(this.Form1_Load);
+ this.groupBox1.ResumeLayout(false);
+ this.groupBox2.ResumeLayout(false);
+ this.ResumeLayout(false);
+ this.PerformLayout();
+
+ }
+
+ #endregion
+
+ private System.Windows.Forms.Panel panel1;
+ private System.Windows.Forms.Timer timer1;
+ private System.Windows.Forms.Panel panel2;
+ private System.Windows.Forms.Button create1;
+ private System.Windows.Forms.Button dispose1;
+ private System.Windows.Forms.GroupBox groupBox1;
+ private System.Windows.Forms.GroupBox groupBox2;
+ private System.Windows.Forms.Button create2;
+ private System.Windows.Forms.Button dispose2;
+ private System.Windows.Forms.Label label1;
+ }
+}
+
diff --git a/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.cs b/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.cs
new file mode 100644
index 00000000..ea3a8e39
--- /dev/null
+++ b/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.cs
@@ -0,0 +1,264 @@
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+using OpenTK.OpenGL;
+using Enums = OpenTK.OpenGL.Enums;
+using OpenTK;
+using OpenTK.Platform;
+
+#endregion
+
+namespace Examples.Windowing
+{
+ public partial class W02_Multiple_GLControls : Form
+ {
+ OpenTK.GLControl glWindow1, glWindow2;
+
+ public W02_Multiple_GLControls()
+ {
+ InitializeComponent();
+
+ timer1.Enabled = true;
+
+ throw new NotImplementedException();
+ }
+
+ protected override void OnClosed(EventArgs e)
+ {
+ base.OnClosed(e);
+
+ if (glWindow1 != null)
+ glWindow1.Dispose();
+
+ if (glWindow2 != null)
+ glWindow2.Dispose();
+ }
+ static float angle;
+
+ #region Load event handler
+
+ protected override void OnLoad(EventArgs e)
+ {
+ base.OnLoad(e);
+
+ OnResize(e);
+ }
+
+ #endregion
+
+ int count;
+
+ private void timer1_Tick(object sender, EventArgs e)
+ {
+ PaintGLScene();
+
+ count++;
+
+ if (count == 20)
+ create1_Click(null, EventArgs.Empty);
+
+ if (glWindow1 == null)
+ return;
+
+ //if (count == 60)
+ // ToggleFullScreen();
+
+ if (glWindow1.Fullscreen)
+ {
+ this.Location = new Point(this.Location.X + (int)(Math.Sin(count / (5 * Math.PI)) * 3),
+ this.Location.Y);
+ }
+ }
+
+ protected override void OnPaint(PaintEventArgs e)
+ {
+ base.OnPaint(e);
+ PaintGLScene();
+ }
+
+ private void PaintGLScene()
+ {
+ RenderToContext(glWindow1, 0);
+ RenderToContext(glWindow2, 45);
+
+ }
+
+ private void RenderToContext(OpenTK.GLControl glWindow, float angle_add)
+ {
+ glWindow.Context.MakeCurrent();
+
+ GL.ClearColor(0.1f, 0.1f, 0.5f, 0.0f);
+ GL.Enable(Enums.EnableCap.DEPTH_TEST);
+
+ GL.Viewport(0, 0, glWindow.Width, glWindow.Height);
+
+ double ratio = 0.0;
+ ratio = glWindow.Width / (double)glWindow.Height;
+
+ GL.MatrixMode(Enums.MatrixMode.PROJECTION);
+ GL.LoadIdentity();
+ Glu.Perspective(45.0, ratio, 1.0, 64.0);
+
+
+ GL.MatrixMode(Enums.MatrixMode.MODELVIEW);
+ GL.LoadIdentity();
+ Glu.LookAt(
+ 0.0, 5.0, 5.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0
+ );
+ GL.Rotatef(angle + angle_add, 0.0f, 1.0f, 0.0f);
+ angle += 0.5f;
+
+ GL.Clear(Enums.ClearBufferMask.COLOR_BUFFER_BIT | Enums.ClearBufferMask.DEPTH_BUFFER_BIT);
+
+ DrawCube();
+
+ glWindow.Context.SwapBuffers();
+ }
+
+ #region KeyDown event handler
+
+ protected override void OnKeyDown(KeyEventArgs e)
+ {
+ base.OnKeyDown(e);
+
+ switch (e.KeyData)
+ {
+ case Keys.Escape:
+ Application.Exit();
+ break;
+
+ case Keys.F1:
+ //this.SetResolution(this.Width, this.Height, this.ColorDepth, !this.Fullscreen);
+ break;
+ }
+ }
+
+ #endregion
+
+ #region DrawCube
+ public void DrawCube()
+ {
+ GL.Begin(Enums.BeginMode.QUADS);
+
+ GL.Color3f(1, 0, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+
+ GL.Color3f(1, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+
+ GL.Color3f(1, 0, 1);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+
+ GL.Color3f(0, 0, 1);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 1);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+
+ GL.End();
+ }
+ #endregion
+
+ private void create1_Click(object sender, EventArgs e)
+ {
+ glWindow1 = new OpenTK.GLControl();
+
+ create1.Enabled = false;
+ dispose1.Enabled = true;
+
+
+ Text =
+ GL.GetString(Enums.StringName.VENDOR) + " " +
+ GL.GetString(Enums.StringName.RENDERER) + " " +
+ GL.GetString(Enums.StringName.VERSION);
+
+ }
+
+ private void create2_Click(object sender, EventArgs e)
+ {
+ //glWindow2 = GLContext.Create(panel2, new OpenTK.OpenGL.ColorDepth(8, 8, 8, 8), 8, 0);
+ glWindow2 = new GLControl(
+ new DisplayMode(0, 0, new OpenTK.Platform.ColorDepth(32), 16, 0, 0, 2, false, false, false, 0.0f));
+
+ create2.Enabled = false;
+ dispose2.Enabled = true;
+ }
+
+ private void dispose1_Click(object sender, EventArgs e)
+ {
+ glWindow1.Dispose();
+ glWindow1 = null;
+ panel1.Invalidate();
+
+ create1.Enabled = true;
+ dispose1.Enabled = false;
+ }
+
+ private void dispose2_Click(object sender, EventArgs e)
+ {
+ glWindow2.Dispose();
+ glWindow2 = null;
+ panel2.Invalidate();
+
+ create2.Enabled = true;
+ dispose2.Enabled = false;
+ }
+
+ private void Form1_Load(object sender, EventArgs e)
+ {
+ this.BringToFront();
+ }
+ private void Form1_KeyDown(object sender, KeyEventArgs e)
+ {
+ if (glWindow1 == null)
+ return;
+
+ if (e.KeyCode == Keys.F1)
+ {
+ ToggleFullScreen();
+ }
+ }
+
+ private void ToggleFullScreen()
+ {
+ glWindow1.Fullscreen = !glWindow1.Fullscreen;
+ /*
+ if (glWindow1.Fullscreen)
+ glWindow1.SetWindowed();
+ else
+ {
+ glWindow1.SetFullScreen(640, 480, new OpenTK.OpenGL.ColorDepth(8, 8, 8, 8));
+ }
+ */
+ }
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.resx b/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.resx
new file mode 100644
index 00000000..93f75a97
--- /dev/null
+++ b/Source/Examples/OpenGL/Basic/NoFramework/QueryModesForm.resx
@@ -0,0 +1,123 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ 17, 17
+
+
\ No newline at end of file
diff --git a/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.Designer.cs b/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.Designer.cs
new file mode 100644
index 00000000..7aaa261c
--- /dev/null
+++ b/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.Designer.cs
@@ -0,0 +1,60 @@
+namespace Examples.Windowing
+{
+ partial class W01_DisplayModesForm
+ {
+ ///
+ /// Required designer variable.
+ ///
+ private System.ComponentModel.IContainer components = null;
+
+ ///
+ /// Clean up any resources being used.
+ ///
+ /// true if managed resources should be disposed; otherwise, false.
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && (components != null))
+ {
+ components.Dispose();
+ }
+ base.Dispose(disposing);
+ }
+
+ #region Windows Form Designer generated code
+
+ ///
+ /// Required method for Designer support - do not modify
+ /// the contents of this method with the code editor.
+ ///
+ private void InitializeComponent()
+ {
+ this.listBox1 = new System.Windows.Forms.ListBox();
+ this.SuspendLayout();
+ //
+ // listBox1
+ //
+ this.listBox1.Dock = System.Windows.Forms.DockStyle.Fill;
+ this.listBox1.FormattingEnabled = true;
+ this.listBox1.Location = new System.Drawing.Point(0, 0);
+ this.listBox1.Name = "listBox1";
+ this.listBox1.Size = new System.Drawing.Size(292, 264);
+ this.listBox1.TabIndex = 0;
+ //
+ // DisplayModes
+ //
+ this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+ this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+ this.ClientSize = new System.Drawing.Size(292, 266);
+ this.Controls.Add(this.listBox1);
+ this.Name = "DisplayModes";
+ this.Text = "Query Display Modes";
+ this.ResumeLayout(false);
+
+ }
+
+ #endregion
+
+ private System.Windows.Forms.ListBox listBox1;
+ }
+}
+
diff --git a/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.cs b/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.cs
new file mode 100644
index 00000000..863c8f80
--- /dev/null
+++ b/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+using OpenTK;
+using OpenTK.Platform;
+
+namespace Examples.Windowing
+{
+ public partial class W01_DisplayModesForm : Form
+ {
+ OpenTK.Platform.IGLControl glWindow;
+
+ public W01_DisplayModesForm()
+ {
+ InitializeComponent();
+
+ glWindow = new GLControl();
+
+ IEnumerable modes = glWindow.Context.GetDisplayModes();
+
+ foreach (DisplayMode m in modes)
+ {
+ listBox1.Items.Add(m);
+ }
+
+ }
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.resx b/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.resx
new file mode 100644
index 00000000..ff31a6db
--- /dev/null
+++ b/Source/Examples/OpenGL/Basic/QueryDisplayModes/DisplayModesForm.resx
@@ -0,0 +1,120 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
\ No newline at end of file
diff --git a/Source/Examples/OpenGL/Basic/QueryDisplayModes/Program.cs b/Source/Examples/OpenGL/Basic/QueryDisplayModes/Program.cs
new file mode 100644
index 00000000..718313ec
--- /dev/null
+++ b/Source/Examples/OpenGL/Basic/QueryDisplayModes/Program.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+
+namespace QueryDisplayModes
+{
+ static class Program
+ {
+
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/Tutorial/T03_RotatingCube.cs b/Source/Examples/Tutorial/T03_RotatingCube.cs
new file mode 100644
index 00000000..12d6a02c
--- /dev/null
+++ b/Source/Examples/Tutorial/T03_RotatingCube.cs
@@ -0,0 +1,187 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Windows.Forms;
+
+using OpenTK;
+using OpenTK.OpenGL;
+using OpenTK.Platform;
+using Enums = OpenTK.OpenGL.Enums;
+using OpenTK.Input;
+
+#endregion
+
+namespace Examples.Tutorial
+{
+ public class T03_RotatingCube : OpenTK.GameWindow, IExample
+ {
+ #region --- Fields ---
+
+ ///
+ /// Denotes the cube rotation.
+ ///
+ float angle = 0.0f;
+
+ #endregion
+
+ #region --- Constructors ---
+
+ public T03_RotatingCube()
+ {
+ Context.MakeCurrent();
+
+ GL.ClearColor(0.1f, 0.1f, 0.5f, 0.0f);
+ GL.Enable(Enums.EnableCap.DEPTH_TEST);
+
+ this.OnResize(new ResizeEventArgs(this.Width, this.Height));
+ }
+
+ #endregion
+
+ #region Resize event handler
+
+ ///
+ /// Called when the user resizes the window.
+ ///
+ /// Contains the new width/height of the window.
+ ///
+ /// You want the OpenGL viewport to match the window. This is the place to do it!
+ ///
+ protected override void OnResize(OpenTK.Platform.ResizeEventArgs e)
+ {
+ base.OnResize(e);
+
+ GL.Viewport(0, 0, e.Width, e.Height);
+
+ double ratio = e.Width / (double)e.Height;
+
+ GL.MatrixMode(Enums.MatrixMode.PROJECTION);
+ GL.LoadIdentity();
+ Glu.Perspective(45.0, ratio, 1.0, 64.0);
+ }
+
+ #endregion
+
+ #region UpdateFrame function
+
+ ///
+ /// Prepares the next frame for rendering.
+ ///
+ ///
+ /// Place your control logic here. This is the place to respond to user input,
+ /// update object positions etc.
+ ///
+ public override void UpdateFrame()
+ {
+ if (Key.Escape)
+ {
+ Quit = true;
+ return;
+ }
+
+ GL.MatrixMode(Enums.MatrixMode.MODELVIEW);
+ GL.LoadIdentity();
+ Glu.LookAt(
+ 0.0, 5.0, 5.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0
+ );
+
+ GL.Rotatef(angle, 0.0f, 1.0f, 0.0f);
+ angle += 0.5f;
+ }
+
+ #endregion
+
+ #region RenderFrame function
+
+ ///
+ /// Place your rendering code here.
+ ///
+ public override void RenderFrame()
+ {
+ GL.Clear(Enums.ClearBufferMask.COLOR_BUFFER_BIT | Enums.ClearBufferMask.DEPTH_BUFFER_BIT);
+
+ DrawCube();
+
+ Context.SwapBuffers();
+ }
+
+ #endregion
+
+ #region DrawCube function
+
+ ///
+ /// Draws simple, colored cube.
+ ///
+ protected void DrawCube()
+ {
+ GL.Begin(Enums.BeginMode.QUADS);
+
+ GL.Color3f(1, 0, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+
+ GL.Color3f(1, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+
+ GL.Color3f(1, 0, 1);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+
+ GL.Color3f(0, 0, 1);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 1);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+
+ GL.End();
+ }
+
+ #endregion
+
+ #region static public void Launch()
+
+ ///
+ /// Launches this example.
+ ///
+ ///
+ /// Provides a simple way for the example launcher to launch the examples.
+ ///
+ static public void Launch()
+ {
+ using (T03_RotatingCube ex = new T03_RotatingCube())
+ {
+ ex.Run();
+ }
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/Examples/Tutorial/T07_DisplayLists_Cube.cs b/Source/Examples/Tutorial/T07_DisplayLists_Cube.cs
new file mode 100644
index 00000000..cae35d41
--- /dev/null
+++ b/Source/Examples/Tutorial/T07_DisplayLists_Cube.cs
@@ -0,0 +1,170 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+using OpenTK.OpenGL;
+using Enums = OpenTK.OpenGL.Enums;
+using OpenTK;
+using OpenTK.Input;
+
+#endregion --- Using Directives ---
+
+namespace Examples.Tutorial
+{
+ public partial class T07_DisplayLists_Cube : GameWindow, IExample
+ {
+ #region --- Variables ---
+
+ List lists = new List();
+
+ #endregion --- Variables ---
+
+ #region --- Constructors ---
+
+ public T07_DisplayLists_Cube()
+ {
+ //Text =
+ // "DisplayLists example (" +
+ // GL.GetString(Enums.StringName.RENDERER) + " " +
+ // GL.GetString(Enums.StringName.VERSION)
+ // + ")";
+
+ GL.ClearColor(0.1f, 0.1f, 0.5f, 0.0f);
+ GL.Enable(Enums.EnableCap.DEPTH_TEST);
+
+ // Build some display lists.
+ float c = 0;
+ const int numDisplayLists = 9;
+ for (int i = numDisplayLists; i > 0; i--)
+ {
+ DisplayList d = new DisplayList();
+
+ d.Begin();
+
+ GL.Color3d(
+ 1.0,
+ c,
+ 1 - c
+ );
+
+ GL.Begin(Enums.BeginMode.QUADS);
+
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f( 1.0f, -1.0f, 1.0f);
+ GL.Vertex3f( 1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+
+ GL.End();
+
+ d.End();
+
+ lists.Add(d);
+
+ c += 1 / (float)numDisplayLists;
+ }
+
+ OnResize(new OpenTK.Platform.ResizeEventArgs(this.Width, this.Height));
+ }
+
+ #endregion
+
+ #region static public void Launch()
+
+ ///
+ /// Launches this example.
+ ///
+ ///
+ /// Provides a simple way for the example launcher to launch the examples.
+ ///
+ static public void Launch()
+ {
+ using (T03_RotatingCube ex = new T03_RotatingCube())
+ {
+ ex.Run();
+ }
+ }
+
+ #endregion
+
+ #region --- Event Handlers ---
+
+ #region OnResize
+
+ protected override void OnResize(OpenTK.Platform.ResizeEventArgs e)
+ {
+ base.OnResize(e);
+
+ GL.Viewport(0, 0, this.Width, this.Height);
+
+ double ratio = 0.0;
+ ratio = this.Width / (double)this.Height;
+
+ GL.MatrixMode(Enums.MatrixMode.PROJECTION);
+ GL.LoadIdentity();
+ Glu.Perspective(45.0, ratio, 1.0, 64.0);
+ Glu.LookAt(
+ 0.0, 0.0, 16.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0
+ );
+ }
+
+ #endregion
+
+ #region RenderFrame
+
+ public override void RenderFrame()
+ {
+ base.RenderFrame();
+
+ GL.MatrixMode(Enums.MatrixMode.MODELVIEW);
+ GL.LoadIdentity();
+
+ GL.Clear(Enums.ClearBufferMask.COLOR_BUFFER_BIT | Enums.ClearBufferMask.DEPTH_BUFFER_BIT);
+
+ double angle = 0.0;
+ foreach (DisplayList d in lists)
+ {
+ GL.LoadIdentity();
+ GL.Rotated(angle, 0.0, 0.0, 1.0);
+ GL.Translated(5.0, 0.0, 0.0);
+
+ d.Render();
+ angle += 360 / lists.Count;
+ }
+
+
+ Context.SwapBuffers();
+ }
+
+ #endregion
+
+ #region UpdateFrame
+
+ public override void UpdateFrame()
+ {
+ base.UpdateFrame();
+
+ if (Key.Escape)
+ {
+ this.Quit = true;
+ }
+ }
+
+ #endregion
+
+ #endregion --- Event Handlers ---
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/Tutorial/T08_VBO.cs b/Source/Examples/Tutorial/T08_VBO.cs
new file mode 100644
index 00000000..36fa5121
--- /dev/null
+++ b/Source/Examples/Tutorial/T08_VBO.cs
@@ -0,0 +1,235 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenTK;
+using OpenTK.OpenGL;
+using OpenTK.Input;
+using OpenTK.Platform;
+
+#endregion
+
+namespace Examples.Tutorial
+{
+ public class T08_VBO : OpenTK.GameWindow, IExample
+ {
+ #region --- Private Fields ---
+
+ int vbo, ibo, nbo; // vertex, index and normal buffer objects.
+ float angle;
+
+ // Cube vertices
+ float[] vdata =
+ {
+ -1.0f, -1.0f, 1.0f ,
+ 1.0f, -1.0f, 1.0f ,
+ 1.0f, 1.0f, 1.0f ,
+ -1.0f, 1.0f, 1.0f ,
+ -1.0f, -1.0f, -1.0f ,
+ 1.0f, -1.0f, -1.0f ,
+ 1.0f, 1.0f, -1.0f ,
+ -1.0f, 1.0f, -1.0f ,
+ };
+
+ // Cube normals
+ float[,] ndata =
+ {
+ { 1.0f, 0.0f, 0.0f },
+ { 0.0f, 1.0f, 0.0f },
+ { 0.0f, 0.0f, 1.0f },
+ { -1.0f, 0.0f, 0.0f },
+ { 0.0f, -1.0f, 0.0f },
+ { 0.0f, 0.0f, -1.0f },
+ };
+
+ // Indices
+ ushort[] idata =
+ {
+ // front face
+ 0, 1, 2, 3,
+ // top face
+ 3, 4, 6, 7,
+ // back face
+ 7, 6, 5, 4,
+ // left face
+ 4, 0, 3, 7,
+ // bottom face
+ 0, 1, 5, 4,
+ // right face
+ 1, 5, 6, 2,
+ };
+
+ #endregion
+
+ #region --- Constructor ---
+
+ public T08_VBO()
+ {
+ this.Context.MakeCurrent();
+
+ GL.ClearColor(0.1f, 0.1f, 0.5f, 0.0f);
+ GL.Enable(OpenTK.OpenGL.Enums.EnableCap.DEPTH_TEST);
+ GL.EnableClientState(OpenTK.OpenGL.Enums.EnableCap.VERTEX_ARRAY);
+ GL.EnableClientState(OpenTK.OpenGL.Enums.EnableCap.INDEX_ARRAY);
+ //GL.Enable(OpenTK.OpenGL.Enums.EnableCap.VERTEX_ARRAY);
+ //GL.Enable(OpenTK.OpenGL.Enums.EnableCap.INDEX_ARRAY);
+
+ LoadCube();
+
+ this.OnResize(new ResizeEventArgs(this.Width, this.Height));
+ }
+
+ #endregion
+
+ #region RenderFrame
+
+ public override void RenderFrame()
+ {
+ base.RenderFrame();
+
+ GL.Clear(
+ OpenTK.OpenGL.Enums.ClearBufferMask.COLOR_BUFFER_BIT |
+ OpenTK.OpenGL.Enums.ClearBufferMask.DEPTH_BUFFER_BIT);
+
+ GL.BindBuffer(OpenTK.OpenGL.Enums.VERSION_1_5.ARRAY_BUFFER, vbo);
+ GL.VertexPointer(3, OpenTK.OpenGL.Enums.VertexPointerType.FLOAT, 0, 0);
+
+ GL.BindBuffer(OpenTK.OpenGL.Enums.VERSION_1_5.ELEMENT_ARRAY_BUFFER, ibo);
+ GL.IndexPointer(OpenTK.OpenGL.Enums.IndexPointerType.FLOAT, 0, 0);
+
+ GL.Color3f(1.0f, 1.0f, 1.0f);
+ GL.DrawElements(
+ OpenTK.OpenGL.Enums.BeginMode.QUADS,
+ idata.Length,
+ OpenTK.OpenGL.Enums.GLenum.UNSIGNED_SHORT,
+ idata);
+
+ GL.BindBuffer(OpenTK.OpenGL.Enums.VERSION_1_5.ARRAY_BUFFER, 0);
+ GL.BindBuffer(OpenTK.OpenGL.Enums.VERSION_1_5.ELEMENT_ARRAY_BUFFER, 0);
+
+ Context.SwapBuffers();
+ }
+
+ #endregion
+
+ #region UpdateFrame
+
+ ///
+ /// Prepares the next frame for rendering.
+ ///
+ ///
+ /// Place your control logic here. This is the place to respond to user input,
+ /// update object positions etc.
+ ///
+ public override void UpdateFrame()
+ {
+ if (Key.Escape)
+ {
+ Quit = true;
+ return;
+ }
+
+ GL.MatrixMode(OpenTK.OpenGL.Enums.MatrixMode.MODELVIEW);
+ GL.LoadIdentity();
+ Glu.LookAt(
+ 0.0, 5.0, 5.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0
+ );
+
+ //GL.Rotatef(angle, 0.0f, 1.0f, 0.0f);
+ //angle += 0.5f;
+ }
+
+ #endregion
+
+ #region Resize event
+
+ protected override void OnResize(OpenTK.Platform.ResizeEventArgs e)
+ {
+ base.OnResize(e);
+
+ GL.Viewport(0, 0, e.Width, e.Height);
+
+ double ratio = e.Width / (double)e.Height;
+
+ GL.MatrixMode(OpenTK.OpenGL.Enums.MatrixMode.PROJECTION);
+ GL.LoadIdentity();
+ Glu.Perspective(45.0, ratio, 1.0, 64.0);
+ }
+
+ #endregion
+
+ #region LoadCube
+
+ private void LoadCube()
+ {
+ int size; // To check whether the buffers were uploaded correctly.
+
+ // First, generate the buffer objects
+ GL.GenBuffers(1, out vbo);
+ GL.GenBuffers(1, out ibo);
+
+ // Upload the vertex data
+ GL.BindBuffer(OpenTK.OpenGL.Enums.VERSION_1_5.ARRAY_BUFFER, vbo);
+ GL.BufferData(
+ OpenTK.OpenGL.Enums.VERSION_1_5.ARRAY_BUFFER,
+ (IntPtr)(vdata.Length * 4),
+ vdata,
+ OpenTK.OpenGL.Enums.VERSION_1_5.STATIC_DRAW);
+ GL.GetBufferParameteriv(
+ OpenTK.OpenGL.Enums.VERSION_1_5.ARRAY_BUFFER,
+ OpenTK.OpenGL.Enums.VERSION_1_5.BUFFER_SIZE,
+ out size);
+ if (vdata.Length * 4 != size)
+ {
+ throw new ApplicationException("Vertex array not uploaded correctly");
+ }
+
+ // Upload the index data
+ GL.BindBuffer(OpenTK.OpenGL.Enums.VERSION_1_5.ELEMENT_ARRAY_BUFFER, ibo);
+ GL.BufferData(
+ OpenTK.OpenGL.Enums.VERSION_1_5.ELEMENT_ARRAY_BUFFER,
+ (IntPtr)(idata.Length * 2),
+ idata,
+ OpenTK.OpenGL.Enums.VERSION_1_5.STATIC_DRAW
+ );
+ GL.GetBufferParameteriv(
+ OpenTK.OpenGL.Enums.VERSION_1_5.ELEMENT_ARRAY_BUFFER,
+ OpenTK.OpenGL.Enums.VERSION_1_5.BUFFER_SIZE,
+ out size);
+ if (idata.Length * 2 != size)
+ {
+ throw new ApplicationException("Index array not uploaded correctly");
+ }
+ }
+
+ #endregion
+
+ #region static public void Launch()
+
+ ///
+ /// Launches this example.
+ ///
+ ///
+ /// Provides a simple way for the example launcher to launch the examples.
+ ///
+ static public void Launch()
+ {
+ using (T08_VBO ex = new T08_VBO())
+ {
+ ex.Run();
+ }
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/Examples/Tutorial/T10_GLSL_Cube.cs b/Source/Examples/Tutorial/T10_GLSL_Cube.cs
new file mode 100644
index 00000000..669bc6ae
--- /dev/null
+++ b/Source/Examples/Tutorial/T10_GLSL_Cube.cs
@@ -0,0 +1,228 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+using System.Threading;
+
+using OpenTK.OpenGL;
+using Enums = OpenTK.OpenGL.Enums;
+using OpenTK;
+using OpenTK.Input;
+
+#endregion --- Using Directives ---
+
+namespace Examples.Tutorial
+{
+ public class T10_GLSL_Cube : GameWindow, IExample
+ {
+ #region --- Fields ---
+
+ #region Shaders
+
+ string[] vertex_shader_source =
+ {
+ "void main() {",
+ "gl_FrontColor = gl_Color;",
+ "gl_Position = ftransform();",
+ "}",
+ };
+
+ string[] fragment_shader_source =
+ {
+ "void main() { gl_FragColor = gl_Color; }\0"
+ };
+
+ #endregion
+
+ static float angle;
+
+ #endregion
+
+ #region --- Constructors ---
+
+ public T10_GLSL_Cube()
+ {
+ Context.MakeCurrent();
+
+ //Text =
+ // GL.GetString(Enums.StringName.VENDOR) + " " +
+ // GL.GetString(Enums.StringName.RENDERER) + " " +
+ // GL.GetString(Enums.StringName.VERSION);
+
+ GL.ClearColor(0.1f, 0.1f, 0.5f, 0.0f);
+ GL.Enable(Enums.EnableCap.DEPTH_TEST);
+
+ int vertex_shader_object, fragment_shader_object;
+ int status;
+ int shader_program;
+
+ vertex_shader_object = GL.CreateShader(Enums.VERSION_2_0.VERTEX_SHADER);
+ fragment_shader_object = GL.CreateShader(Enums.VERSION_2_0.FRAGMENT_SHADER);
+
+ GL.ShaderSource(vertex_shader_object, vertex_shader_source.Length, vertex_shader_source, null);
+ GL.CompileShader(vertex_shader_object);
+ GL.GetShaderiv(vertex_shader_object, Enums.VERSION_2_0.COMPILE_STATUS, out status);
+ if (status != (int)Enums.Boolean.TRUE)
+ {
+ StringBuilder info = new StringBuilder(1024);
+ GL.GetShaderInfoLog(vertex_shader_object, info.MaxCapacity, null, info);
+
+ throw new Exception(info.ToString());
+ }
+
+ GL.ShaderSource(fragment_shader_object, fragment_shader_source.Length, fragment_shader_source, null);
+ GL.CompileShader(fragment_shader_object);
+ GL.GetShaderiv(fragment_shader_object, Enums.VERSION_2_0.COMPILE_STATUS, out status);
+ if (status != (int)Enums.Boolean.TRUE)
+ {
+ StringBuilder info = new StringBuilder(1024);
+ GL.GetShaderInfoLog(fragment_shader_object, 1024, null, info);
+
+ throw new Exception(info.ToString());
+ }
+
+ shader_program = GL.CreateProgram();
+ GL.AttachShader(shader_program, fragment_shader_object);
+ GL.AttachShader(shader_program, vertex_shader_object);
+
+ GL.LinkProgram(shader_program);
+ GL.UseProgram(shader_program);
+
+ OnResize(new OpenTK.Platform.ResizeEventArgs(this.Width, this.Height));
+ }
+
+ #endregion
+
+ #region static public void Launch()
+
+ ///
+ /// Launches this example.
+ ///
+ ///
+ /// Provides a simple way for the example launcher to launch the examples.
+ ///
+ static public void Launch()
+ {
+ using (T10_GLSL_Cube ex = new T10_GLSL_Cube())
+ {
+ ex.Run();
+ }
+ }
+
+ #endregion
+
+ #region OnResize
+
+ protected override void OnResize(OpenTK.Platform.ResizeEventArgs e)
+ {
+ base.OnResize(e);
+
+ GL.Viewport(0, 0, this.Width, this.Height);
+
+ double ratio = 0.0;
+ ratio = this.Width / (double)this.Height;
+
+ GL.MatrixMode(Enums.MatrixMode.PROJECTION);
+ GL.LoadIdentity();
+ Glu.Perspective(45.0, ratio, 1.0, 64.0);
+ }
+
+ #endregion
+
+ #region UpdateFrame
+
+ public override void UpdateFrame()
+ {
+ base.UpdateFrame();
+
+ if (Key.Escape)
+ {
+ this.Quit = true;
+ }
+
+ GL.MatrixMode(Enums.MatrixMode.MODELVIEW);
+ GL.LoadIdentity();
+ Glu.LookAt(
+ 0.0, 5.0, 5.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0
+ );
+ GL.Rotatef(angle, 0.0f, 1.0f, 0.0f);
+ angle += 0.05f;
+ }
+
+ #endregion
+
+ #region RenderFrame
+
+ public override void RenderFrame()
+ {
+ base.RenderFrame();
+
+ GL.Clear(Enums.ClearBufferMask.COLOR_BUFFER_BIT | Enums.ClearBufferMask.DEPTH_BUFFER_BIT);
+
+ DrawCube();
+
+ Context.SwapBuffers();
+ }
+
+ #endregion
+
+ #region DrawCube
+
+ public void DrawCube()
+ {
+ GL.Begin(Enums.BeginMode.QUADS);
+
+ GL.Color3f(1, 0, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+
+ GL.Color3f(1, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+
+ GL.Color3f(1, 0, 1);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+
+ GL.Color3f(0, 0, 1);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 1);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+
+ GL.End();
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/Examples/WinForms/Cube.Designer.cs b/Source/Examples/WinForms/Cube.Designer.cs
new file mode 100644
index 00000000..2c5293f0
--- /dev/null
+++ b/Source/Examples/WinForms/Cube.Designer.cs
@@ -0,0 +1,60 @@
+namespace Examples.WinForms
+{
+ partial class Cube
+ {
+ ///
+ /// Required designer variable.
+ ///
+ private System.ComponentModel.IContainer components = null;
+
+ ///
+ /// Clean up any resources being used.
+ ///
+ /// true if managed resources should be disposed; otherwise, false.
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && (components != null))
+ {
+ components.Dispose();
+ }
+ base.Dispose(disposing);
+ }
+
+ #region Windows Form Designer generated code
+
+ ///
+ /// Required method for Designer support - do not modify
+ /// the contents of this method with the code editor.
+ ///
+ private void InitializeComponent()
+ {
+ this.glControl = new OpenTK.GLControl();
+ this.SuspendLayout();
+ //
+ // glControl
+ //
+ this.glControl.BackColor = System.Drawing.Color.MidnightBlue;
+ this.glControl.Dock = System.Windows.Forms.DockStyle.Fill;
+ this.glControl.Fullscreen = false;
+ this.glControl.Location = new System.Drawing.Point(0, 0);
+ this.glControl.Name = "glControl";
+ this.glControl.Size = new System.Drawing.Size(624, 444);
+ this.glControl.TabIndex = 0;
+ //
+ // Cube
+ //
+ this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+ this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+ this.ClientSize = new System.Drawing.Size(624, 444);
+ this.Controls.Add(this.glControl);
+ this.Name = "Cube";
+ this.Text = "Cube";
+ this.ResumeLayout(false);
+
+ }
+
+ #endregion
+
+ private OpenTK.GLControl glControl;
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/WinForms/Cube.cs b/Source/Examples/WinForms/Cube.cs
new file mode 100644
index 00000000..c824ce53
--- /dev/null
+++ b/Source/Examples/WinForms/Cube.cs
@@ -0,0 +1,210 @@
+#region --- License ---
+/* This source file is released under the MIT license. See License.txt for more information.
+ * Coded by Erik Ylvisaker and Stefanos Apostolopoulos.
+ */
+#endregion
+
+#region --- Using directives ---
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+using OpenTK.OpenGL;
+using Enums = OpenTK.OpenGL.Enums;
+using OpenTK.Platform;
+
+#endregion
+
+namespace Examples.WinForms
+{
+ public partial class Cube : Form, IExample
+ {
+ static float angle;
+
+ #region --- Constructor ---
+
+ public Cube()
+ {
+ InitializeComponent();
+
+ Application.Idle += Application_Idle;
+
+ this.ShowDialog();
+ }
+
+ #endregion
+
+ #region Closing event
+
+ protected override void OnClosing(CancelEventArgs e)
+ {
+ base.OnClosing(e);
+
+ Application.Idle -= Application_Idle;
+ }
+
+ #endregion
+
+ #region Application_Idle event
+
+ void Application_Idle(object sender, EventArgs e)
+ {
+ while (glControl.IsIdle)
+ {
+ Render();
+ }
+ }
+
+ #endregion
+
+ #region private void Render()
+
+ private void Render()
+ {
+ GL.MatrixMode(Enums.MatrixMode.MODELVIEW);
+ GL.LoadIdentity();
+ Glu.LookAt(
+ 0.0, 5.0, 5.0,
+ 0.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0
+ );
+ GL.Rotatef(angle, 0.0f, 1.0f, 0.0f);
+ angle += 0.5f;
+
+ GL.Clear(Enums.ClearBufferMask.COLOR_BUFFER_BIT | Enums.ClearBufferMask.DEPTH_BUFFER_BIT);
+
+ DrawCube();
+
+ glControl.Context.SwapBuffers();
+ }
+
+ #endregion
+
+ #region Load event handler
+
+ protected override void OnLoad(EventArgs e)
+ {
+ base.OnLoad(e);
+
+ Text =
+ GL.GetString(Enums.StringName.VENDOR) + " " +
+ GL.GetString(Enums.StringName.RENDERER) + " " +
+ GL.GetString(Enums.StringName.VERSION);
+
+ GL.ClearColor(0.1f, 0.1f, 0.5f, 0.0f);
+ GL.Enable(Enums.EnableCap.DEPTH_TEST);
+
+ glControl.KeyDown += new KeyEventHandler(Cube_KeyDown);
+
+ OnResize(e);
+ }
+
+ #endregion
+
+ #region Resize event handler
+
+ protected override void OnResize(EventArgs e)
+ {
+ base.OnResize(e);
+
+ if (ClientSize.Height == 0)
+ ClientSize = new System.Drawing.Size(ClientSize.Width, 1);
+
+ GL.Viewport(0, 0, ClientSize.Width, ClientSize.Height);
+
+ double ratio = 0.0;
+ ratio = ClientSize.Width / (double)ClientSize.Height;
+ //if (ClientSize.Width > ClientSize.Height)
+ // ratio = ClientSize.Width / (double)ClientSize.Height;
+ //else
+ // ratio = ClientSize.Height / (double)ClientSize.Width;
+
+ GL.MatrixMode(Enums.MatrixMode.PROJECTION);
+ GL.LoadIdentity();
+ Glu.Perspective(45.0, ratio, 1.0, 64.0);
+ }
+
+ #endregion
+
+ #region Paint event handler
+
+ protected override void OnPaint(PaintEventArgs e)
+ {
+ base.OnPaint(e);
+
+ Render();
+ }
+
+ #endregion
+
+ #region KeyDown event handler
+
+ void Cube_KeyDown(object sender, KeyEventArgs e)
+ {
+ if (e.Alt && e.Shift)
+ {
+ //this.SetResolution(this.Width, this.Height, this.ColorDepth, !this.IsFullscreen);
+ glControl.Fullscreen = !glControl.Fullscreen;
+ }
+
+ switch (e.KeyData)
+ {
+ case Keys.Escape:
+ this.Close();
+ break;
+ }
+ }
+
+ #endregion
+
+ #region DrawCube
+ public void DrawCube()
+ {
+ GL.Begin(Enums.BeginMode.QUADS);
+
+ GL.Color3f(1, 0, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+
+ GL.Color3f(1, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+
+ GL.Color3f(1, 0, 1);
+ GL.Vertex3f(-1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 0);
+ GL.Vertex3f(-1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+
+ GL.Color3f(0, 0, 1);
+ GL.Vertex3f(-1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(-1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+
+ GL.Color3f(0, 1, 1);
+ GL.Vertex3f(1.0f, -1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, -1.0f);
+ GL.Vertex3f(1.0f, 1.0f, 1.0f);
+ GL.Vertex3f(1.0f, -1.0f, 1.0f);
+
+ GL.End();
+ }
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/WinForms/Cube.resx b/Source/Examples/WinForms/Cube.resx
new file mode 100644
index 00000000..ff31a6db
--- /dev/null
+++ b/Source/Examples/WinForms/Cube.resx
@@ -0,0 +1,120 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
\ No newline at end of file
diff --git a/Source/Examples/WinForms/W01_First_Window.Designer.cs b/Source/Examples/WinForms/W01_First_Window.Designer.cs
new file mode 100644
index 00000000..abd7da73
--- /dev/null
+++ b/Source/Examples/WinForms/W01_First_Window.Designer.cs
@@ -0,0 +1,107 @@
+namespace Examples.WinForms
+{
+ partial class W01_First_Window
+ {
+ ///
+ /// Required designer variable.
+ ///
+ private System.ComponentModel.IContainer components = null;
+
+ ///
+ /// Clean up any resources being used.
+ ///
+ /// true if managed resources should be disposed; otherwise, false.
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && (components != null))
+ {
+ components.Dispose();
+ }
+ base.Dispose(disposing);
+ }
+
+ #region Windows Form Designer generated code
+
+ ///
+ /// Required method for Designer support - do not modify
+ /// the contents of this method with the code editor.
+ ///
+ private void InitializeComponent()
+ {
+ this.glControl1 = new OpenTK.GLControl();
+ this.redButton = new System.Windows.Forms.Button();
+ this.greenButton = new System.Windows.Forms.Button();
+ this.blueButton = new System.Windows.Forms.Button();
+ this.SuspendLayout();
+ //
+ // glControl1
+ //
+ this.glControl1.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+ | System.Windows.Forms.AnchorStyles.Left)
+ | System.Windows.Forms.AnchorStyles.Right)));
+ this.glControl1.BackColor = System.Drawing.SystemColors.ControlDarkDark;
+ this.glControl1.Fullscreen = false;
+ this.glControl1.Location = new System.Drawing.Point(1, 0);
+ this.glControl1.Name = "glControl1";
+ this.glControl1.Size = new System.Drawing.Size(629, 565);
+ this.glControl1.TabIndex = 0;
+ this.glControl1.Resize += new OpenTK.Platform.ResizeEvent(this.glControl1_Resize);
+ this.glControl1.Paint += new System.Windows.Forms.PaintEventHandler(this.glControl1_Paint);
+ this.glControl1.KeyDown += new System.Windows.Forms.KeyEventHandler(this.glControl1_KeyDown);
+ //
+ // redButton
+ //
+ this.redButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+ this.redButton.Location = new System.Drawing.Point(639, 13);
+ this.redButton.Name = "redButton";
+ this.redButton.Size = new System.Drawing.Size(133, 23);
+ this.redButton.TabIndex = 1;
+ this.redButton.Text = "Red";
+ this.redButton.UseVisualStyleBackColor = true;
+ this.redButton.Click += new System.EventHandler(this.redButton_Click);
+ //
+ // greenButton
+ //
+ this.greenButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+ this.greenButton.Location = new System.Drawing.Point(639, 43);
+ this.greenButton.Name = "greenButton";
+ this.greenButton.Size = new System.Drawing.Size(133, 23);
+ this.greenButton.TabIndex = 2;
+ this.greenButton.Text = "Green";
+ this.greenButton.UseVisualStyleBackColor = true;
+ this.greenButton.Click += new System.EventHandler(this.greenButton_Click);
+ //
+ // blueButton
+ //
+ this.blueButton.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+ this.blueButton.Location = new System.Drawing.Point(639, 73);
+ this.blueButton.Name = "blueButton";
+ this.blueButton.Size = new System.Drawing.Size(133, 23);
+ this.blueButton.TabIndex = 3;
+ this.blueButton.Text = "Blue";
+ this.blueButton.UseVisualStyleBackColor = true;
+ this.blueButton.Click += new System.EventHandler(this.blueButton_Click);
+ //
+ // W01_First_Window
+ //
+ this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+ this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+ this.ClientSize = new System.Drawing.Size(781, 564);
+ this.Controls.Add(this.blueButton);
+ this.Controls.Add(this.greenButton);
+ this.Controls.Add(this.redButton);
+ this.Controls.Add(this.glControl1);
+ this.Name = "W01_First_Window";
+ this.Text = "OpenTK Windows Forms Tutorial 01 - Your first window";
+ this.ResumeLayout(false);
+
+ }
+
+ #endregion
+
+ private OpenTK.GLControl glControl1;
+ private System.Windows.Forms.Button redButton;
+ private System.Windows.Forms.Button greenButton;
+ private System.Windows.Forms.Button blueButton;
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/WinForms/W01_First_Window.cs b/Source/Examples/WinForms/W01_First_Window.cs
new file mode 100644
index 00000000..732cc481
--- /dev/null
+++ b/Source/Examples/WinForms/W01_First_Window.cs
@@ -0,0 +1,75 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using directives ---
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Data;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+
+using OpenTK;
+using OpenTK.OpenGL;
+
+#endregion
+
+namespace Examples.WinForms
+{
+ public partial class W01_First_Window : Form, IExample
+ {
+ public W01_First_Window()
+ {
+ InitializeComponent();
+
+ this.ShowDialog();
+ }
+
+ private void redButton_Click(object sender, EventArgs e)
+ {
+ GL.ClearColor(0.7f, 0.0f, 0.0f, 0.0f);
+ glControl1.Invalidate();
+ }
+
+ private void greenButton_Click(object sender, EventArgs e)
+ {
+ GL.ClearColor(0.0f, 0.5f, 0.0f, 0.0f);
+ glControl1.Invalidate();
+ }
+
+ private void blueButton_Click(object sender, EventArgs e)
+ {
+ GL.ClearColor(0.0f, 0.0f, 0.7f, 0.0f);
+ glControl1.Invalidate();
+ }
+
+ private void glControl1_Paint(object sender, PaintEventArgs e)
+ {
+ GL.Clear(OpenTK.OpenGL.Enums.ClearBufferMask.COLOR_BUFFER_BIT);
+ glControl1.Context.SwapBuffers();
+ }
+
+ private void glControl1_Resize(object sender, OpenTK.Platform.ResizeEventArgs e)
+ {
+ if (glControl1.ClientSize.Height == 0)
+ glControl1.ClientSize = new System.Drawing.Size(glControl1.ClientSize.Width, 1);
+
+ GL.Viewport(0, 0, glControl1.ClientSize.Width, glControl1.ClientSize.Height);
+ }
+
+ private void glControl1_KeyDown(object sender, KeyEventArgs e)
+ {
+ switch (e.KeyData)
+ {
+ case Keys.Escape:
+ this.Close();
+ break;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/Source/Examples/WinForms/W01_First_Window.resx b/Source/Examples/WinForms/W01_First_Window.resx
new file mode 100644
index 00000000..ff31a6db
--- /dev/null
+++ b/Source/Examples/WinForms/W01_First_Window.resx
@@ -0,0 +1,120 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ text/microsoft-resx
+
+
+ 2.0
+
+
+ System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
+ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
+
+
\ No newline at end of file
diff --git a/Source/OpenTK/GLControl.Designer.cs b/Source/OpenTK/GLControl.Designer.cs
new file mode 100644
index 00000000..092b00f1
--- /dev/null
+++ b/Source/OpenTK/GLControl.Designer.cs
@@ -0,0 +1,39 @@
+using System;
+
+namespace OpenTK
+{
+ partial class GLControl
+ {
+ ///
+ /// Required designer variable.
+ ///
+ private System.ComponentModel.IContainer components = null;
+
+ ///
+ /// Clean up any resources being used.
+ ///
+ /// true if managed resources should be disposed; otherwise, false.
+ protected override void Dispose(bool disposing)
+ {
+ if (disposing && (components != null))
+ {
+ components.Dispose();
+ }
+ base.Dispose(disposing);
+ }
+
+ #region Component Designer generated code
+
+ ///
+ /// Required method for Designer support - do not modify
+ /// the contents of this method with the code editor.
+ ///
+ private void InitializeComponent()
+ {
+ components = new System.ComponentModel.Container();
+ this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/GLControl.cs b/Source/OpenTK/GLControl.cs
new file mode 100644
index 00000000..81befbb6
--- /dev/null
+++ b/Source/OpenTK/GLControl.cs
@@ -0,0 +1,296 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Drawing;
+using System.Text;
+using System.Windows.Forms;
+using System.Diagnostics;
+
+using OpenTK.Platform;
+
+#endregion
+
+namespace OpenTK
+{
+ // TODO: Document the GLControl class.
+
+ ///
+ ///
+ ///
+ public partial class GLControl : UserControl, IGLControl
+ {
+ #region --- Private Fields ---
+
+ private bool fullscreen;
+ private IGLControl glControl;
+
+ #endregion
+
+ #region --- Contructors ---
+
+ ///
+ /// Constructs a new GLControl.
+ ///
+ public GLControl()
+ :this(new DisplayMode())
+ {
+ }
+
+ public GLControl(DisplayMode mode)
+ {
+ InitializeComponent();
+
+ System.Diagnostics.Debug.Listeners.Clear();
+ System.Diagnostics.Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
+ System.Diagnostics.Debug.AutoFlush = true;
+ System.Diagnostics.Trace.Listeners.Clear();
+ System.Diagnostics.Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
+ System.Diagnostics.Trace.AutoFlush = true;
+ Trace.AutoFlush = true;
+
+ if (Environment.OSVersion.Platform == PlatformID.Win32NT ||
+ Environment.OSVersion.Platform == PlatformID.Win32Windows)
+ {
+ glControl = new OpenTK.Platform.Windows.WinGLControl(this, Width, Height, false);
+ }
+ else if (Environment.OSVersion.Platform == PlatformID.Unix ||
+ Environment.OSVersion.Platform == (PlatformID)128)
+ // some older versions of Mono reported 128.
+ {
+ glControl = new OpenTK.Platform.X11.X11GLControl(this, Width, Height, false);
+ }
+ else
+ {
+ throw new PlatformNotSupportedException(
+ "Your operating system is not currently supported. We are sorry for the inconvenience."
+ );
+ }
+
+ glControl.Context.MakeCurrent();
+ /*
+ Context.MakeCurrent();
+
+ //GL.ReloadFunctions();
+
+ if (width > 0)
+ this.Width = width;
+ if (height > 0)
+ this.Height = height;
+ */
+ if (fullscreen)
+ this.Fullscreen = true;
+
+ this.SetStyle(ControlStyles.UserPaint, true);
+ this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
+ }
+
+ #endregion
+
+ #region --- Public Methods ---
+
+ ///
+ /// Swaps the front and back buffers, and presents the rendered scene to the screen.
+ ///
+ public void SwapBuffers()
+ {
+ Context.SwapBuffers();
+ }
+
+ ///
+ /// Makes the underlying GLContext of this GLControl current. All OpenGL commands issued
+ /// from this point are interpreted by this GLContext.
+ ///
+ public void MakeCurrent()
+ {
+ Context.MakeCurrent();
+ }
+
+ #endregion
+
+ #region --- Public Properties ---
+
+ ///
+ /// Gets the AspectRatio of the control this GLContext object
+ /// renders to. This is usually used in a call to Glu.Perspective.
+ ///
+ public double AspectRatio
+ {
+ get
+ {
+ return this.Width / (double)this.Height;
+ }
+ }
+
+ ///
+ /// Gets or sets the display mode of the control.
+ ///
+ public bool Fullscreen
+ {
+ get
+ {
+ return fullscreen;
+ }
+ set
+ {
+ if (!fullscreen && value)
+ {
+ //fullscreen = this.SetFullscreenResolution(this.Width, this.Height);
+ }
+ else if (fullscreen && !value)
+ {
+ }
+ }
+ }
+
+ #endregion
+
+ #region --- IGLControl Members ---
+
+ public event CreateEvent Create;
+
+ #region public bool IsIdle
+
+ ///
+ /// Gets the idle status of the control.
+ ///
+ public bool IsIdle
+ {
+ get { return glControl.IsIdle; }
+ }
+
+ #endregion
+
+ #region public IGLContext Context
+
+ ///
+ /// Gets the opengl context associated with this control.
+ ///
+ public IGLContext Context
+ {
+ get { return glControl.Context; }
+ }
+
+ #endregion
+
+ #region DisplayMode changes
+
+ ///
+ /// Selects the fullscreen DisplayMode closest to the DisplayMode requested.
+ ///
+ ///
+ /// The fullscreen DisplayMode to match, or null to get the current screen DisplayMode.
+ ///
+ /// The DisplayMode closest to the requested one, or null if no DisplayModes are available.
+ ///
+ /// SetDisplayMode
+ ///
+ public DisplayMode SelectDisplayMode(DisplayMode mode)
+ {
+ throw new NotImplementedException();
+ //return glWindow.SelectDisplayMode(mode);
+ }
+
+ ///
+ /// Selects the fullscreen DisplayMode closest to the DisplayMode requested, accoriding to the specified
+ /// parameters.
+ ///
+ ///
+ /// The fullscreen DisplayMode to match, or null to get the current screen DisplayMode.
+ ///
+ ///
+ /// The DisplayModeMatchOptions flags that indicate how to search for the requested DisplayMode.
+ ///
+ ///
+ /// The DisplayMode closest to the requested one, or null if no DisplayModes are available or
+ /// DisplayModeMatchOptions.ExactMatch was passed.
+ ///
+ ///
+ /// SetDisplayMode
+ ///
+ public DisplayMode SelectDisplayMode(DisplayMode mode, DisplayModeMatchOptions options)
+ {
+ throw new NotImplementedException();
+ //return glWindow.SelectDisplayMode(mode, options);
+ }
+
+ ///
+ /// Sets the requested DisplayMode.
+ ///
+ ///
+ /// The fulscreen DisplayMode to set. Passing null will return the application to windowed
+ /// mode.
+ ///
+ ///
+ /// Use SelectDisplayMode to select one of the available fullscreen modes.
+ ///
+ /// If the mode requested is not available, this function will throw a
+ /// DisplayModeNotAvailable exception.
+ ///
+ ///
+ /// Pass null to return to windowed mode. The previous desktop DisplayMode will be automatically reset by this
+ /// function. This function cannot be used to permanently change the user's desktop DisplayMode.
+ ///
+ /// SelectDisplayMode
+ /// DisplayModeNotAvailable exception
+ ///
+ public void SetDisplayMode(DisplayMode mode)
+ {
+ throw new NotImplementedException();
+ //glWindow.SetDisplayMode(mode);
+ }
+
+ #endregion
+
+ public void ProcessEvents()
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+
+ #endregion
+
+ #region --- IResizable Members ---
+
+ public new event ResizeEvent Resize;
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ protected override void DestroyHandle()
+ {
+ base.DestroyHandle();
+
+ glControl.Dispose();
+ }
+
+ /*
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private void Dispose(bool manuallyCalled)
+ {
+ if (manuallyCalled)
+ {
+ glWindow.Dispose();
+ }
+ }
+
+ ~GLControl()
+ {
+ this.Dispose(false);
+ }
+ */
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/GameWindow.cs b/Source/OpenTK/GameWindow.cs
new file mode 100644
index 00000000..8a3dbb01
--- /dev/null
+++ b/Source/OpenTK/GameWindow.cs
@@ -0,0 +1,263 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenTK.Platform;
+using System.Diagnostics;
+
+namespace OpenTK
+{
+ public class GameWindow : OpenTK.Platform.IGLControl, OpenTK.Platform.IGameWindow
+ {
+ INativeWindow glWindow;
+
+ private ResizeEventArgs resizeEventArgs = new ResizeEventArgs();
+
+ #region --- Contructors ---
+
+ ///
+ /// Constructs a new GameWindow, using a safe DisplayMode.
+ ///
+ public GameWindow()
+ {
+ System.Diagnostics.Debug.Listeners.Clear();
+ System.Diagnostics.Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
+ System.Diagnostics.Debug.AutoFlush = true;
+ System.Diagnostics.Trace.Listeners.Clear();
+ System.Diagnostics.Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
+ System.Diagnostics.Trace.AutoFlush = true;
+
+ if (Environment.OSVersion.Platform == PlatformID.Win32NT ||
+ Environment.OSVersion.Platform == PlatformID.Win32Windows)
+ {
+ // Create a new Windows native window. We want to be notified when it's ready,
+ // in order to do some preparatory work.
+ glWindow = new OpenTK.Platform.Windows.WinGLNative();
+ }
+ else if (Environment.OSVersion.Platform == PlatformID.Unix ||
+ Environment.OSVersion.Platform == (PlatformID)128) // some older versions of Mono reported 128.
+ {
+ glWindow = new OpenTK.Platform.X11.X11GLNative();
+ }
+ else
+ {
+ throw new PlatformNotSupportedException(
+ "Your operating system is not currently supported. We are sorry for the inconvenience."
+ );
+ }
+
+ glWindow.Context.MakeCurrent();
+
+ // When the glWindow construction is complete, hook the resize events.
+ resizeEventArgs.Width = this.Width;
+ resizeEventArgs.Height = this.Height;
+ glWindow.Resize += new ResizeEvent(glWindow_Resize);
+ glWindow.Create += new CreateEvent(glWindow_Create);
+ }
+
+ void glWindow_Create(object sender, EventArgs e)
+ {
+ this.OnCreate(e);
+ }
+
+ void glWindow_Resize(object sender, ResizeEventArgs e)
+ {
+ this.OnResize(e);
+ }
+
+ #endregion
+
+ #region --- IGLWindow Members ---
+
+ #region public bool IsIdle
+
+ public bool IsIdle
+ {
+ get { return glWindow.IsIdle; }
+ }
+
+ #endregion
+
+ #region public bool Fullscreen
+
+ public bool Fullscreen
+ {
+ get { return glWindow.Fullscreen; }
+ set { glWindow.Fullscreen = value; }
+ }
+
+ #endregion
+
+ #region public OpenTK.Platform.IGLContext Context
+
+ public OpenTK.Platform.IGLContext Context
+ {
+ get { return glWindow.Context; }
+ }
+
+ #endregion
+
+ #region public bool Quit
+
+ public bool Quit
+ {
+ get { return glWindow.Quit; }
+ set { glWindow.Quit = value; }
+ }
+
+ #endregion
+
+ #endregion
+
+ #region --- IGameWindow Members ---
+
+ ///
+ /// Runs a default game loop on the GameWindow.
+ ///
+ ///
+ ///
+ /// A default game loop consists of three parts: Event processing,
+ /// a frame update and a frame render.
+ ///
+ ///
+ /// Override this function if you want to change the behaviour of the
+ /// default game loop. If you override this function, you must place
+ /// a call to the ProcessEvents function, so that your window will respond
+ /// to Operating System events.
+ ///
+ ///
+ public virtual void Run()
+ {
+ while (!this.Quit)
+ {
+ this.ProcessEvents();
+ this.UpdateFrame();
+ this.RenderFrame();
+ }
+ }
+
+ public void ProcessEvents()
+ {
+ glWindow.ProcessEvents();
+ }
+
+ #region public event CreateEvent Create;
+
+ public event CreateEvent Create;
+
+ private void OnCreate(EventArgs e)
+ {
+ if (this.Create != null)
+ {
+ this.Create(this, e);
+ }
+ }
+
+ #endregion
+
+ public virtual void RenderFrame()
+ {
+ if (RenderFrameNotify != null)
+ RenderFrameNotify(EventArgs.Empty);
+ }
+
+ public virtual void UpdateFrame()
+ {
+ if (UpdateFrameNotify != null)
+ UpdateFrameNotify(EventArgs.Empty);
+ }
+
+ public event UpdateFrameEvent UpdateFrameNotify;
+ public event RenderFrameEvent RenderFrameNotify;
+
+ #endregion
+
+ #region --- IResizable Members ---
+
+ #region public int Width, Height
+
+ public int Width
+ {
+ get { return glWindow.Width; }
+ set
+ {
+ if (value == this.Width)
+ {
+ return;
+ }
+ else if (value > 0)
+ {
+ glWindow.Width = value;
+ }
+ else
+ {
+ throw new ArgumentOutOfRangeException(
+ "Width",
+ value,
+ "Width must be greater than 0"
+ );
+ }
+ }
+ }
+
+ public int Height
+ {
+ get { return glWindow.Height; }
+ set
+ {
+ if (value == this.Height)
+ {
+ return;
+ }
+ else if (value > 0)
+ {
+ glWindow.Height = value;
+ }
+ else
+ {
+ throw new ArgumentOutOfRangeException(
+ "Height",
+ value,
+ "Height must be greater than 0"
+ );
+ }
+ }
+ }
+
+ #endregion
+
+ #region public event ResizeEvent Resize;
+
+ public event ResizeEvent Resize;
+
+ ///
+ /// Raises the Resize event.
+ ///
+ /// Contains the new Width and Height of the window.
+ protected virtual void OnResize(ResizeEventArgs e)
+ {
+ if (this.Resize != null)
+ this.Resize(this, e);
+ }
+
+ #endregion
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ public void Dispose()
+ {
+ glWindow.Dispose();
+ glWindow = null;
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Input/Key.cs b/Source/OpenTK/Input/Key.cs
new file mode 100644
index 00000000..31bdbe39
--- /dev/null
+++ b/Source/OpenTK/Input/Key.cs
@@ -0,0 +1,255 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.Input
+{
+ static public class Key
+ {
+ static private bool[] keys = new bool[(int)Keys.MaxKeys];
+
+ #region Modifiers
+
+ static public bool LeftShift
+ {
+ get { return keys[(int)Keys.LeftShift]; }
+ internal set { keys[(int)Keys.LeftShift] = value; }
+ }
+
+ static public bool RightShift
+ {
+ get { return keys[(int)Keys.RightShift]; }
+ internal set { keys[(int)Keys.RightShift] = value; }
+ }
+
+ static public bool LeftControl
+ {
+ get { return keys[(int)Keys.LeftControl]; }
+ internal set { keys[(int)Keys.LeftControl] = value; }
+ }
+
+ static public bool RightControl
+ {
+ get { return keys[(int)Keys.RightControl]; }
+ internal set { keys[(int)Keys.RightControl] = value; }
+ }
+
+ static public bool LeftAlt
+ {
+ get { return keys[(int)Keys.LeftAlt]; }
+ internal set { keys[(int)Keys.LeftAlt] = value; }
+ }
+
+ static public bool RightAlt
+ {
+ get { return keys[(int)Keys.RightAlt]; }
+ internal set { keys[(int)Keys.RightAlt] = value; }
+ }
+
+ #endregion
+
+ #region Function Keys
+
+ static public bool F1
+ {
+ get { return keys[(int)Keys.F1]; }
+ internal set { keys[(int)Keys.F1] = value; }
+ }
+
+ static public bool F2
+ {
+ get { return keys[(int)Keys.F2]; }
+ internal set { keys[(int)Keys.F2] = value; }
+ }
+
+ static public bool F3
+ {
+ get { return keys[(int)Keys.F3]; }
+ internal set { keys[(int)Keys.F3] = value; }
+ }
+
+ static public bool F4
+ {
+ get { return keys[(int)Keys.F4]; }
+ internal set { keys[(int)Keys.F4] = value; }
+ }
+
+ static public bool F5
+ {
+ get { return keys[(int)Keys.F5]; }
+ internal set { keys[(int)Keys.F5] = value; }
+ }
+
+ static public bool F6
+ {
+ get { return keys[(int)Keys.F6]; }
+ internal set { keys[(int)Keys.F6] = value; }
+ }
+
+ static public bool F7
+ {
+ get { return keys[(int)Keys.F7]; }
+ internal set { keys[(int)Keys.F7] = value; }
+ }
+
+ static public bool F8
+ {
+ get { return keys[(int)Keys.F8]; }
+ internal set { keys[(int)Keys.F8] = value; }
+ }
+
+ static public bool F9
+ {
+ get { return keys[(int)Keys.F9]; }
+ internal set { keys[(int)Keys.F9] = value; }
+ }
+
+ static public bool F10
+ {
+ get { return keys[(int)Keys.F10]; }
+ internal set { keys[(int)Keys.F10] = value; }
+ }
+
+ static public bool F11
+ {
+ get { return keys[(int)Keys.F11]; }
+ internal set { keys[(int)Keys.F11] = value; }
+ }
+
+ static public bool F12
+ {
+ get { return keys[(int)Keys.F12]; }
+ internal set { keys[(int)Keys.F12] = value; }
+ }
+
+ static public bool F13
+ {
+ get { return keys[(int)Keys.F13]; }
+ internal set { keys[(int)Keys.F13] = value; }
+ }
+
+ static public bool F14
+ {
+ get { return keys[(int)Keys.F14]; }
+ internal set { keys[(int)Keys.F14] = value; }
+ }
+
+ static public bool F15
+ {
+ get { return keys[(int)Keys.F15]; }
+ internal set { keys[(int)Keys.F15] = value; }
+ }
+
+ static public bool F16
+ {
+ get { return keys[(int)Keys.F16]; }
+ internal set { keys[(int)Keys.F16] = value; }
+ }
+
+ #endregion
+
+ static public bool Enter
+ {
+ get { return keys[(int)Keys.Enter]; }
+ internal set { keys[(int)Keys.Enter] = value; }
+ }
+
+ static public bool Escape
+ {
+ get { return keys[(int)Keys.Escape]; }
+ internal set { keys[(int)Keys.Escape] = value; }
+ }
+ }
+
+ enum Keys : int
+ {
+ // Modifiers
+ LeftShift = 0,
+ RightShift,
+ LeftControl,
+ RightControl,
+ LeftAlt,
+ RightAlt,
+
+ // Function keys (hopefully enough for most keyboards - mine has 26)
+ F1, F2, F3, F4,
+ F5, F6, F7, F8,
+ F9, F10, F11, F12,
+ F13, F14, F15, F16,
+ F17, F18, F19, F20,
+ F21, F22, F23, F24,
+ F25, F26, F27, F28,
+ F29, F30, F31, F32,
+
+ // Direction arrows
+ Up,
+ Down,
+ Left,
+ Right,
+
+ // Special keys
+ Enter,
+ Escape,
+ Space,
+ Tab,
+ Backspace,
+ Insert,
+ Delete,
+ PageUp,
+ PageDown,
+ Home,
+ End,
+ CapsLock,
+
+ // Keypad keys
+ Keypad0,
+ Keypad1,
+ Keypad2,
+ Keypad3,
+ Keypad4,
+ Keypad5,
+ Keypad6,
+ Keypad7,
+ Keypad8,
+ Keypad9,
+ KeypadDivide,
+ KeypadMultiply,
+ KeypadSubtract,
+ KeypadAdd,
+ KeypadDecimal,
+ KeypadEqual,
+ KeypadEnter,
+
+ // Letters
+ A, B, C, D, E, F, G,
+ H, I, J, K, L, M, N,
+ O, P, Q, R, S, T, U,
+ V, W, X, Y, Z,
+
+ // Numbers
+ Number0,
+ Number1,
+ Number2,
+ Number3,
+ Number4,
+ Number5,
+ Number6,
+ Number7,
+ Number8,
+ Number9,
+
+ // Symbols
+ Minus,
+ Equal,
+ LeftBracket,
+ RightBracket,
+ Semicolon,
+ QuotationMark,
+ Comma,
+ FullStop,
+ Slash,
+ BackSlash,
+
+ MaxKeys
+ }
+}
diff --git a/Source/OpenTK/OpenGL/Bindings/GL.cs b/Source/OpenTK/OpenGL/Bindings/GL.cs
new file mode 100644
index 00000000..a5ecd6a1
--- /dev/null
+++ b/Source/OpenTK/OpenGL/Bindings/GL.cs
@@ -0,0 +1,49886 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:2.0.50727.312
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace OpenTK.OpenGL
+{
+ using System;
+ using System.Runtime.InteropServices;
+ using System.Text;
+ using GLsizei = System.Int32;
+ using GLsizeiptr = System.IntPtr;
+ using GLintptr = System.IntPtr;
+ using GLboolean = System.Boolean;
+ using GLbitfield = System.Int32;
+ using GLvoid = System.Object;
+ using GLchar = System.Char;
+ using GLbyte = System.Byte;
+ using GLubyte = System.Byte;
+ using GLshort = System.Int16;
+ using GLushort = System.Int16;
+ using GLint = System.Int32;
+ using GLuint = System.Int32;
+ using GLfloat = System.Single;
+ using GLclampf = System.Single;
+ using GLdouble = System.Double;
+ using GLclampd = System.Double;
+ using GLstring = System.String;
+ 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 GLint64EXT = System.Int64;
+ using GLuint64EXT = System.Int64;
+ using GLint64 = System.Int64;
+ using GLuint64 = System.Int64;
+
+ #region GL class
+ public partial class GL
+ {
+ #pragma warning disable 1591
+
+ #region Private Constants
+
+ #region string GL_NATIVE_LIBRARY
+ ///
+ /// Specifies OpenGl's native library archive.
+ ///
+ ///
+ /// Specifies opengl32.dll everywhere; will be mapped via .config for mono.
+ ///
+ internal const string GL_NATIVE_LIBRARY = "opengl32.dll";
+ #endregion string GL_NATIVE_LIBRARY
+
+ #endregion Private Constants
+
+ #region OpenGL functions
+ public static void Accum(Enums.AccumOp op, GLfloat value)
+ {
+ Delegates.glAccum(op, value);
+ }
+ public static void ActiveStencilFaceEXT(Enums.EXT_stencil_two_side face)
+ {
+ Delegates.glActiveStencilFaceEXT(face);
+ }
+ public static void ActiveTexture(Enums.VERSION_1_3 texture)
+ {
+ Delegates.glActiveTexture(texture);
+ }
+ public static void ActiveTextureARB(Enums.ARB_multitexture texture)
+ {
+ Delegates.glActiveTextureARB(texture);
+ }
+ public static void ActiveVaryingNV(GLuint program, string name)
+ {
+ Delegates.glActiveVaryingNV(program, name);
+ }
+ public static void AlphaFragmentOp1ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
+ {
+ Delegates.glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
+ }
+ public static void AlphaFragmentOp2ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
+ {
+ Delegates.glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
+ }
+ public static void AlphaFragmentOp3ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
+ {
+ Delegates.glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
+ }
+ public static void AlphaFunc(Enums.AlphaFunction func, GLclampf @ref)
+ {
+ Delegates.glAlphaFunc(func, @ref);
+ }
+ public static void ApplyTextureEXT(Enums.EXT_light_texture mode)
+ {
+ Delegates.glApplyTextureEXT(mode);
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, [In, Out()] System.IntPtr residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ residences = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (System.IntPtr)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, System.IntPtr programs, out Enums.Boolean residences)
+ {
+ residences = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, programs, h0.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h0.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, GLuint[] programs, out Enums.Boolean residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ residences = default(Enums.Boolean);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, ref GLuint programs, out Enums.Boolean residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ residences = default(Enums.Boolean);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, ref GLuint programs, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, ref GLuint programs, [In, Out()] System.IntPtr residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ residences = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (System.IntPtr)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, System.IntPtr programs, [In, Out()] System.IntPtr residences)
+ {
+ return Delegates.glAreProgramsResidentNV(n, programs, residences);
+ }
+ public static GLboolean AreProgramsResidentNV(GLsizei n, System.IntPtr programs, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreProgramsResidentNV(n, programs, h0.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, System.IntPtr textures, [In, Out()] System.IntPtr residences)
+ {
+ return Delegates.glAreTexturesResident(n, textures, residences);
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, System.IntPtr textures, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, textures, h0.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, out Enums.Boolean residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(Enums.Boolean);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, ref GLuint textures, out Enums.Boolean residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(Enums.Boolean);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, ref GLuint textures, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, ref GLuint textures, [In, Out()] System.IntPtr residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (System.IntPtr)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, System.IntPtr textures, out Enums.Boolean residences)
+ {
+ residences = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, textures, h0.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h0.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLboolean AreTexturesResident(GLsizei n, GLuint[] textures, [In, Out()] System.IntPtr residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResident(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (System.IntPtr)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, out Enums.Boolean residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(Enums.Boolean);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, ref GLuint textures, [In, Out()] System.IntPtr residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (System.IntPtr)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, ref GLuint textures, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, System.IntPtr textures, [In, Out()] System.IntPtr residences)
+ {
+ return Delegates.glAreTexturesResidentEXT(n, textures, residences);
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, GLuint[] textures, [In, Out()] System.IntPtr residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (System.IntPtr)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, System.IntPtr textures, Enums.Boolean[] residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, textures, h0.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, ref GLuint textures, out Enums.Boolean residences)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ residences = default(Enums.Boolean);
+ GCHandle h1 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h1.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLboolean AreTexturesResidentEXT(GLsizei n, System.IntPtr textures, out Enums.Boolean residences)
+ {
+ residences = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(residences, GCHandleType.Pinned);
+ try
+ {
+ GLboolean retval;
+ retval = Delegates.glAreTexturesResidentEXT(n, textures, h0.AddrOfPinnedObject());
+ residences = (Enums.Boolean)h0.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ArrayElement(GLint i)
+ {
+ Delegates.glArrayElement(i);
+ }
+ public static void ArrayElementEXT(GLint i)
+ {
+ Delegates.glArrayElementEXT(i);
+ }
+ public static void ArrayObjectATI(Enums.EnableCap array, GLint size, Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset)
+ {
+ Delegates.glArrayObjectATI(array, size, type, stride, buffer, offset);
+ }
+ public static void AsyncMarkerSGIX(GLuint marker)
+ {
+ Delegates.glAsyncMarkerSGIX(marker);
+ }
+ public static void AttachObjectARB(GLhandleARB containerObj, GLhandleARB obj)
+ {
+ Delegates.glAttachObjectARB(containerObj, obj);
+ }
+ public static void AttachShader(GLuint program, GLuint shader)
+ {
+ Delegates.glAttachShader(program, shader);
+ }
+ public static void Begin(Enums.BeginMode mode)
+ {
+ Delegates.glBegin(mode);
+ }
+ public static void BeginFragmentShaderATI()
+ {
+ Delegates.glBeginFragmentShaderATI();
+ }
+ public static void BeginOcclusionQueryNV(GLuint id)
+ {
+ Delegates.glBeginOcclusionQueryNV(id);
+ }
+ public static void BeginQuery(Enums.VERSION_1_5 target, GLuint id)
+ {
+ Delegates.glBeginQuery(target, id);
+ }
+ public static void BeginQueryARB(Enums.ARB_occlusion_query target, GLuint id)
+ {
+ Delegates.glBeginQueryARB(target, id);
+ }
+ public static void BeginTransformFeedbackNV(Enums.GLenum primitiveMode)
+ {
+ Delegates.glBeginTransformFeedbackNV(primitiveMode);
+ }
+ public static void BeginVertexShaderEXT()
+ {
+ Delegates.glBeginVertexShaderEXT();
+ }
+ public static void BindAttribLocation(GLuint program, GLuint index, string name)
+ {
+ Delegates.glBindAttribLocation(program, index, name);
+ }
+ public static void BindAttribLocationARB(GLhandleARB programObj, GLuint index, string name)
+ {
+ Delegates.glBindAttribLocationARB(programObj, index, name);
+ }
+ public static void BindBuffer(Enums.VERSION_1_5 target, GLuint buffer)
+ {
+ Delegates.glBindBuffer(target, buffer);
+ }
+ public static void BindBufferARB(Enums.ARB_vertex_buffer_object target, GLuint buffer)
+ {
+ Delegates.glBindBufferARB(target, buffer);
+ }
+ public static void BindBufferBaseNV(Enums.GLenum target, GLuint index, GLuint buffer)
+ {
+ Delegates.glBindBufferBaseNV(target, index, buffer);
+ }
+ public static void BindBufferOffsetNV(Enums.GLenum target, GLuint index, GLuint buffer, GLintptr offset)
+ {
+ Delegates.glBindBufferOffsetNV(target, index, buffer, offset);
+ }
+ public static void BindBufferRangeNV(Enums.GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+ {
+ Delegates.glBindBufferRangeNV(target, index, buffer, offset, size);
+ }
+ public static void BindFragDataLocationEXT(GLuint program, GLuint color, string name)
+ {
+ Delegates.glBindFragDataLocationEXT(program, color, name);
+ }
+ public static void BindFragmentShaderATI(GLuint id)
+ {
+ Delegates.glBindFragmentShaderATI(id);
+ }
+ public static void BindFramebufferEXT(Enums.EXT_framebuffer_object target, GLuint framebuffer)
+ {
+ Delegates.glBindFramebufferEXT(target, framebuffer);
+ }
+ public static GLuint BindLightParameterEXT(Enums.LightName light, Enums.LightParameter value)
+ {
+ return Delegates.glBindLightParameterEXT(light, value);
+ }
+ public static GLuint BindMaterialParameterEXT(Enums.MaterialFace face, Enums.MaterialParameter value)
+ {
+ return Delegates.glBindMaterialParameterEXT(face, value);
+ }
+ public static GLuint BindParameterEXT(Enums.EXT_vertex_shader value)
+ {
+ return Delegates.glBindParameterEXT(value);
+ }
+ public static void BindProgramARB(Enums.ARB_vertex_program target, GLuint program)
+ {
+ Delegates.glBindProgramARB(target, program);
+ }
+ public static void BindProgramNV(Enums.NV_vertex_program target, GLuint id)
+ {
+ Delegates.glBindProgramNV(target, id);
+ }
+ public static void BindRenderbufferEXT(Enums.EXT_framebuffer_object target, GLuint renderbuffer)
+ {
+ Delegates.glBindRenderbufferEXT(target, renderbuffer);
+ }
+ public static GLuint BindTexGenParameterEXT(Enums.EXT_vertex_shader unit, Enums.TextureCoordName coord, Enums.TextureGenParameter value)
+ {
+ return Delegates.glBindTexGenParameterEXT(unit, coord, value);
+ }
+ public static void BindTexture(Enums.TextureTarget target, GLuint texture)
+ {
+ Delegates.glBindTexture(target, texture);
+ }
+ public static void BindTextureEXT(Enums.TextureTarget target, GLuint texture)
+ {
+ Delegates.glBindTextureEXT(target, texture);
+ }
+ public static GLuint BindTextureUnitParameterEXT(Enums.EXT_vertex_shader unit, Enums.EXT_vertex_shader value)
+ {
+ return Delegates.glBindTextureUnitParameterEXT(unit, value);
+ }
+ public static void BindVertexArrayAPPLE(GLuint array)
+ {
+ Delegates.glBindVertexArrayAPPLE(array);
+ }
+ public static void BindVertexShaderEXT(GLuint id)
+ {
+ Delegates.glBindVertexShaderEXT(id);
+ }
+ public static void Binormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz)
+ {
+ Delegates.glBinormal3bEXT(bx, by, bz);
+ }
+ public static void Binormal3bvEXT(ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3bvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3bvEXT(System.IntPtr v)
+ {
+ Delegates.glBinormal3bvEXT(v);
+ }
+ public static void Binormal3bvEXT(GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3bvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz)
+ {
+ Delegates.glBinormal3dEXT(bx, by, bz);
+ }
+ public static void Binormal3dvEXT(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3dvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3dvEXT(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3dvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3dvEXT(System.IntPtr v)
+ {
+ Delegates.glBinormal3dvEXT(v);
+ }
+ public static void Binormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz)
+ {
+ Delegates.glBinormal3fEXT(bx, by, bz);
+ }
+ public static void Binormal3fvEXT(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3fvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3fvEXT(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3fvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3fvEXT(System.IntPtr v)
+ {
+ Delegates.glBinormal3fvEXT(v);
+ }
+ public static void Binormal3iEXT(GLint bx, GLint by, GLint bz)
+ {
+ Delegates.glBinormal3iEXT(bx, by, bz);
+ }
+ public static void Binormal3ivEXT(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3ivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3ivEXT(System.IntPtr v)
+ {
+ Delegates.glBinormal3ivEXT(v);
+ }
+ public static void Binormal3ivEXT(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3ivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3sEXT(GLshort bx, GLshort by, GLshort bz)
+ {
+ Delegates.glBinormal3sEXT(bx, by, bz);
+ }
+ public static void Binormal3svEXT(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3svEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Binormal3svEXT(System.IntPtr v)
+ {
+ Delegates.glBinormal3svEXT(v);
+ }
+ public static void Binormal3svEXT(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormal3svEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void BinormalPointerEXT(Enums.EXT_coordinate_frame type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glBinormalPointerEXT(type, stride, pointer);
+ }
+ public static void BinormalPointerEXT(Enums.EXT_coordinate_frame type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBinormalPointerEXT(type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, GLubyte[] bitmap)
+ {
+ GCHandle h0 = GCHandle.Alloc(bitmap, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBitmap(width, height, xorig, yorig, xmove, ymove, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, System.IntPtr bitmap)
+ {
+ Delegates.glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+ }
+ public static void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, ref GLubyte bitmap)
+ {
+ GCHandle h0 = GCHandle.Alloc(bitmap, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBitmap(width, height, xorig, yorig, xmove, ymove, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+ {
+ Delegates.glBlendColor(red, green, blue, alpha);
+ }
+ public static void BlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+ {
+ Delegates.glBlendColorEXT(red, green, blue, alpha);
+ }
+ public static void BlendEquation(Enums.VERSION_1_2 mode)
+ {
+ Delegates.glBlendEquation(mode);
+ }
+ public static void BlendEquationEXT(Enums.BlendEquationModeEXT mode)
+ {
+ Delegates.glBlendEquationEXT(mode);
+ }
+ public static void BlendEquationSeparate(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha)
+ {
+ Delegates.glBlendEquationSeparate(modeRGB, modeAlpha);
+ }
+ public static void BlendEquationSeparateEXT(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha)
+ {
+ Delegates.glBlendEquationSeparateEXT(modeRGB, modeAlpha);
+ }
+ public static void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor)
+ {
+ Delegates.glBlendFunc(sfactor, dfactor);
+ }
+ public static void BlendFuncSeparate(Enums.VERSION_1_4 sfactorRGB, Enums.VERSION_1_4 dfactorRGB, Enums.VERSION_1_4 sfactorAlpha, Enums.VERSION_1_4 dfactorAlpha)
+ {
+ Delegates.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+ }
+ public static void BlendFuncSeparateEXT(Enums.EXT_blend_func_separate sfactorRGB, Enums.EXT_blend_func_separate dfactorRGB, Enums.EXT_blend_func_separate sfactorAlpha, Enums.EXT_blend_func_separate dfactorAlpha)
+ {
+ Delegates.glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+ }
+ public static void BlendFuncSeparateINGR(Enums.GLenum sfactorRGB, Enums.GLenum dfactorRGB, Enums.GLenum sfactorAlpha, Enums.GLenum dfactorAlpha)
+ {
+ Delegates.glBlendFuncSeparateINGR(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+ }
+ public static void BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, Enums.ClearBufferMask mask, Enums.GLenum filter)
+ {
+ Delegates.glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+ }
+ public static void BufferData(Enums.VERSION_1_5 target, GLsizeiptr size, object data, Enums.VERSION_1_5 usage)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBufferData(target, size, h0.AddrOfPinnedObject(), usage);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void BufferData(Enums.VERSION_1_5 target, GLsizeiptr size, System.IntPtr data, Enums.VERSION_1_5 usage)
+ {
+ Delegates.glBufferData(target, size, data, usage);
+ }
+ public static void BufferDataARB(Enums.ARB_vertex_buffer_object target, GLsizeiptrARB size, object data, Enums.ARB_vertex_buffer_object usage)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBufferDataARB(target, size, h0.AddrOfPinnedObject(), usage);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void BufferDataARB(Enums.ARB_vertex_buffer_object target, GLsizeiptrARB size, System.IntPtr data, Enums.ARB_vertex_buffer_object usage)
+ {
+ Delegates.glBufferDataARB(target, size, data, usage);
+ }
+ public static void BufferParameteriAPPLE(Enums.GLenum target, Enums.GLenum pname, GLint param)
+ {
+ Delegates.glBufferParameteriAPPLE(target, pname, param);
+ }
+ public static void BufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, System.IntPtr data)
+ {
+ Delegates.glBufferSubData(target, offset, size, data);
+ }
+ public static void BufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBufferSubData(target, offset, size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void BufferSubDataARB(Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glBufferSubDataARB(target, offset, size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void BufferSubDataARB(Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, System.IntPtr data)
+ {
+ Delegates.glBufferSubDataARB(target, offset, size, data);
+ }
+ public static void CallList(GLuint list)
+ {
+ Delegates.glCallList(list);
+ }
+ public static void CallLists(GLsizei n, Enums.ListNameType type, object lists)
+ {
+ GCHandle h0 = GCHandle.Alloc(lists, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCallLists(n, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CallLists(GLsizei n, Enums.ListNameType type, System.IntPtr lists)
+ {
+ Delegates.glCallLists(n, type, lists);
+ }
+ public static Enums.GLenum CheckFramebufferStatusEXT(Enums.EXT_framebuffer_object target)
+ {
+ return Delegates.glCheckFramebufferStatusEXT(target);
+ }
+ public static void ClampColorARB(Enums.ARB_color_buffer_float target, Enums.ARB_color_buffer_float clamp)
+ {
+ Delegates.glClampColorARB(target, clamp);
+ }
+ public static void Clear(Enums.ClearBufferMask mask)
+ {
+ Delegates.glClear(mask);
+ }
+ public static void ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+ {
+ Delegates.glClearAccum(red, green, blue, alpha);
+ }
+ public static void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+ {
+ Delegates.glClearColor(red, green, blue, alpha);
+ }
+ public static void ClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha)
+ {
+ Delegates.glClearColorIiEXT(red, green, blue, alpha);
+ }
+ public static void ClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+ {
+ Delegates.glClearColorIuiEXT(red, green, blue, alpha);
+ }
+ public static void ClearDepth(GLclampd depth)
+ {
+ Delegates.glClearDepth(depth);
+ }
+ public static void ClearDepthdNV(GLdouble depth)
+ {
+ Delegates.glClearDepthdNV(depth);
+ }
+ public static void ClearIndex(GLfloat c)
+ {
+ Delegates.glClearIndex(c);
+ }
+ public static void ClearStencil(GLint s)
+ {
+ Delegates.glClearStencil(s);
+ }
+ public static void ClientActiveTexture(Enums.VERSION_1_3 texture)
+ {
+ Delegates.glClientActiveTexture(texture);
+ }
+ public static void ClientActiveTextureARB(Enums.ARB_multitexture texture)
+ {
+ Delegates.glClientActiveTextureARB(texture);
+ }
+ public static void ClientActiveVertexStreamATI(Enums.ATI_vertex_streams stream)
+ {
+ Delegates.glClientActiveVertexStreamATI(stream);
+ }
+ public static void ClipPlane(Enums.ClipPlaneName plane, System.IntPtr equation)
+ {
+ Delegates.glClipPlane(plane, equation);
+ }
+ public static void ClipPlane(Enums.ClipPlaneName plane, GLdouble[] equation)
+ {
+ GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glClipPlane(plane, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ClipPlane(Enums.ClipPlaneName plane, ref GLdouble equation)
+ {
+ GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glClipPlane(plane, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3b(GLbyte red, GLbyte green, GLbyte blue)
+ {
+ Delegates.glColor3b(red, green, blue);
+ }
+ public static void Color3bv(ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3bv(GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3bv(System.IntPtr v)
+ {
+ Delegates.glColor3bv(v);
+ }
+ public static void Color3d(GLdouble red, GLdouble green, GLdouble blue)
+ {
+ Delegates.glColor3d(red, green, blue);
+ }
+ public static void Color3dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3dv(System.IntPtr v)
+ {
+ Delegates.glColor3dv(v);
+ }
+ public static void Color3f(GLfloat red, GLfloat green, GLfloat blue)
+ {
+ Delegates.glColor3f(red, green, blue);
+ }
+ public static void Color3fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3fv(System.IntPtr v)
+ {
+ Delegates.glColor3fv(v);
+ }
+ public static void Color3fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glColor3fVertex3fSUN(r, g, b, x, y, z);
+ }
+ public static void Color3fVertex3fvSUN(ref GLfloat c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(ref GLfloat c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(ref GLfloat c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(GLfloat[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(GLfloat[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(GLfloat[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3fVertex3fvSUN(c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3fVertex3fvSUN(System.IntPtr c, System.IntPtr v)
+ {
+ Delegates.glColor3fVertex3fvSUN(c, v);
+ }
+ public static void Color3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
+ {
+ Delegates.glColor3hNV(red, green, blue);
+ }
+ public static void Color3hvNV(System.IntPtr v)
+ {
+ Delegates.glColor3hvNV(v);
+ }
+ public static void Color3hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3i(GLint red, GLint green, GLint blue)
+ {
+ Delegates.glColor3i(red, green, blue);
+ }
+ public static void Color3iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3iv(System.IntPtr v)
+ {
+ Delegates.glColor3iv(v);
+ }
+ public static void Color3s(GLshort red, GLshort green, GLshort blue)
+ {
+ Delegates.glColor3s(red, green, blue);
+ }
+ public static void Color3sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3sv(System.IntPtr v)
+ {
+ Delegates.glColor3sv(v);
+ }
+ public static void Color3sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3ub(GLubyte red, GLubyte green, GLubyte blue)
+ {
+ Delegates.glColor3ub(red, green, blue);
+ }
+ public static void Color3ubv(GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3ubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3ubv(ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3ubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3ubv(System.IntPtr v)
+ {
+ Delegates.glColor3ubv(v);
+ }
+ public static void Color3ui(GLuint red, GLuint green, GLuint blue)
+ {
+ Delegates.glColor3ui(red, green, blue);
+ }
+ public static void Color3uiv(GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3uiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3uiv(System.IntPtr v)
+ {
+ Delegates.glColor3uiv(v);
+ }
+ public static void Color3uiv(ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3uiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3us(GLushort red, GLushort green, GLushort blue)
+ {
+ Delegates.glColor3us(red, green, blue);
+ }
+ public static void Color3usv(GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3usv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color3usv(System.IntPtr v)
+ {
+ Delegates.glColor3usv(v);
+ }
+ public static void Color3usv(ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor3usv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
+ {
+ Delegates.glColor4b(red, green, blue, alpha);
+ }
+ public static void Color4bv(GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4bv(ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4bv(System.IntPtr v)
+ {
+ Delegates.glColor4bv(v);
+ }
+ public static void Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+ {
+ Delegates.glColor4d(red, green, blue, alpha);
+ }
+ public static void Color4dv(System.IntPtr v)
+ {
+ Delegates.glColor4dv(v);
+ }
+ public static void Color4dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+ {
+ Delegates.glColor4f(red, green, blue, alpha);
+ }
+ public static void Color4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, n, v);
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4fNormal3fVertex3fvSUN(ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void Color4fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4fv(System.IntPtr v)
+ {
+ Delegates.glColor4fv(v);
+ }
+ public static void Color4fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha)
+ {
+ Delegates.glColor4hNV(red, green, blue, alpha);
+ }
+ public static void Color4hvNV(System.IntPtr v)
+ {
+ Delegates.glColor4hvNV(v);
+ }
+ public static void Color4hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4i(GLint red, GLint green, GLint blue, GLint alpha)
+ {
+ Delegates.glColor4i(red, green, blue, alpha);
+ }
+ public static void Color4iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4iv(System.IntPtr v)
+ {
+ Delegates.glColor4iv(v);
+ }
+ public static void Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
+ {
+ Delegates.glColor4s(red, green, blue, alpha);
+ }
+ public static void Color4sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4sv(System.IntPtr v)
+ {
+ Delegates.glColor4sv(v);
+ }
+ public static void Color4sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
+ {
+ Delegates.glColor4ub(red, green, blue, alpha);
+ }
+ public static void Color4ubv(GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubv(ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubv(System.IntPtr v)
+ {
+ Delegates.glColor4ubv(v);
+ }
+ public static void Color4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)
+ {
+ Delegates.glColor4ubVertex2fSUN(r, g, b, a, x, y);
+ }
+ public static void Color4ubVertex2fvSUN(ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex2fvSUN(System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubVertex2fvSUN(GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubVertex2fvSUN(System.IntPtr c, System.IntPtr v)
+ {
+ Delegates.glColor4ubVertex2fvSUN(c, v);
+ }
+ public static void Color4ubVertex2fvSUN(System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubVertex2fvSUN(ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubVertex2fvSUN(ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex2fvSUN(GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex2fvSUN(GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex2fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glColor4ubVertex3fSUN(r, g, b, a, x, y, z);
+ }
+ public static void Color4ubVertex3fvSUN(GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex3fvSUN(ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex3fvSUN(ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex3fvSUN(ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubVertex3fvSUN(GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Color4ubVertex3fvSUN(System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubVertex3fvSUN(System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ubVertex3fvSUN(System.IntPtr c, System.IntPtr v)
+ {
+ Delegates.glColor4ubVertex3fvSUN(c, v);
+ }
+ public static void Color4ubVertex3fvSUN(GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
+ {
+ Delegates.glColor4ui(red, green, blue, alpha);
+ }
+ public static void Color4uiv(GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4uiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4uiv(ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4uiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4uiv(System.IntPtr v)
+ {
+ Delegates.glColor4uiv(v);
+ }
+ public static void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+ {
+ Delegates.glColor4us(red, green, blue, alpha);
+ }
+ public static void Color4usv(ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4usv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4usv(GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColor4usv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Color4usv(System.IntPtr v)
+ {
+ Delegates.glColor4usv(v);
+ }
+ public static void ColorFragmentOp1ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
+ {
+ Delegates.glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
+ }
+ public static void ColorFragmentOp2ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
+ {
+ Delegates.glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
+ }
+ public static void ColorFragmentOp3ATI(Enums.ATI_fragment_shader 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)
+ {
+ Delegates.glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
+ }
+ public static void ColorMask([MarshalAs(UnmanagedType.Bool)] bool red, [MarshalAs(UnmanagedType.Bool)] bool green, [MarshalAs(UnmanagedType.Bool)] bool blue, [MarshalAs(UnmanagedType.Bool)] bool alpha)
+ {
+ Delegates.glColorMask(red, green, blue, alpha);
+ }
+ public static void ColorMaskIndexedEXT(GLuint index, [MarshalAs(UnmanagedType.Bool)] bool r, [MarshalAs(UnmanagedType.Bool)] bool g, [MarshalAs(UnmanagedType.Bool)] bool b, [MarshalAs(UnmanagedType.Bool)] bool a)
+ {
+ Delegates.glColorMaskIndexedEXT(index, r, g, b, a);
+ }
+ public static void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode)
+ {
+ Delegates.glColorMaterial(face, mode);
+ }
+ public static void ColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorPointer(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glColorPointer(size, type, stride, pointer);
+ }
+ public static void ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer)
+ {
+ Delegates.glColorPointerEXT(size, type, stride, count, pointer);
+ }
+ public static void ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorPointerEXT(size, type, stride, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glColorPointerListIBM(size, type, stride, pointer, ptrstride);
+ }
+ public static void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, System.IntPtr pointer)
+ {
+ Delegates.glColorPointervINTEL(size, type, pointer);
+ }
+ public static void ColorSubTable(Enums.VERSION_1_2 target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr data)
+ {
+ Delegates.glColorSubTable(target, start, count, format, type, data);
+ }
+ public static void ColorSubTable(Enums.VERSION_1_2 target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorSubTable(target, start, count, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorSubTableEXT(Enums.EXT_color_subtable target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr data)
+ {
+ Delegates.glColorSubTableEXT(target, start, count, format, type, data);
+ }
+ public static void ColorSubTableEXT(Enums.EXT_color_subtable target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorSubTableEXT(target, start, count, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTable(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
+ {
+ GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTable(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTable(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table)
+ {
+ Delegates.glColorTable(target, internalformat, width, format, type, table);
+ }
+ public static void ColorTableEXT(Enums.EXT_paletted_texture target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
+ {
+ GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableEXT(target, internalFormat, width, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableEXT(Enums.EXT_paletted_texture target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table)
+ {
+ Delegates.glColorTableEXT(target, internalFormat, width, format, type, table);
+ }
+ public static void ColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params)
+ {
+ Delegates.glColorTableParameterfv(target, pname, @params);
+ }
+ public static void ColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameterfvSGI(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, System.IntPtr @params)
+ {
+ Delegates.glColorTableParameterfvSGI(target, pname, @params);
+ }
+ public static void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameterfvSGI(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params)
+ {
+ Delegates.glColorTableParameteriv(target, pname, @params);
+ }
+ public static void ColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameterivSGI(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableParameterivSGI(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, System.IntPtr @params)
+ {
+ Delegates.glColorTableParameterivSGI(target, pname, @params);
+ }
+ public static void ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object table)
+ {
+ GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glColorTableSGI(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table)
+ {
+ Delegates.glColorTableSGI(target, internalformat, width, format, type, table);
+ }
+ public static void CombinerInputNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners input, Enums.NV_register_combiners mapping, Enums.NV_register_combiners componentUsage)
+ {
+ Delegates.glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);
+ }
+ public static void CombinerOutputNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners abOutput, Enums.NV_register_combiners cdOutput, Enums.NV_register_combiners sumOutput, Enums.NV_register_combiners scale, Enums.NV_register_combiners bias, [MarshalAs(UnmanagedType.Bool)] bool abDotProduct, [MarshalAs(UnmanagedType.Bool)] bool cdDotProduct, [MarshalAs(UnmanagedType.Bool)] bool muxSum)
+ {
+ Delegates.glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
+ }
+ public static void CombinerParameterfNV(Enums.NV_register_combiners pname, GLfloat param)
+ {
+ Delegates.glCombinerParameterfNV(pname, param);
+ }
+ public static void CombinerParameterfvNV(Enums.NV_register_combiners pname, System.IntPtr @params)
+ {
+ Delegates.glCombinerParameterfvNV(pname, @params);
+ }
+ public static void CombinerParameterfvNV(Enums.NV_register_combiners pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCombinerParameterfvNV(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CombinerParameterfvNV(Enums.NV_register_combiners pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCombinerParameterfvNV(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CombinerParameteriNV(Enums.NV_register_combiners pname, GLint param)
+ {
+ Delegates.glCombinerParameteriNV(pname, param);
+ }
+ public static void CombinerParameterivNV(Enums.NV_register_combiners pname, System.IntPtr @params)
+ {
+ Delegates.glCombinerParameterivNV(pname, @params);
+ }
+ public static void CombinerParameterivNV(Enums.NV_register_combiners pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCombinerParameterivNV(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CombinerParameterivNV(Enums.NV_register_combiners pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCombinerParameterivNV(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCombinerStageParameterfvNV(stage, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCombinerStageParameterfvNV(stage, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, System.IntPtr @params)
+ {
+ Delegates.glCombinerStageParameterfvNV(stage, pname, @params);
+ }
+ public static void CompileShader(GLuint shader)
+ {
+ Delegates.glCompileShader(shader);
+ }
+ public static void CompileShaderARB(GLhandleARB shaderObj)
+ {
+ Delegates.glCompileShaderARB(shaderObj);
+ }
+ public static void CompressedTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+ }
+ public static void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data);
+ }
+ public static void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+ }
+ public static void CompressedTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data);
+ }
+ public static void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexImage3D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexImage3D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+ }
+ public static void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);
+ }
+ public static void CompressedTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+ }
+ public static void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data);
+ }
+ public static void CompressedTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+ }
+ public static void CompressedTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+ }
+ public static void CompressedTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+ }
+ public static void CompressedTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data)
+ {
+ Delegates.glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+ }
+ public static void CompressedTexSubImage3DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionFilter1D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image)
+ {
+ Delegates.glConvolutionFilter1D(target, internalformat, width, format, type, image);
+ }
+ public static void ConvolutionFilter1D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object image)
+ {
+ GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionFilter1D(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image)
+ {
+ Delegates.glConvolutionFilter1DEXT(target, internalformat, width, format, type, image);
+ }
+ public static void ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object image)
+ {
+ GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionFilter1DEXT(target, internalformat, width, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object image)
+ {
+ GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionFilter2D(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image)
+ {
+ Delegates.glConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+ }
+ public static void ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object image)
+ {
+ GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image)
+ {
+ Delegates.glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);
+ }
+ public static void ConvolutionParameterf(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat @params)
+ {
+ Delegates.glConvolutionParameterf(target, pname, @params);
+ }
+ public static void ConvolutionParameterfEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat @params)
+ {
+ Delegates.glConvolutionParameterfEXT(target, pname, @params);
+ }
+ public static void ConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params)
+ {
+ Delegates.glConvolutionParameterfv(target, pname, @params);
+ }
+ public static void ConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, System.IntPtr @params)
+ {
+ Delegates.glConvolutionParameterfvEXT(target, pname, @params);
+ }
+ public static void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameteri(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint @params)
+ {
+ Delegates.glConvolutionParameteri(target, pname, @params);
+ }
+ public static void ConvolutionParameteriEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint @params)
+ {
+ Delegates.glConvolutionParameteriEXT(target, pname, @params);
+ }
+ public static void ConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params)
+ {
+ Delegates.glConvolutionParameteriv(target, pname, @params);
+ }
+ public static void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glConvolutionParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, System.IntPtr @params)
+ {
+ Delegates.glConvolutionParameterivEXT(target, pname, @params);
+ }
+ public static void CopyColorSubTable(Enums.VERSION_1_2 target, GLsizei start, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyColorSubTable(target, start, x, y, width);
+ }
+ public static void CopyColorSubTableEXT(Enums.EXT_color_subtable target, GLsizei start, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyColorSubTableEXT(target, start, x, y, width);
+ }
+ public static void CopyColorTable(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyColorTable(target, internalformat, x, y, width);
+ }
+ public static void CopyColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyColorTableSGI(target, internalformat, x, y, width);
+ }
+ public static void CopyConvolutionFilter1D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyConvolutionFilter1D(target, internalformat, x, y, width);
+ }
+ public static void CopyConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyConvolutionFilter1DEXT(target, internalformat, x, y, width);
+ }
+ public static void CopyConvolutionFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+ }
+ public static void CopyConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glCopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);
+ }
+ public static void CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelCopyType type)
+ {
+ Delegates.glCopyPixels(x, y, width, height, type);
+ }
+ public static void CopyTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border)
+ {
+ Delegates.glCopyTexImage1D(target, level, internalformat, x, y, width, border);
+ }
+ public static void CopyTexImage1DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border)
+ {
+ Delegates.glCopyTexImage1DEXT(target, level, internalformat, x, y, width, border);
+ }
+ public static void CopyTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+ {
+ Delegates.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+ }
+ public static void CopyTexImage2DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+ {
+ Delegates.glCopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);
+ }
+ public static void CopyTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyTexSubImage1D(target, level, xoffset, x, y, width);
+ }
+ public static void CopyTexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+ {
+ Delegates.glCopyTexSubImage1DEXT(target, level, xoffset, x, y, width);
+ }
+ public static void CopyTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+ }
+ public static void CopyTexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glCopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);
+ }
+ public static void CopyTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+ }
+ public static void CopyTexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glCopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+ }
+ public static GLuint CreateProgram()
+ {
+ return Delegates.glCreateProgram();
+ }
+ public static GLhandleARB CreateProgramObjectARB()
+ {
+ return Delegates.glCreateProgramObjectARB();
+ }
+ public static GLuint CreateShader(Enums.VERSION_2_0 type)
+ {
+ return Delegates.glCreateShader(type);
+ }
+ public static GLhandleARB CreateShaderObjectARB(Enums.ARB_shader_objects shaderType)
+ {
+ return Delegates.glCreateShaderObjectARB(shaderType);
+ }
+ public static void CullFace(Enums.CullFaceMode mode)
+ {
+ Delegates.glCullFace(mode);
+ }
+ public static void CullParameterdvEXT(Enums.EXT_cull_vertex pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glCullParameterdvEXT(pname, @params);
+ }
+ public static void CullParameterdvEXT(Enums.EXT_cull_vertex pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCullParameterdvEXT(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CullParameterdvEXT(Enums.EXT_cull_vertex pname, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCullParameterdvEXT(pname, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CullParameterfvEXT(Enums.EXT_cull_vertex pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glCullParameterfvEXT(pname, @params);
+ }
+ public static void CullParameterfvEXT(Enums.EXT_cull_vertex pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCullParameterfvEXT(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CullParameterfvEXT(Enums.EXT_cull_vertex pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glCullParameterfvEXT(pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void CurrentPaletteMatrixARB(GLint index)
+ {
+ Delegates.glCurrentPaletteMatrixARB(index);
+ }
+ public static 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, GLdouble[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, System.IntPtr points)
+ {
+ Delegates.glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
+ }
+ public static 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, ref GLdouble points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, System.IntPtr points)
+ {
+ Delegates.glDeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
+ }
+ public static 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, ref GLfloat points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeformSGIX(Enums.FfdMaskSGIX mask)
+ {
+ Delegates.glDeformSGIX(mask);
+ }
+ public static void DeleteAsyncMarkersSGIX(GLuint marker, GLsizei range)
+ {
+ Delegates.glDeleteAsyncMarkersSGIX(marker, range);
+ }
+ public static void DeleteBuffers(GLsizei n, GLuint[] buffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteBuffers(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteBuffers(GLsizei n, System.IntPtr buffers)
+ {
+ Delegates.glDeleteBuffers(n, buffers);
+ }
+ public static void DeleteBuffers(GLsizei n, ref GLuint buffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteBuffers(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteBuffersARB(GLsizei n, System.IntPtr buffers)
+ {
+ Delegates.glDeleteBuffersARB(n, buffers);
+ }
+ public static void DeleteBuffersARB(GLsizei n, ref GLuint buffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteBuffersARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteBuffersARB(GLsizei n, GLuint[] buffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteBuffersARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteFencesAPPLE(GLsizei n, ref GLuint fences)
+ {
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteFencesAPPLE(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteFencesAPPLE(GLsizei n, System.IntPtr fences)
+ {
+ Delegates.glDeleteFencesAPPLE(n, fences);
+ }
+ public static void DeleteFencesAPPLE(GLsizei n, GLuint[] fences)
+ {
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteFencesAPPLE(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteFencesNV(GLsizei n, ref GLuint fences)
+ {
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteFencesNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteFencesNV(GLsizei n, GLuint[] fences)
+ {
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteFencesNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteFencesNV(GLsizei n, System.IntPtr fences)
+ {
+ Delegates.glDeleteFencesNV(n, fences);
+ }
+ public static void DeleteFragmentShaderATI(GLuint id)
+ {
+ Delegates.glDeleteFragmentShaderATI(id);
+ }
+ public static void DeleteFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteFramebuffersEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteFramebuffersEXT(GLsizei n, ref GLuint framebuffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteFramebuffersEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteFramebuffersEXT(GLsizei n, System.IntPtr framebuffers)
+ {
+ Delegates.glDeleteFramebuffersEXT(n, framebuffers);
+ }
+ public static void DeleteLists(GLuint list, GLsizei range)
+ {
+ Delegates.glDeleteLists(list, range);
+ }
+ public static void DeleteObjectARB(GLhandleARB obj)
+ {
+ Delegates.glDeleteObjectARB(obj);
+ }
+ public static void DeleteOcclusionQueriesNV(GLsizei n, System.IntPtr ids)
+ {
+ Delegates.glDeleteOcclusionQueriesNV(n, ids);
+ }
+ public static void DeleteOcclusionQueriesNV(GLsizei n, ref GLuint ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteOcclusionQueriesNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteOcclusionQueriesNV(GLsizei n, GLuint[] ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteOcclusionQueriesNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteProgram(GLuint program)
+ {
+ Delegates.glDeleteProgram(program);
+ }
+ public static void DeleteProgramsARB(GLsizei n, ref GLuint programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteProgramsARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteProgramsARB(GLsizei n, System.IntPtr programs)
+ {
+ Delegates.glDeleteProgramsARB(n, programs);
+ }
+ public static void DeleteProgramsARB(GLsizei n, GLuint[] programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteProgramsARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteProgramsNV(GLsizei n, ref GLuint programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteProgramsNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteProgramsNV(GLsizei n, System.IntPtr programs)
+ {
+ Delegates.glDeleteProgramsNV(n, programs);
+ }
+ public static void DeleteProgramsNV(GLsizei n, GLuint[] programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteProgramsNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteQueries(GLsizei n, ref GLuint ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteQueries(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteQueries(GLsizei n, System.IntPtr ids)
+ {
+ Delegates.glDeleteQueries(n, ids);
+ }
+ public static void DeleteQueries(GLsizei n, GLuint[] ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteQueries(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteQueriesARB(GLsizei n, ref GLuint ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteQueriesARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteQueriesARB(GLsizei n, GLuint[] ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteQueriesARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteQueriesARB(GLsizei n, System.IntPtr ids)
+ {
+ Delegates.glDeleteQueriesARB(n, ids);
+ }
+ public static void DeleteRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteRenderbuffersEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteRenderbuffersEXT(GLsizei n, System.IntPtr renderbuffers)
+ {
+ Delegates.glDeleteRenderbuffersEXT(n, renderbuffers);
+ }
+ public static void DeleteRenderbuffersEXT(GLsizei n, ref GLuint renderbuffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteRenderbuffersEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteShader(GLuint shader)
+ {
+ Delegates.glDeleteShader(shader);
+ }
+ public static void DeleteTextures(GLsizei n, ref GLuint textures)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteTextures(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteTextures(GLsizei n, GLuint[] textures)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteTextures(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteTextures(GLsizei n, System.IntPtr textures)
+ {
+ Delegates.glDeleteTextures(n, textures);
+ }
+ public static void DeleteTexturesEXT(GLsizei n, ref GLuint textures)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteTexturesEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteTexturesEXT(GLsizei n, GLuint[] textures)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteTexturesEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteTexturesEXT(GLsizei n, System.IntPtr textures)
+ {
+ Delegates.glDeleteTexturesEXT(n, textures);
+ }
+ public static void DeleteVertexArraysAPPLE(GLsizei n, ref GLuint arrays)
+ {
+ GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteVertexArraysAPPLE(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteVertexArraysAPPLE(GLsizei n, System.IntPtr arrays)
+ {
+ Delegates.glDeleteVertexArraysAPPLE(n, arrays);
+ }
+ public static void DeleteVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
+ {
+ GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDeleteVertexArraysAPPLE(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DeleteVertexShaderEXT(GLuint id)
+ {
+ Delegates.glDeleteVertexShaderEXT(id);
+ }
+ public static void DepthBoundsdNV(GLdouble zmin, GLdouble zmax)
+ {
+ Delegates.glDepthBoundsdNV(zmin, zmax);
+ }
+ public static void DepthBoundsEXT(GLclampd zmin, GLclampd zmax)
+ {
+ Delegates.glDepthBoundsEXT(zmin, zmax);
+ }
+ public static void DepthFunc(Enums.DepthFunction func)
+ {
+ Delegates.glDepthFunc(func);
+ }
+ public static void DepthMask([MarshalAs(UnmanagedType.Bool)] bool flag)
+ {
+ Delegates.glDepthMask(flag);
+ }
+ public static void DepthRange(GLclampd near, GLclampd far)
+ {
+ Delegates.glDepthRange(near, far);
+ }
+ public static void DepthRangedNV(GLdouble zNear, GLdouble zFar)
+ {
+ Delegates.glDepthRangedNV(zNear, zFar);
+ }
+ public static void DetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj)
+ {
+ Delegates.glDetachObjectARB(containerObj, attachedObj);
+ }
+ public static void DetachShader(GLuint program, GLuint shader)
+ {
+ Delegates.glDetachShader(program, shader);
+ }
+ public static void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, System.IntPtr points)
+ {
+ Delegates.glDetailTexFuncSGIS(target, n, points);
+ }
+ public static void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, ref GLfloat points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDetailTexFuncSGIS(target, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDetailTexFuncSGIS(target, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Disable(Enums.EnableCap cap)
+ {
+ Delegates.glDisable(cap);
+ }
+ public static void DisableClientState(Enums.EnableCap array)
+ {
+ Delegates.glDisableClientState(array);
+ }
+ public static void DisableIndexedEXT(Enums.GLenum target, GLuint index)
+ {
+ Delegates.glDisableIndexedEXT(target, index);
+ }
+ public static void DisableVariantClientStateEXT(GLuint id)
+ {
+ Delegates.glDisableVariantClientStateEXT(id);
+ }
+ public static void DisableVertexAttribArray(GLuint index)
+ {
+ Delegates.glDisableVertexAttribArray(index);
+ }
+ public static void DisableVertexAttribArrayARB(GLuint index)
+ {
+ Delegates.glDisableVertexAttribArrayARB(index);
+ }
+ public static void DrawArrays(Enums.BeginMode mode, GLint first, GLsizei count)
+ {
+ Delegates.glDrawArrays(mode, first, count);
+ }
+ public static void DrawArraysEXT(Enums.BeginMode mode, GLint first, GLsizei count)
+ {
+ Delegates.glDrawArraysEXT(mode, first, count);
+ }
+ public static void DrawArraysInstancedEXT(Enums.BeginMode mode, GLint start, GLsizei count, GLsizei primcount)
+ {
+ Delegates.glDrawArraysInstancedEXT(mode, start, count, primcount);
+ }
+ public static void DrawBuffer(Enums.DrawBufferMode mode)
+ {
+ Delegates.glDrawBuffer(mode);
+ }
+ public static void DrawBuffers(GLsizei n, System.IntPtr bufs)
+ {
+ Delegates.glDrawBuffers(n, bufs);
+ }
+ public static void DrawBuffers(GLsizei n, Enums.VERSION_2_0[] bufs)
+ {
+ GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawBuffers(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawBuffers(GLsizei n, ref Enums.VERSION_2_0 bufs)
+ {
+ GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawBuffers(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawBuffersARB(GLsizei n, Enums.ARB_draw_buffers[] bufs)
+ {
+ GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawBuffersARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawBuffersARB(GLsizei n, System.IntPtr bufs)
+ {
+ Delegates.glDrawBuffersARB(n, bufs);
+ }
+ public static void DrawBuffersARB(GLsizei n, ref Enums.ARB_draw_buffers bufs)
+ {
+ GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawBuffersARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawBuffersATI(GLsizei n, System.IntPtr bufs)
+ {
+ Delegates.glDrawBuffersATI(n, bufs);
+ }
+ public static void DrawBuffersATI(GLsizei n, Enums.ATI_draw_buffers[] bufs)
+ {
+ GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawBuffersATI(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawBuffersATI(GLsizei n, ref Enums.ATI_draw_buffers bufs)
+ {
+ GCHandle h0 = GCHandle.Alloc(bufs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawBuffersATI(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawElementArrayAPPLE(Enums.BeginMode mode, GLint first, GLsizei count)
+ {
+ Delegates.glDrawElementArrayAPPLE(mode, first, count);
+ }
+ public static void DrawElementArrayATI(Enums.BeginMode mode, GLsizei count)
+ {
+ Delegates.glDrawElementArrayATI(mode, count);
+ }
+ public static void DrawElements(Enums.BeginMode mode, GLsizei count, Enums.GLenum type, object indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawElements(mode, count, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawElements(Enums.BeginMode mode, GLsizei count, Enums.GLenum type, System.IntPtr indices)
+ {
+ Delegates.glDrawElements(mode, count, type, indices);
+ }
+ public static void DrawElementsInstancedEXT(Enums.BeginMode mode, GLsizei count, Enums.EXT_draw_instanced type, System.IntPtr indices, GLsizei primcount)
+ {
+ Delegates.glDrawElementsInstancedEXT(mode, count, type, indices, primcount);
+ }
+ public static void DrawElementsInstancedEXT(Enums.BeginMode mode, GLsizei count, Enums.EXT_draw_instanced type, object indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawElementsInstancedEXT(mode, count, type, h0.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawMeshArraysSUN(Enums.BeginMode mode, GLint first, GLsizei count, GLsizei width)
+ {
+ Delegates.glDrawMeshArraysSUN(mode, first, count, width);
+ }
+ public static void DrawPixels(GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawPixels(width, height, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawPixels(GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glDrawPixels(width, height, format, type, pixels);
+ }
+ public static void DrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint first, GLsizei count)
+ {
+ Delegates.glDrawRangeElementArrayAPPLE(mode, start, end, first, count);
+ }
+ public static void DrawRangeElementArrayATI(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count)
+ {
+ Delegates.glDrawRangeElementArrayATI(mode, start, end, count);
+ }
+ public static void DrawRangeElements(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, Enums.VERSION_1_2 type, object indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawRangeElements(mode, start, end, count, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawRangeElements(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, Enums.VERSION_1_2 type, System.IntPtr indices)
+ {
+ Delegates.glDrawRangeElements(mode, start, end, count, type, indices);
+ }
+ public static void DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, Enums.EXT_draw_range_elements type, object indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glDrawRangeElementsEXT(mode, start, end, count, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, Enums.EXT_draw_range_elements type, System.IntPtr indices)
+ {
+ Delegates.glDrawRangeElementsEXT(mode, start, end, count, type, indices);
+ }
+ public static void EdgeFlag([MarshalAs(UnmanagedType.Bool)] bool flag)
+ {
+ Delegates.glEdgeFlag(flag);
+ }
+ public static void EdgeFlagPointer(GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glEdgeFlagPointer(stride, pointer);
+ }
+ public static void EdgeFlagPointer(GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEdgeFlagPointer(stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, ref Enums.Boolean pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEdgeFlagPointerEXT(stride, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, System.IntPtr pointer)
+ {
+ Delegates.glEdgeFlagPointerEXT(stride, count, pointer);
+ }
+ public static void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, Enums.Boolean[] pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEdgeFlagPointerEXT(stride, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EdgeFlagPointerListIBM(GLint stride, ref GLboolean pointer, GLint ptrstride)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEdgeFlagPointerListIBM(stride, h0.AddrOfPinnedObject(), ptrstride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EdgeFlagPointerListIBM(GLint stride, GLboolean[] pointer, GLint ptrstride)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEdgeFlagPointerListIBM(stride, h0.AddrOfPinnedObject(), ptrstride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EdgeFlagPointerListIBM(GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glEdgeFlagPointerListIBM(stride, pointer, ptrstride);
+ }
+ public static void EdgeFlagv(ref Enums.Boolean flag)
+ {
+ GCHandle h0 = GCHandle.Alloc(flag, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEdgeFlagv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EdgeFlagv(Enums.Boolean[] flag)
+ {
+ GCHandle h0 = GCHandle.Alloc(flag, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEdgeFlagv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EdgeFlagv(System.IntPtr flag)
+ {
+ Delegates.glEdgeFlagv(flag);
+ }
+ public static void ElementPointerAPPLE(Enums.APPLE_element_array type, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glElementPointerAPPLE(type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ElementPointerAPPLE(Enums.APPLE_element_array type, System.IntPtr pointer)
+ {
+ Delegates.glElementPointerAPPLE(type, pointer);
+ }
+ public static void ElementPointerATI(Enums.ATI_element_array type, System.IntPtr pointer)
+ {
+ Delegates.glElementPointerATI(type, pointer);
+ }
+ public static void ElementPointerATI(Enums.ATI_element_array type, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glElementPointerATI(type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Enable(Enums.EnableCap cap)
+ {
+ Delegates.glEnable(cap);
+ }
+ public static void EnableClientState(Enums.EnableCap array)
+ {
+ Delegates.glEnableClientState(array);
+ }
+ public static void EnableIndexedEXT(Enums.GLenum target, GLuint index)
+ {
+ Delegates.glEnableIndexedEXT(target, index);
+ }
+ public static void EnableVariantClientStateEXT(GLuint id)
+ {
+ Delegates.glEnableVariantClientStateEXT(id);
+ }
+ public static void EnableVertexAttribArray(GLuint index)
+ {
+ Delegates.glEnableVertexAttribArray(index);
+ }
+ public static void EnableVertexAttribArrayARB(GLuint index)
+ {
+ Delegates.glEnableVertexAttribArrayARB(index);
+ }
+ public static void End()
+ {
+ Delegates.glEnd();
+ }
+ public static void EndFragmentShaderATI()
+ {
+ Delegates.glEndFragmentShaderATI();
+ }
+ public static void EndList()
+ {
+ Delegates.glEndList();
+ }
+ public static void EndOcclusionQueryNV()
+ {
+ Delegates.glEndOcclusionQueryNV();
+ }
+ public static void EndQuery(Enums.VERSION_1_5 target)
+ {
+ Delegates.glEndQuery(target);
+ }
+ public static void EndQueryARB(Enums.ARB_occlusion_query target)
+ {
+ Delegates.glEndQueryARB(target);
+ }
+ public static void EndTransformFeedbackNV()
+ {
+ Delegates.glEndTransformFeedbackNV();
+ }
+ public static void EndVertexShaderEXT()
+ {
+ Delegates.glEndVertexShaderEXT();
+ }
+ public static void EvalCoord1d(GLdouble u)
+ {
+ Delegates.glEvalCoord1d(u);
+ }
+ public static void EvalCoord1dv(GLdouble[] u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord1dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord1dv(ref GLdouble u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord1dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord1dv(System.IntPtr u)
+ {
+ Delegates.glEvalCoord1dv(u);
+ }
+ public static void EvalCoord1f(GLfloat u)
+ {
+ Delegates.glEvalCoord1f(u);
+ }
+ public static void EvalCoord1fv(System.IntPtr u)
+ {
+ Delegates.glEvalCoord1fv(u);
+ }
+ public static void EvalCoord1fv(GLfloat[] u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord1fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord1fv(ref GLfloat u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord1fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord2d(GLdouble u, GLdouble v)
+ {
+ Delegates.glEvalCoord2d(u, v);
+ }
+ public static void EvalCoord2dv(System.IntPtr u)
+ {
+ Delegates.glEvalCoord2dv(u);
+ }
+ public static void EvalCoord2dv(ref GLdouble u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord2dv(GLdouble[] u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord2f(GLfloat u, GLfloat v)
+ {
+ Delegates.glEvalCoord2f(u, v);
+ }
+ public static void EvalCoord2fv(ref GLfloat u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord2fv(GLfloat[] u)
+ {
+ GCHandle h0 = GCHandle.Alloc(u, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glEvalCoord2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void EvalCoord2fv(System.IntPtr u)
+ {
+ Delegates.glEvalCoord2fv(u);
+ }
+ public static void EvalMapsNV(Enums.NV_evaluators target, Enums.NV_evaluators mode)
+ {
+ Delegates.glEvalMapsNV(target, mode);
+ }
+ public static void EvalMesh1(Enums.MeshMode1 mode, GLint i1, GLint i2)
+ {
+ Delegates.glEvalMesh1(mode, i1, i2);
+ }
+ public static void EvalMesh2(Enums.MeshMode2 mode, GLint i1, GLint i2, GLint j1, GLint j2)
+ {
+ Delegates.glEvalMesh2(mode, i1, i2, j1, j2);
+ }
+ public static void EvalPoint1(GLint i)
+ {
+ Delegates.glEvalPoint1(i);
+ }
+ public static void EvalPoint2(GLint i, GLint j)
+ {
+ Delegates.glEvalPoint2(i, j);
+ }
+ public static void ExecuteProgramNV(Enums.NV_vertex_program target, GLuint id, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glExecuteProgramNV(target, id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ExecuteProgramNV(Enums.NV_vertex_program target, GLuint id, System.IntPtr @params)
+ {
+ Delegates.glExecuteProgramNV(target, id, @params);
+ }
+ public static void ExecuteProgramNV(Enums.NV_vertex_program target, GLuint id, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glExecuteProgramNV(target, id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ExtractComponentEXT(GLuint res, GLuint src, GLuint num)
+ {
+ Delegates.glExtractComponentEXT(res, src, num);
+ }
+ public static void FeedbackBuffer(GLsizei size, Enums.FeedbackType type, [In, Out()] System.IntPtr buffer)
+ {
+ Delegates.glFeedbackBuffer(size, type, buffer);
+ }
+ public static void FeedbackBuffer(GLsizei size, Enums.FeedbackType type, out GLfloat buffer)
+ {
+ buffer = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFeedbackBuffer(size, type, h0.AddrOfPinnedObject());
+ buffer = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FeedbackBuffer(GLsizei size, Enums.FeedbackType type, GLfloat[] buffer)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFeedbackBuffer(size, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FinalCombinerInputNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners input, Enums.NV_register_combiners mapping, Enums.NV_register_combiners componentUsage)
+ {
+ Delegates.glFinalCombinerInputNV(variable, input, mapping, componentUsage);
+ }
+ public static void Finish()
+ {
+ Delegates.glFinish();
+ }
+ public static GLint FinishAsyncSGIX([In, Out()] System.IntPtr markerp)
+ {
+ return Delegates.glFinishAsyncSGIX(markerp);
+ }
+ public static GLint FinishAsyncSGIX(GLuint[] markerp)
+ {
+ GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+ try
+ {
+ GLint retval;
+ retval = Delegates.glFinishAsyncSGIX(h0.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLint FinishAsyncSGIX(out GLuint markerp)
+ {
+ markerp = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+ try
+ {
+ GLint retval;
+ retval = Delegates.glFinishAsyncSGIX(h0.AddrOfPinnedObject());
+ markerp = (GLuint)h0.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FinishFenceAPPLE(GLuint fence)
+ {
+ Delegates.glFinishFenceAPPLE(fence);
+ }
+ public static void FinishFenceNV(GLuint fence)
+ {
+ Delegates.glFinishFenceNV(fence);
+ }
+ public static void FinishObjectAPPLE(Enums.APPLE_fence @object, GLint name)
+ {
+ Delegates.glFinishObjectAPPLE(@object, name);
+ }
+ public static void FinishTextureSUNX()
+ {
+ Delegates.glFinishTextureSUNX();
+ }
+ public static void Flush()
+ {
+ Delegates.glFlush();
+ }
+ public static void FlushMappedBufferRangeAPPLE(Enums.GLenum target, GLintptr offset, GLsizeiptr size)
+ {
+ Delegates.glFlushMappedBufferRangeAPPLE(target, offset, size);
+ }
+ public static void FlushPixelDataRangeNV(Enums.NV_pixel_data_range target)
+ {
+ Delegates.glFlushPixelDataRangeNV(target);
+ }
+ public static void FlushRasterSGIX()
+ {
+ Delegates.glFlushRasterSGIX();
+ }
+ public static void FlushVertexArrayRangeAPPLE(GLsizei length, [In, Out()] System.IntPtr pointer)
+ {
+ Delegates.glFlushVertexArrayRangeAPPLE(length, pointer);
+ }
+ public static void FlushVertexArrayRangeAPPLE(GLsizei length, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFlushVertexArrayRangeAPPLE(length, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FlushVertexArrayRangeNV()
+ {
+ Delegates.glFlushVertexArrayRangeNV();
+ }
+ public static void FogCoordd(GLdouble coord)
+ {
+ Delegates.glFogCoordd(coord);
+ }
+ public static void FogCoorddEXT(GLdouble coord)
+ {
+ Delegates.glFogCoorddEXT(coord);
+ }
+ public static void FogCoorddv(ref GLdouble coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoorddv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoorddv(GLdouble[] coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoorddv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoorddv(System.IntPtr coord)
+ {
+ Delegates.glFogCoorddv(coord);
+ }
+ public static void FogCoorddvEXT(System.IntPtr coord)
+ {
+ Delegates.glFogCoorddvEXT(coord);
+ }
+ public static void FogCoorddvEXT(GLdouble[] coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoorddvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoorddvEXT(ref GLdouble coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoorddvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordf(GLfloat coord)
+ {
+ Delegates.glFogCoordf(coord);
+ }
+ public static void FogCoordfEXT(GLfloat coord)
+ {
+ Delegates.glFogCoordfEXT(coord);
+ }
+ public static void FogCoordfv(System.IntPtr coord)
+ {
+ Delegates.glFogCoordfv(coord);
+ }
+ public static void FogCoordfv(ref GLfloat coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordfv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordfv(GLfloat[] coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordfv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordfvEXT(ref GLfloat coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordfvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordfvEXT(System.IntPtr coord)
+ {
+ Delegates.glFogCoordfvEXT(coord);
+ }
+ public static void FogCoordfvEXT(GLfloat[] coord)
+ {
+ GCHandle h0 = GCHandle.Alloc(coord, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordfvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordhNV(GLhalfNV fog)
+ {
+ Delegates.glFogCoordhNV(fog);
+ }
+ public static void FogCoordhvNV(ref GLhalfNV fog)
+ {
+ GCHandle h0 = GCHandle.Alloc(fog, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordhvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordhvNV(GLhalfNV[] fog)
+ {
+ GCHandle h0 = GCHandle.Alloc(fog, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordhvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordhvNV(System.IntPtr fog)
+ {
+ Delegates.glFogCoordhvNV(fog);
+ }
+ public static void FogCoordPointer(Enums.VERSION_1_4 type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glFogCoordPointer(type, stride, pointer);
+ }
+ public static void FogCoordPointer(Enums.VERSION_1_4 type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordPointer(type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordPointerEXT(Enums.EXT_fog_coord type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogCoordPointerEXT(type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogCoordPointerEXT(Enums.EXT_fog_coord type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glFogCoordPointerEXT(type, stride, pointer);
+ }
+ public static void FogCoordPointerListIBM(Enums.IBM_vertex_array_lists type, GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glFogCoordPointerListIBM(type, stride, pointer, ptrstride);
+ }
+ public static void Fogf(Enums.FogParameter pname, GLfloat param)
+ {
+ Delegates.glFogf(pname, param);
+ }
+ public static void FogFuncSGIS(GLsizei n, ref GLfloat points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogFuncSGIS(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogFuncSGIS(GLsizei n, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogFuncSGIS(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FogFuncSGIS(GLsizei n, System.IntPtr points)
+ {
+ Delegates.glFogFuncSGIS(n, points);
+ }
+ public static void Fogfv(Enums.FogParameter pname, System.IntPtr @params)
+ {
+ Delegates.glFogfv(pname, @params);
+ }
+ public static void Fogfv(Enums.FogParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogfv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Fogfv(Enums.FogParameter pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogfv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Fogi(Enums.FogParameter pname, GLint param)
+ {
+ Delegates.glFogi(pname, param);
+ }
+ public static void Fogiv(Enums.FogParameter pname, System.IntPtr @params)
+ {
+ Delegates.glFogiv(pname, @params);
+ }
+ public static void Fogiv(Enums.FogParameter pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogiv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Fogiv(Enums.FogParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFogiv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentColorMaterialSGIX(Enums.MaterialFace face, Enums.MaterialParameter mode)
+ {
+ Delegates.glFragmentColorMaterialSGIX(face, mode);
+ }
+ public static void FragmentLightfSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLfloat param)
+ {
+ Delegates.glFragmentLightfSGIX(light, pname, param);
+ }
+ public static void FragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightfvSGIX(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightfvSGIX(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, System.IntPtr @params)
+ {
+ Delegates.glFragmentLightfvSGIX(light, pname, @params);
+ }
+ public static void FragmentLightiSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLint param)
+ {
+ Delegates.glFragmentLightiSGIX(light, pname, param);
+ }
+ public static void FragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightivSGIX(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightivSGIX(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, System.IntPtr @params)
+ {
+ Delegates.glFragmentLightivSGIX(light, pname, @params);
+ }
+ public static void FragmentLightModelfSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat param)
+ {
+ Delegates.glFragmentLightModelfSGIX(pname, param);
+ }
+ public static void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightModelfvSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightModelfvSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, System.IntPtr @params)
+ {
+ Delegates.glFragmentLightModelfvSGIX(pname, @params);
+ }
+ public static void FragmentLightModeliSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint param)
+ {
+ Delegates.glFragmentLightModeliSGIX(pname, param);
+ }
+ public static void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, System.IntPtr @params)
+ {
+ Delegates.glFragmentLightModelivSGIX(pname, @params);
+ }
+ public static void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightModelivSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentLightModelivSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentMaterialfSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param)
+ {
+ Delegates.glFragmentMaterialfSGIX(face, pname, param);
+ }
+ public static void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params)
+ {
+ Delegates.glFragmentMaterialfvSGIX(face, pname, @params);
+ }
+ public static void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentMaterialfvSGIX(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentMaterialfvSGIX(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentMaterialiSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param)
+ {
+ Delegates.glFragmentMaterialiSGIX(face, pname, param);
+ }
+ public static void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentMaterialivSGIX(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glFragmentMaterialivSGIX(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params)
+ {
+ Delegates.glFragmentMaterialivSGIX(face, pname, @params);
+ }
+ public static void FramebufferRenderbufferEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object renderbuffertarget, GLuint renderbuffer)
+ {
+ Delegates.glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
+ }
+ public static void FramebufferTexture1DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum textarget, GLuint texture, GLint level)
+ {
+ Delegates.glFramebufferTexture1DEXT(target, attachment, textarget, texture, level);
+ }
+ public static void FramebufferTexture2DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum textarget, GLuint texture, GLint level)
+ {
+ Delegates.glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
+ }
+ public static void FramebufferTexture3DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+ {
+ Delegates.glFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
+ }
+ public static void FramebufferTextureEXT(Enums.NV_geometry_program4 target, Enums.NV_geometry_program4 attachment, GLuint texture, GLint level)
+ {
+ Delegates.glFramebufferTextureEXT(target, attachment, texture, level);
+ }
+ public static void FramebufferTextureFaceEXT(Enums.NV_geometry_program4 target, Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, Enums.TextureTarget face)
+ {
+ Delegates.glFramebufferTextureFaceEXT(target, attachment, texture, level, face);
+ }
+ public static void FramebufferTextureLayerEXT(Enums.NV_geometry_program4 target, Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, GLint layer)
+ {
+ Delegates.glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);
+ }
+ public static void FrameZoomSGIX(GLint factor)
+ {
+ Delegates.glFrameZoomSGIX(factor);
+ }
+ public static void FreeObjectBufferATI(GLuint buffer)
+ {
+ Delegates.glFreeObjectBufferATI(buffer);
+ }
+ public static void FrontFace(Enums.FrontFaceDirection mode)
+ {
+ Delegates.glFrontFace(mode);
+ }
+ public static void Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+ {
+ Delegates.glFrustum(left, right, bottom, top, zNear, zFar);
+ }
+ public static GLuint GenAsyncMarkersSGIX(GLsizei range)
+ {
+ return Delegates.glGenAsyncMarkersSGIX(range);
+ }
+ public static void GenBuffers(GLsizei n, out GLuint buffers)
+ {
+ buffers = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenBuffers(n, h0.AddrOfPinnedObject());
+ buffers = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenBuffers(GLsizei n, [In, Out()] System.IntPtr buffers)
+ {
+ Delegates.glGenBuffers(n, buffers);
+ }
+ public static void GenBuffers(GLsizei n, GLuint[] buffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenBuffers(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenBuffersARB(GLsizei n, out GLuint buffers)
+ {
+ buffers = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenBuffersARB(n, h0.AddrOfPinnedObject());
+ buffers = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenBuffersARB(GLsizei n, GLuint[] buffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenBuffersARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenBuffersARB(GLsizei n, [In, Out()] System.IntPtr buffers)
+ {
+ Delegates.glGenBuffersARB(n, buffers);
+ }
+ public static void GenerateMipmapEXT(Enums.GLenum target)
+ {
+ Delegates.glGenerateMipmapEXT(target);
+ }
+ public static void GenFencesAPPLE(GLsizei n, [In, Out()] System.IntPtr fences)
+ {
+ Delegates.glGenFencesAPPLE(n, fences);
+ }
+ public static void GenFencesAPPLE(GLsizei n, GLuint[] fences)
+ {
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenFencesAPPLE(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenFencesAPPLE(GLsizei n, out GLuint fences)
+ {
+ fences = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenFencesAPPLE(n, h0.AddrOfPinnedObject());
+ fences = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenFencesNV(GLsizei n, GLuint[] fences)
+ {
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenFencesNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenFencesNV(GLsizei n, out GLuint fences)
+ {
+ fences = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(fences, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenFencesNV(n, h0.AddrOfPinnedObject());
+ fences = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenFencesNV(GLsizei n, [In, Out()] System.IntPtr fences)
+ {
+ Delegates.glGenFencesNV(n, fences);
+ }
+ public static GLuint GenFragmentShadersATI(GLuint range)
+ {
+ return Delegates.glGenFragmentShadersATI(range);
+ }
+ public static void GenFramebuffersEXT(GLsizei n, [In, Out()] System.IntPtr framebuffers)
+ {
+ Delegates.glGenFramebuffersEXT(n, framebuffers);
+ }
+ public static void GenFramebuffersEXT(GLsizei n, out GLuint framebuffers)
+ {
+ framebuffers = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenFramebuffersEXT(n, h0.AddrOfPinnedObject());
+ framebuffers = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenFramebuffersEXT(GLsizei n, GLuint[] framebuffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(framebuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenFramebuffersEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLuint GenLists(GLsizei range)
+ {
+ return Delegates.glGenLists(range);
+ }
+ public static void GenOcclusionQueriesNV(GLsizei n, GLuint[] ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenOcclusionQueriesNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenOcclusionQueriesNV(GLsizei n, [In, Out()] System.IntPtr ids)
+ {
+ Delegates.glGenOcclusionQueriesNV(n, ids);
+ }
+ public static void GenOcclusionQueriesNV(GLsizei n, out GLuint ids)
+ {
+ ids = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenOcclusionQueriesNV(n, h0.AddrOfPinnedObject());
+ ids = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenProgramsARB(GLsizei n, out GLuint programs)
+ {
+ programs = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenProgramsARB(n, h0.AddrOfPinnedObject());
+ programs = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenProgramsARB(GLsizei n, GLuint[] programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenProgramsARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenProgramsARB(GLsizei n, [In, Out()] System.IntPtr programs)
+ {
+ Delegates.glGenProgramsARB(n, programs);
+ }
+ public static void GenProgramsNV(GLsizei n, out GLuint programs)
+ {
+ programs = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenProgramsNV(n, h0.AddrOfPinnedObject());
+ programs = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenProgramsNV(GLsizei n, GLuint[] programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenProgramsNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenProgramsNV(GLsizei n, [In, Out()] System.IntPtr programs)
+ {
+ Delegates.glGenProgramsNV(n, programs);
+ }
+ public static void GenQueries(GLsizei n, [In, Out()] System.IntPtr ids)
+ {
+ Delegates.glGenQueries(n, ids);
+ }
+ public static void GenQueries(GLsizei n, out GLuint ids)
+ {
+ ids = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenQueries(n, h0.AddrOfPinnedObject());
+ ids = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenQueries(GLsizei n, GLuint[] ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenQueries(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenQueriesARB(GLsizei n, [In, Out()] System.IntPtr ids)
+ {
+ Delegates.glGenQueriesARB(n, ids);
+ }
+ public static void GenQueriesARB(GLsizei n, GLuint[] ids)
+ {
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenQueriesARB(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenQueriesARB(GLsizei n, out GLuint ids)
+ {
+ ids = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(ids, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenQueriesARB(n, h0.AddrOfPinnedObject());
+ ids = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenRenderbuffersEXT(GLsizei n, [In, Out()] System.IntPtr renderbuffers)
+ {
+ Delegates.glGenRenderbuffersEXT(n, renderbuffers);
+ }
+ public static void GenRenderbuffersEXT(GLsizei n, GLuint[] renderbuffers)
+ {
+ GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenRenderbuffersEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenRenderbuffersEXT(GLsizei n, out GLuint renderbuffers)
+ {
+ renderbuffers = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(renderbuffers, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenRenderbuffersEXT(n, h0.AddrOfPinnedObject());
+ renderbuffers = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLuint GenSymbolsEXT(Enums.EXT_vertex_shader datatype, Enums.EXT_vertex_shader storagetype, Enums.EXT_vertex_shader range, GLuint components)
+ {
+ return Delegates.glGenSymbolsEXT(datatype, storagetype, range, components);
+ }
+ public static void GenTextures(GLsizei n, GLuint[] textures)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenTextures(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenTextures(GLsizei n, [In, Out()] System.IntPtr textures)
+ {
+ Delegates.glGenTextures(n, textures);
+ }
+ public static void GenTextures(GLsizei n, out GLuint textures)
+ {
+ textures = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenTextures(n, h0.AddrOfPinnedObject());
+ textures = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenTexturesEXT(GLsizei n, [In, Out()] System.IntPtr textures)
+ {
+ Delegates.glGenTexturesEXT(n, textures);
+ }
+ public static void GenTexturesEXT(GLsizei n, out GLuint textures)
+ {
+ textures = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenTexturesEXT(n, h0.AddrOfPinnedObject());
+ textures = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenTexturesEXT(GLsizei n, GLuint[] textures)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenTexturesEXT(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenVertexArraysAPPLE(GLsizei n, [In, Out()] System.IntPtr arrays)
+ {
+ Delegates.glGenVertexArraysAPPLE(n, arrays);
+ }
+ public static void GenVertexArraysAPPLE(GLsizei n, GLuint[] arrays)
+ {
+ GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenVertexArraysAPPLE(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GenVertexArraysAPPLE(GLsizei n, out GLuint arrays)
+ {
+ arrays = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(arrays, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGenVertexArraysAPPLE(n, h0.AddrOfPinnedObject());
+ arrays = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLuint GenVertexShadersEXT(GLuint range)
+ {
+ return Delegates.glGenVertexShadersEXT(range);
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLint[] size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, length, size, type, name);
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLint[] size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLint size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLint size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttrib(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, GLint[] size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, GLint[] size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, [In, Out()] System.IntPtr size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, [In, Out()] System.IntPtr size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, out GLint size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, length, size, type, name);
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, out GLint size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, [In, Out()] System.IntPtr size, out Enums.ARB_vertex_shader type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_vertex_shader);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.ARB_vertex_shader)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, [In, Out()] System.IntPtr size, Enums.ARB_vertex_shader[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveAttribARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLint size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLint size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLint size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, length, size, type, name);
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLint[] size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLint[] size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, out Enums.VERSION_2_0 type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.VERSION_2_0);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (Enums.VERSION_2_0)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, Enums.VERSION_2_0[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniform(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, GLint[] size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, [In, Out()] System.IntPtr size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, [In, Out()] System.IntPtr size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, GLint[] size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, GLint[] size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, length, size, type, name);
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, out GLint size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, GLint[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, [In, Out()] System.IntPtr size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, out GLint size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, out GLint size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, [In, Out()] System.IntPtr size, Enums.ARB_shader_objects[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, out GLsizei length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei[] length, out GLint size, out Enums.ARB_shader_objects type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLint);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.ARB_shader_objects);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveUniformARB(programObj, index, maxLength, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLint)h1.Target;
+ type = (Enums.ARB_shader_objects)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLsizei)h1.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLsizei size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLsizei)h1.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLsizei size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, [In, Out()] System.IntPtr size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, out GLsizei size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (GLsizei)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, length, size, type, name);
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLsizei[] size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLsizei[] size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, GLsizei[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (System.IntPtr)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, [In, Out()] System.IntPtr size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLsizei)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, out GLsizei size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ size = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, out GLsizei length, GLsizei[] size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ length = (GLsizei)h0.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLsizei)h1.Target;
+ type = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, out GLsizei size, out Enums.GLenum type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ size = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ type = default(Enums.GLenum);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ size = (GLsizei)h1.Target;
+ type = (Enums.GLenum)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei[] length, GLsizei[] size, Enums.GLenum[] type, [In, Out()] System.Text.StringBuilder name)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(size, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(type, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetActiveVaryingNV(program, index, bufSize, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), name);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetArrayObjectfvATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetArrayObjectfvATI(array, pname, @params);
+ }
+ public static void GetArrayObjectfvATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetArrayObjectfvATI(array, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetArrayObjectfvATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetArrayObjectfvATI(array, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetArrayObjectivATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetArrayObjectivATI(array, pname, @params);
+ }
+ public static void GetArrayObjectivATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetArrayObjectivATI(array, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetArrayObjectivATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetArrayObjectivATI(array, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, GLhandleARB[] obj)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, out GLhandleARB obj)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(GLhandleARB);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ obj = (GLhandleARB)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei[] count, [In, Out()] System.IntPtr obj)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ obj = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, [In, Out()] System.IntPtr count, GLhandleARB[] obj)
+ {
+ count = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, [In, Out()] System.IntPtr count, out GLhandleARB obj)
+ {
+ count = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(GLhandleARB);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (System.IntPtr)h0.Target;
+ obj = (GLhandleARB)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, [In, Out()] System.IntPtr obj)
+ {
+ count = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (GLsizei)h0.Target;
+ obj = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, [In, Out()] System.IntPtr count, [In, Out()] System.IntPtr obj)
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, count, obj);
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, out GLhandleARB obj)
+ {
+ count = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(GLhandleARB);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (GLsizei)h0.Target;
+ obj = (GLhandleARB)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, out GLsizei count, GLhandleARB[] obj)
+ {
+ count = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedObjectsARB(containerObj, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, out GLuint obj)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(GLuint);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ obj = (GLuint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, GLuint[] obj)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, [In, Out()] System.IntPtr obj)
+ {
+ count = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (GLsizei)h0.Target;
+ obj = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, GLuint[] obj)
+ {
+ count = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, out GLsizei count, out GLuint obj)
+ {
+ count = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(GLuint);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (GLsizei)h0.Target;
+ obj = (GLuint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei[] count, [In, Out()] System.IntPtr obj)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ obj = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, [In, Out()] System.IntPtr count, [In, Out()] System.IntPtr obj)
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, count, obj);
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, [In, Out()] System.IntPtr count, GLuint[] obj)
+ {
+ count = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetAttachedShaders(GLuint program, GLsizei maxCount, [In, Out()] System.IntPtr count, out GLuint obj)
+ {
+ count = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ obj = default(GLuint);
+ GCHandle h1 = GCHandle.Alloc(obj, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetAttachedShaders(program, maxCount, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ count = (System.IntPtr)h0.Target;
+ obj = (GLuint)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static GLint GetAttribLocation(GLuint program, string name)
+ {
+ return Delegates.glGetAttribLocation(program, name);
+ }
+ public static GLint GetAttribLocationARB(GLhandleARB programObj, string name)
+ {
+ return Delegates.glGetAttribLocationARB(programObj, name);
+ }
+ public static void GetBooleanIndexedvEXT(Enums.GLenum target, GLuint index, Enums.Boolean[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBooleanIndexedvEXT(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBooleanIndexedvEXT(Enums.GLenum target, GLuint index, out Enums.Boolean data)
+ {
+ data = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBooleanIndexedvEXT(target, index, h0.AddrOfPinnedObject());
+ data = (Enums.Boolean)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBooleanIndexedvEXT(Enums.GLenum target, GLuint index, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetBooleanIndexedvEXT(target, index, data);
+ }
+ public static void GetBooleanv(Enums.GetPName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetBooleanv(pname, @params);
+ }
+ public static void GetBooleanv(Enums.GetPName pname, Enums.Boolean[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBooleanv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBooleanv(Enums.GetPName pname, out Enums.Boolean @params)
+ {
+ @params = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBooleanv(pname, h0.AddrOfPinnedObject());
+ @params = (Enums.Boolean)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBufferParameteriv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBufferParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBufferParameteriv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBufferParameteriv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBufferParameteriv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetBufferParameteriv(target, pname, @params);
+ }
+ public static void GetBufferParameterivARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetBufferParameterivARB(target, pname, @params);
+ }
+ public static void GetBufferParameterivARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBufferParameterivARB(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBufferParameterivARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBufferParameterivARB(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBufferPointerv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetBufferPointerv(target, pname, @params);
+ }
+ public static void GetBufferPointervARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetBufferPointervARB(target, pname, @params);
+ }
+ public static void GetBufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBufferSubData(target, offset, size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetBufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetBufferSubData(target, offset, size, data);
+ }
+ public static void GetBufferSubDataARB(Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetBufferSubDataARB(target, offset, size, data);
+ }
+ public static void GetBufferSubDataARB(Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetBufferSubDataARB(target, offset, size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetClipPlane(Enums.ClipPlaneName plane, [In, Out()] System.IntPtr equation)
+ {
+ Delegates.glGetClipPlane(plane, equation);
+ }
+ public static void GetClipPlane(Enums.ClipPlaneName plane, out GLdouble equation)
+ {
+ equation = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetClipPlane(plane, h0.AddrOfPinnedObject());
+ equation = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetClipPlane(Enums.ClipPlaneName plane, GLdouble[] equation)
+ {
+ GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetClipPlane(plane, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTable(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr table)
+ {
+ Delegates.glGetColorTable(target, format, type, table);
+ }
+ public static void GetColorTable(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, object table)
+ {
+ GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTable(target, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableEXT(Enums.EXT_paletted_texture target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetColorTableEXT(target, format, type, data);
+ }
+ public static void GetColorTableEXT(Enums.EXT_paletted_texture target, Enums.PixelFormat format, Enums.PixelType type, object data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableEXT(target, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetColorTableParameterfv(target, pname, @params);
+ }
+ public static void GetColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterfv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterfvEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterfvEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterfvEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetColorTableParameterfvEXT(target, pname, @params);
+ }
+ public static void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetColorTableParameterfvSGI(target, pname, @params);
+ }
+ public static void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterfvSGI(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterfvSGI(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetColorTableParameteriv(target, pname, @params);
+ }
+ public static void GetColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameteriv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterivEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterivEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterivEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetColorTableParameterivEXT(target, pname, @params);
+ }
+ public static void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetColorTableParameterivSGI(target, pname, @params);
+ }
+ public static void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterivSGI(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableParameterivSGI(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, object table)
+ {
+ GCHandle h0 = GCHandle.Alloc(table, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetColorTableSGI(target, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr table)
+ {
+ Delegates.glGetColorTableSGI(target, format, type, table);
+ }
+ public static void GetCombinerInputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerInputParameterfvNV(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerInputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerInputParameterfvNV(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerInputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetCombinerInputParameterfvNV(stage, portion, variable, pname, @params);
+ }
+ public static void GetCombinerInputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerInputParameterivNV(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerInputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerInputParameterivNV(stage, portion, variable, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerInputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetCombinerInputParameterivNV(stage, portion, variable, pname, @params);
+ }
+ public static void GetCombinerOutputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerOutputParameterfvNV(stage, portion, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerOutputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerOutputParameterfvNV(stage, portion, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerOutputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetCombinerOutputParameterfvNV(stage, portion, pname, @params);
+ }
+ public static void GetCombinerOutputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerOutputParameterivNV(stage, portion, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerOutputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetCombinerOutputParameterivNV(stage, portion, pname, @params);
+ }
+ public static void GetCombinerOutputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerOutputParameterivNV(stage, portion, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerStageParameterfvNV(stage, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCombinerStageParameterfvNV(stage, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetCombinerStageParameterfvNV(stage, pname, @params);
+ }
+ public static void GetCompressedTexImage(Enums.TextureTarget target, GLint level, object img)
+ {
+ GCHandle h0 = GCHandle.Alloc(img, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCompressedTexImage(target, level, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetCompressedTexImage(Enums.TextureTarget target, GLint level, [In, Out()] System.IntPtr img)
+ {
+ Delegates.glGetCompressedTexImage(target, level, img);
+ }
+ public static void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, [In, Out()] System.IntPtr img)
+ {
+ Delegates.glGetCompressedTexImageARB(target, level, img);
+ }
+ public static void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, object img)
+ {
+ GCHandle h0 = GCHandle.Alloc(img, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetCompressedTexImageARB(target, level, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr image)
+ {
+ Delegates.glGetConvolutionFilter(target, format, type, image);
+ }
+ public static void GetConvolutionFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, object image)
+ {
+ GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionFilter(target, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object image)
+ {
+ GCHandle h0 = GCHandle.Alloc(image, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionFilterEXT(target, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr image)
+ {
+ Delegates.glGetConvolutionFilterEXT(target, format, type, image);
+ }
+ public static void GetConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameterfv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetConvolutionParameterfv(target, pname, @params);
+ }
+ public static void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetConvolutionParameterfvEXT(target, pname, @params);
+ }
+ public static void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameteriv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetConvolutionParameteriv(target, pname, @params);
+ }
+ public static void GetConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetConvolutionParameterivEXT(target, pname, @params);
+ }
+ public static void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetConvolutionParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetDetailTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetDetailTexFuncSGIS(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetDetailTexFuncSGIS(Enums.TextureTarget target, out GLfloat points)
+ {
+ points = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetDetailTexFuncSGIS(target, h0.AddrOfPinnedObject());
+ points = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetDetailTexFuncSGIS(Enums.TextureTarget target, [In, Out()] System.IntPtr points)
+ {
+ Delegates.glGetDetailTexFuncSGIS(target, points);
+ }
+ public static void GetDoublev(Enums.GetPName pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetDoublev(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetDoublev(Enums.GetPName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetDoublev(pname, @params);
+ }
+ public static void GetDoublev(Enums.GetPName pname, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetDoublev(pname, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static Enums.GLenum GetError()
+ {
+ return Delegates.glGetError();
+ }
+ public static void GetFenceivNV(GLuint fence, Enums.NV_fence pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFenceivNV(fence, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFenceivNV(GLuint fence, Enums.NV_fence pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFenceivNV(fence, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFenceivNV(GLuint fence, Enums.NV_fence pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFenceivNV(fence, pname, @params);
+ }
+ public static void GetFinalCombinerInputParameterfvNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFinalCombinerInputParameterfvNV(variable, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFinalCombinerInputParameterfvNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFinalCombinerInputParameterfvNV(variable, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFinalCombinerInputParameterfvNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFinalCombinerInputParameterfvNV(variable, pname, @params);
+ }
+ public static void GetFinalCombinerInputParameterivNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFinalCombinerInputParameterivNV(variable, pname, @params);
+ }
+ public static void GetFinalCombinerInputParameterivNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFinalCombinerInputParameterivNV(variable, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFinalCombinerInputParameterivNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFinalCombinerInputParameterivNV(variable, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFloatv(Enums.GetPName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFloatv(pname, @params);
+ }
+ public static void GetFloatv(Enums.GetPName pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFloatv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFloatv(Enums.GetPName pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFloatv(pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFogFuncSGIS(GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFogFuncSGIS(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFogFuncSGIS(out GLfloat points)
+ {
+ points = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFogFuncSGIS(h0.AddrOfPinnedObject());
+ points = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFogFuncSGIS([In, Out()] System.IntPtr points)
+ {
+ Delegates.glGetFogFuncSGIS(points);
+ }
+ public static GLint GetFragDataLocationEXT(GLuint program, string name)
+ {
+ return Delegates.glGetFragDataLocationEXT(program, name);
+ }
+ public static void GetFragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentLightfvSGIX(light, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFragmentLightfvSGIX(light, pname, @params);
+ }
+ public static void GetFragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentLightfvSGIX(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFragmentLightivSGIX(light, pname, @params);
+ }
+ public static void GetFragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentLightivSGIX(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentLightivSGIX(light, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentMaterialfvSGIX(face, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentMaterialfvSGIX(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFragmentMaterialfvSGIX(face, pname, @params);
+ }
+ public static void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentMaterialivSGIX(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFragmentMaterialivSGIX(face, pname, @params);
+ }
+ public static void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFragmentMaterialivSGIX(face, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, @params);
+ }
+ public static void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLhandleARB GetHandleARB(Enums.ARB_shader_objects pname)
+ {
+ return Delegates.glGetHandleARB(pname);
+ }
+ public static void GetHistogram(Enums.VERSION_1_2 target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogram(target, reset, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogram(Enums.VERSION_1_2 target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values)
+ {
+ Delegates.glGetHistogram(target, reset, format, type, values);
+ }
+ public static void GetHistogramEXT(Enums.HistogramTargetEXT target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values)
+ {
+ Delegates.glGetHistogramEXT(target, reset, format, type, values);
+ }
+ public static void GetHistogramEXT(Enums.HistogramTargetEXT target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramEXT(target, reset, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetHistogramParameterfv(target, pname, @params);
+ }
+ public static void GetHistogramParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameterfv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetHistogramParameterfvEXT(target, pname, @params);
+ }
+ public static void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameteriv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetHistogramParameteriv(target, pname, @params);
+ }
+ public static void GetHistogramParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetHistogramParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetHistogramParameterivEXT(target, pname, @params);
+ }
+ public static void GetImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetImageTransformParameterfvHP(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetImageTransformParameterfvHP(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetImageTransformParameterfvHP(target, pname, @params);
+ }
+ public static void GetImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetImageTransformParameterivHP(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetImageTransformParameterivHP(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetImageTransformParameterivHP(target, pname, @params);
+ }
+ public static void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInfoLogARB(obj, maxLength, h0.AddrOfPinnedObject(), infoLog);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, out GLsizei length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInfoLogARB(obj, maxLength, h0.AddrOfPinnedObject(), infoLog);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ Delegates.glGetInfoLogARB(obj, maxLength, length, infoLog);
+ }
+ public static GLint GetInstrumentsSGIX()
+ {
+ return Delegates.glGetInstrumentsSGIX();
+ }
+ public static void GetIntegerIndexedvEXT(Enums.GLenum target, GLuint index, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetIntegerIndexedvEXT(target, index, data);
+ }
+ public static void GetIntegerIndexedvEXT(Enums.GLenum target, GLuint index, GLint[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetIntegerIndexedvEXT(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetIntegerIndexedvEXT(Enums.GLenum target, GLuint index, out GLint data)
+ {
+ data = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetIntegerIndexedvEXT(target, index, h0.AddrOfPinnedObject());
+ data = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetIntegerv(Enums.GetPName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetIntegerv(pname, @params);
+ }
+ public static void GetIntegerv(Enums.GetPName pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetIntegerv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetIntegerv(Enums.GetPName pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetIntegerv(pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInvariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetInvariantBooleanvEXT(id, value, data);
+ }
+ public static void GetInvariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, Enums.Boolean[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInvariantBooleanvEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInvariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, out Enums.Boolean data)
+ {
+ data = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInvariantBooleanvEXT(id, value, h0.AddrOfPinnedObject());
+ data = (Enums.Boolean)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInvariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetInvariantFloatvEXT(id, value, data);
+ }
+ public static void GetInvariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, GLfloat[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInvariantFloatvEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInvariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, out GLfloat data)
+ {
+ data = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInvariantFloatvEXT(id, value, h0.AddrOfPinnedObject());
+ data = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInvariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetInvariantIntegervEXT(id, value, data);
+ }
+ public static void GetInvariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, GLint[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInvariantIntegervEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetInvariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, out GLint data)
+ {
+ data = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetInvariantIntegervEXT(id, value, h0.AddrOfPinnedObject());
+ data = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLightfv(Enums.LightName light, Enums.LightParameter pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLightfv(light, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLightfv(Enums.LightName light, Enums.LightParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLightfv(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLightfv(Enums.LightName light, Enums.LightParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetLightfv(light, pname, @params);
+ }
+ public static void GetLightiv(Enums.LightName light, Enums.LightParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLightiv(light, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLightiv(Enums.LightName light, Enums.LightParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLightiv(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLightiv(Enums.LightName light, Enums.LightParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetLightiv(light, pname, @params);
+ }
+ public static void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetListParameterfvSGIX(list, pname, @params);
+ }
+ public static void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetListParameterfvSGIX(list, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetListParameterfvSGIX(list, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetListParameterivSGIX(list, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetListParameterivSGIX(list, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetListParameterivSGIX(list, pname, @params);
+ }
+ public static void GetLocalConstantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, out Enums.Boolean data)
+ {
+ data = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLocalConstantBooleanvEXT(id, value, h0.AddrOfPinnedObject());
+ data = (Enums.Boolean)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLocalConstantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetLocalConstantBooleanvEXT(id, value, data);
+ }
+ public static void GetLocalConstantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, Enums.Boolean[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLocalConstantBooleanvEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLocalConstantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, out GLfloat data)
+ {
+ data = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLocalConstantFloatvEXT(id, value, h0.AddrOfPinnedObject());
+ data = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLocalConstantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetLocalConstantFloatvEXT(id, value, data);
+ }
+ public static void GetLocalConstantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, GLfloat[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLocalConstantFloatvEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLocalConstantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetLocalConstantIntegervEXT(id, value, data);
+ }
+ public static void GetLocalConstantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, GLint[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLocalConstantIntegervEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetLocalConstantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, out GLint data)
+ {
+ data = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetLocalConstantIntegervEXT(id, value, h0.AddrOfPinnedObject());
+ data = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapAttribParameterfvNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMapAttribParameterfvNV(target, index, pname, @params);
+ }
+ public static void GetMapAttribParameterfvNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapAttribParameterfvNV(target, index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapAttribParameterfvNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapAttribParameterfvNV(target, index, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapAttribParameterivNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapAttribParameterivNV(target, index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapAttribParameterivNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMapAttribParameterivNV(target, index, pname, @params);
+ }
+ public static void GetMapAttribParameterivNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapAttribParameterivNV(target, index, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapControlPointsNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, [MarshalAs(UnmanagedType.Bool)] bool packed, [In, Out()] System.IntPtr points)
+ {
+ Delegates.glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);
+ }
+ public static void GetMapControlPointsNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, [MarshalAs(UnmanagedType.Bool)] bool packed, object points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, out GLdouble v)
+ {
+ v = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapdv(target, query, h0.AddrOfPinnedObject());
+ v = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, [In, Out()] System.IntPtr v)
+ {
+ Delegates.glGetMapdv(target, query, v);
+ }
+ public static void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapdv(target, query, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapfv(target, query, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, [In, Out()] System.IntPtr v)
+ {
+ Delegates.glGetMapfv(target, query, v);
+ }
+ public static void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, out GLfloat v)
+ {
+ v = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapfv(target, query, h0.AddrOfPinnedObject());
+ v = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapiv(target, query, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, out GLint v)
+ {
+ v = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapiv(target, query, h0.AddrOfPinnedObject());
+ v = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, [In, Out()] System.IntPtr v)
+ {
+ Delegates.glGetMapiv(target, query, v);
+ }
+ public static void GetMapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMapParameterfvNV(target, pname, @params);
+ }
+ public static void GetMapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapParameterfvNV(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapParameterfvNV(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapParameterivNV(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMapParameterivNV(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMapParameterivNV(target, pname, @params);
+ }
+ public static void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMaterialfv(face, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMaterialfv(face, pname, @params);
+ }
+ public static void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMaterialfv(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMaterialiv(face, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMaterialiv(face, pname, @params);
+ }
+ public static void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMaterialiv(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmax(Enums.VERSION_1_2 target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values)
+ {
+ Delegates.glGetMinmax(target, reset, format, type, values);
+ }
+ public static void GetMinmax(Enums.VERSION_1_2 target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmax(target, reset, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxEXT(Enums.MinmaxTargetEXT target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values)
+ {
+ Delegates.glGetMinmaxEXT(target, reset, format, type, values);
+ }
+ public static void GetMinmaxEXT(Enums.MinmaxTargetEXT target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, object values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxEXT(target, reset, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameterfv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMinmaxParameterfv(target, pname, @params);
+ }
+ public static void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMinmaxParameterfvEXT(target, pname, @params);
+ }
+ public static void GetMinmaxParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameteriv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMinmaxParameteriv(target, pname, @params);
+ }
+ public static void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetMinmaxParameterivEXT(target, pname, @params);
+ }
+ public static void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetMinmaxParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectBufferfvATI(GLuint buffer, Enums.ATI_vertex_array_object pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectBufferfvATI(buffer, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectBufferfvATI(GLuint buffer, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetObjectBufferfvATI(buffer, pname, @params);
+ }
+ public static void GetObjectBufferfvATI(GLuint buffer, Enums.ATI_vertex_array_object pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectBufferfvATI(buffer, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectBufferivATI(GLuint buffer, Enums.ATI_vertex_array_object pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectBufferivATI(buffer, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectBufferivATI(GLuint buffer, Enums.ATI_vertex_array_object pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectBufferivATI(buffer, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectBufferivATI(GLuint buffer, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetObjectBufferivATI(buffer, pname, @params);
+ }
+ public static void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectParameterfvARB(obj, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetObjectParameterfvARB(obj, pname, @params);
+ }
+ public static void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectParameterfvARB(obj, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectParameterivARB(obj, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetObjectParameterivARB(obj, pname, @params);
+ }
+ public static void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetObjectParameterivARB(obj, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetOcclusionQueryivNV(GLuint id, Enums.NV_occlusion_query pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetOcclusionQueryivNV(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetOcclusionQueryivNV(GLuint id, Enums.NV_occlusion_query pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetOcclusionQueryivNV(id, pname, @params);
+ }
+ public static void GetOcclusionQueryivNV(GLuint id, Enums.NV_occlusion_query pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetOcclusionQueryivNV(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetOcclusionQueryuivNV(GLuint id, Enums.NV_occlusion_query pname, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetOcclusionQueryuivNV(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetOcclusionQueryuivNV(GLuint id, Enums.NV_occlusion_query pname, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetOcclusionQueryuivNV(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetOcclusionQueryuivNV(GLuint id, Enums.NV_occlusion_query pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetOcclusionQueryuivNV(id, pname, @params);
+ }
+ public static void GetPixelMapfv(Enums.PixelMap map, out GLfloat values)
+ {
+ values = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelMapfv(map, h0.AddrOfPinnedObject());
+ values = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelMapfv(Enums.PixelMap map, GLfloat[] values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelMapfv(map, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelMapfv(Enums.PixelMap map, [In, Out()] System.IntPtr values)
+ {
+ Delegates.glGetPixelMapfv(map, values);
+ }
+ public static void GetPixelMapuiv(Enums.PixelMap map, out GLuint values)
+ {
+ values = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelMapuiv(map, h0.AddrOfPinnedObject());
+ values = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelMapuiv(Enums.PixelMap map, [In, Out()] System.IntPtr values)
+ {
+ Delegates.glGetPixelMapuiv(map, values);
+ }
+ public static void GetPixelMapuiv(Enums.PixelMap map, GLuint[] values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelMapuiv(map, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelMapusv(Enums.PixelMap map, [In, Out()] System.IntPtr values)
+ {
+ Delegates.glGetPixelMapusv(map, values);
+ }
+ public static void GetPixelMapusv(Enums.PixelMap map, GLushort[] values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelMapusv(map, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelMapusv(Enums.PixelMap map, out GLushort values)
+ {
+ values = default(GLushort);
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelMapusv(map, h0.AddrOfPinnedObject());
+ values = (GLushort)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetPixelTexGenParameterfvSGIS(pname, @params);
+ }
+ public static void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelTexGenParameterfvSGIS(pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelTexGenParameterfvSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelTexGenParameterivSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPixelTexGenParameterivSGIS(pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetPixelTexGenParameterivSGIS(pname, @params);
+ }
+ public static void GetPointerv(Enums.GetPointervPName pname, out object @params)
+ {
+ @params = default(System.Object);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPointerv(pname, h0.AddrOfPinnedObject());
+ @params = (System.Object)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPointerv(Enums.GetPointervPName pname, object[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPointerv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPointerv(Enums.GetPointervPName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetPointerv(pname, @params);
+ }
+ public static void GetPointervEXT(Enums.GetPointervPName pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetPointervEXT(pname, @params);
+ }
+ public static void GetPolygonStipple([In, Out()] System.IntPtr mask)
+ {
+ Delegates.glGetPolygonStipple(mask);
+ }
+ public static void GetPolygonStipple(GLubyte[] mask)
+ {
+ GCHandle h0 = GCHandle.Alloc(mask, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPolygonStipple(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetPolygonStipple(out GLubyte mask)
+ {
+ mask = default(GLubyte);
+ GCHandle h0 = GCHandle.Alloc(mask, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetPolygonStipple(h0.AddrOfPinnedObject());
+ mask = (GLubyte)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterdvARB(Enums.ARB_vertex_program target, GLuint index, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterdvARB(target, index, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterdvARB(Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterdvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterdvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramEnvParameterdvARB(target, index, @params);
+ }
+ public static void GetProgramEnvParameterfvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramEnvParameterfvARB(target, index, @params);
+ }
+ public static void GetProgramEnvParameterfvARB(Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterfvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterfvARB(Enums.ARB_vertex_program target, GLuint index, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterfvARB(target, index, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterIivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterIivNV(target, index, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramEnvParameterIivNV(target, index, @params);
+ }
+ public static void GetProgramEnvParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterIuivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramEnvParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramEnvParameterIuivNV(target, index, @params);
+ }
+ public static void GetProgramEnvParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramEnvParameterIuivNV(target, index, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramInfoLog(GLuint program, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ Delegates.glGetProgramInfoLog(program, bufSize, length, infoLog);
+ }
+ public static void GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei[] length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramInfoLog(program, bufSize, h0.AddrOfPinnedObject(), infoLog);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramInfoLog(GLuint program, GLsizei bufSize, out GLsizei length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramInfoLog(program, bufSize, h0.AddrOfPinnedObject(), infoLog);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramiv(GLuint program, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramiv(program, pname, @params);
+ }
+ public static void GetProgramiv(GLuint program, Enums.VERSION_2_0 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramiv(program, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramiv(GLuint program, Enums.VERSION_2_0 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramiv(program, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramivARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramivARB(target, pname, @params);
+ }
+ public static void GetProgramivARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramivARB(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramivARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramivARB(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramivNV(GLuint id, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramivNV(id, pname, @params);
+ }
+ public static void GetProgramivNV(GLuint id, Enums.NV_vertex_program pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramivNV(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramivNV(GLuint id, Enums.NV_vertex_program pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramivNV(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterdvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramLocalParameterdvARB(target, index, @params);
+ }
+ public static void GetProgramLocalParameterdvARB(Enums.ARB_vertex_program target, GLuint index, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterdvARB(target, index, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterdvARB(Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterdvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterfvARB(Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterfvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterfvARB(Enums.ARB_vertex_program target, GLuint index, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterfvARB(target, index, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterfvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramLocalParameterfvARB(target, index, @params);
+ }
+ public static void GetProgramLocalParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramLocalParameterIivNV(target, index, @params);
+ }
+ public static void GetProgramLocalParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterIivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterIivNV(target, index, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramLocalParameterIuivNV(target, index, @params);
+ }
+ public static void GetProgramLocalParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterIuivNV(target, index, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramLocalParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramLocalParameterIuivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, ref GLubyte name, [In, Out()] System.IntPtr @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, out GLdouble @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(GLdouble);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (GLdouble)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, ref GLubyte name, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, ref GLubyte name, out GLdouble @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(GLdouble);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (GLdouble)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, System.IntPtr name, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, name, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, System.IntPtr name, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, name, @params);
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, GLubyte[] name, [In, Out()] System.IntPtr @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, System.IntPtr name, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterdvNV(id, len, name, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, [In, Out()] System.IntPtr @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, System.IntPtr name, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, name, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, System.IntPtr name, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, name, @params);
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, System.IntPtr name, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, name, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, GLubyte[] name, out GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(GLfloat);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (GLfloat)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, ref GLubyte name, out GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(GLfloat);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (GLfloat)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, ref GLubyte name, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, ref GLubyte name, [In, Out()] System.IntPtr @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ @params = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramNamedParameterfvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ @params = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void GetProgramParameterdvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramParameterdvNV(target, index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramParameterdvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramParameterdvNV(target, index, pname, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramParameterdvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramParameterdvNV(target, index, pname, @params);
+ }
+ public static void GetProgramParameterfvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramParameterfvNV(target, index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramParameterfvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramParameterfvNV(target, index, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramParameterfvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetProgramParameterfvNV(target, index, pname, @params);
+ }
+ public static void GetProgramStringARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program pname, object @string)
+ {
+ GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramStringARB(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramStringARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @string)
+ {
+ Delegates.glGetProgramStringARB(target, pname, @string);
+ }
+ public static void GetProgramStringNV(GLuint id, Enums.NV_vertex_program pname, out GLubyte program)
+ {
+ program = default(GLubyte);
+ GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramStringNV(id, pname, h0.AddrOfPinnedObject());
+ program = (GLubyte)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramStringNV(GLuint id, Enums.NV_vertex_program pname, GLubyte[] program)
+ {
+ GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetProgramStringNV(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetProgramStringNV(GLuint id, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr program)
+ {
+ Delegates.glGetProgramStringNV(id, pname, program);
+ }
+ public static void GetQueryiv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryiv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryiv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryiv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryiv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryiv(target, pname, @params);
+ }
+ public static void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryivARB(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryivARB(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryivARB(target, pname, @params);
+ }
+ public static void GetQueryObjecti64vEXT(GLuint id, Enums.GLenum pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryObjecti64vEXT(id, pname, @params);
+ }
+ public static void GetQueryObjecti64vEXT(GLuint id, Enums.GLenum pname, GLint64EXT[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjecti64vEXT(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjecti64vEXT(GLuint id, Enums.GLenum pname, out GLint64EXT @params)
+ {
+ @params = default(GLint64EXT);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjecti64vEXT(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLint64EXT)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectiv(GLuint id, Enums.VERSION_1_5 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectiv(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectiv(GLuint id, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryObjectiv(id, pname, @params);
+ }
+ public static void GetQueryObjectiv(GLuint id, Enums.VERSION_1_5 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectiv(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectivARB(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectivARB(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryObjectivARB(id, pname, @params);
+ }
+ public static void GetQueryObjectui64vEXT(GLuint id, Enums.GLenum pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryObjectui64vEXT(id, pname, @params);
+ }
+ public static void GetQueryObjectui64vEXT(GLuint id, Enums.GLenum pname, GLuint64EXT[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectui64vEXT(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectui64vEXT(GLuint id, Enums.GLenum pname, out GLuint64EXT @params)
+ {
+ @params = default(GLuint64EXT);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectui64vEXT(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLuint64EXT)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectuiv(GLuint id, Enums.VERSION_1_5 pname, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectuiv(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectuiv(GLuint id, Enums.VERSION_1_5 pname, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectuiv(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectuiv(GLuint id, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryObjectuiv(id, pname, @params);
+ }
+ public static void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectuivARB(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetQueryObjectuivARB(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetQueryObjectuivARB(id, pname, @params);
+ }
+ public static void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetRenderbufferParameterivEXT(target, pname, @params);
+ }
+ public static void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetRenderbufferParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetRenderbufferParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, object column, object span)
+ {
+ row = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilter(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ row = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, object row, [In, Out()] System.IntPtr column, object span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ column = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilter(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ column = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, [In, Out()] System.IntPtr column, [In, Out()] System.IntPtr span)
+ {
+ Delegates.glGetSeparableFilter(target, format, type, row, column, span);
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, object row, [In, Out()] System.IntPtr column, [In, Out()] System.IntPtr span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ column = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ span = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilter(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ column = (System.IntPtr)h1.Target;
+ span = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, [In, Out()] System.IntPtr column, object span)
+ {
+ row = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ column = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilter(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ row = (System.IntPtr)h0.Target;
+ column = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, object column, [In, Out()] System.IntPtr span)
+ {
+ row = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ span = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilter(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ row = (System.IntPtr)h0.Target;
+ span = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, [In, Out()] System.IntPtr span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ span = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilter(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ span = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, object span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilter(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, [In, Out()] System.IntPtr column, object span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ column = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ column = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, [In, Out()] System.IntPtr column, [In, Out()] System.IntPtr span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ column = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ span = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ column = (System.IntPtr)h1.Target;
+ span = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, object span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, object row, object column, [In, Out()] System.IntPtr span)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ span = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ span = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, [In, Out()] System.IntPtr column, object span)
+ {
+ row = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ column = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ row = (System.IntPtr)h0.Target;
+ column = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, [In, Out()] System.IntPtr column, [In, Out()] System.IntPtr span)
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, row, column, span);
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, object column, object span)
+ {
+ row = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ row = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, object column, [In, Out()] System.IntPtr span)
+ {
+ row = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ span = default(System.IntPtr);
+ GCHandle h2 = GCHandle.Alloc(span, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSeparableFilterEXT(target, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ row = (System.IntPtr)h0.Target;
+ span = (System.IntPtr)h2.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void GetShaderInfoLog(GLuint shader, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ Delegates.glGetShaderInfoLog(shader, bufSize, length, infoLog);
+ }
+ public static void GetShaderInfoLog(GLuint shader, GLsizei bufSize, out GLsizei length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderInfoLog(shader, bufSize, h0.AddrOfPinnedObject(), infoLog);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei[] length, [In, Out()] System.Text.StringBuilder infoLog)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderInfoLog(shader, bufSize, h0.AddrOfPinnedObject(), infoLog);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderiv(GLuint shader, Enums.VERSION_2_0 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderiv(shader, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderiv(GLuint shader, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetShaderiv(shader, pname, @params);
+ }
+ public static void GetShaderiv(GLuint shader, Enums.VERSION_2_0 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderiv(shader, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderSource(GLuint shader, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder source)
+ {
+ Delegates.glGetShaderSource(shader, bufSize, length, source);
+ }
+ public static void GetShaderSource(GLuint shader, GLsizei bufSize, out GLsizei length, [In, Out()] System.Text.StringBuilder source)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderSource(shader, bufSize, h0.AddrOfPinnedObject(), source);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei[] length, [In, Out()] System.Text.StringBuilder source)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderSource(shader, bufSize, h0.AddrOfPinnedObject(), source);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, out GLsizei length, [In, Out()] System.Text.StringBuilder source)
+ {
+ length = default(GLsizei);
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderSourceARB(obj, maxLength, h0.AddrOfPinnedObject(), source);
+ length = (GLsizei)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei[] length, [In, Out()] System.Text.StringBuilder source)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetShaderSourceARB(obj, maxLength, h0.AddrOfPinnedObject(), source);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder source)
+ {
+ Delegates.glGetShaderSourceARB(obj, maxLength, length, source);
+ }
+ public static void GetSharpenTexFuncSGIS(Enums.TextureTarget target, out GLfloat points)
+ {
+ points = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSharpenTexFuncSGIS(target, h0.AddrOfPinnedObject());
+ points = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetSharpenTexFuncSGIS(Enums.TextureTarget target, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetSharpenTexFuncSGIS(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetSharpenTexFuncSGIS(Enums.TextureTarget target, [In, Out()] System.IntPtr points)
+ {
+ Delegates.glGetSharpenTexFuncSGIS(target, points);
+ }
+ public static string GetString(Enums.StringName name)
+ {
+ return Marshal.PtrToStringAnsi(Delegates.glGetString(name));
+ }
+ public static void GetTexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, GLfloat[] param)
+ {
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexBumpParameterfvATI(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, [In, Out()] System.IntPtr param)
+ {
+ Delegates.glGetTexBumpParameterfvATI(pname, param);
+ }
+ public static void GetTexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, out GLfloat param)
+ {
+ param = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexBumpParameterfvATI(pname, h0.AddrOfPinnedObject());
+ param = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, out GLint param)
+ {
+ param = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexBumpParameterivATI(pname, h0.AddrOfPinnedObject());
+ param = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, GLint[] param)
+ {
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexBumpParameterivATI(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, [In, Out()] System.IntPtr param)
+ {
+ Delegates.glGetTexBumpParameterivATI(pname, param);
+ }
+ public static void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexEnvfv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexEnvfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexEnvfv(target, pname, @params);
+ }
+ public static void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexEnviv(target, pname, @params);
+ }
+ public static void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexEnviv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexEnviv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, [In, Out()] System.IntPtr weights)
+ {
+ Delegates.glGetTexFilterFuncSGIS(target, filter, weights);
+ }
+ public static void GetTexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, GLfloat[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexFilterFuncSGIS(target, filter, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, out GLfloat weights)
+ {
+ weights = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexFilterFuncSGIS(target, filter, h0.AddrOfPinnedObject());
+ weights = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexGendv(coord, pname, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexGendv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexGendv(coord, pname, @params);
+ }
+ public static void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexGenfv(coord, pname, @params);
+ }
+ public static void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexGenfv(coord, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexGenfv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexGeniv(coord, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexGeniv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexGeniv(coord, pname, @params);
+ }
+ public static void GetTexImage(Enums.TextureTarget target, GLint level, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexImage(target, level, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexImage(Enums.TextureTarget target, GLint level, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr pixels)
+ {
+ Delegates.glGetTexImage(target, level, format, type, pixels);
+ }
+ public static void GetTexLevelParameterfv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexLevelParameterfv(target, level, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexLevelParameterfv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexLevelParameterfv(target, level, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexLevelParameterfv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexLevelParameterfv(target, level, pname, @params);
+ }
+ public static void GetTexLevelParameteriv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexLevelParameteriv(target, level, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexLevelParameteriv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexLevelParameteriv(target, level, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexLevelParameteriv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexLevelParameteriv(target, level, pname, @params);
+ }
+ public static void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameterfv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexParameterfv(target, pname, @params);
+ }
+ public static void GetTexParameterIivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexParameterIivEXT(target, pname, @params);
+ }
+ public static void GetTexParameterIivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameterIivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexParameterIivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameterIivEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexParameterIuivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameterIuivEXT(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexParameterIuivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameterIuivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexParameterIuivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexParameterIuivEXT(target, pname, @params);
+ }
+ public static void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTexParameteriv(target, pname, @params);
+ }
+ public static void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTexParameteriv(target, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTrackMatrixivNV(Enums.NV_vertex_program target, GLuint address, Enums.NV_vertex_program pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTrackMatrixivNV(target, address, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTrackMatrixivNV(Enums.NV_vertex_program target, GLuint address, Enums.NV_vertex_program pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTrackMatrixivNV(target, address, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTrackMatrixivNV(Enums.NV_vertex_program target, GLuint address, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetTrackMatrixivNV(target, address, pname, @params);
+ }
+ public static void GetTransformFeedbackVaryingNV(GLuint program, GLuint index, [In, Out()] System.IntPtr location)
+ {
+ Delegates.glGetTransformFeedbackVaryingNV(program, index, location);
+ }
+ public static void GetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint[] location)
+ {
+ GCHandle h0 = GCHandle.Alloc(location, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTransformFeedbackVaryingNV(program, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetTransformFeedbackVaryingNV(GLuint program, GLuint index, out GLint location)
+ {
+ location = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(location, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetTransformFeedbackVaryingNV(program, index, h0.AddrOfPinnedObject());
+ location = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLint GetUniformBufferSizeEXT(GLuint program, GLint location)
+ {
+ return Delegates.glGetUniformBufferSizeEXT(program, location);
+ }
+ public static void GetUniformfv(GLuint program, GLint location, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetUniformfv(program, location, @params);
+ }
+ public static void GetUniformfv(GLuint program, GLint location, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformfv(program, location, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformfv(GLuint program, GLint location, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformfv(program, location, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformfvARB(GLhandleARB programObj, GLint location, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformfvARB(programObj, location, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformfvARB(programObj, location, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformfvARB(GLhandleARB programObj, GLint location, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetUniformfvARB(programObj, location, @params);
+ }
+ public static void GetUniformiv(GLuint program, GLint location, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformiv(program, location, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformiv(GLuint program, GLint location, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformiv(program, location, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformiv(GLuint program, GLint location, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetUniformiv(program, location, @params);
+ }
+ public static void GetUniformivARB(GLhandleARB programObj, GLint location, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformivARB(programObj, location, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformivARB(GLhandleARB programObj, GLint location, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetUniformivARB(programObj, location, @params);
+ }
+ public static void GetUniformivARB(GLhandleARB programObj, GLint location, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformivARB(programObj, location, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLint GetUniformLocation(GLuint program, string name)
+ {
+ return Delegates.glGetUniformLocation(program, name);
+ }
+ public static GLint GetUniformLocationARB(GLhandleARB programObj, string name)
+ {
+ return Delegates.glGetUniformLocationARB(programObj, name);
+ }
+ public static GLintptr GetUniformOffsetEXT(GLuint program, GLint location)
+ {
+ return Delegates.glGetUniformOffsetEXT(program, location);
+ }
+ public static void GetUniformuivEXT(GLuint program, GLint location, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformuivEXT(program, location, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformuivEXT(GLuint program, GLint location, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetUniformuivEXT(program, location, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetUniformuivEXT(GLuint program, GLint location, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetUniformuivEXT(program, location, @params);
+ }
+ public static void GetVariantArrayObjectfvATI(GLuint id, Enums.ATI_vertex_array_object pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantArrayObjectfvATI(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantArrayObjectfvATI(GLuint id, Enums.ATI_vertex_array_object pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantArrayObjectfvATI(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantArrayObjectfvATI(GLuint id, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVariantArrayObjectfvATI(id, pname, @params);
+ }
+ public static void GetVariantArrayObjectivATI(GLuint id, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVariantArrayObjectivATI(id, pname, @params);
+ }
+ public static void GetVariantArrayObjectivATI(GLuint id, Enums.ATI_vertex_array_object pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantArrayObjectivATI(id, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantArrayObjectivATI(GLuint id, Enums.ATI_vertex_array_object pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantArrayObjectivATI(id, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, out Enums.Boolean data)
+ {
+ data = default(Enums.Boolean);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantBooleanvEXT(id, value, h0.AddrOfPinnedObject());
+ data = (Enums.Boolean)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, Enums.Boolean[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantBooleanvEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetVariantBooleanvEXT(id, value, data);
+ }
+ public static void GetVariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetVariantFloatvEXT(id, value, data);
+ }
+ public static void GetVariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, GLfloat[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantFloatvEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, out GLfloat data)
+ {
+ data = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantFloatvEXT(id, value, h0.AddrOfPinnedObject());
+ data = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, out GLint data)
+ {
+ data = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantIntegervEXT(id, value, h0.AddrOfPinnedObject());
+ data = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, GLint[] data)
+ {
+ GCHandle h0 = GCHandle.Alloc(data, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVariantIntegervEXT(id, value, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetVariantIntegervEXT(id, value, data);
+ }
+ public static void GetVariantPointervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data)
+ {
+ Delegates.glGetVariantPointervEXT(id, value, data);
+ }
+ public static GLint GetVaryingLocationNV(GLuint program, string name)
+ {
+ return Delegates.glGetVaryingLocationNV(program, name);
+ }
+ public static void GetVertexAttribArrayObjectfvATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribArrayObjectfvATI(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribArrayObjectfvATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribArrayObjectfvATI(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribArrayObjectfvATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribArrayObjectfvATI(index, pname, @params);
+ }
+ public static void GetVertexAttribArrayObjectivATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribArrayObjectivATI(index, pname, @params);
+ }
+ public static void GetVertexAttribArrayObjectivATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribArrayObjectivATI(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribArrayObjectivATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribArrayObjectivATI(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribdv(GLuint index, Enums.VERSION_2_0 pname, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribdv(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribdv(GLuint index, Enums.VERSION_2_0 pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribdv(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribdv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribdv(index, pname, @params);
+ }
+ public static void GetVertexAttribdvARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribdvARB(index, pname, @params);
+ }
+ public static void GetVertexAttribdvARB(GLuint index, Enums.ARB_vertex_program pname, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribdvARB(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribdvARB(GLuint index, Enums.ARB_vertex_program pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribdvARB(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribdvNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribdvNV(index, pname, @params);
+ }
+ public static void GetVertexAttribdvNV(GLuint index, Enums.NV_vertex_program pname, out GLdouble @params)
+ {
+ @params = default(GLdouble);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribdvNV(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLdouble)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribdvNV(GLuint index, Enums.NV_vertex_program pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribdvNV(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribfv(GLuint index, Enums.VERSION_2_0 pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribfv(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribfv(GLuint index, Enums.VERSION_2_0 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribfv(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribfv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribfv(index, pname, @params);
+ }
+ public static void GetVertexAttribfvARB(GLuint index, Enums.ARB_vertex_program pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribfvARB(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribfvARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribfvARB(index, pname, @params);
+ }
+ public static void GetVertexAttribfvARB(GLuint index, Enums.ARB_vertex_program pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribfvARB(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribfvNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribfvNV(index, pname, @params);
+ }
+ public static void GetVertexAttribfvNV(GLuint index, Enums.NV_vertex_program pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribfvNV(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribfvNV(GLuint index, Enums.NV_vertex_program pname, out GLfloat @params)
+ {
+ @params = default(GLfloat);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribfvNV(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLfloat)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribIivEXT(GLuint index, Enums.NV_vertex_program4 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribIivEXT(index, pname, @params);
+ }
+ public static void GetVertexAttribIivEXT(GLuint index, Enums.NV_vertex_program4 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribIivEXT(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribIivEXT(GLuint index, Enums.NV_vertex_program4 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribIivEXT(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribIuivEXT(GLuint index, Enums.NV_vertex_program4 pname, out GLuint @params)
+ {
+ @params = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribIuivEXT(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribIuivEXT(GLuint index, Enums.NV_vertex_program4 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribIuivEXT(index, pname, @params);
+ }
+ public static void GetVertexAttribIuivEXT(GLuint index, Enums.NV_vertex_program4 pname, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribIuivEXT(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribiv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribiv(index, pname, @params);
+ }
+ public static void GetVertexAttribiv(GLuint index, Enums.VERSION_2_0 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribiv(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribiv(GLuint index, Enums.VERSION_2_0 pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribiv(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribivARB(GLuint index, Enums.ARB_vertex_program pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribivARB(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribivARB(GLuint index, Enums.ARB_vertex_program pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribivARB(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribivARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribivARB(index, pname, @params);
+ }
+ public static void GetVertexAttribivNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params)
+ {
+ Delegates.glGetVertexAttribivNV(index, pname, @params);
+ }
+ public static void GetVertexAttribivNV(GLuint index, Enums.NV_vertex_program pname, out GLint @params)
+ {
+ @params = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribivNV(index, pname, h0.AddrOfPinnedObject());
+ @params = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribivNV(GLuint index, Enums.NV_vertex_program pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glGetVertexAttribivNV(index, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void GetVertexAttribPointerv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr pointer)
+ {
+ Delegates.glGetVertexAttribPointerv(index, pname, pointer);
+ }
+ public static void GetVertexAttribPointervARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr pointer)
+ {
+ Delegates.glGetVertexAttribPointervARB(index, pname, pointer);
+ }
+ public static void GetVertexAttribPointervNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr pointer)
+ {
+ Delegates.glGetVertexAttribPointervNV(index, pname, pointer);
+ }
+ public static void GlobalAlphaFactorbSUN(GLbyte factor)
+ {
+ Delegates.glGlobalAlphaFactorbSUN(factor);
+ }
+ public static void GlobalAlphaFactordSUN(GLdouble factor)
+ {
+ Delegates.glGlobalAlphaFactordSUN(factor);
+ }
+ public static void GlobalAlphaFactorfSUN(GLfloat factor)
+ {
+ Delegates.glGlobalAlphaFactorfSUN(factor);
+ }
+ public static void GlobalAlphaFactoriSUN(GLint factor)
+ {
+ Delegates.glGlobalAlphaFactoriSUN(factor);
+ }
+ public static void GlobalAlphaFactorsSUN(GLshort factor)
+ {
+ Delegates.glGlobalAlphaFactorsSUN(factor);
+ }
+ public static void GlobalAlphaFactorubSUN(GLubyte factor)
+ {
+ Delegates.glGlobalAlphaFactorubSUN(factor);
+ }
+ public static void GlobalAlphaFactoruiSUN(GLuint factor)
+ {
+ Delegates.glGlobalAlphaFactoruiSUN(factor);
+ }
+ public static void GlobalAlphaFactorusSUN(GLushort factor)
+ {
+ Delegates.glGlobalAlphaFactorusSUN(factor);
+ }
+ public static void Hint(Enums.HintTarget target, Enums.HintMode mode)
+ {
+ Delegates.glHint(target, mode);
+ }
+ public static void HintPGI(Enums.PGI_misc_hints target, GLint mode)
+ {
+ Delegates.glHintPGI(target, mode);
+ }
+ public static void Histogram(Enums.VERSION_1_2 target, GLsizei width, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink)
+ {
+ Delegates.glHistogram(target, width, internalformat, sink);
+ }
+ public static void HistogramEXT(Enums.HistogramTargetEXT target, GLsizei width, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink)
+ {
+ Delegates.glHistogramEXT(target, width, internalformat, sink);
+ }
+ public static void IglooInterfaceSGIX(Enums.GLenum pname, System.IntPtr @params)
+ {
+ Delegates.glIglooInterfaceSGIX(pname, @params);
+ }
+ public static void IglooInterfaceSGIX(Enums.GLenum pname, object @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIglooInterfaceSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ImageTransformParameterfHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLfloat param)
+ {
+ Delegates.glImageTransformParameterfHP(target, pname, param);
+ }
+ public static void ImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glImageTransformParameterfvHP(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glImageTransformParameterfvHP(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, System.IntPtr @params)
+ {
+ Delegates.glImageTransformParameterfvHP(target, pname, @params);
+ }
+ public static void ImageTransformParameteriHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLint param)
+ {
+ Delegates.glImageTransformParameteriHP(target, pname, param);
+ }
+ public static void ImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glImageTransformParameterivHP(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glImageTransformParameterivHP(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, System.IntPtr @params)
+ {
+ Delegates.glImageTransformParameterivHP(target, pname, @params);
+ }
+ public static void Indexd(GLdouble c)
+ {
+ Delegates.glIndexd(c);
+ }
+ public static void Indexdv(System.IntPtr c)
+ {
+ Delegates.glIndexdv(c);
+ }
+ public static void Indexdv(GLdouble[] c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexdv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexdv(ref GLdouble c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexdv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexf(GLfloat c)
+ {
+ Delegates.glIndexf(c);
+ }
+ public static void IndexFuncEXT(Enums.EXT_index_func func, GLclampf @ref)
+ {
+ Delegates.glIndexFuncEXT(func, @ref);
+ }
+ public static void Indexfv(GLfloat[] c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexfv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexfv(System.IntPtr c)
+ {
+ Delegates.glIndexfv(c);
+ }
+ public static void Indexfv(ref GLfloat c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexfv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexi(GLint c)
+ {
+ Delegates.glIndexi(c);
+ }
+ public static void Indexiv(System.IntPtr c)
+ {
+ Delegates.glIndexiv(c);
+ }
+ public static void Indexiv(GLint[] c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexiv(ref GLint c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void IndexMask(GLuint mask)
+ {
+ Delegates.glIndexMask(mask);
+ }
+ public static void IndexMaterialEXT(Enums.MaterialFace face, Enums.EXT_index_material mode)
+ {
+ Delegates.glIndexMaterialEXT(face, mode);
+ }
+ public static void IndexPointer(Enums.IndexPointerType type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexPointer(type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void IndexPointer(Enums.IndexPointerType type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glIndexPointer(type, stride, pointer);
+ }
+ public static void IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexPointerEXT(type, stride, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer)
+ {
+ Delegates.glIndexPointerEXT(type, stride, count, pointer);
+ }
+ public static void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glIndexPointerListIBM(type, stride, pointer, ptrstride);
+ }
+ public static void Indexs(GLshort c)
+ {
+ Delegates.glIndexs(c);
+ }
+ public static void Indexsv(GLshort[] c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexsv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexsv(ref GLshort c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexsv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexsv(System.IntPtr c)
+ {
+ Delegates.glIndexsv(c);
+ }
+ public static void Indexub(GLubyte c)
+ {
+ Delegates.glIndexub(c);
+ }
+ public static void Indexubv(System.IntPtr c)
+ {
+ Delegates.glIndexubv(c);
+ }
+ public static void Indexubv(ref GLubyte c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Indexubv(GLubyte[] c)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glIndexubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void InitNames()
+ {
+ Delegates.glInitNames();
+ }
+ public static void InsertComponentEXT(GLuint res, GLuint src, GLuint num)
+ {
+ Delegates.glInsertComponentEXT(res, src, num);
+ }
+ public static void InstrumentsBufferSGIX(GLsizei size, GLint[] buffer)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glInstrumentsBufferSGIX(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void InstrumentsBufferSGIX(GLsizei size, out GLint buffer)
+ {
+ buffer = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glInstrumentsBufferSGIX(size, h0.AddrOfPinnedObject());
+ buffer = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void InstrumentsBufferSGIX(GLsizei size, [In, Out()] System.IntPtr buffer)
+ {
+ Delegates.glInstrumentsBufferSGIX(size, buffer);
+ }
+ public static void InterleavedArrays(Enums.InterleavedArrayFormat format, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glInterleavedArrays(format, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void InterleavedArrays(Enums.InterleavedArrayFormat format, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glInterleavedArrays(format, stride, pointer);
+ }
+ public static GLboolean IsAsyncMarkerSGIX(GLuint marker)
+ {
+ return Delegates.glIsAsyncMarkerSGIX(marker);
+ }
+ public static GLboolean IsBuffer(GLuint buffer)
+ {
+ return Delegates.glIsBuffer(buffer);
+ }
+ public static GLboolean IsBufferARB(GLuint buffer)
+ {
+ return Delegates.glIsBufferARB(buffer);
+ }
+ public static GLboolean IsEnabled(Enums.EnableCap cap)
+ {
+ return Delegates.glIsEnabled(cap);
+ }
+ public static GLboolean IsEnabledIndexedEXT(Enums.GLenum target, GLuint index)
+ {
+ return Delegates.glIsEnabledIndexedEXT(target, index);
+ }
+ public static GLboolean IsFenceAPPLE(GLuint fence)
+ {
+ return Delegates.glIsFenceAPPLE(fence);
+ }
+ public static GLboolean IsFenceNV(GLuint fence)
+ {
+ return Delegates.glIsFenceNV(fence);
+ }
+ public static GLboolean IsFramebufferEXT(GLuint framebuffer)
+ {
+ return Delegates.glIsFramebufferEXT(framebuffer);
+ }
+ public static GLboolean IsList(GLuint list)
+ {
+ return Delegates.glIsList(list);
+ }
+ public static GLboolean IsObjectBufferATI(GLuint buffer)
+ {
+ return Delegates.glIsObjectBufferATI(buffer);
+ }
+ public static GLboolean IsOcclusionQueryNV(GLuint id)
+ {
+ return Delegates.glIsOcclusionQueryNV(id);
+ }
+ public static GLboolean IsProgram(GLuint program)
+ {
+ return Delegates.glIsProgram(program);
+ }
+ public static GLboolean IsProgramARB(GLuint program)
+ {
+ return Delegates.glIsProgramARB(program);
+ }
+ public static GLboolean IsProgramNV(GLuint id)
+ {
+ return Delegates.glIsProgramNV(id);
+ }
+ public static GLboolean IsQuery(GLuint id)
+ {
+ return Delegates.glIsQuery(id);
+ }
+ public static GLboolean IsQueryARB(GLuint id)
+ {
+ return Delegates.glIsQueryARB(id);
+ }
+ public static GLboolean IsRenderbufferEXT(GLuint renderbuffer)
+ {
+ return Delegates.glIsRenderbufferEXT(renderbuffer);
+ }
+ public static GLboolean IsShader(GLuint shader)
+ {
+ return Delegates.glIsShader(shader);
+ }
+ public static GLboolean IsTexture(GLuint texture)
+ {
+ return Delegates.glIsTexture(texture);
+ }
+ public static GLboolean IsTextureEXT(GLuint texture)
+ {
+ return Delegates.glIsTextureEXT(texture);
+ }
+ public static GLboolean IsVariantEnabledEXT(GLuint id, Enums.EXT_vertex_shader cap)
+ {
+ return Delegates.glIsVariantEnabledEXT(id, cap);
+ }
+ public static GLboolean IsVertexArrayAPPLE(GLuint array)
+ {
+ return Delegates.glIsVertexArrayAPPLE(array);
+ }
+ public static void LightEnviSGIX(Enums.LightEnvParameterSGIX pname, GLint param)
+ {
+ Delegates.glLightEnviSGIX(pname, param);
+ }
+ public static void Lightf(Enums.LightName light, Enums.LightParameter pname, GLfloat param)
+ {
+ Delegates.glLightf(light, pname, param);
+ }
+ public static void Lightfv(Enums.LightName light, Enums.LightParameter pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightfv(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Lightfv(Enums.LightName light, Enums.LightParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightfv(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Lightfv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params)
+ {
+ Delegates.glLightfv(light, pname, @params);
+ }
+ public static void Lighti(Enums.LightName light, Enums.LightParameter pname, GLint param)
+ {
+ Delegates.glLighti(light, pname, param);
+ }
+ public static void Lightiv(Enums.LightName light, Enums.LightParameter pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightiv(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Lightiv(Enums.LightName light, Enums.LightParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightiv(light, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Lightiv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params)
+ {
+ Delegates.glLightiv(light, pname, @params);
+ }
+ public static void LightModelf(Enums.LightModelParameter pname, GLfloat param)
+ {
+ Delegates.glLightModelf(pname, param);
+ }
+ public static void LightModelfv(Enums.LightModelParameter pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightModelfv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LightModelfv(Enums.LightModelParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightModelfv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LightModelfv(Enums.LightModelParameter pname, System.IntPtr @params)
+ {
+ Delegates.glLightModelfv(pname, @params);
+ }
+ public static void LightModeli(Enums.LightModelParameter pname, GLint param)
+ {
+ Delegates.glLightModeli(pname, param);
+ }
+ public static void LightModeliv(Enums.LightModelParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightModeliv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LightModeliv(Enums.LightModelParameter pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLightModeliv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LightModeliv(Enums.LightModelParameter pname, System.IntPtr @params)
+ {
+ Delegates.glLightModeliv(pname, @params);
+ }
+ public static void LineStipple(GLint factor, GLushort pattern)
+ {
+ Delegates.glLineStipple(factor, unchecked((GLushort)pattern));
+ }
+ public static void LineWidth(GLfloat width)
+ {
+ Delegates.glLineWidth(width);
+ }
+ public static void LinkProgram(GLuint program)
+ {
+ Delegates.glLinkProgram(program);
+ }
+ public static void LinkProgramARB(GLhandleARB programObj)
+ {
+ Delegates.glLinkProgramARB(programObj);
+ }
+ public static void ListBase(GLuint @base)
+ {
+ Delegates.glListBase(@base);
+ }
+ public static void ListParameterfSGIX(GLuint list, Enums.ListParameterName pname, GLfloat param)
+ {
+ Delegates.glListParameterfSGIX(list, pname, param);
+ }
+ public static void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, System.IntPtr @params)
+ {
+ Delegates.glListParameterfvSGIX(list, pname, @params);
+ }
+ public static void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glListParameterfvSGIX(list, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glListParameterfvSGIX(list, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ListParameteriSGIX(GLuint list, Enums.ListParameterName pname, GLint param)
+ {
+ Delegates.glListParameteriSGIX(list, pname, param);
+ }
+ public static void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glListParameterivSGIX(list, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glListParameterivSGIX(list, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, System.IntPtr @params)
+ {
+ Delegates.glListParameterivSGIX(list, pname, @params);
+ }
+ public static void LoadIdentity()
+ {
+ Delegates.glLoadIdentity();
+ }
+ public static void LoadIdentityDeformationMapSGIX(Enums.FfdMaskSGIX mask)
+ {
+ Delegates.glLoadIdentityDeformationMapSGIX(mask);
+ }
+ public static void LoadMatrixd(ref GLdouble m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadMatrixd(System.IntPtr m)
+ {
+ Delegates.glLoadMatrixd(m);
+ }
+ public static void LoadMatrixd(GLdouble[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadMatrixf(System.IntPtr m)
+ {
+ Delegates.glLoadMatrixf(m);
+ }
+ public static void LoadMatrixf(ref GLfloat m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadMatrixf(GLfloat[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadName(GLuint name)
+ {
+ Delegates.glLoadName(name);
+ }
+ public static void LoadProgramNV(Enums.NV_vertex_program target, GLuint id, GLsizei len, ref GLubyte program)
+ {
+ GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadProgramNV(target, id, len, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadProgramNV(Enums.NV_vertex_program target, GLuint id, GLsizei len, GLubyte[] program)
+ {
+ GCHandle h0 = GCHandle.Alloc(program, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadProgramNV(target, id, len, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadProgramNV(Enums.NV_vertex_program target, GLuint id, GLsizei len, System.IntPtr program)
+ {
+ Delegates.glLoadProgramNV(target, id, len, program);
+ }
+ public static void LoadTransposeMatrixd(GLdouble[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadTransposeMatrixd(ref GLdouble m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadTransposeMatrixd(System.IntPtr m)
+ {
+ Delegates.glLoadTransposeMatrixd(m);
+ }
+ public static void LoadTransposeMatrixdARB(ref GLdouble m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixdARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadTransposeMatrixdARB(System.IntPtr m)
+ {
+ Delegates.glLoadTransposeMatrixdARB(m);
+ }
+ public static void LoadTransposeMatrixdARB(GLdouble[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixdARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadTransposeMatrixf(System.IntPtr m)
+ {
+ Delegates.glLoadTransposeMatrixf(m);
+ }
+ public static void LoadTransposeMatrixf(ref GLfloat m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadTransposeMatrixf(GLfloat[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadTransposeMatrixfARB(ref GLfloat m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixfARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LoadTransposeMatrixfARB(System.IntPtr m)
+ {
+ Delegates.glLoadTransposeMatrixfARB(m);
+ }
+ public static void LoadTransposeMatrixfARB(GLfloat[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glLoadTransposeMatrixfARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void LockArraysEXT(GLint first, GLsizei count)
+ {
+ Delegates.glLockArraysEXT(first, count);
+ }
+ public static void LogicOp(Enums.LogicOp opcode)
+ {
+ Delegates.glLogicOp(opcode);
+ }
+ public static void Map1d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, System.IntPtr points)
+ {
+ Delegates.glMap1d(target, u1, u2, stride, order, points);
+ }
+ public static void Map1d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, GLdouble[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap1d(target, u1, u2, stride, order, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map1d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, ref GLdouble points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap1d(target, u1, u2, stride, order, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map1f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, System.IntPtr points)
+ {
+ Delegates.glMap1f(target, u1, u2, stride, order, points);
+ }
+ public static void Map1f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap1f(target, u1, u2, stride, order, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map1f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, ref GLfloat points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap1f(target, u1, u2, stride, order, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map2d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, System.IntPtr points)
+ {
+ Delegates.glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+ }
+ public static void Map2d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, ref GLdouble points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map2d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map2f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map2f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, ref GLfloat points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Map2f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, System.IntPtr points)
+ {
+ Delegates.glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+ }
+ public static IntPtr MapBuffer(Enums.VERSION_1_5 target, Enums.VERSION_1_5 access)
+ {
+ return Delegates.glMapBuffer(target, access);
+ }
+ public static IntPtr MapBufferARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object access)
+ {
+ return Delegates.glMapBufferARB(target, access);
+ }
+ public static void MapControlPointsNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, [MarshalAs(UnmanagedType.Bool)] bool packed, object points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MapControlPointsNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, [MarshalAs(UnmanagedType.Bool)] bool packed, System.IntPtr points)
+ {
+ Delegates.glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);
+ }
+ public static void MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+ {
+ Delegates.glMapGrid1d(un, u1, u2);
+ }
+ public static void MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+ {
+ Delegates.glMapGrid1f(un, u1, u2);
+ }
+ public static void MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+ {
+ Delegates.glMapGrid2d(un, u1, u2, vn, v1, v2);
+ }
+ public static void MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+ {
+ Delegates.glMapGrid2f(un, u1, u2, vn, v1, v2);
+ }
+ public static IntPtr MapObjectBufferATI(GLuint buffer)
+ {
+ return Delegates.glMapObjectBufferATI(buffer);
+ }
+ public static void MapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMapParameterfvNV(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMapParameterfvNV(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, System.IntPtr @params)
+ {
+ Delegates.glMapParameterfvNV(target, pname, @params);
+ }
+ public static void MapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMapParameterivNV(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMapParameterivNV(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, System.IntPtr @params)
+ {
+ Delegates.glMapParameterivNV(target, pname, @params);
+ }
+ public static void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param)
+ {
+ Delegates.glMaterialf(face, pname, param);
+ }
+ public static void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMaterialfv(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMaterialfv(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params)
+ {
+ Delegates.glMaterialfv(face, pname, @params);
+ }
+ public static void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param)
+ {
+ Delegates.glMateriali(face, pname, param);
+ }
+ public static void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMaterialiv(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMaterialiv(face, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params)
+ {
+ Delegates.glMaterialiv(face, pname, @params);
+ }
+ public static void MatrixIndexPointerARB(GLint size, Enums.ARB_matrix_palette type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glMatrixIndexPointerARB(size, type, stride, pointer);
+ }
+ public static void MatrixIndexPointerARB(GLint size, Enums.ARB_matrix_palette type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMatrixIndexPointerARB(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MatrixIndexubvARB(GLint size, System.IntPtr indices)
+ {
+ Delegates.glMatrixIndexubvARB(size, indices);
+ }
+ public static void MatrixIndexubvARB(GLint size, GLubyte[] indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMatrixIndexubvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MatrixIndexubvARB(GLint size, ref GLubyte indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMatrixIndexubvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MatrixIndexuivARB(GLint size, GLuint[] indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMatrixIndexuivARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MatrixIndexuivARB(GLint size, ref GLuint indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMatrixIndexuivARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MatrixIndexuivARB(GLint size, System.IntPtr indices)
+ {
+ Delegates.glMatrixIndexuivARB(size, indices);
+ }
+ public static void MatrixIndexusvARB(GLint size, GLushort[] indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMatrixIndexusvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MatrixIndexusvARB(GLint size, ref GLushort indices)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMatrixIndexusvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MatrixIndexusvARB(GLint size, System.IntPtr indices)
+ {
+ Delegates.glMatrixIndexusvARB(size, indices);
+ }
+ public static void MatrixMode(Enums.MatrixMode mode)
+ {
+ Delegates.glMatrixMode(mode);
+ }
+ public static void Minmax(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink)
+ {
+ Delegates.glMinmax(target, internalformat, sink);
+ }
+ public static void MinmaxEXT(Enums.MinmaxTargetEXT target, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink)
+ {
+ Delegates.glMinmaxEXT(target, internalformat, sink);
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, GLint[] first, out GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ count = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, out GLint first, [In, Out()] System.IntPtr count, GLsizei primcount)
+ {
+ first = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (GLint)h0.Target;
+ count = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, out GLint first, GLsizei[] count, GLsizei primcount)
+ {
+ first = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, GLint[] first, [In, Out()] System.IntPtr count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ count = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, [In, Out()] System.IntPtr first, out GLsizei count, GLsizei primcount)
+ {
+ first = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (System.IntPtr)h0.Target;
+ count = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, [In, Out()] System.IntPtr first, GLsizei[] count, GLsizei primcount)
+ {
+ first = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, [In, Out()] System.IntPtr first, [In, Out()] System.IntPtr count, GLsizei primcount)
+ {
+ Delegates.glMultiDrawArrays(mode, first, count, primcount);
+ }
+ public static void MultiDrawArrays(Enums.BeginMode mode, out GLint first, out GLsizei count, GLsizei primcount)
+ {
+ first = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArrays(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (GLint)h0.Target;
+ count = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, [In, Out()] System.IntPtr first, out GLsizei count, GLsizei primcount)
+ {
+ first = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (System.IntPtr)h0.Target;
+ count = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, [In, Out()] System.IntPtr count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ count = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, [In, Out()] System.IntPtr first, [In, Out()] System.IntPtr count, GLsizei primcount)
+ {
+ Delegates.glMultiDrawArraysEXT(mode, first, count, primcount);
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, [In, Out()] System.IntPtr first, GLsizei[] count, GLsizei primcount)
+ {
+ first = default(System.IntPtr);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (System.IntPtr)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, out GLint first, GLsizei[] count, GLsizei primcount)
+ {
+ first = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (GLint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, out GLint first, out GLsizei count, GLsizei primcount)
+ {
+ first = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (GLint)h0.Target;
+ count = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, GLint[] first, out GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(GLsizei);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ count = (GLsizei)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawArraysEXT(Enums.BeginMode mode, out GLint first, [In, Out()] System.IntPtr count, GLsizei primcount)
+ {
+ first = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ count = default(System.IntPtr);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawArraysEXT(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ first = (GLint)h0.Target;
+ count = (System.IntPtr)h1.Target;
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, ref GLint first, System.IntPtr count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, h0.AddrOfPinnedObject(), count, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, ref GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, ref GLint first, ref GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, ref GLint first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, System.IntPtr first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, first, h0.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, System.IntPtr first, System.IntPtr count, GLsizei primcount)
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, first, count, primcount);
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, GLint[] first, System.IntPtr count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, h0.AddrOfPinnedObject(), count, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, System.IntPtr first, ref GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementArrayAPPLE(mode, first, h0.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, System.IntPtr count, Enums.VERSION_1_4 type, ref object indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, count, type, h0.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, GLsizei[] count, Enums.VERSION_1_4 type, System.IntPtr indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, System.IntPtr count, Enums.VERSION_1_4 type, System.IntPtr indices, GLsizei primcount)
+ {
+ Delegates.glMultiDrawElements(mode, count, type, indices, primcount);
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, System.IntPtr count, Enums.VERSION_1_4 type, object[] indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, count, type, h0.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, GLsizei[] count, Enums.VERSION_1_4 type, object[] indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, ref GLsizei count, Enums.VERSION_1_4 type, object[] indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, ref GLsizei count, Enums.VERSION_1_4 type, ref object indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, GLsizei[] count, Enums.VERSION_1_4 type, ref object indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawElements(Enums.BeginMode mode, ref GLsizei count, Enums.VERSION_1_4 type, System.IntPtr indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElements(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElementsEXT(Enums.BeginMode mode, System.IntPtr count, Enums.EXT_multi_draw_arrays type, System.IntPtr indices, GLsizei primcount)
+ {
+ Delegates.glMultiDrawElementsEXT(mode, count, type, indices, primcount);
+ }
+ public static void MultiDrawElementsEXT(Enums.BeginMode mode, GLsizei[] count, Enums.EXT_multi_draw_arrays type, System.IntPtr indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementsEXT(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawElementsEXT(Enums.BeginMode mode, ref GLsizei count, Enums.EXT_multi_draw_arrays type, System.IntPtr indices, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawElementsEXT(mode, h0.AddrOfPinnedObject(), type, indices, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, ref GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, System.IntPtr first, System.IntPtr count, GLsizei primcount)
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount);
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, System.IntPtr count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, h0.AddrOfPinnedObject(), count, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, ref GLint first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, System.IntPtr first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, h0.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, GLsizei[] count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, ref GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, System.IntPtr first, ref GLsizei count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, h0.AddrOfPinnedObject(), primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint[] first, System.IntPtr count, GLsizei primcount)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiDrawRangeElementArrayAPPLE(mode, start, end, h0.AddrOfPinnedObject(), count, primcount);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, ref GLint first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, h0.AddrOfPinnedObject(), count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, System.IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, first, h0.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, System.IntPtr first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, first, count, primcount, modestride);
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, GLint[] first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, h0.AddrOfPinnedObject(), count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(System.IntPtr mode, System.IntPtr first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(mode, first, h0.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, System.IntPtr first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), first, count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, GLint[] first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, System.IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, System.IntPtr first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, ref GLint first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(ref Enums.BeginMode mode, System.IntPtr first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), first, count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, System.IntPtr first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, System.IntPtr first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), first, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, GLint[] first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, ref GLint first, ref GLsizei count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, ref GLint first, GLsizei[] count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawArraysIBM(Enums.BeginMode[] mode, ref GLint first, System.IntPtr count, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(first, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawArraysIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), count, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, System.IntPtr count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), count, type, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, System.IntPtr count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), count, type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(System.IntPtr mode, ref GLsizei count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(mode, h0.AddrOfPinnedObject(), type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(System.IntPtr mode, ref GLsizei count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, ref GLsizei count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(ref Enums.BeginMode mode, System.IntPtr count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), count, type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(ref Enums.BeginMode mode, ref GLsizei count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, GLsizei[] count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(Enums.BeginMode[] mode, ref GLsizei count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(System.IntPtr mode, GLsizei[] count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(mode, h0.AddrOfPinnedObject(), type, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(ref Enums.BeginMode mode, GLsizei[] count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, h2.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(ref Enums.BeginMode mode, GLsizei[] count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(System.IntPtr mode, System.IntPtr count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ Delegates.glMultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);
+ }
+ public static void MultiModeDrawElementsIBM(ref Enums.BeginMode mode, ref GLsizei count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(System.IntPtr mode, GLsizei[] count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(count, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(mode, h0.AddrOfPinnedObject(), type, indices, primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(System.IntPtr mode, System.IntPtr count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(mode, count, type, h0.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiModeDrawElementsIBM(ref Enums.BeginMode mode, System.IntPtr count, Enums.IBM_multimode_draw_arrays type, object indices, GLsizei primcount, GLint modestride)
+ {
+ GCHandle h0 = GCHandle.Alloc(mode, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(indices, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiModeDrawElementsIBM(h0.AddrOfPinnedObject(), count, type, h1.AddrOfPinnedObject(), primcount, modestride);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void MultiTexCoord1d(Enums.VERSION_1_3 target, GLdouble s)
+ {
+ Delegates.glMultiTexCoord1d(target, s);
+ }
+ public static void MultiTexCoord1dARB(Enums.ARB_multitexture target, GLdouble s)
+ {
+ Delegates.glMultiTexCoord1dARB(target, s);
+ }
+ public static void MultiTexCoord1dv(Enums.VERSION_1_3 target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1dv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1dv(target, v);
+ }
+ public static void MultiTexCoord1dv(Enums.VERSION_1_3 target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1dvARB(Enums.ARB_multitexture target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1dvARB(Enums.ARB_multitexture target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1dvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1dvARB(target, v);
+ }
+ public static void MultiTexCoord1f(Enums.VERSION_1_3 target, GLfloat s)
+ {
+ Delegates.glMultiTexCoord1f(target, s);
+ }
+ public static void MultiTexCoord1fARB(Enums.ARB_multitexture target, GLfloat s)
+ {
+ Delegates.glMultiTexCoord1fARB(target, s);
+ }
+ public static void MultiTexCoord1fv(Enums.VERSION_1_3 target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1fv(Enums.VERSION_1_3 target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1fv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1fv(target, v);
+ }
+ public static void MultiTexCoord1fvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1fvARB(target, v);
+ }
+ public static void MultiTexCoord1fvARB(Enums.ARB_multitexture target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1fvARB(Enums.ARB_multitexture target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1hNV(Enums.NV_half_float target, GLhalfNV s)
+ {
+ Delegates.glMultiTexCoord1hNV(target, s);
+ }
+ public static void MultiTexCoord1hvNV(Enums.NV_half_float target, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1hvNV(Enums.NV_half_float target, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1hvNV(Enums.NV_half_float target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1hvNV(target, v);
+ }
+ public static void MultiTexCoord1i(Enums.VERSION_1_3 target, GLint s)
+ {
+ Delegates.glMultiTexCoord1i(target, s);
+ }
+ public static void MultiTexCoord1iARB(Enums.ARB_multitexture target, GLint s)
+ {
+ Delegates.glMultiTexCoord1iARB(target, s);
+ }
+ public static void MultiTexCoord1iv(Enums.VERSION_1_3 target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1iv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1iv(target, v);
+ }
+ public static void MultiTexCoord1iv(Enums.VERSION_1_3 target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1ivARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1ivARB(target, v);
+ }
+ public static void MultiTexCoord1ivARB(Enums.ARB_multitexture target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1ivARB(Enums.ARB_multitexture target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1s(Enums.VERSION_1_3 target, GLshort s)
+ {
+ Delegates.glMultiTexCoord1s(target, s);
+ }
+ public static void MultiTexCoord1sARB(Enums.ARB_multitexture target, GLshort s)
+ {
+ Delegates.glMultiTexCoord1sARB(target, s);
+ }
+ public static void MultiTexCoord1sv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1sv(target, v);
+ }
+ public static void MultiTexCoord1sv(Enums.VERSION_1_3 target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1sv(Enums.VERSION_1_3 target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1svARB(Enums.ARB_multitexture target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1svARB(Enums.ARB_multitexture target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord1svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord1svARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord1svARB(target, v);
+ }
+ public static void MultiTexCoord2d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t)
+ {
+ Delegates.glMultiTexCoord2d(target, s, t);
+ }
+ public static void MultiTexCoord2dARB(Enums.ARB_multitexture target, GLdouble s, GLdouble t)
+ {
+ Delegates.glMultiTexCoord2dARB(target, s, t);
+ }
+ public static void MultiTexCoord2dv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2dv(target, v);
+ }
+ public static void MultiTexCoord2dv(Enums.VERSION_1_3 target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2dv(Enums.VERSION_1_3 target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2dvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2dvARB(target, v);
+ }
+ public static void MultiTexCoord2dvARB(Enums.ARB_multitexture target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2dvARB(Enums.ARB_multitexture target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t)
+ {
+ Delegates.glMultiTexCoord2f(target, s, t);
+ }
+ public static void MultiTexCoord2fARB(Enums.ARB_multitexture target, GLfloat s, GLfloat t)
+ {
+ Delegates.glMultiTexCoord2fARB(target, s, t);
+ }
+ public static void MultiTexCoord2fv(Enums.VERSION_1_3 target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2fv(Enums.VERSION_1_3 target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2fv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2fv(target, v);
+ }
+ public static void MultiTexCoord2fvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2fvARB(target, v);
+ }
+ public static void MultiTexCoord2fvARB(Enums.ARB_multitexture target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2fvARB(Enums.ARB_multitexture target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2hNV(Enums.NV_half_float target, GLhalfNV s, GLhalfNV t)
+ {
+ Delegates.glMultiTexCoord2hNV(target, s, t);
+ }
+ public static void MultiTexCoord2hvNV(Enums.NV_half_float target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2hvNV(target, v);
+ }
+ public static void MultiTexCoord2hvNV(Enums.NV_half_float target, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2hvNV(Enums.NV_half_float target, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2i(Enums.VERSION_1_3 target, GLint s, GLint t)
+ {
+ Delegates.glMultiTexCoord2i(target, s, t);
+ }
+ public static void MultiTexCoord2iARB(Enums.ARB_multitexture target, GLint s, GLint t)
+ {
+ Delegates.glMultiTexCoord2iARB(target, s, t);
+ }
+ public static void MultiTexCoord2iv(Enums.VERSION_1_3 target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2iv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2iv(target, v);
+ }
+ public static void MultiTexCoord2iv(Enums.VERSION_1_3 target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2ivARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2ivARB(target, v);
+ }
+ public static void MultiTexCoord2ivARB(Enums.ARB_multitexture target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2ivARB(Enums.ARB_multitexture target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2s(Enums.VERSION_1_3 target, GLshort s, GLshort t)
+ {
+ Delegates.glMultiTexCoord2s(target, s, t);
+ }
+ public static void MultiTexCoord2sARB(Enums.ARB_multitexture target, GLshort s, GLshort t)
+ {
+ Delegates.glMultiTexCoord2sARB(target, s, t);
+ }
+ public static void MultiTexCoord2sv(Enums.VERSION_1_3 target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2sv(Enums.VERSION_1_3 target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2sv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2sv(target, v);
+ }
+ public static void MultiTexCoord2svARB(Enums.ARB_multitexture target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2svARB(Enums.ARB_multitexture target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord2svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord2svARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord2svARB(target, v);
+ }
+ public static void MultiTexCoord3d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r)
+ {
+ Delegates.glMultiTexCoord3d(target, s, t, r);
+ }
+ public static void MultiTexCoord3dARB(Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r)
+ {
+ Delegates.glMultiTexCoord3dARB(target, s, t, r);
+ }
+ public static void MultiTexCoord3dv(Enums.VERSION_1_3 target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3dv(Enums.VERSION_1_3 target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3dv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3dv(target, v);
+ }
+ public static void MultiTexCoord3dvARB(Enums.ARB_multitexture target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3dvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3dvARB(target, v);
+ }
+ public static void MultiTexCoord3dvARB(Enums.ARB_multitexture target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r)
+ {
+ Delegates.glMultiTexCoord3f(target, s, t, r);
+ }
+ public static void MultiTexCoord3fARB(Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r)
+ {
+ Delegates.glMultiTexCoord3fARB(target, s, t, r);
+ }
+ public static void MultiTexCoord3fv(Enums.VERSION_1_3 target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3fv(Enums.VERSION_1_3 target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3fv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3fv(target, v);
+ }
+ public static void MultiTexCoord3fvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3fvARB(target, v);
+ }
+ public static void MultiTexCoord3fvARB(Enums.ARB_multitexture target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3fvARB(Enums.ARB_multitexture target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3hNV(Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r)
+ {
+ Delegates.glMultiTexCoord3hNV(target, s, t, r);
+ }
+ public static void MultiTexCoord3hvNV(Enums.NV_half_float target, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3hvNV(Enums.NV_half_float target, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3hvNV(Enums.NV_half_float target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3hvNV(target, v);
+ }
+ public static void MultiTexCoord3i(Enums.VERSION_1_3 target, GLint s, GLint t, GLint r)
+ {
+ Delegates.glMultiTexCoord3i(target, s, t, r);
+ }
+ public static void MultiTexCoord3iARB(Enums.ARB_multitexture target, GLint s, GLint t, GLint r)
+ {
+ Delegates.glMultiTexCoord3iARB(target, s, t, r);
+ }
+ public static void MultiTexCoord3iv(Enums.VERSION_1_3 target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3iv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3iv(target, v);
+ }
+ public static void MultiTexCoord3iv(Enums.VERSION_1_3 target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3ivARB(Enums.ARB_multitexture target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3ivARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3ivARB(target, v);
+ }
+ public static void MultiTexCoord3ivARB(Enums.ARB_multitexture target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3s(Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r)
+ {
+ Delegates.glMultiTexCoord3s(target, s, t, r);
+ }
+ public static void MultiTexCoord3sARB(Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r)
+ {
+ Delegates.glMultiTexCoord3sARB(target, s, t, r);
+ }
+ public static void MultiTexCoord3sv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3sv(target, v);
+ }
+ public static void MultiTexCoord3sv(Enums.VERSION_1_3 target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3sv(Enums.VERSION_1_3 target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3svARB(Enums.ARB_multitexture target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord3svARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord3svARB(target, v);
+ }
+ public static void MultiTexCoord3svARB(Enums.ARB_multitexture target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord3svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+ {
+ Delegates.glMultiTexCoord4d(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4dARB(Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+ {
+ Delegates.glMultiTexCoord4dARB(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4dv(Enums.VERSION_1_3 target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4dv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4dv(target, v);
+ }
+ public static void MultiTexCoord4dv(Enums.VERSION_1_3 target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4dv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4dvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4dvARB(target, v);
+ }
+ public static void MultiTexCoord4dvARB(Enums.ARB_multitexture target, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4dvARB(Enums.ARB_multitexture target, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4dvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+ {
+ Delegates.glMultiTexCoord4f(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4fARB(Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+ {
+ Delegates.glMultiTexCoord4fARB(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4fv(Enums.VERSION_1_3 target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4fv(Enums.VERSION_1_3 target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4fv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4fv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4fv(target, v);
+ }
+ public static void MultiTexCoord4fvARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4fvARB(target, v);
+ }
+ public static void MultiTexCoord4fvARB(Enums.ARB_multitexture target, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4fvARB(Enums.ARB_multitexture target, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4fvARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4hNV(Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
+ {
+ Delegates.glMultiTexCoord4hNV(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4hvNV(Enums.NV_half_float target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4hvNV(target, v);
+ }
+ public static void MultiTexCoord4hvNV(Enums.NV_half_float target, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4hvNV(Enums.NV_half_float target, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4hvNV(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4i(Enums.VERSION_1_3 target, GLint s, GLint t, GLint r, GLint q)
+ {
+ Delegates.glMultiTexCoord4i(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4iARB(Enums.ARB_multitexture target, GLint s, GLint t, GLint r, GLint q)
+ {
+ Delegates.glMultiTexCoord4iARB(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4iv(Enums.VERSION_1_3 target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4iv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4iv(target, v);
+ }
+ public static void MultiTexCoord4iv(Enums.VERSION_1_3 target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4iv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4ivARB(Enums.ARB_multitexture target, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4ivARB(Enums.ARB_multitexture target, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4ivARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4ivARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4ivARB(target, v);
+ }
+ public static void MultiTexCoord4s(Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r, GLshort q)
+ {
+ Delegates.glMultiTexCoord4s(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4sARB(Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r, GLshort q)
+ {
+ Delegates.glMultiTexCoord4sARB(target, s, t, r, q);
+ }
+ public static void MultiTexCoord4sv(Enums.VERSION_1_3 target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4sv(Enums.VERSION_1_3 target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4sv(target, v);
+ }
+ public static void MultiTexCoord4sv(Enums.VERSION_1_3 target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4sv(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4svARB(Enums.ARB_multitexture target, System.IntPtr v)
+ {
+ Delegates.glMultiTexCoord4svARB(target, v);
+ }
+ public static void MultiTexCoord4svARB(Enums.ARB_multitexture target, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultiTexCoord4svARB(Enums.ARB_multitexture target, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultiTexCoord4svARB(target, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultMatrixd(System.IntPtr m)
+ {
+ Delegates.glMultMatrixd(m);
+ }
+ public static void MultMatrixd(GLdouble[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultMatrixd(ref GLdouble m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultMatrixf(ref GLfloat m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultMatrixf(GLfloat[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultMatrixf(System.IntPtr m)
+ {
+ Delegates.glMultMatrixf(m);
+ }
+ public static void MultTransposeMatrixd(GLdouble[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixd(System.IntPtr m)
+ {
+ Delegates.glMultTransposeMatrixd(m);
+ }
+ public static void MultTransposeMatrixd(ref GLdouble m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixd(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixdARB(System.IntPtr m)
+ {
+ Delegates.glMultTransposeMatrixdARB(m);
+ }
+ public static void MultTransposeMatrixdARB(GLdouble[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixdARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixdARB(ref GLdouble m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixdARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixf(ref GLfloat m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixf(GLfloat[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixf(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixf(System.IntPtr m)
+ {
+ Delegates.glMultTransposeMatrixf(m);
+ }
+ public static void MultTransposeMatrixfARB(ref GLfloat m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixfARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixfARB(GLfloat[] m)
+ {
+ GCHandle h0 = GCHandle.Alloc(m, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glMultTransposeMatrixfARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void MultTransposeMatrixfARB(System.IntPtr m)
+ {
+ Delegates.glMultTransposeMatrixfARB(m);
+ }
+ public static void NewList(GLuint list, Enums.ListMode mode)
+ {
+ Delegates.glNewList(list, mode);
+ }
+ public static GLuint NewObjectBufferATI(GLsizei size, System.IntPtr pointer, Enums.ATI_vertex_array_object usage)
+ {
+ return Delegates.glNewObjectBufferATI(size, pointer, usage);
+ }
+ public static GLuint NewObjectBufferATI(GLsizei size, object pointer, Enums.ATI_vertex_array_object usage)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ GLuint retval;
+ retval = Delegates.glNewObjectBufferATI(size, h0.AddrOfPinnedObject(), usage);
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
+ {
+ Delegates.glNormal3b(nx, ny, nz);
+ }
+ public static void Normal3bv(System.IntPtr v)
+ {
+ Delegates.glNormal3bv(v);
+ }
+ public static void Normal3bv(ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3bv(GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
+ {
+ Delegates.glNormal3d(nx, ny, nz);
+ }
+ public static void Normal3dv(System.IntPtr v)
+ {
+ Delegates.glNormal3dv(v);
+ }
+ public static void Normal3dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
+ {
+ Delegates.glNormal3f(nx, ny, nz);
+ }
+ public static void Normal3fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3fv(System.IntPtr v)
+ {
+ Delegates.glNormal3fv(v);
+ }
+ public static void Normal3fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);
+ }
+ public static void Normal3fVertex3fvSUN(System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3fVertex3fvSUN(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3fVertex3fvSUN(System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glNormal3fVertex3fvSUN(n, v);
+ }
+ public static void Normal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz)
+ {
+ Delegates.glNormal3hNV(nx, ny, nz);
+ }
+ public static void Normal3hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3hvNV(System.IntPtr v)
+ {
+ Delegates.glNormal3hvNV(v);
+ }
+ public static void Normal3i(GLint nx, GLint ny, GLint nz)
+ {
+ Delegates.glNormal3i(nx, ny, nz);
+ }
+ public static void Normal3iv(System.IntPtr v)
+ {
+ Delegates.glNormal3iv(v);
+ }
+ public static void Normal3iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3s(GLshort nx, GLshort ny, GLshort nz)
+ {
+ Delegates.glNormal3s(nx, ny, nz);
+ }
+ public static void Normal3sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormal3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Normal3sv(System.IntPtr v)
+ {
+ Delegates.glNormal3sv(v);
+ }
+ public static void NormalPointer(Enums.NormalPointerType type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glNormalPointer(type, stride, pointer);
+ }
+ public static void NormalPointer(Enums.NormalPointerType type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalPointer(type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalPointerEXT(type, stride, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer)
+ {
+ Delegates.glNormalPointerEXT(type, stride, count, pointer);
+ }
+ public static void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glNormalPointerListIBM(type, stride, pointer, ptrstride);
+ }
+ public static void NormalPointervINTEL(Enums.NormalPointerType type, System.IntPtr pointer)
+ {
+ Delegates.glNormalPointervINTEL(type, pointer);
+ }
+ public static void NormalStream3bATI(Enums.ATI_vertex_streams stream, GLbyte nx, GLbyte ny, GLbyte nz)
+ {
+ Delegates.glNormalStream3bATI(stream, nx, ny, nz);
+ }
+ public static void NormalStream3bvATI(Enums.ATI_vertex_streams stream, GLbyte[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3bvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3bvATI(Enums.ATI_vertex_streams stream, ref GLbyte coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3bvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3bvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glNormalStream3bvATI(stream, coords);
+ }
+ public static void NormalStream3dATI(Enums.ATI_vertex_streams stream, GLdouble nx, GLdouble ny, GLdouble nz)
+ {
+ Delegates.glNormalStream3dATI(stream, nx, ny, nz);
+ }
+ public static void NormalStream3dvATI(Enums.ATI_vertex_streams stream, GLdouble[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3dvATI(Enums.ATI_vertex_streams stream, ref GLdouble coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glNormalStream3dvATI(stream, coords);
+ }
+ public static void NormalStream3fATI(Enums.ATI_vertex_streams stream, GLfloat nx, GLfloat ny, GLfloat nz)
+ {
+ Delegates.glNormalStream3fATI(stream, nx, ny, nz);
+ }
+ public static void NormalStream3fvATI(Enums.ATI_vertex_streams stream, ref GLfloat coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3fvATI(Enums.ATI_vertex_streams stream, GLfloat[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glNormalStream3fvATI(stream, coords);
+ }
+ public static void NormalStream3iATI(Enums.ATI_vertex_streams stream, GLint nx, GLint ny, GLint nz)
+ {
+ Delegates.glNormalStream3iATI(stream, nx, ny, nz);
+ }
+ public static void NormalStream3ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glNormalStream3ivATI(stream, coords);
+ }
+ public static void NormalStream3ivATI(Enums.ATI_vertex_streams stream, GLint[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3ivATI(Enums.ATI_vertex_streams stream, ref GLint coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3sATI(Enums.ATI_vertex_streams stream, GLshort nx, GLshort ny, GLshort nz)
+ {
+ Delegates.glNormalStream3sATI(stream, nx, ny, nz);
+ }
+ public static void NormalStream3svATI(Enums.ATI_vertex_streams stream, GLshort[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3svATI(Enums.ATI_vertex_streams stream, ref GLshort coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glNormalStream3svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void NormalStream3svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glNormalStream3svATI(stream, coords);
+ }
+ public static void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+ {
+ Delegates.glOrtho(left, right, bottom, top, zNear, zFar);
+ }
+ public static void PassTexCoordATI(GLuint dst, GLuint coord, Enums.ATI_fragment_shader swizzle)
+ {
+ Delegates.glPassTexCoordATI(dst, coord, swizzle);
+ }
+ public static void PassThrough(GLfloat token)
+ {
+ Delegates.glPassThrough(token);
+ }
+ public static void PixelDataRangeNV(Enums.NV_pixel_data_range target, GLsizei length, [In, Out()] System.IntPtr pointer)
+ {
+ Delegates.glPixelDataRangeNV(target, length, pointer);
+ }
+ public static void PixelDataRangeNV(Enums.NV_pixel_data_range target, GLsizei length, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelDataRangeNV(target, length, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelMapfv(Enums.PixelMap map, GLint mapsize, GLfloat[] values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelMapfv(map, mapsize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelMapfv(Enums.PixelMap map, GLint mapsize, ref GLfloat values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelMapfv(map, mapsize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelMapfv(Enums.PixelMap map, GLint mapsize, System.IntPtr values)
+ {
+ Delegates.glPixelMapfv(map, mapsize, values);
+ }
+ public static void PixelMapuiv(Enums.PixelMap map, GLint mapsize, System.IntPtr values)
+ {
+ Delegates.glPixelMapuiv(map, mapsize, values);
+ }
+ public static void PixelMapuiv(Enums.PixelMap map, GLint mapsize, GLuint[] values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelMapuiv(map, mapsize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelMapuiv(Enums.PixelMap map, GLint mapsize, ref GLuint values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelMapuiv(map, mapsize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelMapusv(Enums.PixelMap map, GLint mapsize, ref GLushort values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelMapusv(map, mapsize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelMapusv(Enums.PixelMap map, GLint mapsize, GLushort[] values)
+ {
+ GCHandle h0 = GCHandle.Alloc(values, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelMapusv(map, mapsize, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelMapusv(Enums.PixelMap map, GLint mapsize, System.IntPtr values)
+ {
+ Delegates.glPixelMapusv(map, mapsize, values);
+ }
+ public static void PixelStoref(Enums.PixelStoreParameter pname, GLfloat param)
+ {
+ Delegates.glPixelStoref(pname, param);
+ }
+ public static void PixelStorei(Enums.PixelStoreParameter pname, GLint param)
+ {
+ Delegates.glPixelStorei(pname, param);
+ }
+ public static void PixelTexGenParameterfSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat param)
+ {
+ Delegates.glPixelTexGenParameterfSGIS(pname, param);
+ }
+ public static void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, System.IntPtr @params)
+ {
+ Delegates.glPixelTexGenParameterfvSGIS(pname, @params);
+ }
+ public static void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTexGenParameterfvSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTexGenParameterfvSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelTexGenParameteriSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint param)
+ {
+ Delegates.glPixelTexGenParameteriSGIS(pname, param);
+ }
+ public static void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTexGenParameterivSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTexGenParameterivSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, System.IntPtr @params)
+ {
+ Delegates.glPixelTexGenParameterivSGIS(pname, @params);
+ }
+ public static void PixelTexGenSGIX(Enums.SGIX_pixel_texture mode)
+ {
+ Delegates.glPixelTexGenSGIX(mode);
+ }
+ public static void PixelTransferf(Enums.PixelTransferParameter pname, GLfloat param)
+ {
+ Delegates.glPixelTransferf(pname, param);
+ }
+ public static void PixelTransferi(Enums.PixelTransferParameter pname, GLint param)
+ {
+ Delegates.glPixelTransferi(pname, param);
+ }
+ public static void PixelTransformParameterfEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, GLfloat param)
+ {
+ Delegates.glPixelTransformParameterfEXT(target, pname, param);
+ }
+ public static void PixelTransformParameterfvEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTransformParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelTransformParameterfvEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, System.IntPtr @params)
+ {
+ Delegates.glPixelTransformParameterfvEXT(target, pname, @params);
+ }
+ public static void PixelTransformParameterfvEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTransformParameterfvEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelTransformParameteriEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, GLint param)
+ {
+ Delegates.glPixelTransformParameteriEXT(target, pname, param);
+ }
+ public static void PixelTransformParameterivEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, System.IntPtr @params)
+ {
+ Delegates.glPixelTransformParameterivEXT(target, pname, @params);
+ }
+ public static void PixelTransformParameterivEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTransformParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelTransformParameterivEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPixelTransformParameterivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PixelZoom(GLfloat xfactor, GLfloat yfactor)
+ {
+ Delegates.glPixelZoom(xfactor, yfactor);
+ }
+ public static void PNTrianglesfATI(Enums.ATI_pn_triangles pname, GLfloat param)
+ {
+ Delegates.glPNTrianglesfATI(pname, param);
+ }
+ public static void PNTrianglesiATI(Enums.ATI_pn_triangles pname, GLint param)
+ {
+ Delegates.glPNTrianglesiATI(pname, param);
+ }
+ public static void PointParameterf(Enums.VERSION_1_4 pname, GLfloat param)
+ {
+ Delegates.glPointParameterf(pname, param);
+ }
+ public static void PointParameterfARB(Enums.ARB_point_parameters pname, GLfloat param)
+ {
+ Delegates.glPointParameterfARB(pname, param);
+ }
+ public static void PointParameterfEXT(Enums.EXT_point_parameters pname, GLfloat param)
+ {
+ Delegates.glPointParameterfEXT(pname, param);
+ }
+ public static void PointParameterfSGIS(Enums.SGIS_point_parameters pname, GLfloat param)
+ {
+ Delegates.glPointParameterfSGIS(pname, param);
+ }
+ public static void PointParameterfv(Enums.VERSION_1_4 pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterfv(Enums.VERSION_1_4 pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterfv(Enums.VERSION_1_4 pname, System.IntPtr @params)
+ {
+ Delegates.glPointParameterfv(pname, @params);
+ }
+ public static void PointParameterfvARB(Enums.ARB_point_parameters pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfvARB(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterfvARB(Enums.ARB_point_parameters pname, System.IntPtr @params)
+ {
+ Delegates.glPointParameterfvARB(pname, @params);
+ }
+ public static void PointParameterfvARB(Enums.ARB_point_parameters pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfvARB(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterfvEXT(Enums.EXT_point_parameters pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfvEXT(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterfvEXT(Enums.EXT_point_parameters pname, System.IntPtr @params)
+ {
+ Delegates.glPointParameterfvEXT(pname, @params);
+ }
+ public static void PointParameterfvEXT(Enums.EXT_point_parameters pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfvEXT(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterfvSGIS(Enums.SGIS_point_parameters pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfvSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterfvSGIS(Enums.SGIS_point_parameters pname, System.IntPtr @params)
+ {
+ Delegates.glPointParameterfvSGIS(pname, @params);
+ }
+ public static void PointParameterfvSGIS(Enums.SGIS_point_parameters pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterfvSGIS(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameteri(Enums.VERSION_1_4 pname, GLint param)
+ {
+ Delegates.glPointParameteri(pname, param);
+ }
+ public static void PointParameteriNV(Enums.NV_point_sprite pname, GLint param)
+ {
+ Delegates.glPointParameteriNV(pname, param);
+ }
+ public static void PointParameteriv(Enums.VERSION_1_4 pname, System.IntPtr @params)
+ {
+ Delegates.glPointParameteriv(pname, @params);
+ }
+ public static void PointParameteriv(Enums.VERSION_1_4 pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameteriv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameteriv(Enums.VERSION_1_4 pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameteriv(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterivNV(Enums.NV_point_sprite pname, System.IntPtr @params)
+ {
+ Delegates.glPointParameterivNV(pname, @params);
+ }
+ public static void PointParameterivNV(Enums.NV_point_sprite pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterivNV(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointParameterivNV(Enums.NV_point_sprite pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPointParameterivNV(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PointSize(GLfloat size)
+ {
+ Delegates.glPointSize(size);
+ }
+ public static GLint PollAsyncSGIX(GLuint[] markerp)
+ {
+ GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+ try
+ {
+ GLint retval;
+ retval = Delegates.glPollAsyncSGIX(h0.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLint PollAsyncSGIX([In, Out()] System.IntPtr markerp)
+ {
+ return Delegates.glPollAsyncSGIX(markerp);
+ }
+ public static GLint PollAsyncSGIX(out GLuint markerp)
+ {
+ markerp = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(markerp, GCHandleType.Pinned);
+ try
+ {
+ GLint retval;
+ retval = Delegates.glPollAsyncSGIX(h0.AddrOfPinnedObject());
+ markerp = (GLuint)h0.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLint PollInstrumentsSGIX(out GLint marker_p)
+ {
+ marker_p = default(GLint);
+ GCHandle h0 = GCHandle.Alloc(marker_p, GCHandleType.Pinned);
+ try
+ {
+ GLint retval;
+ retval = Delegates.glPollInstrumentsSGIX(h0.AddrOfPinnedObject());
+ marker_p = (GLint)h0.Target;
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static GLint PollInstrumentsSGIX([In, Out()] System.IntPtr marker_p)
+ {
+ return Delegates.glPollInstrumentsSGIX(marker_p);
+ }
+ public static GLint PollInstrumentsSGIX(GLint[] marker_p)
+ {
+ GCHandle h0 = GCHandle.Alloc(marker_p, GCHandleType.Pinned);
+ try
+ {
+ GLint retval;
+ retval = Delegates.glPollInstrumentsSGIX(h0.AddrOfPinnedObject());
+ return retval;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode)
+ {
+ Delegates.glPolygonMode(face, mode);
+ }
+ public static void PolygonOffset(GLfloat factor, GLfloat units)
+ {
+ Delegates.glPolygonOffset(factor, units);
+ }
+ public static void PolygonOffsetEXT(GLfloat factor, GLfloat bias)
+ {
+ Delegates.glPolygonOffsetEXT(factor, bias);
+ }
+ public static void PolygonStipple(System.IntPtr mask)
+ {
+ Delegates.glPolygonStipple(mask);
+ }
+ public static void PolygonStipple(GLubyte[] mask)
+ {
+ GCHandle h0 = GCHandle.Alloc(mask, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPolygonStipple(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PolygonStipple(ref GLubyte mask)
+ {
+ GCHandle h0 = GCHandle.Alloc(mask, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPolygonStipple(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PopAttrib()
+ {
+ Delegates.glPopAttrib();
+ }
+ public static void PopClientAttrib()
+ {
+ Delegates.glPopClientAttrib();
+ }
+ public static void PopMatrix()
+ {
+ Delegates.glPopMatrix();
+ }
+ public static void PopName()
+ {
+ Delegates.glPopName();
+ }
+ public static void PrimitiveRestartIndexNV(GLuint index)
+ {
+ Delegates.glPrimitiveRestartIndexNV(index);
+ }
+ public static void PrimitiveRestartNV()
+ {
+ Delegates.glPrimitiveRestartNV();
+ }
+ public static void PrioritizeTextures(GLsizei n, ref GLuint textures, System.IntPtr priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, h0.AddrOfPinnedObject(), priorities);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PrioritizeTextures(GLsizei n, GLuint[] textures, ref GLclampf priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTextures(GLsizei n, ref GLuint textures, ref GLclampf priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTextures(GLsizei n, ref GLuint textures, GLclampf[] priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTextures(GLsizei n, GLuint[] textures, GLclampf[] priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTextures(GLsizei n, System.IntPtr textures, GLclampf[] priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, textures, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PrioritizeTextures(GLsizei n, System.IntPtr textures, System.IntPtr priorities)
+ {
+ Delegates.glPrioritizeTextures(n, textures, priorities);
+ }
+ public static void PrioritizeTextures(GLsizei n, GLuint[] textures, System.IntPtr priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, h0.AddrOfPinnedObject(), priorities);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PrioritizeTextures(GLsizei n, System.IntPtr textures, ref GLclampf priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTextures(n, textures, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, ref GLuint textures, System.IntPtr priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, h0.AddrOfPinnedObject(), priorities);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, ref GLclampf priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, ref GLuint textures, ref GLclampf priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, ref GLuint textures, GLclampf[] priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, GLclampf[] priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, System.IntPtr textures, GLclampf[] priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, textures, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, System.IntPtr textures, System.IntPtr priorities)
+ {
+ Delegates.glPrioritizeTexturesEXT(n, textures, priorities);
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, GLuint[] textures, System.IntPtr priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(textures, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, h0.AddrOfPinnedObject(), priorities);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void PrioritizeTexturesEXT(GLsizei n, System.IntPtr textures, ref GLclampf priorities)
+ {
+ GCHandle h0 = GCHandle.Alloc(priorities, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glPrioritizeTexturesEXT(n, textures, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramBufferParametersfvNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramBufferParametersfvNV(target, buffer, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramBufferParametersfvNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramBufferParametersfvNV(target, buffer, index, count, @params);
+ }
+ public static void ProgramBufferParametersfvNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramBufferParametersfvNV(target, buffer, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramBufferParametersIivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramBufferParametersIivNV(target, buffer, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramBufferParametersIivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramBufferParametersIivNV(target, buffer, index, count, @params);
+ }
+ public static void ProgramBufferParametersIivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramBufferParametersIivNV(target, buffer, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramBufferParametersIuivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, ref GLuint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramBufferParametersIuivNV(target, buffer, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramBufferParametersIuivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramBufferParametersIuivNV(target, buffer, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramBufferParametersIuivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramBufferParametersIuivNV(target, buffer, index, count, @params);
+ }
+ public static void ProgramEnvParameter4dARB(Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glProgramEnvParameter4dARB(target, index, x, y, z, w);
+ }
+ public static void ProgramEnvParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, ref GLdouble @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameter4dvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameter4dvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramEnvParameter4dvARB(target, index, @params);
+ }
+ public static void ProgramEnvParameter4fARB(Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glProgramEnvParameter4fARB(target, index, x, y, z, w);
+ }
+ public static void ProgramEnvParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramEnvParameter4fvARB(target, index, @params);
+ }
+ public static void ProgramEnvParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameter4fvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameter4fvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameterI4iNV(Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w)
+ {
+ Delegates.glProgramEnvParameterI4iNV(target, index, x, y, z, w);
+ }
+ public static void ProgramEnvParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameterI4ivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramEnvParameterI4ivNV(target, index, @params);
+ }
+ public static void ProgramEnvParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameterI4ivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameterI4uiNV(Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+ {
+ Delegates.glProgramEnvParameterI4uiNV(target, index, x, y, z, w);
+ }
+ public static void ProgramEnvParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, ref GLuint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameterI4uivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameterI4uivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramEnvParameterI4uivNV(target, index, @params);
+ }
+ public static void ProgramEnvParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameters4fvEXT(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParameters4fvEXT(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramEnvParameters4fvEXT(target, index, count, @params);
+ }
+ public static void ProgramEnvParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParametersI4ivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramEnvParametersI4ivNV(target, index, count, @params);
+ }
+ public static void ProgramEnvParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParametersI4ivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParametersI4uivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLuint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramEnvParametersI4uivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramEnvParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramEnvParametersI4uivNV(target, index, count, @params);
+ }
+ public static void ProgramLocalParameter4dARB(Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glProgramLocalParameter4dARB(target, index, x, y, z, w);
+ }
+ public static void ProgramLocalParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, ref GLdouble @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameter4dvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameter4dvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramLocalParameter4dvARB(target, index, @params);
+ }
+ public static void ProgramLocalParameter4fARB(Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glProgramLocalParameter4fARB(target, index, x, y, z, w);
+ }
+ public static void ProgramLocalParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameter4fvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameter4fvARB(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramLocalParameter4fvARB(target, index, @params);
+ }
+ public static void ProgramLocalParameterI4iNV(Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w)
+ {
+ Delegates.glProgramLocalParameterI4iNV(target, index, x, y, z, w);
+ }
+ public static void ProgramLocalParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameterI4ivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramLocalParameterI4ivNV(target, index, @params);
+ }
+ public static void ProgramLocalParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameterI4ivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameterI4uiNV(Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+ {
+ Delegates.glProgramLocalParameterI4uiNV(target, index, x, y, z, w);
+ }
+ public static void ProgramLocalParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params)
+ {
+ Delegates.glProgramLocalParameterI4uivNV(target, index, @params);
+ }
+ public static void ProgramLocalParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, ref GLuint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameterI4uivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameterI4uivNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameters4fvEXT(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParameters4fvEXT(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramLocalParameters4fvEXT(target, index, count, @params);
+ }
+ public static void ProgramLocalParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramLocalParametersI4ivNV(target, index, count, @params);
+ }
+ public static void ProgramLocalParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParametersI4ivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParametersI4ivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, ref GLuint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParametersI4uivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramLocalParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params)
+ {
+ Delegates.glProgramLocalParametersI4uivNV(target, index, count, @params);
+ }
+ public static void ProgramLocalParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramLocalParametersI4uivNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dNV(GLuint id, GLsizei len, System.IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glProgramNamedParameter4dNV(id, len, name, x, y, z, w);
+ }
+ public static void ProgramNamedParameter4dNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dNV(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dNV(GLuint id, GLsizei len, ref GLubyte name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dNV(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, GLubyte[] name, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, ref GLubyte name, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, ref GLubyte name, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, ref GLubyte name, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, System.IntPtr name, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, name, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, System.IntPtr name, System.IntPtr v)
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, name, v);
+ }
+ public static void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, System.IntPtr name, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4dvNV(id, len, name, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fNV(GLuint id, GLsizei len, System.IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glProgramNamedParameter4fNV(id, len, name, x, y, z, w);
+ }
+ public static void ProgramNamedParameter4fNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fNV(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fNV(GLuint id, GLsizei len, ref GLubyte name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fNV(id, len, h0.AddrOfPinnedObject(), x, y, z, w);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, System.IntPtr name, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, name, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, System.IntPtr name, System.IntPtr v)
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, name, v);
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, ref GLubyte name, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, ref GLubyte name, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, GLubyte[] name, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, System.IntPtr name, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, name, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, ref GLubyte name, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(name, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramNamedParameter4fvNV(id, len, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ProgramParameter4dNV(Enums.NV_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glProgramParameter4dNV(target, index, x, y, z, w);
+ }
+ public static void ProgramParameter4dvNV(Enums.NV_vertex_program target, GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameter4dvNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramParameter4dvNV(Enums.NV_vertex_program target, GLuint index, System.IntPtr v)
+ {
+ Delegates.glProgramParameter4dvNV(target, index, v);
+ }
+ public static void ProgramParameter4dvNV(Enums.NV_vertex_program target, GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameter4dvNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramParameter4fNV(Enums.NV_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glProgramParameter4fNV(target, index, x, y, z, w);
+ }
+ public static void ProgramParameter4fvNV(Enums.NV_vertex_program target, GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameter4fvNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramParameter4fvNV(Enums.NV_vertex_program target, GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameter4fvNV(target, index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramParameter4fvNV(Enums.NV_vertex_program target, GLuint index, System.IntPtr v)
+ {
+ Delegates.glProgramParameter4fvNV(target, index, v);
+ }
+ public static void ProgramParameteriEXT(GLuint program, Enums.EXT_geometry_shader4 pname, GLint value)
+ {
+ Delegates.glProgramParameteriEXT(program, pname, value);
+ }
+ public static void ProgramParameters4dvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameters4dvNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramParameters4dvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, System.IntPtr v)
+ {
+ Delegates.glProgramParameters4dvNV(target, index, count, v);
+ }
+ public static void ProgramParameters4dvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameters4dvNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramParameters4fvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameters4fvNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramParameters4fvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, System.IntPtr v)
+ {
+ Delegates.glProgramParameters4fvNV(target, index, count, v);
+ }
+ public static void ProgramParameters4fvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramParameters4fvNV(target, index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramStringARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program format, GLsizei len, System.IntPtr @string)
+ {
+ Delegates.glProgramStringARB(target, format, len, @string);
+ }
+ public static void ProgramStringARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program format, GLsizei len, object @string)
+ {
+ GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glProgramStringARB(target, format, len, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ProgramVertexLimitNV(Enums.NV_geometry_program4 target, GLint limit)
+ {
+ Delegates.glProgramVertexLimitNV(target, limit);
+ }
+ public static void PushAttrib(Enums.AttribMask mask)
+ {
+ Delegates.glPushAttrib(mask);
+ }
+ public static void PushClientAttrib(Enums.ClientAttribMask mask)
+ {
+ Delegates.glPushClientAttrib(mask);
+ }
+ public static void PushMatrix()
+ {
+ Delegates.glPushMatrix();
+ }
+ public static void PushName(GLuint name)
+ {
+ Delegates.glPushName(name);
+ }
+ public static void RasterPos2d(GLdouble x, GLdouble y)
+ {
+ Delegates.glRasterPos2d(x, y);
+ }
+ public static void RasterPos2dv(System.IntPtr v)
+ {
+ Delegates.glRasterPos2dv(v);
+ }
+ public static void RasterPos2dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2f(GLfloat x, GLfloat y)
+ {
+ Delegates.glRasterPos2f(x, y);
+ }
+ public static void RasterPos2fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2fv(System.IntPtr v)
+ {
+ Delegates.glRasterPos2fv(v);
+ }
+ public static void RasterPos2i(GLint x, GLint y)
+ {
+ Delegates.glRasterPos2i(x, y);
+ }
+ public static void RasterPos2iv(System.IntPtr v)
+ {
+ Delegates.glRasterPos2iv(v);
+ }
+ public static void RasterPos2iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2s(GLshort x, GLshort y)
+ {
+ Delegates.glRasterPos2s(x, y);
+ }
+ public static void RasterPos2sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos2sv(System.IntPtr v)
+ {
+ Delegates.glRasterPos2sv(v);
+ }
+ public static void RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glRasterPos3d(x, y, z);
+ }
+ public static void RasterPos3dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos3dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos3dv(System.IntPtr v)
+ {
+ Delegates.glRasterPos3dv(v);
+ }
+ public static void RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glRasterPos3f(x, y, z);
+ }
+ public static void RasterPos3fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos3fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos3fv(System.IntPtr v)
+ {
+ Delegates.glRasterPos3fv(v);
+ }
+ public static void RasterPos3i(GLint x, GLint y, GLint z)
+ {
+ Delegates.glRasterPos3i(x, y, z);
+ }
+ public static void RasterPos3iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos3iv(System.IntPtr v)
+ {
+ Delegates.glRasterPos3iv(v);
+ }
+ public static void RasterPos3iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos3s(GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glRasterPos3s(x, y, z);
+ }
+ public static void RasterPos3sv(System.IntPtr v)
+ {
+ Delegates.glRasterPos3sv(v);
+ }
+ public static void RasterPos3sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos3sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glRasterPos4d(x, y, z, w);
+ }
+ public static void RasterPos4dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4dv(System.IntPtr v)
+ {
+ Delegates.glRasterPos4dv(v);
+ }
+ public static void RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glRasterPos4f(x, y, z, w);
+ }
+ public static void RasterPos4fv(System.IntPtr v)
+ {
+ Delegates.glRasterPos4fv(v);
+ }
+ public static void RasterPos4fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4i(GLint x, GLint y, GLint z, GLint w)
+ {
+ Delegates.glRasterPos4i(x, y, z, w);
+ }
+ public static void RasterPos4iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4iv(System.IntPtr v)
+ {
+ Delegates.glRasterPos4iv(v);
+ }
+ public static void RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
+ {
+ Delegates.glRasterPos4s(x, y, z, w);
+ }
+ public static void RasterPos4sv(System.IntPtr v)
+ {
+ Delegates.glRasterPos4sv(v);
+ }
+ public static void RasterPos4sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RasterPos4sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRasterPos4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReadBuffer(Enums.ReadBufferMode mode)
+ {
+ Delegates.glReadBuffer(mode);
+ }
+ public static void ReadInstrumentsSGIX(GLint marker)
+ {
+ Delegates.glReadInstrumentsSGIX(marker);
+ }
+ public static void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr pixels)
+ {
+ Delegates.glReadPixels(x, y, width, height, format, type, pixels);
+ }
+ public static void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReadPixels(x, y, width, height, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
+ {
+ Delegates.glRectd(x1, y1, x2, y2);
+ }
+ public static void Rectdv(System.IntPtr v1, ref GLdouble v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectdv(GLdouble[] v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectdv(ref GLdouble v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectdv(GLdouble[] v1, ref GLdouble v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectdv(ref GLdouble v1, GLdouble[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectdv(GLdouble[] v1, GLdouble[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectdv(System.IntPtr v1, GLdouble[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectdv(ref GLdouble v1, ref GLdouble v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectdv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectdv(System.IntPtr v1, System.IntPtr v2)
+ {
+ Delegates.glRectdv(v1, v2);
+ }
+ public static void Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+ {
+ Delegates.glRectf(x1, y1, x2, y2);
+ }
+ public static void Rectfv(System.IntPtr v1, GLfloat[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectfv(System.IntPtr v1, System.IntPtr v2)
+ {
+ Delegates.glRectfv(v1, v2);
+ }
+ public static void Rectfv(GLfloat[] v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectfv(System.IntPtr v1, ref GLfloat v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectfv(ref GLfloat v1, ref GLfloat v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectfv(GLfloat[] v1, ref GLfloat v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectfv(GLfloat[] v1, GLfloat[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectfv(ref GLfloat v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectfv(ref GLfloat v1, GLfloat[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectfv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Recti(GLint x1, GLint y1, GLint x2, GLint y2)
+ {
+ Delegates.glRecti(x1, y1, x2, y2);
+ }
+ public static void Rectiv(ref GLint v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectiv(ref GLint v1, ref GLint v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectiv(ref GLint v1, GLint[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectiv(GLint[] v1, ref GLint v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectiv(System.IntPtr v1, GLint[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectiv(System.IntPtr v1, System.IntPtr v2)
+ {
+ Delegates.glRectiv(v1, v2);
+ }
+ public static void Rectiv(System.IntPtr v1, ref GLint v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectiv(GLint[] v1, GLint[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectiv(GLint[] v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectiv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
+ {
+ Delegates.glRects(x1, y1, x2, y2);
+ }
+ public static void Rectsv(GLshort[] v1, GLshort[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectsv(GLshort[] v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectsv(System.IntPtr v1, ref GLshort v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectsv(ref GLshort v1, System.IntPtr v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(h0.AddrOfPinnedObject(), v2);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectsv(ref GLshort v1, GLshort[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectsv(GLshort[] v1, ref GLshort v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectsv(System.IntPtr v1, GLshort[] v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(v1, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Rectsv(ref GLshort v1, ref GLshort v2)
+ {
+ GCHandle h0 = GCHandle.Alloc(v1, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v2, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRectsv(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void Rectsv(System.IntPtr v1, System.IntPtr v2)
+ {
+ Delegates.glRectsv(v1, v2);
+ }
+ public static void ReferencePlaneSGIX(GLdouble[] equation)
+ {
+ GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReferencePlaneSGIX(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReferencePlaneSGIX(System.IntPtr equation)
+ {
+ Delegates.glReferencePlaneSGIX(equation);
+ }
+ public static void ReferencePlaneSGIX(ref GLdouble equation)
+ {
+ GCHandle h0 = GCHandle.Alloc(equation, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReferencePlaneSGIX(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RenderbufferStorageEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object internalformat, GLsizei width, GLsizei height)
+ {
+ Delegates.glRenderbufferStorageEXT(target, internalformat, width, height);
+ }
+ public static void RenderbufferStorageMultisampleCoverageNV(Enums.NV_framebuffer_multisample_coverage target, GLsizei coverageSamples, GLsizei colorSamples, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height)
+ {
+ Delegates.glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);
+ }
+ public static void RenderbufferStorageMultisampleEXT(Enums.GLenum target, GLsizei samples, Enums.GLenum internalformat, GLsizei width, GLsizei height)
+ {
+ Delegates.glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
+ }
+ public static GLint RenderMode(Enums.RenderingMode mode)
+ {
+ return Delegates.glRenderMode(mode);
+ }
+ public static void ReplacementCodePointerSUN(Enums.SUN_triangle_list type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glReplacementCodePointerSUN(type, stride, pointer);
+ }
+ public static void ReplacementCodeubSUN(GLubyte code)
+ {
+ Delegates.glReplacementCodeubSUN(code);
+ }
+ public static void ReplacementCodeubvSUN(GLubyte[] code)
+ {
+ GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeubvSUN(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeubvSUN(ref GLubyte code)
+ {
+ GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeubvSUN(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeubvSUN(System.IntPtr code)
+ {
+ Delegates.glReplacementCodeubvSUN(code);
+ }
+ public static void ReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, c, v);
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v);
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(GLuint[] rc, ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(ref GLuint rc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v);
+ }
+ public static void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v);
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiSUN(GLuint code)
+ {
+ Delegates.glReplacementCodeuiSUN(code);
+ }
+ public static 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)
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v);
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), n, h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h4 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject(), h4.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ h4.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), c, h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v);
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, System.IntPtr tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, GLfloat[] tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, ref GLfloat tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, GLfloat[] tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, GLfloat[] tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, ref GLfloat tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(GLuint[] rc, ref GLfloat tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(ref GLuint rc, System.IntPtr tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), tc, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v);
+ }
+ public static void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glReplacementCodeuiVertex3fSUN(rc, x, y, z);
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(System.IntPtr rc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(rc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(System.IntPtr rc, System.IntPtr v)
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(rc, v);
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(System.IntPtr rc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(rc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(ref GLuint rc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(ref GLuint rc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(ref GLuint rc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuiVertex3fvSUN(GLuint[] rc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(rc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuiVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void ReplacementCodeuivSUN(ref GLuint code)
+ {
+ GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuivSUN(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuivSUN(GLuint[] code)
+ {
+ GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeuivSUN(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeuivSUN(System.IntPtr code)
+ {
+ Delegates.glReplacementCodeuivSUN(code);
+ }
+ public static void ReplacementCodeusSUN(GLushort code)
+ {
+ Delegates.glReplacementCodeusSUN(code);
+ }
+ public static void ReplacementCodeusvSUN(ref GLushort code)
+ {
+ GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeusvSUN(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ReplacementCodeusvSUN(System.IntPtr code)
+ {
+ Delegates.glReplacementCodeusvSUN(code);
+ }
+ public static void ReplacementCodeusvSUN(GLushort[] code)
+ {
+ GCHandle h0 = GCHandle.Alloc(code, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glReplacementCodeusvSUN(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RequestResidentProgramsNV(GLsizei n, GLuint[] programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRequestResidentProgramsNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RequestResidentProgramsNV(GLsizei n, ref GLuint programs)
+ {
+ GCHandle h0 = GCHandle.Alloc(programs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glRequestResidentProgramsNV(n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void RequestResidentProgramsNV(GLsizei n, System.IntPtr programs)
+ {
+ Delegates.glRequestResidentProgramsNV(n, programs);
+ }
+ public static void ResetHistogram(Enums.VERSION_1_2 target)
+ {
+ Delegates.glResetHistogram(target);
+ }
+ public static void ResetHistogramEXT(Enums.HistogramTargetEXT target)
+ {
+ Delegates.glResetHistogramEXT(target);
+ }
+ public static void ResetMinmax(Enums.VERSION_1_2 target)
+ {
+ Delegates.glResetMinmax(target);
+ }
+ public static void ResetMinmaxEXT(Enums.MinmaxTargetEXT target)
+ {
+ Delegates.glResetMinmaxEXT(target);
+ }
+ public static void ResizeBuffersMESA()
+ {
+ Delegates.glResizeBuffersMESA();
+ }
+ public static void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glRotated(angle, x, y, z);
+ }
+ public static void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glRotatef(angle, x, y, z);
+ }
+ public static void SampleCoverage(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert)
+ {
+ Delegates.glSampleCoverage(value, invert);
+ }
+ public static void SampleCoverageARB(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert)
+ {
+ Delegates.glSampleCoverageARB(value, invert);
+ }
+ public static void SampleMapATI(GLuint dst, GLuint interp, Enums.ATI_fragment_shader swizzle)
+ {
+ Delegates.glSampleMapATI(dst, interp, swizzle);
+ }
+ public static void SampleMaskEXT(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert)
+ {
+ Delegates.glSampleMaskEXT(value, invert);
+ }
+ public static void SampleMaskSGIS(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert)
+ {
+ Delegates.glSampleMaskSGIS(value, invert);
+ }
+ public static void SamplePatternEXT(Enums.EXT_multisample pattern)
+ {
+ Delegates.glSamplePatternEXT(pattern);
+ }
+ public static void SamplePatternSGIS(Enums.SamplePatternSGIS pattern)
+ {
+ Delegates.glSamplePatternSGIS(pattern);
+ }
+ public static void Scaled(GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glScaled(x, y, z);
+ }
+ public static void Scalef(GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glScalef(x, y, z);
+ }
+ public static void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glScissor(x, y, width, height);
+ }
+ public static void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
+ {
+ Delegates.glSecondaryColor3b(red, green, blue);
+ }
+ public static void SecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
+ {
+ Delegates.glSecondaryColor3bEXT(red, green, blue);
+ }
+ public static void SecondaryColor3bv(ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3bv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3bv(v);
+ }
+ public static void SecondaryColor3bv(GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3bv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3bvEXT(ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3bvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3bvEXT(GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3bvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3bvEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3bvEXT(v);
+ }
+ public static void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
+ {
+ Delegates.glSecondaryColor3d(red, green, blue);
+ }
+ public static void SecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
+ {
+ Delegates.glSecondaryColor3dEXT(red, green, blue);
+ }
+ public static void SecondaryColor3dv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3dv(v);
+ }
+ public static void SecondaryColor3dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3dvEXT(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3dvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3dvEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3dvEXT(v);
+ }
+ public static void SecondaryColor3dvEXT(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3dvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
+ {
+ Delegates.glSecondaryColor3f(red, green, blue);
+ }
+ public static void SecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
+ {
+ Delegates.glSecondaryColor3fEXT(red, green, blue);
+ }
+ public static void SecondaryColor3fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3fv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3fv(v);
+ }
+ public static void SecondaryColor3fvEXT(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3fvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3fvEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3fvEXT(v);
+ }
+ public static void SecondaryColor3fvEXT(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3fvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
+ {
+ Delegates.glSecondaryColor3hNV(red, green, blue);
+ }
+ public static void SecondaryColor3hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3hvNV(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3hvNV(v);
+ }
+ public static void SecondaryColor3i(GLint red, GLint green, GLint blue)
+ {
+ Delegates.glSecondaryColor3i(red, green, blue);
+ }
+ public static void SecondaryColor3iEXT(GLint red, GLint green, GLint blue)
+ {
+ Delegates.glSecondaryColor3iEXT(red, green, blue);
+ }
+ public static void SecondaryColor3iv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3iv(v);
+ }
+ public static void SecondaryColor3iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ivEXT(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3ivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ivEXT(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3ivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ivEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3ivEXT(v);
+ }
+ public static void SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
+ {
+ Delegates.glSecondaryColor3s(red, green, blue);
+ }
+ public static void SecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
+ {
+ Delegates.glSecondaryColor3sEXT(red, green, blue);
+ }
+ public static void SecondaryColor3sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3sv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3sv(v);
+ }
+ public static void SecondaryColor3sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3svEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3svEXT(v);
+ }
+ public static void SecondaryColor3svEXT(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3svEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3svEXT(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3svEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
+ {
+ Delegates.glSecondaryColor3ub(red, green, blue);
+ }
+ public static void SecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
+ {
+ Delegates.glSecondaryColor3ubEXT(red, green, blue);
+ }
+ public static void SecondaryColor3ubv(ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3ubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ubv(GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3ubv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ubv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3ubv(v);
+ }
+ public static void SecondaryColor3ubvEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3ubvEXT(v);
+ }
+ public static void SecondaryColor3ubvEXT(GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3ubvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ubvEXT(ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3ubvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
+ {
+ Delegates.glSecondaryColor3ui(red, green, blue);
+ }
+ public static void SecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
+ {
+ Delegates.glSecondaryColor3uiEXT(red, green, blue);
+ }
+ public static void SecondaryColor3uiv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3uiv(v);
+ }
+ public static void SecondaryColor3uiv(ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3uiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3uiv(GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3uiv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3uivEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3uivEXT(v);
+ }
+ public static void SecondaryColor3uivEXT(GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3uivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3uivEXT(ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3uivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
+ {
+ Delegates.glSecondaryColor3us(red, green, blue);
+ }
+ public static void SecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
+ {
+ Delegates.glSecondaryColor3usEXT(red, green, blue);
+ }
+ public static void SecondaryColor3usv(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3usv(v);
+ }
+ public static void SecondaryColor3usv(GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3usv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3usv(ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3usv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3usvEXT(ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3usvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3usvEXT(GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColor3usvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColor3usvEXT(System.IntPtr v)
+ {
+ Delegates.glSecondaryColor3usvEXT(v);
+ }
+ public static void SecondaryColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glSecondaryColorPointer(size, type, stride, pointer);
+ }
+ public static void SecondaryColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColorPointer(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSecondaryColorPointerEXT(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glSecondaryColorPointerEXT(size, type, stride, pointer);
+ }
+ public static void SecondaryColorPointerListIBM(GLint size, Enums.IBM_vertex_array_lists type, GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glSecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);
+ }
+ public static void SelectBuffer(GLsizei size, GLuint[] buffer)
+ {
+ GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSelectBuffer(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SelectBuffer(GLsizei size, [In, Out()] System.IntPtr buffer)
+ {
+ Delegates.glSelectBuffer(size, buffer);
+ }
+ public static void SelectBuffer(GLsizei size, out GLuint buffer)
+ {
+ buffer = default(GLuint);
+ GCHandle h0 = GCHandle.Alloc(buffer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSelectBuffer(size, h0.AddrOfPinnedObject());
+ buffer = (GLuint)h0.Target;
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SeparableFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, object column)
+ {
+ GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSeparableFilter2D(target, internalformat, width, height, format, type, row, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SeparableFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, System.IntPtr column)
+ {
+ Delegates.glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+ }
+ public static void SeparableFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, System.IntPtr column)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSeparableFilter2D(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), column);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SeparableFilter2D(Enums.VERSION_1_2 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
+ {
+ Delegates.glSeparableFilter2D(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void SeparableFilter2DEXT(Enums.SeparableTargetEXT 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
+ {
+ Delegates.glSeparableFilter2DEXT(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object row, System.IntPtr column)
+ {
+ GCHandle h0 = GCHandle.Alloc(row, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSeparableFilter2DEXT(target, internalformat, width, height, format, type, h0.AddrOfPinnedObject(), column);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, System.IntPtr column)
+ {
+ Delegates.glSeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column);
+ }
+ public static void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, object column)
+ {
+ GCHandle h0 = GCHandle.Alloc(column, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSeparableFilter2DEXT(target, internalformat, width, height, format, type, row, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SetFenceAPPLE(GLuint fence)
+ {
+ Delegates.glSetFenceAPPLE(fence);
+ }
+ public static void SetFenceNV(GLuint fence, Enums.NV_fence condition)
+ {
+ Delegates.glSetFenceNV(fence, condition);
+ }
+ public static void SetFragmentShaderConstantATI(GLuint dst, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSetFragmentShaderConstantATI(dst, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SetFragmentShaderConstantATI(GLuint dst, System.IntPtr value)
+ {
+ Delegates.glSetFragmentShaderConstantATI(dst, value);
+ }
+ public static void SetFragmentShaderConstantATI(GLuint dst, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSetFragmentShaderConstantATI(dst, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SetInvariantEXT(GLuint id, Enums.EXT_vertex_shader type, object addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSetInvariantEXT(id, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SetInvariantEXT(GLuint id, Enums.EXT_vertex_shader type, System.IntPtr addr)
+ {
+ Delegates.glSetInvariantEXT(id, type, addr);
+ }
+ public static void SetLocalConstantEXT(GLuint id, Enums.EXT_vertex_shader type, object addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSetLocalConstantEXT(id, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SetLocalConstantEXT(GLuint id, Enums.EXT_vertex_shader type, System.IntPtr addr)
+ {
+ Delegates.glSetLocalConstantEXT(id, type, addr);
+ }
+ public static void ShadeModel(Enums.ShadingModel mode)
+ {
+ Delegates.glShadeModel(mode);
+ }
+ public static void ShaderOp1EXT(Enums.EXT_vertex_shader op, GLuint res, GLuint arg1)
+ {
+ Delegates.glShaderOp1EXT(op, res, arg1);
+ }
+ public static void ShaderOp2EXT(Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2)
+ {
+ Delegates.glShaderOp2EXT(op, res, arg1, arg2);
+ }
+ public static void ShaderOp3EXT(Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)
+ {
+ Delegates.glShaderOp3EXT(op, res, arg1, arg2, arg3);
+ }
+ public static void ShaderSource(GLuint shader, GLsizei count, string[] @string, System.IntPtr length)
+ {
+ Delegates.glShaderSource(shader, count, @string, length);
+ }
+ public static void ShaderSource(GLuint shader, GLsizei count, string[] @string, ref GLint length)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glShaderSource(shader, count, @string, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ShaderSource(GLuint shader, GLsizei count, string[] @string, GLint[] length)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glShaderSource(shader, count, @string, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string[] @string, GLint[] length)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glShaderSourceARB(shaderObj, count, @string, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string[] @string, System.IntPtr length)
+ {
+ Delegates.glShaderSourceARB(shaderObj, count, @string, length);
+ }
+ public static void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string[] @string, ref GLint length)
+ {
+ GCHandle h0 = GCHandle.Alloc(length, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glShaderSourceARB(shaderObj, count, @string, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, GLfloat[] points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSharpenTexFuncSGIS(target, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, ref GLfloat points)
+ {
+ GCHandle h0 = GCHandle.Alloc(points, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSharpenTexFuncSGIS(target, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, System.IntPtr points)
+ {
+ Delegates.glSharpenTexFuncSGIS(target, n, points);
+ }
+ public static void SpriteParameterfSGIX(Enums.SGIX_sprite pname, GLfloat param)
+ {
+ Delegates.glSpriteParameterfSGIX(pname, param);
+ }
+ public static void SpriteParameterfvSGIX(Enums.SGIX_sprite pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSpriteParameterfvSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SpriteParameterfvSGIX(Enums.SGIX_sprite pname, System.IntPtr @params)
+ {
+ Delegates.glSpriteParameterfvSGIX(pname, @params);
+ }
+ public static void SpriteParameterfvSGIX(Enums.SGIX_sprite pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSpriteParameterfvSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SpriteParameteriSGIX(Enums.SGIX_sprite pname, GLint param)
+ {
+ Delegates.glSpriteParameteriSGIX(pname, param);
+ }
+ public static void SpriteParameterivSGIX(Enums.SGIX_sprite pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSpriteParameterivSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SpriteParameterivSGIX(Enums.SGIX_sprite pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glSpriteParameterivSGIX(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SpriteParameterivSGIX(Enums.SGIX_sprite pname, System.IntPtr @params)
+ {
+ Delegates.glSpriteParameterivSGIX(pname, @params);
+ }
+ public static void StartInstrumentsSGIX()
+ {
+ Delegates.glStartInstrumentsSGIX();
+ }
+ public static void StencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag)
+ {
+ Delegates.glStencilClearTagEXT(stencilTagBits, stencilClearTag);
+ }
+ public static void StencilFunc(Enums.StencilFunction func, GLint @ref, GLuint mask)
+ {
+ Delegates.glStencilFunc(func, @ref, mask);
+ }
+ public static void StencilFuncSeparate(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint @ref, GLuint mask)
+ {
+ Delegates.glStencilFuncSeparate(frontfunc, backfunc, @ref, mask);
+ }
+ public static void StencilFuncSeparateATI(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint @ref, GLuint mask)
+ {
+ Delegates.glStencilFuncSeparateATI(frontfunc, backfunc, @ref, mask);
+ }
+ public static void StencilMask(GLuint mask)
+ {
+ Delegates.glStencilMask(mask);
+ }
+ public static void StencilMaskSeparate(Enums.VERSION_2_0 face, GLuint mask)
+ {
+ Delegates.glStencilMaskSeparate(face, mask);
+ }
+ public static void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass)
+ {
+ Delegates.glStencilOp(fail, zfail, zpass);
+ }
+ public static void StencilOpSeparate(Enums.VERSION_2_0 face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass)
+ {
+ Delegates.glStencilOpSeparate(face, sfail, dpfail, dppass);
+ }
+ public static void StencilOpSeparateATI(Enums.ATI_separate_stencil face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass)
+ {
+ Delegates.glStencilOpSeparateATI(face, sfail, dpfail, dppass);
+ }
+ public static void StopInstrumentsSGIX(GLint marker)
+ {
+ Delegates.glStopInstrumentsSGIX(marker);
+ }
+ public static void StringMarkerGREMEDY(GLsizei len, System.IntPtr @string)
+ {
+ Delegates.glStringMarkerGREMEDY(len, @string);
+ }
+ public static void StringMarkerGREMEDY(GLsizei len, object @string)
+ {
+ GCHandle h0 = GCHandle.Alloc(@string, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glStringMarkerGREMEDY(len, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void SwizzleEXT(GLuint res, GLuint @in, Enums.EXT_vertex_shader outX, Enums.EXT_vertex_shader outY, Enums.EXT_vertex_shader outZ, Enums.EXT_vertex_shader outW)
+ {
+ Delegates.glSwizzleEXT(res, @in, outX, outY, outZ, outW);
+ }
+ public static void TagSampleBufferSGIX()
+ {
+ Delegates.glTagSampleBufferSGIX();
+ }
+ public static void Tangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz)
+ {
+ Delegates.glTangent3bEXT(tx, ty, tz);
+ }
+ public static void Tangent3bvEXT(GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3bvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3bvEXT(System.IntPtr v)
+ {
+ Delegates.glTangent3bvEXT(v);
+ }
+ public static void Tangent3bvEXT(ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3bvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz)
+ {
+ Delegates.glTangent3dEXT(tx, ty, tz);
+ }
+ public static void Tangent3dvEXT(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3dvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3dvEXT(System.IntPtr v)
+ {
+ Delegates.glTangent3dvEXT(v);
+ }
+ public static void Tangent3dvEXT(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3dvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz)
+ {
+ Delegates.glTangent3fEXT(tx, ty, tz);
+ }
+ public static void Tangent3fvEXT(System.IntPtr v)
+ {
+ Delegates.glTangent3fvEXT(v);
+ }
+ public static void Tangent3fvEXT(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3fvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3fvEXT(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3fvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3iEXT(GLint tx, GLint ty, GLint tz)
+ {
+ Delegates.glTangent3iEXT(tx, ty, tz);
+ }
+ public static void Tangent3ivEXT(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3ivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3ivEXT(System.IntPtr v)
+ {
+ Delegates.glTangent3ivEXT(v);
+ }
+ public static void Tangent3ivEXT(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3ivEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3sEXT(GLshort tx, GLshort ty, GLshort tz)
+ {
+ Delegates.glTangent3sEXT(tx, ty, tz);
+ }
+ public static void Tangent3svEXT(System.IntPtr v)
+ {
+ Delegates.glTangent3svEXT(v);
+ }
+ public static void Tangent3svEXT(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3svEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Tangent3svEXT(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangent3svEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TangentPointerEXT(Enums.EXT_coordinate_frame type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glTangentPointerEXT(type, stride, pointer);
+ }
+ public static void TangentPointerEXT(Enums.EXT_coordinate_frame type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTangentPointerEXT(type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TbufferMask3DFX(GLuint mask)
+ {
+ Delegates.glTbufferMask3DFX(mask);
+ }
+ public static GLboolean TestFenceAPPLE(GLuint fence)
+ {
+ return Delegates.glTestFenceAPPLE(fence);
+ }
+ public static GLboolean TestFenceNV(GLuint fence)
+ {
+ return Delegates.glTestFenceNV(fence);
+ }
+ public static GLboolean TestObjectAPPLE(Enums.APPLE_fence @object, GLuint name)
+ {
+ return Delegates.glTestObjectAPPLE(@object, name);
+ }
+ public static void TexBufferEXT(Enums.TextureTarget target, Enums.GLenum internalformat, GLuint buffer)
+ {
+ Delegates.glTexBufferEXT(target, internalformat, buffer);
+ }
+ public static void TexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, System.IntPtr param)
+ {
+ Delegates.glTexBumpParameterfvATI(pname, param);
+ }
+ public static void TexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, GLfloat[] param)
+ {
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexBumpParameterfvATI(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, ref GLfloat param)
+ {
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexBumpParameterfvATI(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, ref GLint param)
+ {
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexBumpParameterivATI(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, System.IntPtr param)
+ {
+ Delegates.glTexBumpParameterivATI(pname, param);
+ }
+ public static void TexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, GLint[] param)
+ {
+ GCHandle h0 = GCHandle.Alloc(param, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexBumpParameterivATI(pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1d(GLdouble s)
+ {
+ Delegates.glTexCoord1d(s);
+ }
+ public static void TexCoord1dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1dv(System.IntPtr v)
+ {
+ Delegates.glTexCoord1dv(v);
+ }
+ public static void TexCoord1dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1f(GLfloat s)
+ {
+ Delegates.glTexCoord1f(s);
+ }
+ public static void TexCoord1fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1fv(System.IntPtr v)
+ {
+ Delegates.glTexCoord1fv(v);
+ }
+ public static void TexCoord1hNV(GLhalfNV s)
+ {
+ Delegates.glTexCoord1hNV(s);
+ }
+ public static void TexCoord1hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1hvNV(System.IntPtr v)
+ {
+ Delegates.glTexCoord1hvNV(v);
+ }
+ public static void TexCoord1hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1i(GLint s)
+ {
+ Delegates.glTexCoord1i(s);
+ }
+ public static void TexCoord1iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1iv(System.IntPtr v)
+ {
+ Delegates.glTexCoord1iv(v);
+ }
+ public static void TexCoord1s(GLshort s)
+ {
+ Delegates.glTexCoord1s(s);
+ }
+ public static void TexCoord1sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord1sv(System.IntPtr v)
+ {
+ Delegates.glTexCoord1sv(v);
+ }
+ public static void TexCoord1sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord1sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2d(GLdouble s, GLdouble t)
+ {
+ Delegates.glTexCoord2d(s, t);
+ }
+ public static void TexCoord2dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2dv(System.IntPtr v)
+ {
+ Delegates.glTexCoord2dv(v);
+ }
+ public static void TexCoord2dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2f(GLfloat s, GLfloat t)
+ {
+ Delegates.glTexCoord2f(s, t);
+ }
+ public static void TexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr v)
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, c, v);
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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)
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v);
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(ref GLfloat tc, GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, GLubyte[] c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, GLubyte[] c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr v)
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, c, v);
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, c, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, ref GLubyte c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, GLubyte[] c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, ref GLubyte c, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, ref GLubyte c, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fColor4ubVertex3fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fColor4ubVertex3fvSUN(h0.AddrOfPinnedObject(), c, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(ref GLfloat tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, n, v);
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fNormal3fVertex3fvSUN(GLfloat[] tc, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fNormal3fVertex3fvSUN(h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fv(System.IntPtr v)
+ {
+ Delegates.glTexCoord2fv(v);
+ }
+ public static void TexCoord2fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glTexCoord2fVertex3fSUN(s, t, x, y, z);
+ }
+ public static void TexCoord2fVertex3fvSUN(ref GLfloat tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fvSUN(GLfloat[] tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fvSUN(GLfloat[] tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fvSUN(ref GLfloat tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fvSUN(ref GLfloat tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fvSUN(System.IntPtr tc, System.IntPtr v)
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(tc, v);
+ }
+ public static void TexCoord2fVertex3fvSUN(GLfloat[] tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fvSUN(System.IntPtr tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(tc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2fVertex3fvSUN(System.IntPtr tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2fVertex3fvSUN(tc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2hNV(GLhalfNV s, GLhalfNV t)
+ {
+ Delegates.glTexCoord2hNV(s, t);
+ }
+ public static void TexCoord2hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2hvNV(System.IntPtr v)
+ {
+ Delegates.glTexCoord2hvNV(v);
+ }
+ public static void TexCoord2hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2i(GLint s, GLint t)
+ {
+ Delegates.glTexCoord2i(s, t);
+ }
+ public static void TexCoord2iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2iv(System.IntPtr v)
+ {
+ Delegates.glTexCoord2iv(v);
+ }
+ public static void TexCoord2s(GLshort s, GLshort t)
+ {
+ Delegates.glTexCoord2s(s, t);
+ }
+ public static void TexCoord2sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord2sv(System.IntPtr v)
+ {
+ Delegates.glTexCoord2sv(v);
+ }
+ public static void TexCoord2sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3d(GLdouble s, GLdouble t, GLdouble r)
+ {
+ Delegates.glTexCoord3d(s, t, r);
+ }
+ public static void TexCoord3dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3dv(System.IntPtr v)
+ {
+ Delegates.glTexCoord3dv(v);
+ }
+ public static void TexCoord3dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
+ {
+ Delegates.glTexCoord3f(s, t, r);
+ }
+ public static void TexCoord3fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3fv(System.IntPtr v)
+ {
+ Delegates.glTexCoord3fv(v);
+ }
+ public static void TexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r)
+ {
+ Delegates.glTexCoord3hNV(s, t, r);
+ }
+ public static void TexCoord3hvNV(System.IntPtr v)
+ {
+ Delegates.glTexCoord3hvNV(v);
+ }
+ public static void TexCoord3hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3i(GLint s, GLint t, GLint r)
+ {
+ Delegates.glTexCoord3i(s, t, r);
+ }
+ public static void TexCoord3iv(System.IntPtr v)
+ {
+ Delegates.glTexCoord3iv(v);
+ }
+ public static void TexCoord3iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3s(GLshort s, GLshort t, GLshort r)
+ {
+ Delegates.glTexCoord3s(s, t, r);
+ }
+ public static void TexCoord3sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord3sv(System.IntPtr v)
+ {
+ Delegates.glTexCoord3sv(v);
+ }
+ public static void TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+ {
+ Delegates.glTexCoord4d(s, t, r, q);
+ }
+ public static void TexCoord4dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4dv(System.IntPtr v)
+ {
+ Delegates.glTexCoord4dv(v);
+ }
+ public static void TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+ {
+ Delegates.glTexCoord4f(s, t, r, q);
+ }
+ public static 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)
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, GLfloat[] c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(GLfloat[] tc, ref GLfloat c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ GCHandle h2 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h3 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject(), h2.AddrOfPinnedObject(), h3.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ h2.Free();
+ h3.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, n, h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(ref GLfloat tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(h0.AddrOfPinnedObject(), c, n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, GLfloat[] n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v)
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v);
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat n, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, GLfloat[] c, System.IntPtr n, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(c, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, h0.AddrOfPinnedObject(), n, v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, ref GLfloat n, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(n, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fv(System.IntPtr v)
+ {
+ Delegates.glTexCoord4fv(v);
+ }
+ public static void TexCoord4fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);
+ }
+ public static void TexCoord4fVertex4fvSUN(GLfloat[] tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fvSUN(GLfloat[] tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fvSUN(System.IntPtr tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(tc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fvSUN(System.IntPtr tc, System.IntPtr v)
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(tc, v);
+ }
+ public static void TexCoord4fVertex4fvSUN(System.IntPtr tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(tc, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fvSUN(GLfloat[] tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fvSUN(ref GLfloat tc, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fvSUN(ref GLfloat tc, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ GCHandle h1 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(h0.AddrOfPinnedObject(), h1.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ h1.Free();
+ }
+ }
+ public static void TexCoord4fVertex4fvSUN(ref GLfloat tc, System.IntPtr v)
+ {
+ GCHandle h0 = GCHandle.Alloc(tc, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4fVertex4fvSUN(h0.AddrOfPinnedObject(), v);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
+ {
+ Delegates.glTexCoord4hNV(s, t, r, q);
+ }
+ public static void TexCoord4hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4hvNV(System.IntPtr v)
+ {
+ Delegates.glTexCoord4hvNV(v);
+ }
+ public static void TexCoord4hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4i(GLint s, GLint t, GLint r, GLint q)
+ {
+ Delegates.glTexCoord4i(s, t, r, q);
+ }
+ public static void TexCoord4iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4iv(System.IntPtr v)
+ {
+ Delegates.glTexCoord4iv(v);
+ }
+ public static void TexCoord4iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
+ {
+ Delegates.glTexCoord4s(s, t, r, q);
+ }
+ public static void TexCoord4sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoord4sv(System.IntPtr v)
+ {
+ Delegates.glTexCoord4sv(v);
+ }
+ public static void TexCoord4sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoord4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoordPointer(GLint size, Enums.TexCoordPointerType type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glTexCoordPointer(size, type, stride, pointer);
+ }
+ public static void TexCoordPointer(GLint size, Enums.TexCoordPointerType type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoordPointer(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer)
+ {
+ Delegates.glTexCoordPointerEXT(size, type, stride, count, pointer);
+ }
+ public static void TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexCoordPointerEXT(size, type, stride, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glTexCoordPointerListIBM(size, type, stride, pointer, ptrstride);
+ }
+ public static void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, System.IntPtr pointer)
+ {
+ Delegates.glTexCoordPointervINTEL(size, type, pointer);
+ }
+ public static void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLfloat param)
+ {
+ Delegates.glTexEnvf(target, pname, param);
+ }
+ public static void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params)
+ {
+ Delegates.glTexEnvfv(target, pname, @params);
+ }
+ public static void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexEnvfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexEnvfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLint param)
+ {
+ Delegates.glTexEnvi(target, pname, param);
+ }
+ public static void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params)
+ {
+ Delegates.glTexEnviv(target, pname, @params);
+ }
+ public static void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexEnviv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexEnviv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, GLsizei n, GLfloat[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexFilterFuncSGIS(target, filter, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, GLsizei n, System.IntPtr weights)
+ {
+ Delegates.glTexFilterFuncSGIS(target, filter, n, weights);
+ }
+ public static void TexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, GLsizei n, ref GLfloat weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexFilterFuncSGIS(target, filter, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLdouble param)
+ {
+ Delegates.glTexGend(coord, pname, param);
+ }
+ public static void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params)
+ {
+ Delegates.glTexGendv(coord, pname, @params);
+ }
+ public static void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLdouble[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexGendv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, ref GLdouble @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexGendv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLfloat param)
+ {
+ Delegates.glTexGenf(coord, pname, param);
+ }
+ public static void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexGenfv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params)
+ {
+ Delegates.glTexGenfv(coord, pname, @params);
+ }
+ public static void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexGenfv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLint param)
+ {
+ Delegates.glTexGeni(coord, pname, param);
+ }
+ public static void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexGeniv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexGeniv(coord, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params)
+ {
+ Delegates.glTexGeniv(coord, pname, @params);
+ }
+ public static void TexImage1D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
+ }
+ public static void TexImage1D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexImage1D(target, level, internalformat, width, border, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexImage2D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+ }
+ public static void TexImage2D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexImage2D(target, level, internalformat, width, height, border, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexImage3D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexImage3D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+ }
+ public static void TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);
+ }
+ public static void TexImage3DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, System.IntPtr pixels)
+ {
+ Delegates.glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
+ }
+ public static 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, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, GLfloat param)
+ {
+ Delegates.glTexParameterf(target, pname, param);
+ }
+ public static void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, ref GLfloat @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, GLfloat[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameterfv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params)
+ {
+ Delegates.glTexParameterfv(target, pname, @params);
+ }
+ public static void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, GLint param)
+ {
+ Delegates.glTexParameteri(target, pname, param);
+ }
+ public static void TexParameterIivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameterIivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameterIivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params)
+ {
+ Delegates.glTexParameterIivEXT(target, pname, @params);
+ }
+ public static void TexParameterIivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameterIivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameterIuivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, GLuint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameterIuivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameterIuivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, ref GLuint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameterIuivEXT(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameterIuivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params)
+ {
+ Delegates.glTexParameterIuivEXT(target, pname, @params);
+ }
+ public static void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, ref GLint @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, GLint[] @params)
+ {
+ GCHandle h0 = GCHandle.Alloc(@params, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexParameteriv(target, pname, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params)
+ {
+ Delegates.glTexParameteriv(target, pname, @params);
+ }
+ public static void TexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
+ }
+ public static void TexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexSubImage1D(target, level, xoffset, width, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexSubImage1DEXT(target, level, xoffset, width, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);
+ }
+ public static void TexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+ }
+ public static void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels)
+ {
+ Delegates.glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);
+ }
+ public static void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, System.IntPtr pixels)
+ {
+ Delegates.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+ }
+ public static 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, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, System.IntPtr pixels)
+ {
+ Delegates.glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+ }
+ public static 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, object pixels)
+ {
+ GCHandle h0 = GCHandle.Alloc(pixels, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static 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, System.IntPtr pixels)
+ {
+ Delegates.glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
+ }
+ public static void TextureColorMaskSGIS([MarshalAs(UnmanagedType.Bool)] bool red, [MarshalAs(UnmanagedType.Bool)] bool green, [MarshalAs(UnmanagedType.Bool)] bool blue, [MarshalAs(UnmanagedType.Bool)] bool alpha)
+ {
+ Delegates.glTextureColorMaskSGIS(red, green, blue, alpha);
+ }
+ public static void TextureLightEXT(Enums.EXT_light_texture pname)
+ {
+ Delegates.glTextureLightEXT(pname);
+ }
+ public static void TextureMaterialEXT(Enums.MaterialFace face, Enums.MaterialParameter mode)
+ {
+ Delegates.glTextureMaterialEXT(face, mode);
+ }
+ public static void TextureNormalEXT(Enums.EXT_texture_perturb_normal mode)
+ {
+ Delegates.glTextureNormalEXT(mode);
+ }
+ public static void TrackMatrixNV(Enums.NV_vertex_program target, GLuint address, Enums.NV_vertex_program matrix, Enums.NV_vertex_program transform)
+ {
+ Delegates.glTrackMatrixNV(target, address, matrix, transform);
+ }
+ public static void TransformFeedbackAttribsNV(GLuint count, ref GLint attribs, Enums.GLenum bufferMode)
+ {
+ GCHandle h0 = GCHandle.Alloc(attribs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTransformFeedbackAttribsNV(count, h0.AddrOfPinnedObject(), bufferMode);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TransformFeedbackAttribsNV(GLuint count, System.IntPtr attribs, Enums.GLenum bufferMode)
+ {
+ Delegates.glTransformFeedbackAttribsNV(count, attribs, bufferMode);
+ }
+ public static void TransformFeedbackAttribsNV(GLuint count, GLint[] attribs, Enums.GLenum bufferMode)
+ {
+ GCHandle h0 = GCHandle.Alloc(attribs, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTransformFeedbackAttribsNV(count, h0.AddrOfPinnedObject(), bufferMode);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TransformFeedbackVaryingsNV(GLuint program, GLsizei count, System.IntPtr locations, Enums.GLenum bufferMode)
+ {
+ Delegates.glTransformFeedbackVaryingsNV(program, count, locations, bufferMode);
+ }
+ public static void TransformFeedbackVaryingsNV(GLuint program, GLsizei count, GLint[] locations, Enums.GLenum bufferMode)
+ {
+ GCHandle h0 = GCHandle.Alloc(locations, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTransformFeedbackVaryingsNV(program, count, h0.AddrOfPinnedObject(), bufferMode);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void TransformFeedbackVaryingsNV(GLuint program, GLsizei count, ref GLint locations, Enums.GLenum bufferMode)
+ {
+ GCHandle h0 = GCHandle.Alloc(locations, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glTransformFeedbackVaryingsNV(program, count, h0.AddrOfPinnedObject(), bufferMode);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Translated(GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glTranslated(x, y, z);
+ }
+ public static void Translatef(GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glTranslatef(x, y, z);
+ }
+ public static void Uniform1f(GLint location, GLfloat v0)
+ {
+ Delegates.glUniform1f(location, v0);
+ }
+ public static void Uniform1fARB(GLint location, GLfloat v0)
+ {
+ Delegates.glUniform1fARB(location, v0);
+ }
+ public static void Uniform1fv(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1fv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform1fv(location, count, value);
+ }
+ public static void Uniform1fv(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1fvARB(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1fvARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform1fvARB(location, count, value);
+ }
+ public static void Uniform1fvARB(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1i(GLint location, GLint v0)
+ {
+ Delegates.glUniform1i(location, v0);
+ }
+ public static void Uniform1iARB(GLint location, GLint v0)
+ {
+ Delegates.glUniform1iARB(location, v0);
+ }
+ public static void Uniform1iv(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1iv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform1iv(location, count, value);
+ }
+ public static void Uniform1iv(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1ivARB(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1ivARB(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1ivARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform1ivARB(location, count, value);
+ }
+ public static void Uniform1uiEXT(GLint location, GLuint v0)
+ {
+ Delegates.glUniform1uiEXT(location, v0);
+ }
+ public static void Uniform1uivEXT(GLint location, GLsizei count, GLuint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1uivEXT(GLint location, GLsizei count, ref GLuint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform1uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform1uivEXT(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform1uivEXT(location, count, value);
+ }
+ public static void Uniform2f(GLint location, GLfloat v0, GLfloat v1)
+ {
+ Delegates.glUniform2f(location, v0, v1);
+ }
+ public static void Uniform2fARB(GLint location, GLfloat v0, GLfloat v1)
+ {
+ Delegates.glUniform2fARB(location, v0, v1);
+ }
+ public static void Uniform2fv(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2fv(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2fv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform2fv(location, count, value);
+ }
+ public static void Uniform2fvARB(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2fvARB(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2fvARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform2fvARB(location, count, value);
+ }
+ public static void Uniform2i(GLint location, GLint v0, GLint v1)
+ {
+ Delegates.glUniform2i(location, v0, v1);
+ }
+ public static void Uniform2iARB(GLint location, GLint v0, GLint v1)
+ {
+ Delegates.glUniform2iARB(location, v0, v1);
+ }
+ public static void Uniform2iv(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2iv(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2iv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform2iv(location, count, value);
+ }
+ public static void Uniform2ivARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform2ivARB(location, count, value);
+ }
+ public static void Uniform2ivARB(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2ivARB(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2uiEXT(GLint location, GLuint v0, GLuint v1)
+ {
+ Delegates.glUniform2uiEXT(location, v0, v1);
+ }
+ public static void Uniform2uivEXT(GLint location, GLsizei count, ref GLuint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2uivEXT(GLint location, GLsizei count, GLuint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform2uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform2uivEXT(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform2uivEXT(location, count, value);
+ }
+ public static void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+ {
+ Delegates.glUniform3f(location, v0, v1, v2);
+ }
+ public static void Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+ {
+ Delegates.glUniform3fARB(location, v0, v1, v2);
+ }
+ public static void Uniform3fv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform3fv(location, count, value);
+ }
+ public static void Uniform3fv(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3fv(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3fvARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform3fvARB(location, count, value);
+ }
+ public static void Uniform3fvARB(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3fvARB(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
+ {
+ Delegates.glUniform3i(location, v0, v1, v2);
+ }
+ public static void Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)
+ {
+ Delegates.glUniform3iARB(location, v0, v1, v2);
+ }
+ public static void Uniform3iv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform3iv(location, count, value);
+ }
+ public static void Uniform3iv(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3iv(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3ivARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform3ivARB(location, count, value);
+ }
+ public static void Uniform3ivARB(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3ivARB(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2)
+ {
+ Delegates.glUniform3uiEXT(location, v0, v1, v2);
+ }
+ public static void Uniform3uivEXT(GLint location, GLsizei count, ref GLuint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3uivEXT(GLint location, GLsizei count, GLuint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform3uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform3uivEXT(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform3uivEXT(location, count, value);
+ }
+ public static void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+ {
+ Delegates.glUniform4f(location, v0, v1, v2, v3);
+ }
+ public static void Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+ {
+ Delegates.glUniform4fARB(location, v0, v1, v2, v3);
+ }
+ public static void Uniform4fv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform4fv(location, count, value);
+ }
+ public static void Uniform4fv(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4fv(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4fv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4fvARB(GLint location, GLsizei count, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4fvARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform4fvARB(location, count, value);
+ }
+ public static void Uniform4fvARB(GLint location, GLsizei count, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4fvARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+ {
+ Delegates.glUniform4i(location, v0, v1, v2, v3);
+ }
+ public static void Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+ {
+ Delegates.glUniform4iARB(location, v0, v1, v2, v3);
+ }
+ public static void Uniform4iv(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform4iv(location, count, value);
+ }
+ public static void Uniform4iv(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4iv(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4iv(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4ivARB(GLint location, GLsizei count, GLint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4ivARB(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform4ivARB(location, count, value);
+ }
+ public static void Uniform4ivARB(GLint location, GLsizei count, ref GLint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4ivARB(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+ {
+ Delegates.glUniform4uiEXT(location, v0, v1, v2, v3);
+ }
+ public static void Uniform4uivEXT(GLint location, GLsizei count, System.IntPtr value)
+ {
+ Delegates.glUniform4uivEXT(location, count, value);
+ }
+ public static void Uniform4uivEXT(GLint location, GLsizei count, ref GLuint value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Uniform4uivEXT(GLint location, GLsizei count, GLuint[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniform4uivEXT(location, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformBufferEXT(GLuint program, GLint location, GLuint buffer)
+ {
+ Delegates.glUniformBufferEXT(program, location, buffer);
+ }
+ public static void UniformMatrix2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix2fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix2fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2fvARB(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix2fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix2fvARB(location, count, transpose, value);
+ }
+ public static void UniformMatrix2fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2fvARB(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix2x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2x3fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix2x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2x3fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix2x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix2x3fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix2x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix2x4fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix2x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2x4fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix2x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix2x4fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix3fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix3fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3fvARB(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix3fvARB(location, count, transpose, value);
+ }
+ public static void UniformMatrix3fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3fvARB(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix3x2fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix3x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3x2fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3x2fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3x4fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix3x4fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix3x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix3x4fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix4fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix4fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix4fvARB(location, count, transpose, value);
+ }
+ public static void UniformMatrix4fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4fvARB(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix4fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4fvARB(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix4x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix4x2fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix4x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4x2fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix4x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4x2fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix4x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, GLfloat[] value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4x3fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UniformMatrix4x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value)
+ {
+ Delegates.glUniformMatrix4x3fv(location, count, transpose, value);
+ }
+ public static void UniformMatrix4x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, ref GLfloat value)
+ {
+ GCHandle h0 = GCHandle.Alloc(value, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUniformMatrix4x3fv(location, count, transpose, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UnlockArraysEXT()
+ {
+ Delegates.glUnlockArraysEXT();
+ }
+ public static GLboolean UnmapBuffer(Enums.VERSION_1_5 target)
+ {
+ return Delegates.glUnmapBuffer(target);
+ }
+ public static GLboolean UnmapBufferARB(Enums.ARB_vertex_buffer_object target)
+ {
+ return Delegates.glUnmapBufferARB(target);
+ }
+ public static void UnmapObjectBufferATI(GLuint buffer)
+ {
+ Delegates.glUnmapObjectBufferATI(buffer);
+ }
+ public static void UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, System.IntPtr pointer, Enums.ATI_vertex_array_object preserve)
+ {
+ Delegates.glUpdateObjectBufferATI(buffer, offset, size, pointer, preserve);
+ }
+ public static void UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, object pointer, Enums.ATI_vertex_array_object preserve)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glUpdateObjectBufferATI(buffer, offset, size, h0.AddrOfPinnedObject(), preserve);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void UseProgram(GLuint program)
+ {
+ Delegates.glUseProgram(program);
+ }
+ public static void UseProgramObjectARB(GLhandleARB programObj)
+ {
+ Delegates.glUseProgramObjectARB(programObj);
+ }
+ public static void ValidateProgram(GLuint program)
+ {
+ Delegates.glValidateProgram(program);
+ }
+ public static void ValidateProgramARB(GLhandleARB programObj)
+ {
+ Delegates.glValidateProgramARB(programObj);
+ }
+ public static void VariantArrayObjectATI(GLuint id, Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset)
+ {
+ Delegates.glVariantArrayObjectATI(id, type, stride, buffer, offset);
+ }
+ public static void VariantbvEXT(GLuint id, ref GLbyte addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantbvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantbvEXT(GLuint id, GLbyte[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantbvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantbvEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantbvEXT(id, addr);
+ }
+ public static void VariantdvEXT(GLuint id, ref GLdouble addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantdvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantdvEXT(GLuint id, GLdouble[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantdvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantdvEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantdvEXT(id, addr);
+ }
+ public static void VariantfvEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantfvEXT(id, addr);
+ }
+ public static void VariantfvEXT(GLuint id, GLfloat[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantfvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantfvEXT(GLuint id, ref GLfloat addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantfvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantivEXT(GLuint id, ref GLint addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantivEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantivEXT(GLuint id, GLint[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantivEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantivEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantivEXT(id, addr);
+ }
+ public static void VariantPointerEXT(GLuint id, Enums.EXT_vertex_shader type, GLuint stride, System.IntPtr addr)
+ {
+ Delegates.glVariantPointerEXT(id, type, stride, addr);
+ }
+ public static void VariantPointerEXT(GLuint id, Enums.EXT_vertex_shader type, GLuint stride, object addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantPointerEXT(id, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantsvEXT(GLuint id, ref GLshort addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantsvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantsvEXT(GLuint id, GLshort[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantsvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantsvEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantsvEXT(id, addr);
+ }
+ public static void VariantubvEXT(GLuint id, ref GLubyte addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantubvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantubvEXT(GLuint id, GLubyte[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantubvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantubvEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantubvEXT(id, addr);
+ }
+ public static void VariantuivEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantuivEXT(id, addr);
+ }
+ public static void VariantuivEXT(GLuint id, GLuint[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantuivEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantuivEXT(GLuint id, ref GLuint addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantuivEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantusvEXT(GLuint id, System.IntPtr addr)
+ {
+ Delegates.glVariantusvEXT(id, addr);
+ }
+ public static void VariantusvEXT(GLuint id, GLushort[] addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantusvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VariantusvEXT(GLuint id, ref GLushort addr)
+ {
+ GCHandle h0 = GCHandle.Alloc(addr, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVariantusvEXT(id, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2d(GLdouble x, GLdouble y)
+ {
+ Delegates.glVertex2d(x, y);
+ }
+ public static void Vertex2dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2dv(System.IntPtr v)
+ {
+ Delegates.glVertex2dv(v);
+ }
+ public static void Vertex2f(GLfloat x, GLfloat y)
+ {
+ Delegates.glVertex2f(x, y);
+ }
+ public static void Vertex2fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2fv(System.IntPtr v)
+ {
+ Delegates.glVertex2fv(v);
+ }
+ public static void Vertex2hNV(GLhalfNV x, GLhalfNV y)
+ {
+ Delegates.glVertex2hNV(x, y);
+ }
+ public static void Vertex2hvNV(System.IntPtr v)
+ {
+ Delegates.glVertex2hvNV(v);
+ }
+ public static void Vertex2hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2i(GLint x, GLint y)
+ {
+ Delegates.glVertex2i(x, y);
+ }
+ public static void Vertex2iv(System.IntPtr v)
+ {
+ Delegates.glVertex2iv(v);
+ }
+ public static void Vertex2iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2s(GLshort x, GLshort y)
+ {
+ Delegates.glVertex2s(x, y);
+ }
+ public static void Vertex2sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex2sv(System.IntPtr v)
+ {
+ Delegates.glVertex2sv(v);
+ }
+ public static void Vertex3d(GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glVertex3d(x, y, z);
+ }
+ public static void Vertex3dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3dv(System.IntPtr v)
+ {
+ Delegates.glVertex3dv(v);
+ }
+ public static void Vertex3dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3f(GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glVertex3f(x, y, z);
+ }
+ public static void Vertex3fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3fv(System.IntPtr v)
+ {
+ Delegates.glVertex3fv(v);
+ }
+ public static void Vertex3fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z)
+ {
+ Delegates.glVertex3hNV(x, y, z);
+ }
+ public static void Vertex3hvNV(System.IntPtr v)
+ {
+ Delegates.glVertex3hvNV(v);
+ }
+ public static void Vertex3hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3i(GLint x, GLint y, GLint z)
+ {
+ Delegates.glVertex3i(x, y, z);
+ }
+ public static void Vertex3iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3iv(System.IntPtr v)
+ {
+ Delegates.glVertex3iv(v);
+ }
+ public static void Vertex3s(GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glVertex3s(x, y, z);
+ }
+ public static void Vertex3sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex3sv(System.IntPtr v)
+ {
+ Delegates.glVertex3sv(v);
+ }
+ public static void Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glVertex4d(x, y, z, w);
+ }
+ public static void Vertex4dv(System.IntPtr v)
+ {
+ Delegates.glVertex4dv(v);
+ }
+ public static void Vertex4dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glVertex4f(x, y, z, w);
+ }
+ public static void Vertex4fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4fv(System.IntPtr v)
+ {
+ Delegates.glVertex4fv(v);
+ }
+ public static void Vertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
+ {
+ Delegates.glVertex4hNV(x, y, z, w);
+ }
+ public static void Vertex4hvNV(System.IntPtr v)
+ {
+ Delegates.glVertex4hvNV(v);
+ }
+ public static void Vertex4hvNV(GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4hvNV(ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4hvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4i(GLint x, GLint y, GLint z, GLint w)
+ {
+ Delegates.glVertex4i(x, y, z, w);
+ }
+ public static void Vertex4iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4iv(System.IntPtr v)
+ {
+ Delegates.glVertex4iv(v);
+ }
+ public static void Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
+ {
+ Delegates.glVertex4s(x, y, z, w);
+ }
+ public static void Vertex4sv(System.IntPtr v)
+ {
+ Delegates.glVertex4sv(v);
+ }
+ public static void Vertex4sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Vertex4sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertex4sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexArrayParameteriAPPLE(Enums.APPLE_vertex_array_range pname, GLint param)
+ {
+ Delegates.glVertexArrayParameteriAPPLE(pname, param);
+ }
+ public static void VertexArrayRangeAPPLE(GLsizei length, [In, Out()] System.IntPtr pointer)
+ {
+ Delegates.glVertexArrayRangeAPPLE(length, pointer);
+ }
+ public static void VertexArrayRangeAPPLE(GLsizei length, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexArrayRangeAPPLE(length, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexArrayRangeNV(GLsizei length, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexArrayRangeNV(length, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexArrayRangeNV(GLsizei length, System.IntPtr pointer)
+ {
+ Delegates.glVertexArrayRangeNV(length, pointer);
+ }
+ public static void VertexAttrib1d(GLuint index, GLdouble x)
+ {
+ Delegates.glVertexAttrib1d(index, x);
+ }
+ public static void VertexAttrib1dARB(GLuint index, GLdouble x)
+ {
+ Delegates.glVertexAttrib1dARB(index, x);
+ }
+ public static void VertexAttrib1dNV(GLuint index, GLdouble x)
+ {
+ Delegates.glVertexAttrib1dNV(index, x);
+ }
+ public static void VertexAttrib1dv(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1dv(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1dv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1dv(index, v);
+ }
+ public static void VertexAttrib1dvARB(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1dvARB(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1dvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1dvARB(index, v);
+ }
+ public static void VertexAttrib1dvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1dvNV(index, v);
+ }
+ public static void VertexAttrib1dvNV(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1dvNV(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1f(GLuint index, GLfloat x)
+ {
+ Delegates.glVertexAttrib1f(index, x);
+ }
+ public static void VertexAttrib1fARB(GLuint index, GLfloat x)
+ {
+ Delegates.glVertexAttrib1fARB(index, x);
+ }
+ public static void VertexAttrib1fNV(GLuint index, GLfloat x)
+ {
+ Delegates.glVertexAttrib1fNV(index, x);
+ }
+ public static void VertexAttrib1fv(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1fv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1fv(index, v);
+ }
+ public static void VertexAttrib1fv(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1fvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1fvARB(index, v);
+ }
+ public static void VertexAttrib1fvARB(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1fvARB(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1fvNV(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1fvNV(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1fvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1fvNV(index, v);
+ }
+ public static void VertexAttrib1hNV(GLuint index, GLhalfNV x)
+ {
+ Delegates.glVertexAttrib1hNV(index, x);
+ }
+ public static void VertexAttrib1hvNV(GLuint index, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1hvNV(GLuint index, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1hvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1hvNV(index, v);
+ }
+ public static void VertexAttrib1s(GLuint index, GLshort x)
+ {
+ Delegates.glVertexAttrib1s(index, x);
+ }
+ public static void VertexAttrib1sARB(GLuint index, GLshort x)
+ {
+ Delegates.glVertexAttrib1sARB(index, x);
+ }
+ public static void VertexAttrib1sNV(GLuint index, GLshort x)
+ {
+ Delegates.glVertexAttrib1sNV(index, x);
+ }
+ public static void VertexAttrib1sv(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1sv(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1sv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1sv(index, v);
+ }
+ public static void VertexAttrib1svARB(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1svARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1svARB(index, v);
+ }
+ public static void VertexAttrib1svARB(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1svNV(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1svNV(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib1svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib1svNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib1svNV(index, v);
+ }
+ public static void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
+ {
+ Delegates.glVertexAttrib2d(index, x, y);
+ }
+ public static void VertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
+ {
+ Delegates.glVertexAttrib2dARB(index, x, y);
+ }
+ public static void VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
+ {
+ Delegates.glVertexAttrib2dNV(index, x, y);
+ }
+ public static void VertexAttrib2dv(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2dv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2dv(index, v);
+ }
+ public static void VertexAttrib2dv(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2dvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2dvARB(index, v);
+ }
+ public static void VertexAttrib2dvARB(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2dvARB(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2dvNV(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2dvNV(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2dvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2dvNV(index, v);
+ }
+ public static void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
+ {
+ Delegates.glVertexAttrib2f(index, x, y);
+ }
+ public static void VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
+ {
+ Delegates.glVertexAttrib2fARB(index, x, y);
+ }
+ public static void VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
+ {
+ Delegates.glVertexAttrib2fNV(index, x, y);
+ }
+ public static void VertexAttrib2fv(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2fv(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2fv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2fv(index, v);
+ }
+ public static void VertexAttrib2fvARB(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2fvARB(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2fvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2fvARB(index, v);
+ }
+ public static void VertexAttrib2fvNV(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2fvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2fvNV(index, v);
+ }
+ public static void VertexAttrib2fvNV(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y)
+ {
+ Delegates.glVertexAttrib2hNV(index, x, y);
+ }
+ public static void VertexAttrib2hvNV(GLuint index, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2hvNV(GLuint index, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2hvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2hvNV(index, v);
+ }
+ public static void VertexAttrib2s(GLuint index, GLshort x, GLshort y)
+ {
+ Delegates.glVertexAttrib2s(index, x, y);
+ }
+ public static void VertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
+ {
+ Delegates.glVertexAttrib2sARB(index, x, y);
+ }
+ public static void VertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
+ {
+ Delegates.glVertexAttrib2sNV(index, x, y);
+ }
+ public static void VertexAttrib2sv(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2sv(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2sv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2sv(index, v);
+ }
+ public static void VertexAttrib2svARB(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2svARB(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2svARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2svARB(index, v);
+ }
+ public static void VertexAttrib2svNV(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2svNV(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib2svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib2svNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib2svNV(index, v);
+ }
+ public static void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glVertexAttrib3d(index, x, y, z);
+ }
+ public static void VertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glVertexAttrib3dARB(index, x, y, z);
+ }
+ public static void VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glVertexAttrib3dNV(index, x, y, z);
+ }
+ public static void VertexAttrib3dv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3dv(index, v);
+ }
+ public static void VertexAttrib3dv(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3dv(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3dvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3dvARB(index, v);
+ }
+ public static void VertexAttrib3dvARB(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3dvARB(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3dvNV(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3dvNV(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3dvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3dvNV(index, v);
+ }
+ public static void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glVertexAttrib3f(index, x, y, z);
+ }
+ public static void VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glVertexAttrib3fARB(index, x, y, z);
+ }
+ public static void VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glVertexAttrib3fNV(index, x, y, z);
+ }
+ public static void VertexAttrib3fv(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3fv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3fv(index, v);
+ }
+ public static void VertexAttrib3fv(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3fvARB(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3fvARB(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3fvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3fvARB(index, v);
+ }
+ public static void VertexAttrib3fvNV(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3fvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3fvNV(index, v);
+ }
+ public static void VertexAttrib3fvNV(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)
+ {
+ Delegates.glVertexAttrib3hNV(index, x, y, z);
+ }
+ public static void VertexAttrib3hvNV(GLuint index, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3hvNV(GLuint index, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3hvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3hvNV(index, v);
+ }
+ public static void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glVertexAttrib3s(index, x, y, z);
+ }
+ public static void VertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glVertexAttrib3sARB(index, x, y, z);
+ }
+ public static void VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glVertexAttrib3sNV(index, x, y, z);
+ }
+ public static void VertexAttrib3sv(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3sv(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3sv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3sv(index, v);
+ }
+ public static void VertexAttrib3svARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3svARB(index, v);
+ }
+ public static void VertexAttrib3svARB(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3svARB(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3svNV(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib3svNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib3svNV(index, v);
+ }
+ public static void VertexAttrib3svNV(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib3svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4bv(GLuint index, ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4bv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4bv(GLuint index, GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4bv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4bv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4bv(index, v);
+ }
+ public static void VertexAttrib4bvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4bvARB(index, v);
+ }
+ public static void VertexAttrib4bvARB(GLuint index, GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4bvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4bvARB(GLuint index, ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4bvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glVertexAttrib4d(index, x, y, z, w);
+ }
+ public static void VertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glVertexAttrib4dARB(index, x, y, z, w);
+ }
+ public static void VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glVertexAttrib4dNV(index, x, y, z, w);
+ }
+ public static void VertexAttrib4dv(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4dv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4dv(index, v);
+ }
+ public static void VertexAttrib4dv(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4dv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4dvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4dvARB(index, v);
+ }
+ public static void VertexAttrib4dvARB(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4dvARB(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4dvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4dvNV(GLuint index, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4dvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4dvNV(index, v);
+ }
+ public static void VertexAttrib4dvNV(GLuint index, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4dvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glVertexAttrib4f(index, x, y, z, w);
+ }
+ public static void VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glVertexAttrib4fARB(index, x, y, z, w);
+ }
+ public static void VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glVertexAttrib4fNV(index, x, y, z, w);
+ }
+ public static void VertexAttrib4fv(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4fv(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4fv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4fv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4fv(index, v);
+ }
+ public static void VertexAttrib4fvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4fvARB(index, v);
+ }
+ public static void VertexAttrib4fvARB(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4fvARB(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4fvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4fvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4fvNV(index, v);
+ }
+ public static void VertexAttrib4fvNV(GLuint index, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4fvNV(GLuint index, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4fvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
+ {
+ Delegates.glVertexAttrib4hNV(index, x, y, z, w);
+ }
+ public static void VertexAttrib4hvNV(GLuint index, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4hvNV(GLuint index, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4hvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4hvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4hvNV(index, v);
+ }
+ public static void VertexAttrib4iv(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4iv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4iv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4iv(index, v);
+ }
+ public static void VertexAttrib4iv(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4iv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ivARB(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ivARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4ivARB(index, v);
+ }
+ public static void VertexAttrib4ivARB(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nbv(GLuint index, ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nbv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nbv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4Nbv(index, v);
+ }
+ public static void VertexAttrib4Nbv(GLuint index, GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nbv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NbvARB(GLuint index, ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NbvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NbvARB(GLuint index, GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NbvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NbvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4NbvARB(index, v);
+ }
+ public static void VertexAttrib4Niv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4Niv(index, v);
+ }
+ public static void VertexAttrib4Niv(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Niv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Niv(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Niv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NivARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4NivARB(index, v);
+ }
+ public static void VertexAttrib4NivARB(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NivARB(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nsv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4Nsv(index, v);
+ }
+ public static void VertexAttrib4Nsv(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nsv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nsv(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nsv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NsvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4NsvARB(index, v);
+ }
+ public static void VertexAttrib4NsvARB(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NsvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NsvARB(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NsvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+ {
+ Delegates.glVertexAttrib4Nub(index, x, y, z, w);
+ }
+ public static void VertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+ {
+ Delegates.glVertexAttrib4NubARB(index, x, y, z, w);
+ }
+ public static void VertexAttrib4Nubv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4Nubv(index, v);
+ }
+ public static void VertexAttrib4Nubv(GLuint index, GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nubv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nubv(GLuint index, ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nubv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NubvARB(GLuint index, GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NubvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NubvARB(GLuint index, ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NubvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NubvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4NubvARB(index, v);
+ }
+ public static void VertexAttrib4Nuiv(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nuiv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nuiv(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nuiv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nuiv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4Nuiv(index, v);
+ }
+ public static void VertexAttrib4NuivARB(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NuivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NuivARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4NuivARB(index, v);
+ }
+ public static void VertexAttrib4NuivARB(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NuivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nusv(GLuint index, ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nusv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nusv(GLuint index, GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4Nusv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4Nusv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4Nusv(index, v);
+ }
+ public static void VertexAttrib4NusvARB(GLuint index, GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NusvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4NusvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4NusvARB(index, v);
+ }
+ public static void VertexAttrib4NusvARB(GLuint index, ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4NusvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+ {
+ Delegates.glVertexAttrib4s(index, x, y, z, w);
+ }
+ public static void VertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+ {
+ Delegates.glVertexAttrib4sARB(index, x, y, z, w);
+ }
+ public static void VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+ {
+ Delegates.glVertexAttrib4sNV(index, x, y, z, w);
+ }
+ public static void VertexAttrib4sv(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4sv(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4sv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4sv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4sv(index, v);
+ }
+ public static void VertexAttrib4svARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4svARB(index, v);
+ }
+ public static void VertexAttrib4svARB(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4svARB(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4svARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4svNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4svNV(index, v);
+ }
+ public static void VertexAttrib4svNV(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4svNV(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4svNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+ {
+ Delegates.glVertexAttrib4ubNV(index, x, y, z, w);
+ }
+ public static void VertexAttrib4ubv(GLuint index, GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ubv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ubv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4ubv(index, v);
+ }
+ public static void VertexAttrib4ubv(GLuint index, ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ubv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ubvARB(GLuint index, GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ubvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ubvARB(GLuint index, ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ubvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ubvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4ubvARB(index, v);
+ }
+ public static void VertexAttrib4ubvNV(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4ubvNV(index, v);
+ }
+ public static void VertexAttrib4ubvNV(GLuint index, ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ubvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4ubvNV(GLuint index, GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4ubvNV(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4uiv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4uiv(index, v);
+ }
+ public static void VertexAttrib4uiv(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4uiv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4uiv(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4uiv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4uivARB(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4uivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4uivARB(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4uivARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4uivARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4uivARB(index, v);
+ }
+ public static void VertexAttrib4usv(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4usv(index, v);
+ }
+ public static void VertexAttrib4usv(GLuint index, ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4usv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4usv(GLuint index, GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4usv(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4usvARB(GLuint index, GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4usvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttrib4usvARB(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttrib4usvARB(index, v);
+ }
+ public static void VertexAttrib4usvARB(GLuint index, ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttrib4usvARB(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribArrayObjectATI(GLuint index, GLint size, Enums.ATI_vertex_attrib_array_object type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, GLuint buffer, GLuint offset)
+ {
+ Delegates.glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
+ }
+ public static void VertexAttribI1iEXT(GLuint index, GLint x)
+ {
+ Delegates.glVertexAttribI1iEXT(index, x);
+ }
+ public static void VertexAttribI1ivEXT(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI1ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI1ivEXT(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI1ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI1ivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI1ivEXT(index, v);
+ }
+ public static void VertexAttribI1uiEXT(GLuint index, GLuint x)
+ {
+ Delegates.glVertexAttribI1uiEXT(index, x);
+ }
+ public static void VertexAttribI1uivEXT(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI1uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI1uivEXT(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI1uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI1uivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI1uivEXT(index, v);
+ }
+ public static void VertexAttribI2iEXT(GLuint index, GLint x, GLint y)
+ {
+ Delegates.glVertexAttribI2iEXT(index, x, y);
+ }
+ public static void VertexAttribI2ivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI2ivEXT(index, v);
+ }
+ public static void VertexAttribI2ivEXT(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI2ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI2ivEXT(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI2ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y)
+ {
+ Delegates.glVertexAttribI2uiEXT(index, x, y);
+ }
+ public static void VertexAttribI2uivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI2uivEXT(index, v);
+ }
+ public static void VertexAttribI2uivEXT(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI2uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI2uivEXT(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI2uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z)
+ {
+ Delegates.glVertexAttribI3iEXT(index, x, y, z);
+ }
+ public static void VertexAttribI3ivEXT(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI3ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI3ivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI3ivEXT(index, v);
+ }
+ public static void VertexAttribI3ivEXT(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI3ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z)
+ {
+ Delegates.glVertexAttribI3uiEXT(index, x, y, z);
+ }
+ public static void VertexAttribI3uivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI3uivEXT(index, v);
+ }
+ public static void VertexAttribI3uivEXT(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI3uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI3uivEXT(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI3uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4bvEXT(GLuint index, ref GLbyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4bvEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4bvEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI4bvEXT(index, v);
+ }
+ public static void VertexAttribI4bvEXT(GLuint index, GLbyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4bvEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w)
+ {
+ Delegates.glVertexAttribI4iEXT(index, x, y, z, w);
+ }
+ public static void VertexAttribI4ivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI4ivEXT(index, v);
+ }
+ public static void VertexAttribI4ivEXT(GLuint index, GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4ivEXT(GLuint index, ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4ivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4svEXT(GLuint index, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4svEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4svEXT(GLuint index, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4svEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4svEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI4svEXT(index, v);
+ }
+ public static void VertexAttribI4ubvEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI4ubvEXT(index, v);
+ }
+ public static void VertexAttribI4ubvEXT(GLuint index, GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4ubvEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4ubvEXT(GLuint index, ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4ubvEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+ {
+ Delegates.glVertexAttribI4uiEXT(index, x, y, z, w);
+ }
+ public static void VertexAttribI4uivEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI4uivEXT(index, v);
+ }
+ public static void VertexAttribI4uivEXT(GLuint index, GLuint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4uivEXT(GLuint index, ref GLuint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4uivEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4usvEXT(GLuint index, ref GLushort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4usvEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4usvEXT(GLuint index, GLushort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribI4usvEXT(index, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribI4usvEXT(GLuint index, System.IntPtr v)
+ {
+ Delegates.glVertexAttribI4usvEXT(index, v);
+ }
+ public static void VertexAttribIPointerEXT(GLuint index, GLint size, Enums.NV_vertex_program4 type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glVertexAttribIPointerEXT(index, size, type, stride, pointer);
+ }
+ public static void VertexAttribIPointerEXT(GLuint index, GLint size, Enums.NV_vertex_program4 type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribIPointerEXT(index, size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribPointer(GLuint index, GLint size, Enums.VERSION_2_0 type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribPointer(index, size, type, normalized, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribPointer(GLuint index, GLint size, Enums.VERSION_2_0 type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glVertexAttribPointer(index, size, type, normalized, stride, pointer);
+ }
+ public static void VertexAttribPointerARB(GLuint index, GLint size, Enums.ARB_vertex_program type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glVertexAttribPointerARB(index, size, type, normalized, stride, pointer);
+ }
+ public static void VertexAttribPointerARB(GLuint index, GLint size, Enums.ARB_vertex_program type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribPointerARB(index, size, type, normalized, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribPointerNV(GLuint index, GLint fsize, Enums.NV_vertex_program type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glVertexAttribPointerNV(index, fsize, type, stride, pointer);
+ }
+ public static void VertexAttribPointerNV(GLuint index, GLint fsize, Enums.NV_vertex_program type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribPointerNV(index, fsize, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1dvNV(GLuint index, GLsizei count, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1dvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs1dvNV(index, count, v);
+ }
+ public static void VertexAttribs1dvNV(GLuint index, GLsizei count, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1fvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs1fvNV(index, count, v);
+ }
+ public static void VertexAttribs1fvNV(GLuint index, GLsizei count, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1fvNV(GLuint index, GLsizei count, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1hvNV(GLuint index, GLsizei n, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs1hvNV(index, n, v);
+ }
+ public static void VertexAttribs1hvNV(GLuint index, GLsizei n, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1svNV(GLuint index, GLsizei count, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1svNV(GLuint index, GLsizei count, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs1svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs1svNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs1svNV(index, count, v);
+ }
+ public static void VertexAttribs2dvNV(GLuint index, GLsizei count, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2dvNV(GLuint index, GLsizei count, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2dvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs2dvNV(index, count, v);
+ }
+ public static void VertexAttribs2fvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs2fvNV(index, count, v);
+ }
+ public static void VertexAttribs2fvNV(GLuint index, GLsizei count, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2fvNV(GLuint index, GLsizei count, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2hvNV(GLuint index, GLsizei n, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs2hvNV(index, n, v);
+ }
+ public static void VertexAttribs2hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2hvNV(GLuint index, GLsizei n, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2svNV(GLuint index, GLsizei count, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2svNV(GLuint index, GLsizei count, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs2svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs2svNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs2svNV(index, count, v);
+ }
+ public static void VertexAttribs3dvNV(GLuint index, GLsizei count, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs3dvNV(GLuint index, GLsizei count, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs3dvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs3dvNV(index, count, v);
+ }
+ public static void VertexAttribs3fvNV(GLuint index, GLsizei count, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs3fvNV(GLuint index, GLsizei count, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs3fvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs3fvNV(index, count, v);
+ }
+ public static void VertexAttribs3hvNV(GLuint index, GLsizei n, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs3hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs3hvNV(GLuint index, GLsizei n, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs3hvNV(index, n, v);
+ }
+ public static void VertexAttribs3svNV(GLuint index, GLsizei count, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs3svNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs3svNV(index, count, v);
+ }
+ public static void VertexAttribs3svNV(GLuint index, GLsizei count, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs3svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4dvNV(GLuint index, GLsizei count, ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4dvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs4dvNV(index, count, v);
+ }
+ public static void VertexAttribs4dvNV(GLuint index, GLsizei count, GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4dvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4fvNV(GLuint index, GLsizei count, ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4fvNV(GLuint index, GLsizei count, GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4fvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4fvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs4fvNV(index, count, v);
+ }
+ public static void VertexAttribs4hvNV(GLuint index, GLsizei n, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs4hvNV(index, n, v);
+ }
+ public static void VertexAttribs4hvNV(GLuint index, GLsizei n, GLhalfNV[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4hvNV(GLuint index, GLsizei n, ref GLhalfNV v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4hvNV(index, n, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4svNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs4svNV(index, count, v);
+ }
+ public static void VertexAttribs4svNV(GLuint index, GLsizei count, GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4svNV(GLuint index, GLsizei count, ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4svNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4ubvNV(GLuint index, GLsizei count, ref GLubyte v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4ubvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4ubvNV(GLuint index, GLsizei count, GLubyte[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexAttribs4ubvNV(index, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexAttribs4ubvNV(GLuint index, GLsizei count, System.IntPtr v)
+ {
+ Delegates.glVertexAttribs4ubvNV(index, count, v);
+ }
+ public static void VertexBlendARB(GLint count)
+ {
+ Delegates.glVertexBlendARB(count);
+ }
+ public static void VertexBlendEnvfATI(Enums.ATI_vertex_streams pname, GLfloat param)
+ {
+ Delegates.glVertexBlendEnvfATI(pname, param);
+ }
+ public static void VertexBlendEnviATI(Enums.ATI_vertex_streams pname, GLint param)
+ {
+ Delegates.glVertexBlendEnviATI(pname, param);
+ }
+ public static void VertexPointer(GLint size, Enums.VertexPointerType type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexPointer(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexPointer(GLint size, Enums.VertexPointerType type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glVertexPointer(size, type, stride, pointer);
+ }
+ public static void VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexPointerEXT(size, type, stride, count, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer)
+ {
+ Delegates.glVertexPointerEXT(size, type, stride, count, pointer);
+ }
+ public static void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride)
+ {
+ Delegates.glVertexPointerListIBM(size, type, stride, pointer, ptrstride);
+ }
+ public static void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, System.IntPtr pointer)
+ {
+ Delegates.glVertexPointervINTEL(size, type, pointer);
+ }
+ public static void VertexStream1dATI(Enums.ATI_vertex_streams stream, GLdouble x)
+ {
+ Delegates.glVertexStream1dATI(stream, x);
+ }
+ public static void VertexStream1dvATI(Enums.ATI_vertex_streams stream, GLdouble[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream1dvATI(stream, coords);
+ }
+ public static void VertexStream1dvATI(Enums.ATI_vertex_streams stream, ref GLdouble coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1fATI(Enums.ATI_vertex_streams stream, GLfloat x)
+ {
+ Delegates.glVertexStream1fATI(stream, x);
+ }
+ public static void VertexStream1fvATI(Enums.ATI_vertex_streams stream, GLfloat[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream1fvATI(stream, coords);
+ }
+ public static void VertexStream1fvATI(Enums.ATI_vertex_streams stream, ref GLfloat coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1iATI(Enums.ATI_vertex_streams stream, GLint x)
+ {
+ Delegates.glVertexStream1iATI(stream, x);
+ }
+ public static void VertexStream1ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream1ivATI(stream, coords);
+ }
+ public static void VertexStream1ivATI(Enums.ATI_vertex_streams stream, GLint[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1ivATI(Enums.ATI_vertex_streams stream, ref GLint coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1sATI(Enums.ATI_vertex_streams stream, GLshort x)
+ {
+ Delegates.glVertexStream1sATI(stream, x);
+ }
+ public static void VertexStream1svATI(Enums.ATI_vertex_streams stream, ref GLshort coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1svATI(Enums.ATI_vertex_streams stream, GLshort[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream1svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream1svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream1svATI(stream, coords);
+ }
+ public static void VertexStream2dATI(Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y)
+ {
+ Delegates.glVertexStream2dATI(stream, x, y);
+ }
+ public static void VertexStream2dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream2dvATI(stream, coords);
+ }
+ public static void VertexStream2dvATI(Enums.ATI_vertex_streams stream, ref GLdouble coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream2dvATI(Enums.ATI_vertex_streams stream, GLdouble[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream2fATI(Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y)
+ {
+ Delegates.glVertexStream2fATI(stream, x, y);
+ }
+ public static void VertexStream2fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream2fvATI(stream, coords);
+ }
+ public static void VertexStream2fvATI(Enums.ATI_vertex_streams stream, GLfloat[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream2fvATI(Enums.ATI_vertex_streams stream, ref GLfloat coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream2iATI(Enums.ATI_vertex_streams stream, GLint x, GLint y)
+ {
+ Delegates.glVertexStream2iATI(stream, x, y);
+ }
+ public static void VertexStream2ivATI(Enums.ATI_vertex_streams stream, GLint[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream2ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream2ivATI(stream, coords);
+ }
+ public static void VertexStream2ivATI(Enums.ATI_vertex_streams stream, ref GLint coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream2sATI(Enums.ATI_vertex_streams stream, GLshort x, GLshort y)
+ {
+ Delegates.glVertexStream2sATI(stream, x, y);
+ }
+ public static void VertexStream2svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream2svATI(stream, coords);
+ }
+ public static void VertexStream2svATI(Enums.ATI_vertex_streams stream, GLshort[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream2svATI(Enums.ATI_vertex_streams stream, ref GLshort coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream2svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3dATI(Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glVertexStream3dATI(stream, x, y, z);
+ }
+ public static void VertexStream3dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream3dvATI(stream, coords);
+ }
+ public static void VertexStream3dvATI(Enums.ATI_vertex_streams stream, GLdouble[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3dvATI(Enums.ATI_vertex_streams stream, ref GLdouble coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3fATI(Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glVertexStream3fATI(stream, x, y, z);
+ }
+ public static void VertexStream3fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream3fvATI(stream, coords);
+ }
+ public static void VertexStream3fvATI(Enums.ATI_vertex_streams stream, GLfloat[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3fvATI(Enums.ATI_vertex_streams stream, ref GLfloat coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3iATI(Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z)
+ {
+ Delegates.glVertexStream3iATI(stream, x, y, z);
+ }
+ public static void VertexStream3ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream3ivATI(stream, coords);
+ }
+ public static void VertexStream3ivATI(Enums.ATI_vertex_streams stream, GLint[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3ivATI(Enums.ATI_vertex_streams stream, ref GLint coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3sATI(Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glVertexStream3sATI(stream, x, y, z);
+ }
+ public static void VertexStream3svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream3svATI(stream, coords);
+ }
+ public static void VertexStream3svATI(Enums.ATI_vertex_streams stream, ref GLshort coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream3svATI(Enums.ATI_vertex_streams stream, GLshort[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream3svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4dATI(Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glVertexStream4dATI(stream, x, y, z, w);
+ }
+ public static void VertexStream4dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream4dvATI(stream, coords);
+ }
+ public static void VertexStream4dvATI(Enums.ATI_vertex_streams stream, ref GLdouble coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4dvATI(Enums.ATI_vertex_streams stream, GLdouble[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4dvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4fATI(Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glVertexStream4fATI(stream, x, y, z, w);
+ }
+ public static void VertexStream4fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream4fvATI(stream, coords);
+ }
+ public static void VertexStream4fvATI(Enums.ATI_vertex_streams stream, ref GLfloat coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4fvATI(Enums.ATI_vertex_streams stream, GLfloat[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4fvATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4iATI(Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z, GLint w)
+ {
+ Delegates.glVertexStream4iATI(stream, x, y, z, w);
+ }
+ public static void VertexStream4ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream4ivATI(stream, coords);
+ }
+ public static void VertexStream4ivATI(Enums.ATI_vertex_streams stream, ref GLint coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4ivATI(Enums.ATI_vertex_streams stream, GLint[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4ivATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4sATI(Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z, GLshort w)
+ {
+ Delegates.glVertexStream4sATI(stream, x, y, z, w);
+ }
+ public static void VertexStream4svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords)
+ {
+ Delegates.glVertexStream4svATI(stream, coords);
+ }
+ public static void VertexStream4svATI(Enums.ATI_vertex_streams stream, GLshort[] coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexStream4svATI(Enums.ATI_vertex_streams stream, ref GLshort coords)
+ {
+ GCHandle h0 = GCHandle.Alloc(coords, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexStream4svATI(stream, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexWeightfEXT(GLfloat weight)
+ {
+ Delegates.glVertexWeightfEXT(weight);
+ }
+ public static void VertexWeightfvEXT(ref GLfloat weight)
+ {
+ GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexWeightfvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexWeightfvEXT(GLfloat[] weight)
+ {
+ GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexWeightfvEXT(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexWeightfvEXT(System.IntPtr weight)
+ {
+ Delegates.glVertexWeightfvEXT(weight);
+ }
+ public static void VertexWeighthNV(GLhalfNV weight)
+ {
+ Delegates.glVertexWeighthNV(weight);
+ }
+ public static void VertexWeighthvNV(System.IntPtr weight)
+ {
+ Delegates.glVertexWeighthvNV(weight);
+ }
+ public static void VertexWeighthvNV(GLhalfNV[] weight)
+ {
+ GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexWeighthvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexWeighthvNV(ref GLhalfNV weight)
+ {
+ GCHandle h0 = GCHandle.Alloc(weight, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexWeighthvNV(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void VertexWeightPointerEXT(GLsizei size, Enums.EXT_vertex_weighting type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glVertexWeightPointerEXT(size, type, stride, pointer);
+ }
+ public static void VertexWeightPointerEXT(GLsizei size, Enums.EXT_vertex_weighting type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glVertexWeightPointerEXT(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+ {
+ Delegates.glViewport(x, y, width, height);
+ }
+ public static void WeightbvARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightbvARB(size, weights);
+ }
+ public static void WeightbvARB(GLint size, ref GLbyte weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightbvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightbvARB(GLint size, GLbyte[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightbvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightdvARB(GLint size, GLdouble[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightdvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightdvARB(GLint size, ref GLdouble weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightdvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightdvARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightdvARB(size, weights);
+ }
+ public static void WeightfvARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightfvARB(size, weights);
+ }
+ public static void WeightfvARB(GLint size, GLfloat[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightfvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightfvARB(GLint size, ref GLfloat weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightfvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightivARB(GLint size, GLint[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightivARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightivARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightivARB(size, weights);
+ }
+ public static void WeightivARB(GLint size, ref GLint weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightivARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightPointerARB(GLint size, Enums.ARB_vertex_blend type, GLsizei stride, System.IntPtr pointer)
+ {
+ Delegates.glWeightPointerARB(size, type, stride, pointer);
+ }
+ public static void WeightPointerARB(GLint size, Enums.ARB_vertex_blend type, GLsizei stride, object pointer)
+ {
+ GCHandle h0 = GCHandle.Alloc(pointer, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightPointerARB(size, type, stride, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightsvARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightsvARB(size, weights);
+ }
+ public static void WeightsvARB(GLint size, GLshort[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightsvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightsvARB(GLint size, ref GLshort weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightsvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightubvARB(GLint size, ref GLubyte weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightubvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightubvARB(GLint size, GLubyte[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightubvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightubvARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightubvARB(size, weights);
+ }
+ public static void WeightuivARB(GLint size, GLuint[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightuivARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightuivARB(GLint size, ref GLuint weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightuivARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightuivARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightuivARB(size, weights);
+ }
+ public static void WeightusvARB(GLint size, System.IntPtr weights)
+ {
+ Delegates.glWeightusvARB(size, weights);
+ }
+ public static void WeightusvARB(GLint size, GLushort[] weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightusvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WeightusvARB(GLint size, ref GLushort weights)
+ {
+ GCHandle h0 = GCHandle.Alloc(weights, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWeightusvARB(size, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2d(GLdouble x, GLdouble y)
+ {
+ Delegates.glWindowPos2d(x, y);
+ }
+ public static void WindowPos2dARB(GLdouble x, GLdouble y)
+ {
+ Delegates.glWindowPos2dARB(x, y);
+ }
+ public static void WindowPos2dMESA(GLdouble x, GLdouble y)
+ {
+ Delegates.glWindowPos2dMESA(x, y);
+ }
+ public static void WindowPos2dv(System.IntPtr v)
+ {
+ Delegates.glWindowPos2dv(v);
+ }
+ public static void WindowPos2dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2dvARB(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2dvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2dvARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos2dvARB(v);
+ }
+ public static void WindowPos2dvARB(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2dvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2dvMESA(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2dvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2dvMESA(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2dvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2dvMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos2dvMESA(v);
+ }
+ public static void WindowPos2f(GLfloat x, GLfloat y)
+ {
+ Delegates.glWindowPos2f(x, y);
+ }
+ public static void WindowPos2fARB(GLfloat x, GLfloat y)
+ {
+ Delegates.glWindowPos2fARB(x, y);
+ }
+ public static void WindowPos2fMESA(GLfloat x, GLfloat y)
+ {
+ Delegates.glWindowPos2fMESA(x, y);
+ }
+ public static void WindowPos2fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2fv(System.IntPtr v)
+ {
+ Delegates.glWindowPos2fv(v);
+ }
+ public static void WindowPos2fvARB(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2fvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2fvARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos2fvARB(v);
+ }
+ public static void WindowPos2fvARB(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2fvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2fvMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos2fvMESA(v);
+ }
+ public static void WindowPos2fvMESA(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2fvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2fvMESA(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2fvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2i(GLint x, GLint y)
+ {
+ Delegates.glWindowPos2i(x, y);
+ }
+ public static void WindowPos2iARB(GLint x, GLint y)
+ {
+ Delegates.glWindowPos2iARB(x, y);
+ }
+ public static void WindowPos2iMESA(GLint x, GLint y)
+ {
+ Delegates.glWindowPos2iMESA(x, y);
+ }
+ public static void WindowPos2iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2iv(System.IntPtr v)
+ {
+ Delegates.glWindowPos2iv(v);
+ }
+ public static void WindowPos2ivARB(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2ivARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2ivARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos2ivARB(v);
+ }
+ public static void WindowPos2ivARB(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2ivARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2ivMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos2ivMESA(v);
+ }
+ public static void WindowPos2ivMESA(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2ivMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2ivMESA(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2ivMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2s(GLshort x, GLshort y)
+ {
+ Delegates.glWindowPos2s(x, y);
+ }
+ public static void WindowPos2sARB(GLshort x, GLshort y)
+ {
+ Delegates.glWindowPos2sARB(x, y);
+ }
+ public static void WindowPos2sMESA(GLshort x, GLshort y)
+ {
+ Delegates.glWindowPos2sMESA(x, y);
+ }
+ public static void WindowPos2sv(System.IntPtr v)
+ {
+ Delegates.glWindowPos2sv(v);
+ }
+ public static void WindowPos2sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2svARB(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2svARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2svARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos2svARB(v);
+ }
+ public static void WindowPos2svARB(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2svARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2svMESA(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2svMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2svMESA(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos2svMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos2svMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos2svMESA(v);
+ }
+ public static void WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glWindowPos3d(x, y, z);
+ }
+ public static void WindowPos3dARB(GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glWindowPos3dARB(x, y, z);
+ }
+ public static void WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
+ {
+ Delegates.glWindowPos3dMESA(x, y, z);
+ }
+ public static void WindowPos3dv(System.IntPtr v)
+ {
+ Delegates.glWindowPos3dv(v);
+ }
+ public static void WindowPos3dv(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3dv(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3dv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3dvARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos3dvARB(v);
+ }
+ public static void WindowPos3dvARB(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3dvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3dvARB(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3dvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3dvMESA(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3dvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3dvMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos3dvMESA(v);
+ }
+ public static void WindowPos3dvMESA(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3dvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glWindowPos3f(x, y, z);
+ }
+ public static void WindowPos3fARB(GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glWindowPos3fARB(x, y, z);
+ }
+ public static void WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
+ {
+ Delegates.glWindowPos3fMESA(x, y, z);
+ }
+ public static void WindowPos3fv(System.IntPtr v)
+ {
+ Delegates.glWindowPos3fv(v);
+ }
+ public static void WindowPos3fv(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3fv(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3fv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3fvARB(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3fvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3fvARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos3fvARB(v);
+ }
+ public static void WindowPos3fvARB(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3fvARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3fvMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos3fvMESA(v);
+ }
+ public static void WindowPos3fvMESA(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3fvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3fvMESA(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3fvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3i(GLint x, GLint y, GLint z)
+ {
+ Delegates.glWindowPos3i(x, y, z);
+ }
+ public static void WindowPos3iARB(GLint x, GLint y, GLint z)
+ {
+ Delegates.glWindowPos3iARB(x, y, z);
+ }
+ public static void WindowPos3iMESA(GLint x, GLint y, GLint z)
+ {
+ Delegates.glWindowPos3iMESA(x, y, z);
+ }
+ public static void WindowPos3iv(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3iv(System.IntPtr v)
+ {
+ Delegates.glWindowPos3iv(v);
+ }
+ public static void WindowPos3iv(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3iv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3ivARB(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3ivARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3ivARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos3ivARB(v);
+ }
+ public static void WindowPos3ivARB(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3ivARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3ivMESA(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3ivMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3ivMESA(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3ivMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3ivMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos3ivMESA(v);
+ }
+ public static void WindowPos3s(GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glWindowPos3s(x, y, z);
+ }
+ public static void WindowPos3sARB(GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glWindowPos3sARB(x, y, z);
+ }
+ public static void WindowPos3sMESA(GLshort x, GLshort y, GLshort z)
+ {
+ Delegates.glWindowPos3sMESA(x, y, z);
+ }
+ public static void WindowPos3sv(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3sv(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3sv(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3sv(System.IntPtr v)
+ {
+ Delegates.glWindowPos3sv(v);
+ }
+ public static void WindowPos3svARB(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3svARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3svARB(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3svARB(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3svARB(System.IntPtr v)
+ {
+ Delegates.glWindowPos3svARB(v);
+ }
+ public static void WindowPos3svMESA(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3svMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos3svMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos3svMESA(v);
+ }
+ public static void WindowPos3svMESA(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos3svMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+ {
+ Delegates.glWindowPos4dMESA(x, y, z, w);
+ }
+ public static void WindowPos4dvMESA(ref GLdouble v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4dvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4dvMESA(GLdouble[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4dvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4dvMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos4dvMESA(v);
+ }
+ public static void WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ {
+ Delegates.glWindowPos4fMESA(x, y, z, w);
+ }
+ public static void WindowPos4fvMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos4fvMESA(v);
+ }
+ public static void WindowPos4fvMESA(ref GLfloat v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4fvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4fvMESA(GLfloat[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4fvMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
+ {
+ Delegates.glWindowPos4iMESA(x, y, z, w);
+ }
+ public static void WindowPos4ivMESA(GLint[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4ivMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4ivMESA(ref GLint v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4ivMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4ivMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos4ivMESA(v);
+ }
+ public static void WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
+ {
+ Delegates.glWindowPos4sMESA(x, y, z, w);
+ }
+ public static void WindowPos4svMESA(ref GLshort v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4svMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4svMESA(GLshort[] v)
+ {
+ GCHandle h0 = GCHandle.Alloc(v, GCHandleType.Pinned);
+ try
+ {
+ Delegates.glWindowPos4svMESA(h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+ public static void WindowPos4svMESA(System.IntPtr v)
+ {
+ Delegates.glWindowPos4svMESA(v);
+ }
+ public static void WriteMaskEXT(GLuint res, GLuint @in, Enums.EXT_vertex_shader outX, Enums.EXT_vertex_shader outY, Enums.EXT_vertex_shader outZ, Enums.EXT_vertex_shader outW)
+ {
+ Delegates.glWriteMaskEXT(res, @in, outX, outY, outZ, outW);
+ }
+ #endregion
+ }
+ #endregion
+ #region Delegates
+ internal class Delegates
+ {
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Accum(Enums.AccumOp op, GLfloat value);
+ public static Accum glAccum = ((Accum)(GL.GetDelegateForExtensionMethod("glAccum", typeof(Accum)))) ?? new Accum(Imports.Accum);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ActiveStencilFaceEXT(Enums.EXT_stencil_two_side face);
+ public static ActiveStencilFaceEXT glActiveStencilFaceEXT = ((ActiveStencilFaceEXT)(GL.GetDelegateForExtensionMethod("glActiveStencilFaceEXT", typeof(ActiveStencilFaceEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ActiveTexture(Enums.VERSION_1_3 texture);
+ public static ActiveTexture glActiveTexture = ((ActiveTexture)(GL.GetDelegateForExtensionMethod("glActiveTexture", typeof(ActiveTexture)))) ?? new ActiveTexture(Imports.ActiveTexture);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ActiveTextureARB(Enums.ARB_multitexture texture);
+ public static ActiveTextureARB glActiveTextureARB = ((ActiveTextureARB)(GL.GetDelegateForExtensionMethod("glActiveTextureARB", typeof(ActiveTextureARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ActiveVaryingNV(GLuint program, string name);
+ public static ActiveVaryingNV glActiveVaryingNV = ((ActiveVaryingNV)(GL.GetDelegateForExtensionMethod("glActiveVaryingNV", typeof(ActiveVaryingNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void AlphaFragmentOp1ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+ public static AlphaFragmentOp1ATI glAlphaFragmentOp1ATI = ((AlphaFragmentOp1ATI)(GL.GetDelegateForExtensionMethod("glAlphaFragmentOp1ATI", typeof(AlphaFragmentOp1ATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void AlphaFragmentOp2ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+ public static AlphaFragmentOp2ATI glAlphaFragmentOp2ATI = ((AlphaFragmentOp2ATI)(GL.GetDelegateForExtensionMethod("glAlphaFragmentOp2ATI", typeof(AlphaFragmentOp2ATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void AlphaFragmentOp3ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod);
+ public static AlphaFragmentOp3ATI glAlphaFragmentOp3ATI = ((AlphaFragmentOp3ATI)(GL.GetDelegateForExtensionMethod("glAlphaFragmentOp3ATI", typeof(AlphaFragmentOp3ATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void AlphaFunc(Enums.AlphaFunction func, GLclampf @ref);
+ public static AlphaFunc glAlphaFunc = ((AlphaFunc)(GL.GetDelegateForExtensionMethod("glAlphaFunc", typeof(AlphaFunc)))) ?? new AlphaFunc(Imports.AlphaFunc);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ApplyTextureEXT(Enums.EXT_light_texture mode);
+ public static ApplyTextureEXT glApplyTextureEXT = ((ApplyTextureEXT)(GL.GetDelegateForExtensionMethod("glApplyTextureEXT", typeof(ApplyTextureEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean AreProgramsResidentNV(GLsizei n, System.IntPtr programs, [In, Out()] System.IntPtr residences);
+ public static AreProgramsResidentNV glAreProgramsResidentNV = ((AreProgramsResidentNV)(GL.GetDelegateForExtensionMethod("glAreProgramsResidentNV", typeof(AreProgramsResidentNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean AreTexturesResident(GLsizei n, System.IntPtr textures, [In, Out()] System.IntPtr residences);
+ public static AreTexturesResident glAreTexturesResident = ((AreTexturesResident)(GL.GetDelegateForExtensionMethod("glAreTexturesResident", typeof(AreTexturesResident)))) ?? new AreTexturesResident(Imports.AreTexturesResident);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean AreTexturesResidentEXT(GLsizei n, System.IntPtr textures, [In, Out()] System.IntPtr residences);
+ public static AreTexturesResidentEXT glAreTexturesResidentEXT = ((AreTexturesResidentEXT)(GL.GetDelegateForExtensionMethod("glAreTexturesResidentEXT", typeof(AreTexturesResidentEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ArrayElement(GLint i);
+ public static ArrayElement glArrayElement = ((ArrayElement)(GL.GetDelegateForExtensionMethod("glArrayElement", typeof(ArrayElement)))) ?? new ArrayElement(Imports.ArrayElement);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ArrayElementEXT(GLint i);
+ public static ArrayElementEXT glArrayElementEXT = ((ArrayElementEXT)(GL.GetDelegateForExtensionMethod("glArrayElementEXT", typeof(ArrayElementEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ArrayObjectATI(Enums.EnableCap array, GLint size, Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset);
+ public static ArrayObjectATI glArrayObjectATI = ((ArrayObjectATI)(GL.GetDelegateForExtensionMethod("glArrayObjectATI", typeof(ArrayObjectATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void AsyncMarkerSGIX(GLuint marker);
+ public static AsyncMarkerSGIX glAsyncMarkerSGIX = ((AsyncMarkerSGIX)(GL.GetDelegateForExtensionMethod("glAsyncMarkerSGIX", typeof(AsyncMarkerSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void AttachObjectARB(GLhandleARB containerObj, GLhandleARB obj);
+ public static AttachObjectARB glAttachObjectARB = ((AttachObjectARB)(GL.GetDelegateForExtensionMethod("glAttachObjectARB", typeof(AttachObjectARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void AttachShader(GLuint program, GLuint shader);
+ public static AttachShader glAttachShader = ((AttachShader)(GL.GetDelegateForExtensionMethod("glAttachShader", typeof(AttachShader)))) ?? new AttachShader(Imports.AttachShader);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Begin(Enums.BeginMode mode);
+ public static Begin glBegin = ((Begin)(GL.GetDelegateForExtensionMethod("glBegin", typeof(Begin)))) ?? new Begin(Imports.Begin);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BeginFragmentShaderATI();
+ public static BeginFragmentShaderATI glBeginFragmentShaderATI = ((BeginFragmentShaderATI)(GL.GetDelegateForExtensionMethod("glBeginFragmentShaderATI", typeof(BeginFragmentShaderATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BeginOcclusionQueryNV(GLuint id);
+ public static BeginOcclusionQueryNV glBeginOcclusionQueryNV = ((BeginOcclusionQueryNV)(GL.GetDelegateForExtensionMethod("glBeginOcclusionQueryNV", typeof(BeginOcclusionQueryNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BeginQuery(Enums.VERSION_1_5 target, GLuint id);
+ public static BeginQuery glBeginQuery = ((BeginQuery)(GL.GetDelegateForExtensionMethod("glBeginQuery", typeof(BeginQuery)))) ?? new BeginQuery(Imports.BeginQuery);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BeginQueryARB(Enums.ARB_occlusion_query target, GLuint id);
+ public static BeginQueryARB glBeginQueryARB = ((BeginQueryARB)(GL.GetDelegateForExtensionMethod("glBeginQueryARB", typeof(BeginQueryARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BeginTransformFeedbackNV(Enums.GLenum primitiveMode);
+ public static BeginTransformFeedbackNV glBeginTransformFeedbackNV = ((BeginTransformFeedbackNV)(GL.GetDelegateForExtensionMethod("glBeginTransformFeedbackNV", typeof(BeginTransformFeedbackNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BeginVertexShaderEXT();
+ public static BeginVertexShaderEXT glBeginVertexShaderEXT = ((BeginVertexShaderEXT)(GL.GetDelegateForExtensionMethod("glBeginVertexShaderEXT", typeof(BeginVertexShaderEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindAttribLocation(GLuint program, GLuint index, string name);
+ public static BindAttribLocation glBindAttribLocation = ((BindAttribLocation)(GL.GetDelegateForExtensionMethod("glBindAttribLocation", typeof(BindAttribLocation)))) ?? new BindAttribLocation(Imports.BindAttribLocation);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindAttribLocationARB(GLhandleARB programObj, GLuint index, string name);
+ public static BindAttribLocationARB glBindAttribLocationARB = ((BindAttribLocationARB)(GL.GetDelegateForExtensionMethod("glBindAttribLocationARB", typeof(BindAttribLocationARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindBuffer(Enums.VERSION_1_5 target, GLuint buffer);
+ public static BindBuffer glBindBuffer = ((BindBuffer)(GL.GetDelegateForExtensionMethod("glBindBuffer", typeof(BindBuffer)))) ?? new BindBuffer(Imports.BindBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindBufferARB(Enums.ARB_vertex_buffer_object target, GLuint buffer);
+ public static BindBufferARB glBindBufferARB = ((BindBufferARB)(GL.GetDelegateForExtensionMethod("glBindBufferARB", typeof(BindBufferARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindBufferBaseNV(Enums.GLenum target, GLuint index, GLuint buffer);
+ public static BindBufferBaseNV glBindBufferBaseNV = ((BindBufferBaseNV)(GL.GetDelegateForExtensionMethod("glBindBufferBaseNV", typeof(BindBufferBaseNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindBufferOffsetNV(Enums.GLenum target, GLuint index, GLuint buffer, GLintptr offset);
+ public static BindBufferOffsetNV glBindBufferOffsetNV = ((BindBufferOffsetNV)(GL.GetDelegateForExtensionMethod("glBindBufferOffsetNV", typeof(BindBufferOffsetNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindBufferRangeNV(Enums.GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+ public static BindBufferRangeNV glBindBufferRangeNV = ((BindBufferRangeNV)(GL.GetDelegateForExtensionMethod("glBindBufferRangeNV", typeof(BindBufferRangeNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindFragDataLocationEXT(GLuint program, GLuint color, string name);
+ public static BindFragDataLocationEXT glBindFragDataLocationEXT = ((BindFragDataLocationEXT)(GL.GetDelegateForExtensionMethod("glBindFragDataLocationEXT", typeof(BindFragDataLocationEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindFragmentShaderATI(GLuint id);
+ public static BindFragmentShaderATI glBindFragmentShaderATI = ((BindFragmentShaderATI)(GL.GetDelegateForExtensionMethod("glBindFragmentShaderATI", typeof(BindFragmentShaderATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindFramebufferEXT(Enums.EXT_framebuffer_object target, GLuint framebuffer);
+ public static BindFramebufferEXT glBindFramebufferEXT = ((BindFramebufferEXT)(GL.GetDelegateForExtensionMethod("glBindFramebufferEXT", typeof(BindFramebufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint BindLightParameterEXT(Enums.LightName light, Enums.LightParameter value);
+ public static BindLightParameterEXT glBindLightParameterEXT = ((BindLightParameterEXT)(GL.GetDelegateForExtensionMethod("glBindLightParameterEXT", typeof(BindLightParameterEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint BindMaterialParameterEXT(Enums.MaterialFace face, Enums.MaterialParameter value);
+ public static BindMaterialParameterEXT glBindMaterialParameterEXT = ((BindMaterialParameterEXT)(GL.GetDelegateForExtensionMethod("glBindMaterialParameterEXT", typeof(BindMaterialParameterEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint BindParameterEXT(Enums.EXT_vertex_shader value);
+ public static BindParameterEXT glBindParameterEXT = ((BindParameterEXT)(GL.GetDelegateForExtensionMethod("glBindParameterEXT", typeof(BindParameterEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindProgramARB(Enums.ARB_vertex_program target, GLuint program);
+ public static BindProgramARB glBindProgramARB = ((BindProgramARB)(GL.GetDelegateForExtensionMethod("glBindProgramARB", typeof(BindProgramARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindProgramNV(Enums.NV_vertex_program target, GLuint id);
+ public static BindProgramNV glBindProgramNV = ((BindProgramNV)(GL.GetDelegateForExtensionMethod("glBindProgramNV", typeof(BindProgramNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindRenderbufferEXT(Enums.EXT_framebuffer_object target, GLuint renderbuffer);
+ public static BindRenderbufferEXT glBindRenderbufferEXT = ((BindRenderbufferEXT)(GL.GetDelegateForExtensionMethod("glBindRenderbufferEXT", typeof(BindRenderbufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint BindTexGenParameterEXT(Enums.EXT_vertex_shader unit, Enums.TextureCoordName coord, Enums.TextureGenParameter value);
+ public static BindTexGenParameterEXT glBindTexGenParameterEXT = ((BindTexGenParameterEXT)(GL.GetDelegateForExtensionMethod("glBindTexGenParameterEXT", typeof(BindTexGenParameterEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindTexture(Enums.TextureTarget target, GLuint texture);
+ public static BindTexture glBindTexture = ((BindTexture)(GL.GetDelegateForExtensionMethod("glBindTexture", typeof(BindTexture)))) ?? new BindTexture(Imports.BindTexture);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindTextureEXT(Enums.TextureTarget target, GLuint texture);
+ public static BindTextureEXT glBindTextureEXT = ((BindTextureEXT)(GL.GetDelegateForExtensionMethod("glBindTextureEXT", typeof(BindTextureEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint BindTextureUnitParameterEXT(Enums.EXT_vertex_shader unit, Enums.EXT_vertex_shader value);
+ public static BindTextureUnitParameterEXT glBindTextureUnitParameterEXT = ((BindTextureUnitParameterEXT)(GL.GetDelegateForExtensionMethod("glBindTextureUnitParameterEXT", typeof(BindTextureUnitParameterEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindVertexArrayAPPLE(GLuint array);
+ public static BindVertexArrayAPPLE glBindVertexArrayAPPLE = ((BindVertexArrayAPPLE)(GL.GetDelegateForExtensionMethod("glBindVertexArrayAPPLE", typeof(BindVertexArrayAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BindVertexShaderEXT(GLuint id);
+ public static BindVertexShaderEXT glBindVertexShaderEXT = ((BindVertexShaderEXT)(GL.GetDelegateForExtensionMethod("glBindVertexShaderEXT", typeof(BindVertexShaderEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz);
+ public static Binormal3bEXT glBinormal3bEXT = ((Binormal3bEXT)(GL.GetDelegateForExtensionMethod("glBinormal3bEXT", typeof(Binormal3bEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3bvEXT(System.IntPtr v);
+ public static Binormal3bvEXT glBinormal3bvEXT = ((Binormal3bvEXT)(GL.GetDelegateForExtensionMethod("glBinormal3bvEXT", typeof(Binormal3bvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz);
+ public static Binormal3dEXT glBinormal3dEXT = ((Binormal3dEXT)(GL.GetDelegateForExtensionMethod("glBinormal3dEXT", typeof(Binormal3dEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3dvEXT(System.IntPtr v);
+ public static Binormal3dvEXT glBinormal3dvEXT = ((Binormal3dvEXT)(GL.GetDelegateForExtensionMethod("glBinormal3dvEXT", typeof(Binormal3dvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz);
+ public static Binormal3fEXT glBinormal3fEXT = ((Binormal3fEXT)(GL.GetDelegateForExtensionMethod("glBinormal3fEXT", typeof(Binormal3fEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3fvEXT(System.IntPtr v);
+ public static Binormal3fvEXT glBinormal3fvEXT = ((Binormal3fvEXT)(GL.GetDelegateForExtensionMethod("glBinormal3fvEXT", typeof(Binormal3fvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3iEXT(GLint bx, GLint by, GLint bz);
+ public static Binormal3iEXT glBinormal3iEXT = ((Binormal3iEXT)(GL.GetDelegateForExtensionMethod("glBinormal3iEXT", typeof(Binormal3iEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3ivEXT(System.IntPtr v);
+ public static Binormal3ivEXT glBinormal3ivEXT = ((Binormal3ivEXT)(GL.GetDelegateForExtensionMethod("glBinormal3ivEXT", typeof(Binormal3ivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3sEXT(GLshort bx, GLshort by, GLshort bz);
+ public static Binormal3sEXT glBinormal3sEXT = ((Binormal3sEXT)(GL.GetDelegateForExtensionMethod("glBinormal3sEXT", typeof(Binormal3sEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Binormal3svEXT(System.IntPtr v);
+ public static Binormal3svEXT glBinormal3svEXT = ((Binormal3svEXT)(GL.GetDelegateForExtensionMethod("glBinormal3svEXT", typeof(Binormal3svEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BinormalPointerEXT(Enums.EXT_coordinate_frame type, GLsizei stride, System.IntPtr pointer);
+ public static BinormalPointerEXT glBinormalPointerEXT = ((BinormalPointerEXT)(GL.GetDelegateForExtensionMethod("glBinormalPointerEXT", typeof(BinormalPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, System.IntPtr bitmap);
+ public static Bitmap glBitmap = ((Bitmap)(GL.GetDelegateForExtensionMethod("glBitmap", typeof(Bitmap)))) ?? new Bitmap(Imports.Bitmap);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+ public static BlendColor glBlendColor = ((BlendColor)(GL.GetDelegateForExtensionMethod("glBlendColor", typeof(BlendColor)))) ?? new BlendColor(Imports.BlendColor);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+ public static BlendColorEXT glBlendColorEXT = ((BlendColorEXT)(GL.GetDelegateForExtensionMethod("glBlendColorEXT", typeof(BlendColorEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendEquation(Enums.VERSION_1_2 mode);
+ public static BlendEquation glBlendEquation = ((BlendEquation)(GL.GetDelegateForExtensionMethod("glBlendEquation", typeof(BlendEquation)))) ?? new BlendEquation(Imports.BlendEquation);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendEquationEXT(Enums.BlendEquationModeEXT mode);
+ public static BlendEquationEXT glBlendEquationEXT = ((BlendEquationEXT)(GL.GetDelegateForExtensionMethod("glBlendEquationEXT", typeof(BlendEquationEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendEquationSeparate(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha);
+ public static BlendEquationSeparate glBlendEquationSeparate = ((BlendEquationSeparate)(GL.GetDelegateForExtensionMethod("glBlendEquationSeparate", typeof(BlendEquationSeparate)))) ?? new BlendEquationSeparate(Imports.BlendEquationSeparate);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendEquationSeparateEXT(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha);
+ public static BlendEquationSeparateEXT glBlendEquationSeparateEXT = ((BlendEquationSeparateEXT)(GL.GetDelegateForExtensionMethod("glBlendEquationSeparateEXT", typeof(BlendEquationSeparateEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor);
+ public static BlendFunc glBlendFunc = ((BlendFunc)(GL.GetDelegateForExtensionMethod("glBlendFunc", typeof(BlendFunc)))) ?? new BlendFunc(Imports.BlendFunc);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendFuncSeparate(Enums.VERSION_1_4 sfactorRGB, Enums.VERSION_1_4 dfactorRGB, Enums.VERSION_1_4 sfactorAlpha, Enums.VERSION_1_4 dfactorAlpha);
+ public static BlendFuncSeparate glBlendFuncSeparate = ((BlendFuncSeparate)(GL.GetDelegateForExtensionMethod("glBlendFuncSeparate", typeof(BlendFuncSeparate)))) ?? new BlendFuncSeparate(Imports.BlendFuncSeparate);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendFuncSeparateEXT(Enums.EXT_blend_func_separate sfactorRGB, Enums.EXT_blend_func_separate dfactorRGB, Enums.EXT_blend_func_separate sfactorAlpha, Enums.EXT_blend_func_separate dfactorAlpha);
+ public static BlendFuncSeparateEXT glBlendFuncSeparateEXT = ((BlendFuncSeparateEXT)(GL.GetDelegateForExtensionMethod("glBlendFuncSeparateEXT", typeof(BlendFuncSeparateEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlendFuncSeparateINGR(Enums.GLenum sfactorRGB, Enums.GLenum dfactorRGB, Enums.GLenum sfactorAlpha, Enums.GLenum dfactorAlpha);
+ public static BlendFuncSeparateINGR glBlendFuncSeparateINGR = ((BlendFuncSeparateINGR)(GL.GetDelegateForExtensionMethod("glBlendFuncSeparateINGR", typeof(BlendFuncSeparateINGR))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, Enums.ClearBufferMask mask, Enums.GLenum filter);
+ public static BlitFramebufferEXT glBlitFramebufferEXT = ((BlitFramebufferEXT)(GL.GetDelegateForExtensionMethod("glBlitFramebufferEXT", typeof(BlitFramebufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BufferData(Enums.VERSION_1_5 target, GLsizeiptr size, System.IntPtr data, Enums.VERSION_1_5 usage);
+ public static BufferData glBufferData = ((BufferData)(GL.GetDelegateForExtensionMethod("glBufferData", typeof(BufferData)))) ?? new BufferData(Imports.BufferData);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BufferDataARB(Enums.ARB_vertex_buffer_object target, GLsizeiptrARB size, System.IntPtr data, Enums.ARB_vertex_buffer_object usage);
+ public static BufferDataARB glBufferDataARB = ((BufferDataARB)(GL.GetDelegateForExtensionMethod("glBufferDataARB", typeof(BufferDataARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BufferParameteriAPPLE(Enums.GLenum target, Enums.GLenum pname, GLint param);
+ public static BufferParameteriAPPLE glBufferParameteriAPPLE = ((BufferParameteriAPPLE)(GL.GetDelegateForExtensionMethod("glBufferParameteriAPPLE", typeof(BufferParameteriAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, System.IntPtr data);
+ public static BufferSubData glBufferSubData = ((BufferSubData)(GL.GetDelegateForExtensionMethod("glBufferSubData", typeof(BufferSubData)))) ?? new BufferSubData(Imports.BufferSubData);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void BufferSubDataARB(Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, System.IntPtr data);
+ public static BufferSubDataARB glBufferSubDataARB = ((BufferSubDataARB)(GL.GetDelegateForExtensionMethod("glBufferSubDataARB", typeof(BufferSubDataARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CallList(GLuint list);
+ public static CallList glCallList = ((CallList)(GL.GetDelegateForExtensionMethod("glCallList", typeof(CallList)))) ?? new CallList(Imports.CallList);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CallLists(GLsizei n, Enums.ListNameType type, System.IntPtr lists);
+ public static CallLists glCallLists = ((CallLists)(GL.GetDelegateForExtensionMethod("glCallLists", typeof(CallLists)))) ?? new CallLists(Imports.CallLists);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate Enums.GLenum CheckFramebufferStatusEXT(Enums.EXT_framebuffer_object target);
+ public static CheckFramebufferStatusEXT glCheckFramebufferStatusEXT = ((CheckFramebufferStatusEXT)(GL.GetDelegateForExtensionMethod("glCheckFramebufferStatusEXT", typeof(CheckFramebufferStatusEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClampColorARB(Enums.ARB_color_buffer_float target, Enums.ARB_color_buffer_float clamp);
+ public static ClampColorARB glClampColorARB = ((ClampColorARB)(GL.GetDelegateForExtensionMethod("glClampColorARB", typeof(ClampColorARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Clear(Enums.ClearBufferMask mask);
+ public static Clear glClear = ((Clear)(GL.GetDelegateForExtensionMethod("glClear", typeof(Clear)))) ?? new Clear(Imports.Clear);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ public static ClearAccum glClearAccum = ((ClearAccum)(GL.GetDelegateForExtensionMethod("glClearAccum", typeof(ClearAccum)))) ?? new ClearAccum(Imports.ClearAccum);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+ public static ClearColor glClearColor = ((ClearColor)(GL.GetDelegateForExtensionMethod("glClearColor", typeof(ClearColor)))) ?? new ClearColor(Imports.ClearColor);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha);
+ public static ClearColorIiEXT glClearColorIiEXT = ((ClearColorIiEXT)(GL.GetDelegateForExtensionMethod("glClearColorIiEXT", typeof(ClearColorIiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+ public static ClearColorIuiEXT glClearColorIuiEXT = ((ClearColorIuiEXT)(GL.GetDelegateForExtensionMethod("glClearColorIuiEXT", typeof(ClearColorIuiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearDepth(GLclampd depth);
+ public static ClearDepth glClearDepth = ((ClearDepth)(GL.GetDelegateForExtensionMethod("glClearDepth", typeof(ClearDepth)))) ?? new ClearDepth(Imports.ClearDepth);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearDepthdNV(GLdouble depth);
+ public static ClearDepthdNV glClearDepthdNV = ((ClearDepthdNV)(GL.GetDelegateForExtensionMethod("glClearDepthdNV", typeof(ClearDepthdNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearIndex(GLfloat c);
+ public static ClearIndex glClearIndex = ((ClearIndex)(GL.GetDelegateForExtensionMethod("glClearIndex", typeof(ClearIndex)))) ?? new ClearIndex(Imports.ClearIndex);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClearStencil(GLint s);
+ public static ClearStencil glClearStencil = ((ClearStencil)(GL.GetDelegateForExtensionMethod("glClearStencil", typeof(ClearStencil)))) ?? new ClearStencil(Imports.ClearStencil);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClientActiveTexture(Enums.VERSION_1_3 texture);
+ public static ClientActiveTexture glClientActiveTexture = ((ClientActiveTexture)(GL.GetDelegateForExtensionMethod("glClientActiveTexture", typeof(ClientActiveTexture)))) ?? new ClientActiveTexture(Imports.ClientActiveTexture);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClientActiveTextureARB(Enums.ARB_multitexture texture);
+ public static ClientActiveTextureARB glClientActiveTextureARB = ((ClientActiveTextureARB)(GL.GetDelegateForExtensionMethod("glClientActiveTextureARB", typeof(ClientActiveTextureARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClientActiveVertexStreamATI(Enums.ATI_vertex_streams stream);
+ public static ClientActiveVertexStreamATI glClientActiveVertexStreamATI = ((ClientActiveVertexStreamATI)(GL.GetDelegateForExtensionMethod("glClientActiveVertexStreamATI", typeof(ClientActiveVertexStreamATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ClipPlane(Enums.ClipPlaneName plane, System.IntPtr equation);
+ public static ClipPlane glClipPlane = ((ClipPlane)(GL.GetDelegateForExtensionMethod("glClipPlane", typeof(ClipPlane)))) ?? new ClipPlane(Imports.ClipPlane);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3b(GLbyte red, GLbyte green, GLbyte blue);
+ public static Color3b glColor3b = ((Color3b)(GL.GetDelegateForExtensionMethod("glColor3b", typeof(Color3b)))) ?? new Color3b(Imports.Color3b);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3bv(System.IntPtr v);
+ public static Color3bv glColor3bv = ((Color3bv)(GL.GetDelegateForExtensionMethod("glColor3bv", typeof(Color3bv)))) ?? new Color3bv(Imports.Color3bv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3d(GLdouble red, GLdouble green, GLdouble blue);
+ public static Color3d glColor3d = ((Color3d)(GL.GetDelegateForExtensionMethod("glColor3d", typeof(Color3d)))) ?? new Color3d(Imports.Color3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3dv(System.IntPtr v);
+ public static Color3dv glColor3dv = ((Color3dv)(GL.GetDelegateForExtensionMethod("glColor3dv", typeof(Color3dv)))) ?? new Color3dv(Imports.Color3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3f(GLfloat red, GLfloat green, GLfloat blue);
+ public static Color3f glColor3f = ((Color3f)(GL.GetDelegateForExtensionMethod("glColor3f", typeof(Color3f)))) ?? new Color3f(Imports.Color3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3fv(System.IntPtr v);
+ public static Color3fv glColor3fv = ((Color3fv)(GL.GetDelegateForExtensionMethod("glColor3fv", typeof(Color3fv)))) ?? new Color3fv(Imports.Color3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+ public static Color3fVertex3fSUN glColor3fVertex3fSUN = ((Color3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glColor3fVertex3fSUN", typeof(Color3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3fVertex3fvSUN(System.IntPtr c, System.IntPtr v);
+ public static Color3fVertex3fvSUN glColor3fVertex3fvSUN = ((Color3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glColor3fVertex3fvSUN", typeof(Color3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+ public static Color3hNV glColor3hNV = ((Color3hNV)(GL.GetDelegateForExtensionMethod("glColor3hNV", typeof(Color3hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3hvNV(System.IntPtr v);
+ public static Color3hvNV glColor3hvNV = ((Color3hvNV)(GL.GetDelegateForExtensionMethod("glColor3hvNV", typeof(Color3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3i(GLint red, GLint green, GLint blue);
+ public static Color3i glColor3i = ((Color3i)(GL.GetDelegateForExtensionMethod("glColor3i", typeof(Color3i)))) ?? new Color3i(Imports.Color3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3iv(System.IntPtr v);
+ public static Color3iv glColor3iv = ((Color3iv)(GL.GetDelegateForExtensionMethod("glColor3iv", typeof(Color3iv)))) ?? new Color3iv(Imports.Color3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3s(GLshort red, GLshort green, GLshort blue);
+ public static Color3s glColor3s = ((Color3s)(GL.GetDelegateForExtensionMethod("glColor3s", typeof(Color3s)))) ?? new Color3s(Imports.Color3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3sv(System.IntPtr v);
+ public static Color3sv glColor3sv = ((Color3sv)(GL.GetDelegateForExtensionMethod("glColor3sv", typeof(Color3sv)))) ?? new Color3sv(Imports.Color3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3ub(GLubyte red, GLubyte green, GLubyte blue);
+ public static Color3ub glColor3ub = ((Color3ub)(GL.GetDelegateForExtensionMethod("glColor3ub", typeof(Color3ub)))) ?? new Color3ub(Imports.Color3ub);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3ubv(System.IntPtr v);
+ public static Color3ubv glColor3ubv = ((Color3ubv)(GL.GetDelegateForExtensionMethod("glColor3ubv", typeof(Color3ubv)))) ?? new Color3ubv(Imports.Color3ubv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3ui(GLuint red, GLuint green, GLuint blue);
+ public static Color3ui glColor3ui = ((Color3ui)(GL.GetDelegateForExtensionMethod("glColor3ui", typeof(Color3ui)))) ?? new Color3ui(Imports.Color3ui);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3uiv(System.IntPtr v);
+ public static Color3uiv glColor3uiv = ((Color3uiv)(GL.GetDelegateForExtensionMethod("glColor3uiv", typeof(Color3uiv)))) ?? new Color3uiv(Imports.Color3uiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3us(GLushort red, GLushort green, GLushort blue);
+ public static Color3us glColor3us = ((Color3us)(GL.GetDelegateForExtensionMethod("glColor3us", typeof(Color3us)))) ?? new Color3us(Imports.Color3us);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color3usv(System.IntPtr v);
+ public static Color3usv glColor3usv = ((Color3usv)(GL.GetDelegateForExtensionMethod("glColor3usv", typeof(Color3usv)))) ?? new Color3usv(Imports.Color3usv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+ public static Color4b glColor4b = ((Color4b)(GL.GetDelegateForExtensionMethod("glColor4b", typeof(Color4b)))) ?? new Color4b(Imports.Color4b);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4bv(System.IntPtr v);
+ public static Color4bv glColor4bv = ((Color4bv)(GL.GetDelegateForExtensionMethod("glColor4bv", typeof(Color4bv)))) ?? new Color4bv(Imports.Color4bv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+ public static Color4d glColor4d = ((Color4d)(GL.GetDelegateForExtensionMethod("glColor4d", typeof(Color4d)))) ?? new Color4d(Imports.Color4d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4dv(System.IntPtr v);
+ public static Color4dv glColor4dv = ((Color4dv)(GL.GetDelegateForExtensionMethod("glColor4dv", typeof(Color4dv)))) ?? new Color4dv(Imports.Color4dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ public static Color4f glColor4f = ((Color4f)(GL.GetDelegateForExtensionMethod("glColor4f", typeof(Color4f)))) ?? new Color4f(Imports.Color4f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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 static Color4fNormal3fVertex3fSUN glColor4fNormal3fVertex3fSUN = ((Color4fNormal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glColor4fNormal3fVertex3fSUN", typeof(Color4fNormal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4fNormal3fVertex3fvSUN(System.IntPtr c, System.IntPtr n, System.IntPtr v);
+ public static Color4fNormal3fVertex3fvSUN glColor4fNormal3fVertex3fvSUN = ((Color4fNormal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glColor4fNormal3fVertex3fvSUN", typeof(Color4fNormal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4fv(System.IntPtr v);
+ public static Color4fv glColor4fv = ((Color4fv)(GL.GetDelegateForExtensionMethod("glColor4fv", typeof(Color4fv)))) ?? new Color4fv(Imports.Color4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha);
+ public static Color4hNV glColor4hNV = ((Color4hNV)(GL.GetDelegateForExtensionMethod("glColor4hNV", typeof(Color4hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4hvNV(System.IntPtr v);
+ public static Color4hvNV glColor4hvNV = ((Color4hvNV)(GL.GetDelegateForExtensionMethod("glColor4hvNV", typeof(Color4hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4i(GLint red, GLint green, GLint blue, GLint alpha);
+ public static Color4i glColor4i = ((Color4i)(GL.GetDelegateForExtensionMethod("glColor4i", typeof(Color4i)))) ?? new Color4i(Imports.Color4i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4iv(System.IntPtr v);
+ public static Color4iv glColor4iv = ((Color4iv)(GL.GetDelegateForExtensionMethod("glColor4iv", typeof(Color4iv)))) ?? new Color4iv(Imports.Color4iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+ public static Color4s glColor4s = ((Color4s)(GL.GetDelegateForExtensionMethod("glColor4s", typeof(Color4s)))) ?? new Color4s(Imports.Color4s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4sv(System.IntPtr v);
+ public static Color4sv glColor4sv = ((Color4sv)(GL.GetDelegateForExtensionMethod("glColor4sv", typeof(Color4sv)))) ?? new Color4sv(Imports.Color4sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+ public static Color4ub glColor4ub = ((Color4ub)(GL.GetDelegateForExtensionMethod("glColor4ub", typeof(Color4ub)))) ?? new Color4ub(Imports.Color4ub);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4ubv(System.IntPtr v);
+ public static Color4ubv glColor4ubv = ((Color4ubv)(GL.GetDelegateForExtensionMethod("glColor4ubv", typeof(Color4ubv)))) ?? new Color4ubv(Imports.Color4ubv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y);
+ public static Color4ubVertex2fSUN glColor4ubVertex2fSUN = ((Color4ubVertex2fSUN)(GL.GetDelegateForExtensionMethod("glColor4ubVertex2fSUN", typeof(Color4ubVertex2fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4ubVertex2fvSUN(System.IntPtr c, System.IntPtr v);
+ public static Color4ubVertex2fvSUN glColor4ubVertex2fvSUN = ((Color4ubVertex2fvSUN)(GL.GetDelegateForExtensionMethod("glColor4ubVertex2fvSUN", typeof(Color4ubVertex2fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+ public static Color4ubVertex3fSUN glColor4ubVertex3fSUN = ((Color4ubVertex3fSUN)(GL.GetDelegateForExtensionMethod("glColor4ubVertex3fSUN", typeof(Color4ubVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4ubVertex3fvSUN(System.IntPtr c, System.IntPtr v);
+ public static Color4ubVertex3fvSUN glColor4ubVertex3fvSUN = ((Color4ubVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glColor4ubVertex3fvSUN", typeof(Color4ubVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+ public static Color4ui glColor4ui = ((Color4ui)(GL.GetDelegateForExtensionMethod("glColor4ui", typeof(Color4ui)))) ?? new Color4ui(Imports.Color4ui);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4uiv(System.IntPtr v);
+ public static Color4uiv glColor4uiv = ((Color4uiv)(GL.GetDelegateForExtensionMethod("glColor4uiv", typeof(Color4uiv)))) ?? new Color4uiv(Imports.Color4uiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+ public static Color4us glColor4us = ((Color4us)(GL.GetDelegateForExtensionMethod("glColor4us", typeof(Color4us)))) ?? new Color4us(Imports.Color4us);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Color4usv(System.IntPtr v);
+ public static Color4usv glColor4usv = ((Color4usv)(GL.GetDelegateForExtensionMethod("glColor4usv", typeof(Color4usv)))) ?? new Color4usv(Imports.Color4usv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorFragmentOp1ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod);
+ public static ColorFragmentOp1ATI glColorFragmentOp1ATI = ((ColorFragmentOp1ATI)(GL.GetDelegateForExtensionMethod("glColorFragmentOp1ATI", typeof(ColorFragmentOp1ATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorFragmentOp2ATI(Enums.ATI_fragment_shader op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod);
+ public static ColorFragmentOp2ATI glColorFragmentOp2ATI = ((ColorFragmentOp2ATI)(GL.GetDelegateForExtensionMethod("glColorFragmentOp2ATI", typeof(ColorFragmentOp2ATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorFragmentOp3ATI(Enums.ATI_fragment_shader 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 static ColorFragmentOp3ATI glColorFragmentOp3ATI = ((ColorFragmentOp3ATI)(GL.GetDelegateForExtensionMethod("glColorFragmentOp3ATI", typeof(ColorFragmentOp3ATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorMask([MarshalAs(UnmanagedType.Bool)] bool red, [MarshalAs(UnmanagedType.Bool)] bool green, [MarshalAs(UnmanagedType.Bool)] bool blue, [MarshalAs(UnmanagedType.Bool)] bool alpha);
+ public static ColorMask glColorMask = ((ColorMask)(GL.GetDelegateForExtensionMethod("glColorMask", typeof(ColorMask)))) ?? new ColorMask(Imports.ColorMask);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorMaskIndexedEXT(GLuint index, [MarshalAs(UnmanagedType.Bool)] bool r, [MarshalAs(UnmanagedType.Bool)] bool g, [MarshalAs(UnmanagedType.Bool)] bool b, [MarshalAs(UnmanagedType.Bool)] bool a);
+ public static ColorMaskIndexedEXT glColorMaskIndexedEXT = ((ColorMaskIndexedEXT)(GL.GetDelegateForExtensionMethod("glColorMaskIndexedEXT", typeof(ColorMaskIndexedEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode);
+ public static ColorMaterial glColorMaterial = ((ColorMaterial)(GL.GetDelegateForExtensionMethod("glColorMaterial", typeof(ColorMaterial)))) ?? new ColorMaterial(Imports.ColorMaterial);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer);
+ public static ColorPointer glColorPointer = ((ColorPointer)(GL.GetDelegateForExtensionMethod("glColorPointer", typeof(ColorPointer)))) ?? new ColorPointer(Imports.ColorPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer);
+ public static ColorPointerEXT glColorPointerEXT = ((ColorPointerEXT)(GL.GetDelegateForExtensionMethod("glColorPointerEXT", typeof(ColorPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorPointerListIBM(GLint size, Enums.ColorPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static ColorPointerListIBM glColorPointerListIBM = ((ColorPointerListIBM)(GL.GetDelegateForExtensionMethod("glColorPointerListIBM", typeof(ColorPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorPointervINTEL(GLint size, Enums.VertexPointerType type, System.IntPtr pointer);
+ public static ColorPointervINTEL glColorPointervINTEL = ((ColorPointervINTEL)(GL.GetDelegateForExtensionMethod("glColorPointervINTEL", typeof(ColorPointervINTEL))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorSubTable(Enums.VERSION_1_2 target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr data);
+ public static ColorSubTable glColorSubTable = ((ColorSubTable)(GL.GetDelegateForExtensionMethod("glColorSubTable", typeof(ColorSubTable)))) ?? new ColorSubTable(Imports.ColorSubTable);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorSubTableEXT(Enums.EXT_color_subtable target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr data);
+ public static ColorSubTableEXT glColorSubTableEXT = ((ColorSubTableEXT)(GL.GetDelegateForExtensionMethod("glColorSubTableEXT", typeof(ColorSubTableEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorTable(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table);
+ public static ColorTable glColorTable = ((ColorTable)(GL.GetDelegateForExtensionMethod("glColorTable", typeof(ColorTable)))) ?? new ColorTable(Imports.ColorTable);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorTableEXT(Enums.EXT_paletted_texture target, Enums.PixelInternalFormat internalFormat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table);
+ public static ColorTableEXT glColorTableEXT = ((ColorTableEXT)(GL.GetDelegateForExtensionMethod("glColorTableEXT", typeof(ColorTableEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ public static ColorTableParameterfv glColorTableParameterfv = ((ColorTableParameterfv)(GL.GetDelegateForExtensionMethod("glColorTableParameterfv", typeof(ColorTableParameterfv)))) ?? new ColorTableParameterfv(Imports.ColorTableParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, System.IntPtr @params);
+ public static ColorTableParameterfvSGI glColorTableParameterfvSGI = ((ColorTableParameterfvSGI)(GL.GetDelegateForExtensionMethod("glColorTableParameterfvSGI", typeof(ColorTableParameterfvSGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ public static ColorTableParameteriv glColorTableParameteriv = ((ColorTableParameteriv)(GL.GetDelegateForExtensionMethod("glColorTableParameteriv", typeof(ColorTableParameteriv)))) ?? new ColorTableParameteriv(Imports.ColorTableParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.ColorTableParameterPNameSGI pname, System.IntPtr @params);
+ public static ColorTableParameterivSGI glColorTableParameterivSGI = ((ColorTableParameterivSGI)(GL.GetDelegateForExtensionMethod("glColorTableParameterivSGI", typeof(ColorTableParameterivSGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table);
+ public static ColorTableSGI glColorTableSGI = ((ColorTableSGI)(GL.GetDelegateForExtensionMethod("glColorTableSGI", typeof(ColorTableSGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CombinerInputNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners input, Enums.NV_register_combiners mapping, Enums.NV_register_combiners componentUsage);
+ public static CombinerInputNV glCombinerInputNV = ((CombinerInputNV)(GL.GetDelegateForExtensionMethod("glCombinerInputNV", typeof(CombinerInputNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CombinerOutputNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners abOutput, Enums.NV_register_combiners cdOutput, Enums.NV_register_combiners sumOutput, Enums.NV_register_combiners scale, Enums.NV_register_combiners bias, [MarshalAs(UnmanagedType.Bool)] bool abDotProduct, [MarshalAs(UnmanagedType.Bool)] bool cdDotProduct, [MarshalAs(UnmanagedType.Bool)] bool muxSum);
+ public static CombinerOutputNV glCombinerOutputNV = ((CombinerOutputNV)(GL.GetDelegateForExtensionMethod("glCombinerOutputNV", typeof(CombinerOutputNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CombinerParameterfNV(Enums.NV_register_combiners pname, GLfloat param);
+ public static CombinerParameterfNV glCombinerParameterfNV = ((CombinerParameterfNV)(GL.GetDelegateForExtensionMethod("glCombinerParameterfNV", typeof(CombinerParameterfNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CombinerParameterfvNV(Enums.NV_register_combiners pname, System.IntPtr @params);
+ public static CombinerParameterfvNV glCombinerParameterfvNV = ((CombinerParameterfvNV)(GL.GetDelegateForExtensionMethod("glCombinerParameterfvNV", typeof(CombinerParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CombinerParameteriNV(Enums.NV_register_combiners pname, GLint param);
+ public static CombinerParameteriNV glCombinerParameteriNV = ((CombinerParameteriNV)(GL.GetDelegateForExtensionMethod("glCombinerParameteriNV", typeof(CombinerParameteriNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CombinerParameterivNV(Enums.NV_register_combiners pname, System.IntPtr @params);
+ public static CombinerParameterivNV glCombinerParameterivNV = ((CombinerParameterivNV)(GL.GetDelegateForExtensionMethod("glCombinerParameterivNV", typeof(CombinerParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, System.IntPtr @params);
+ public static CombinerStageParameterfvNV glCombinerStageParameterfvNV = ((CombinerStageParameterfvNV)(GL.GetDelegateForExtensionMethod("glCombinerStageParameterfvNV", typeof(CombinerStageParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompileShader(GLuint shader);
+ public static CompileShader glCompileShader = ((CompileShader)(GL.GetDelegateForExtensionMethod("glCompileShader", typeof(CompileShader)))) ?? new CompileShader(Imports.CompileShader);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompileShaderARB(GLhandleARB shaderObj);
+ public static CompileShaderARB glCompileShaderARB = ((CompileShaderARB)(GL.GetDelegateForExtensionMethod("glCompileShaderARB", typeof(CompileShaderARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexImage1D glCompressedTexImage1D = ((CompressedTexImage1D)(GL.GetDelegateForExtensionMethod("glCompressedTexImage1D", typeof(CompressedTexImage1D)))) ?? new CompressedTexImage1D(Imports.CompressedTexImage1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexImage1DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexImage1DARB glCompressedTexImage1DARB = ((CompressedTexImage1DARB)(GL.GetDelegateForExtensionMethod("glCompressedTexImage1DARB", typeof(CompressedTexImage1DARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexImage2D glCompressedTexImage2D = ((CompressedTexImage2D)(GL.GetDelegateForExtensionMethod("glCompressedTexImage2D", typeof(CompressedTexImage2D)))) ?? new CompressedTexImage2D(Imports.CompressedTexImage2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexImage2DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexImage2DARB glCompressedTexImage2DARB = ((CompressedTexImage2DARB)(GL.GetDelegateForExtensionMethod("glCompressedTexImage2DARB", typeof(CompressedTexImage2DARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexImage3D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexImage3D glCompressedTexImage3D = ((CompressedTexImage3D)(GL.GetDelegateForExtensionMethod("glCompressedTexImage3D", typeof(CompressedTexImage3D)))) ?? new CompressedTexImage3D(Imports.CompressedTexImage3D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexImage3DARB(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexImage3DARB glCompressedTexImage3DARB = ((CompressedTexImage3DARB)(GL.GetDelegateForExtensionMethod("glCompressedTexImage3DARB", typeof(CompressedTexImage3DARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexSubImage1D glCompressedTexSubImage1D = ((CompressedTexSubImage1D)(GL.GetDelegateForExtensionMethod("glCompressedTexSubImage1D", typeof(CompressedTexSubImage1D)))) ?? new CompressedTexSubImage1D(Imports.CompressedTexSubImage1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexSubImage1DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexSubImage1DARB glCompressedTexSubImage1DARB = ((CompressedTexSubImage1DARB)(GL.GetDelegateForExtensionMethod("glCompressedTexSubImage1DARB", typeof(CompressedTexSubImage1DARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexSubImage2D glCompressedTexSubImage2D = ((CompressedTexSubImage2D)(GL.GetDelegateForExtensionMethod("glCompressedTexSubImage2D", typeof(CompressedTexSubImage2D)))) ?? new CompressedTexSubImage2D(Imports.CompressedTexSubImage2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CompressedTexSubImage2DARB(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data);
+ public static CompressedTexSubImage2DARB glCompressedTexSubImage2DARB = ((CompressedTexSubImage2DARB)(GL.GetDelegateForExtensionMethod("glCompressedTexSubImage2DARB", typeof(CompressedTexSubImage2DARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr data);
+ public static CompressedTexSubImage3D glCompressedTexSubImage3D = ((CompressedTexSubImage3D)(GL.GetDelegateForExtensionMethod("glCompressedTexSubImage3D", typeof(CompressedTexSubImage3D)))) ?? new CompressedTexSubImage3D(Imports.CompressedTexSubImage3D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr data);
+ public static CompressedTexSubImage3DARB glCompressedTexSubImage3DARB = ((CompressedTexSubImage3DARB)(GL.GetDelegateForExtensionMethod("glCompressedTexSubImage3DARB", typeof(CompressedTexSubImage3DARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionFilter1D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image);
+ public static ConvolutionFilter1D glConvolutionFilter1D = ((ConvolutionFilter1D)(GL.GetDelegateForExtensionMethod("glConvolutionFilter1D", typeof(ConvolutionFilter1D)))) ?? new ConvolutionFilter1D(Imports.ConvolutionFilter1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image);
+ public static ConvolutionFilter1DEXT glConvolutionFilter1DEXT = ((ConvolutionFilter1DEXT)(GL.GetDelegateForExtensionMethod("glConvolutionFilter1DEXT", typeof(ConvolutionFilter1DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image);
+ public static ConvolutionFilter2D glConvolutionFilter2D = ((ConvolutionFilter2D)(GL.GetDelegateForExtensionMethod("glConvolutionFilter2D", typeof(ConvolutionFilter2D)))) ?? new ConvolutionFilter2D(Imports.ConvolutionFilter2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image);
+ public static ConvolutionFilter2DEXT glConvolutionFilter2DEXT = ((ConvolutionFilter2DEXT)(GL.GetDelegateForExtensionMethod("glConvolutionFilter2DEXT", typeof(ConvolutionFilter2DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameterf(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat @params);
+ public static ConvolutionParameterf glConvolutionParameterf = ((ConvolutionParameterf)(GL.GetDelegateForExtensionMethod("glConvolutionParameterf", typeof(ConvolutionParameterf)))) ?? new ConvolutionParameterf(Imports.ConvolutionParameterf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameterfEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLfloat @params);
+ public static ConvolutionParameterfEXT glConvolutionParameterfEXT = ((ConvolutionParameterfEXT)(GL.GetDelegateForExtensionMethod("glConvolutionParameterfEXT", typeof(ConvolutionParameterfEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ public static ConvolutionParameterfv glConvolutionParameterfv = ((ConvolutionParameterfv)(GL.GetDelegateForExtensionMethod("glConvolutionParameterfv", typeof(ConvolutionParameterfv)))) ?? new ConvolutionParameterfv(Imports.ConvolutionParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, System.IntPtr @params);
+ public static ConvolutionParameterfvEXT glConvolutionParameterfvEXT = ((ConvolutionParameterfvEXT)(GL.GetDelegateForExtensionMethod("glConvolutionParameterfvEXT", typeof(ConvolutionParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameteri(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint @params);
+ public static ConvolutionParameteri glConvolutionParameteri = ((ConvolutionParameteri)(GL.GetDelegateForExtensionMethod("glConvolutionParameteri", typeof(ConvolutionParameteri)))) ?? new ConvolutionParameteri(Imports.ConvolutionParameteri);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameteriEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, GLint @params);
+ public static ConvolutionParameteriEXT glConvolutionParameteriEXT = ((ConvolutionParameteriEXT)(GL.GetDelegateForExtensionMethod("glConvolutionParameteriEXT", typeof(ConvolutionParameteriEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ public static ConvolutionParameteriv glConvolutionParameteriv = ((ConvolutionParameteriv)(GL.GetDelegateForExtensionMethod("glConvolutionParameteriv", typeof(ConvolutionParameteriv)))) ?? new ConvolutionParameteriv(Imports.ConvolutionParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, System.IntPtr @params);
+ public static ConvolutionParameterivEXT glConvolutionParameterivEXT = ((ConvolutionParameterivEXT)(GL.GetDelegateForExtensionMethod("glConvolutionParameterivEXT", typeof(ConvolutionParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyColorSubTable(Enums.VERSION_1_2 target, GLsizei start, GLint x, GLint y, GLsizei width);
+ public static CopyColorSubTable glCopyColorSubTable = ((CopyColorSubTable)(GL.GetDelegateForExtensionMethod("glCopyColorSubTable", typeof(CopyColorSubTable)))) ?? new CopyColorSubTable(Imports.CopyColorSubTable);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyColorSubTableEXT(Enums.EXT_color_subtable target, GLsizei start, GLint x, GLint y, GLsizei width);
+ public static CopyColorSubTableEXT glCopyColorSubTableEXT = ((CopyColorSubTableEXT)(GL.GetDelegateForExtensionMethod("glCopyColorSubTableEXT", typeof(CopyColorSubTableEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyColorTable(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+ public static CopyColorTable glCopyColorTable = ((CopyColorTable)(GL.GetDelegateForExtensionMethod("glCopyColorTable", typeof(CopyColorTable)))) ?? new CopyColorTable(Imports.CopyColorTable);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+ public static CopyColorTableSGI glCopyColorTableSGI = ((CopyColorTableSGI)(GL.GetDelegateForExtensionMethod("glCopyColorTableSGI", typeof(CopyColorTableSGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyConvolutionFilter1D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+ public static CopyConvolutionFilter1D glCopyConvolutionFilter1D = ((CopyConvolutionFilter1D)(GL.GetDelegateForExtensionMethod("glCopyConvolutionFilter1D", typeof(CopyConvolutionFilter1D)))) ?? new CopyConvolutionFilter1D(Imports.CopyConvolutionFilter1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyConvolutionFilter1DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+ public static CopyConvolutionFilter1DEXT glCopyConvolutionFilter1DEXT = ((CopyConvolutionFilter1DEXT)(GL.GetDelegateForExtensionMethod("glCopyConvolutionFilter1DEXT", typeof(CopyConvolutionFilter1DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyConvolutionFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+ public static CopyConvolutionFilter2D glCopyConvolutionFilter2D = ((CopyConvolutionFilter2D)(GL.GetDelegateForExtensionMethod("glCopyConvolutionFilter2D", typeof(CopyConvolutionFilter2D)))) ?? new CopyConvolutionFilter2D(Imports.CopyConvolutionFilter2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyConvolutionFilter2DEXT(Enums.ConvolutionTargetEXT target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+ public static CopyConvolutionFilter2DEXT glCopyConvolutionFilter2DEXT = ((CopyConvolutionFilter2DEXT)(GL.GetDelegateForExtensionMethod("glCopyConvolutionFilter2DEXT", typeof(CopyConvolutionFilter2DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelCopyType type);
+ public static CopyPixels glCopyPixels = ((CopyPixels)(GL.GetDelegateForExtensionMethod("glCopyPixels", typeof(CopyPixels)))) ?? new CopyPixels(Imports.CopyPixels);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border);
+ public static CopyTexImage1D glCopyTexImage1D = ((CopyTexImage1D)(GL.GetDelegateForExtensionMethod("glCopyTexImage1D", typeof(CopyTexImage1D)))) ?? new CopyTexImage1D(Imports.CopyTexImage1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexImage1DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border);
+ public static CopyTexImage1DEXT glCopyTexImage1DEXT = ((CopyTexImage1DEXT)(GL.GetDelegateForExtensionMethod("glCopyTexImage1DEXT", typeof(CopyTexImage1DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+ public static CopyTexImage2D glCopyTexImage2D = ((CopyTexImage2D)(GL.GetDelegateForExtensionMethod("glCopyTexImage2D", typeof(CopyTexImage2D)))) ?? new CopyTexImage2D(Imports.CopyTexImage2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexImage2DEXT(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+ public static CopyTexImage2DEXT glCopyTexImage2DEXT = ((CopyTexImage2DEXT)(GL.GetDelegateForExtensionMethod("glCopyTexImage2DEXT", typeof(CopyTexImage2DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+ public static CopyTexSubImage1D glCopyTexSubImage1D = ((CopyTexSubImage1D)(GL.GetDelegateForExtensionMethod("glCopyTexSubImage1D", typeof(CopyTexSubImage1D)))) ?? new CopyTexSubImage1D(Imports.CopyTexSubImage1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+ public static CopyTexSubImage1DEXT glCopyTexSubImage1DEXT = ((CopyTexSubImage1DEXT)(GL.GetDelegateForExtensionMethod("glCopyTexSubImage1DEXT", typeof(CopyTexSubImage1DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ public static CopyTexSubImage2D glCopyTexSubImage2D = ((CopyTexSubImage2D)(GL.GetDelegateForExtensionMethod("glCopyTexSubImage2D", typeof(CopyTexSubImage2D)))) ?? new CopyTexSubImage2D(Imports.CopyTexSubImage2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ public static CopyTexSubImage2DEXT glCopyTexSubImage2DEXT = ((CopyTexSubImage2DEXT)(GL.GetDelegateForExtensionMethod("glCopyTexSubImage2DEXT", typeof(CopyTexSubImage2DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ public static CopyTexSubImage3D glCopyTexSubImage3D = ((CopyTexSubImage3D)(GL.GetDelegateForExtensionMethod("glCopyTexSubImage3D", typeof(CopyTexSubImage3D)))) ?? new CopyTexSubImage3D(Imports.CopyTexSubImage3D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CopyTexSubImage3DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ public static CopyTexSubImage3DEXT glCopyTexSubImage3DEXT = ((CopyTexSubImage3DEXT)(GL.GetDelegateForExtensionMethod("glCopyTexSubImage3DEXT", typeof(CopyTexSubImage3DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint CreateProgram();
+ public static CreateProgram glCreateProgram = ((CreateProgram)(GL.GetDelegateForExtensionMethod("glCreateProgram", typeof(CreateProgram)))) ?? new CreateProgram(Imports.CreateProgram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLhandleARB CreateProgramObjectARB();
+ public static CreateProgramObjectARB glCreateProgramObjectARB = ((CreateProgramObjectARB)(GL.GetDelegateForExtensionMethod("glCreateProgramObjectARB", typeof(CreateProgramObjectARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint CreateShader(Enums.VERSION_2_0 type);
+ public static CreateShader glCreateShader = ((CreateShader)(GL.GetDelegateForExtensionMethod("glCreateShader", typeof(CreateShader)))) ?? new CreateShader(Imports.CreateShader);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLhandleARB CreateShaderObjectARB(Enums.ARB_shader_objects shaderType);
+ public static CreateShaderObjectARB glCreateShaderObjectARB = ((CreateShaderObjectARB)(GL.GetDelegateForExtensionMethod("glCreateShaderObjectARB", typeof(CreateShaderObjectARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CullFace(Enums.CullFaceMode mode);
+ public static CullFace glCullFace = ((CullFace)(GL.GetDelegateForExtensionMethod("glCullFace", typeof(CullFace)))) ?? new CullFace(Imports.CullFace);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CullParameterdvEXT(Enums.EXT_cull_vertex pname, [In, Out()] System.IntPtr @params);
+ public static CullParameterdvEXT glCullParameterdvEXT = ((CullParameterdvEXT)(GL.GetDelegateForExtensionMethod("glCullParameterdvEXT", typeof(CullParameterdvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CullParameterfvEXT(Enums.EXT_cull_vertex pname, [In, Out()] System.IntPtr @params);
+ public static CullParameterfvEXT glCullParameterfvEXT = ((CullParameterfvEXT)(GL.GetDelegateForExtensionMethod("glCullParameterfvEXT", typeof(CullParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void CurrentPaletteMatrixARB(GLint index);
+ public static CurrentPaletteMatrixARB glCurrentPaletteMatrixARB = ((CurrentPaletteMatrixARB)(GL.GetDelegateForExtensionMethod("glCurrentPaletteMatrixARB", typeof(CurrentPaletteMatrixARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr points);
+ public static DeformationMap3dSGIX glDeformationMap3dSGIX = ((DeformationMap3dSGIX)(GL.GetDelegateForExtensionMethod("glDeformationMap3dSGIX", typeof(DeformationMap3dSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr points);
+ public static DeformationMap3fSGIX glDeformationMap3fSGIX = ((DeformationMap3fSGIX)(GL.GetDelegateForExtensionMethod("glDeformationMap3fSGIX", typeof(DeformationMap3fSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeformSGIX(Enums.FfdMaskSGIX mask);
+ public static DeformSGIX glDeformSGIX = ((DeformSGIX)(GL.GetDelegateForExtensionMethod("glDeformSGIX", typeof(DeformSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteAsyncMarkersSGIX(GLuint marker, GLsizei range);
+ public static DeleteAsyncMarkersSGIX glDeleteAsyncMarkersSGIX = ((DeleteAsyncMarkersSGIX)(GL.GetDelegateForExtensionMethod("glDeleteAsyncMarkersSGIX", typeof(DeleteAsyncMarkersSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteBuffers(GLsizei n, System.IntPtr buffers);
+ public static DeleteBuffers glDeleteBuffers = ((DeleteBuffers)(GL.GetDelegateForExtensionMethod("glDeleteBuffers", typeof(DeleteBuffers)))) ?? new DeleteBuffers(Imports.DeleteBuffers);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteBuffersARB(GLsizei n, System.IntPtr buffers);
+ public static DeleteBuffersARB glDeleteBuffersARB = ((DeleteBuffersARB)(GL.GetDelegateForExtensionMethod("glDeleteBuffersARB", typeof(DeleteBuffersARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteFencesAPPLE(GLsizei n, System.IntPtr fences);
+ public static DeleteFencesAPPLE glDeleteFencesAPPLE = ((DeleteFencesAPPLE)(GL.GetDelegateForExtensionMethod("glDeleteFencesAPPLE", typeof(DeleteFencesAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteFencesNV(GLsizei n, System.IntPtr fences);
+ public static DeleteFencesNV glDeleteFencesNV = ((DeleteFencesNV)(GL.GetDelegateForExtensionMethod("glDeleteFencesNV", typeof(DeleteFencesNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteFragmentShaderATI(GLuint id);
+ public static DeleteFragmentShaderATI glDeleteFragmentShaderATI = ((DeleteFragmentShaderATI)(GL.GetDelegateForExtensionMethod("glDeleteFragmentShaderATI", typeof(DeleteFragmentShaderATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteFramebuffersEXT(GLsizei n, System.IntPtr framebuffers);
+ public static DeleteFramebuffersEXT glDeleteFramebuffersEXT = ((DeleteFramebuffersEXT)(GL.GetDelegateForExtensionMethod("glDeleteFramebuffersEXT", typeof(DeleteFramebuffersEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteLists(GLuint list, GLsizei range);
+ public static DeleteLists glDeleteLists = ((DeleteLists)(GL.GetDelegateForExtensionMethod("glDeleteLists", typeof(DeleteLists)))) ?? new DeleteLists(Imports.DeleteLists);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteObjectARB(GLhandleARB obj);
+ public static DeleteObjectARB glDeleteObjectARB = ((DeleteObjectARB)(GL.GetDelegateForExtensionMethod("glDeleteObjectARB", typeof(DeleteObjectARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteOcclusionQueriesNV(GLsizei n, System.IntPtr ids);
+ public static DeleteOcclusionQueriesNV glDeleteOcclusionQueriesNV = ((DeleteOcclusionQueriesNV)(GL.GetDelegateForExtensionMethod("glDeleteOcclusionQueriesNV", typeof(DeleteOcclusionQueriesNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteProgram(GLuint program);
+ public static DeleteProgram glDeleteProgram = ((DeleteProgram)(GL.GetDelegateForExtensionMethod("glDeleteProgram", typeof(DeleteProgram)))) ?? new DeleteProgram(Imports.DeleteProgram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteProgramsARB(GLsizei n, System.IntPtr programs);
+ public static DeleteProgramsARB glDeleteProgramsARB = ((DeleteProgramsARB)(GL.GetDelegateForExtensionMethod("glDeleteProgramsARB", typeof(DeleteProgramsARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteProgramsNV(GLsizei n, System.IntPtr programs);
+ public static DeleteProgramsNV glDeleteProgramsNV = ((DeleteProgramsNV)(GL.GetDelegateForExtensionMethod("glDeleteProgramsNV", typeof(DeleteProgramsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteQueries(GLsizei n, System.IntPtr ids);
+ public static DeleteQueries glDeleteQueries = ((DeleteQueries)(GL.GetDelegateForExtensionMethod("glDeleteQueries", typeof(DeleteQueries)))) ?? new DeleteQueries(Imports.DeleteQueries);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteQueriesARB(GLsizei n, System.IntPtr ids);
+ public static DeleteQueriesARB glDeleteQueriesARB = ((DeleteQueriesARB)(GL.GetDelegateForExtensionMethod("glDeleteQueriesARB", typeof(DeleteQueriesARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteRenderbuffersEXT(GLsizei n, System.IntPtr renderbuffers);
+ public static DeleteRenderbuffersEXT glDeleteRenderbuffersEXT = ((DeleteRenderbuffersEXT)(GL.GetDelegateForExtensionMethod("glDeleteRenderbuffersEXT", typeof(DeleteRenderbuffersEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteShader(GLuint shader);
+ public static DeleteShader glDeleteShader = ((DeleteShader)(GL.GetDelegateForExtensionMethod("glDeleteShader", typeof(DeleteShader)))) ?? new DeleteShader(Imports.DeleteShader);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteTextures(GLsizei n, System.IntPtr textures);
+ public static DeleteTextures glDeleteTextures = ((DeleteTextures)(GL.GetDelegateForExtensionMethod("glDeleteTextures", typeof(DeleteTextures)))) ?? new DeleteTextures(Imports.DeleteTextures);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteTexturesEXT(GLsizei n, System.IntPtr textures);
+ public static DeleteTexturesEXT glDeleteTexturesEXT = ((DeleteTexturesEXT)(GL.GetDelegateForExtensionMethod("glDeleteTexturesEXT", typeof(DeleteTexturesEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteVertexArraysAPPLE(GLsizei n, System.IntPtr arrays);
+ public static DeleteVertexArraysAPPLE glDeleteVertexArraysAPPLE = ((DeleteVertexArraysAPPLE)(GL.GetDelegateForExtensionMethod("glDeleteVertexArraysAPPLE", typeof(DeleteVertexArraysAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DeleteVertexShaderEXT(GLuint id);
+ public static DeleteVertexShaderEXT glDeleteVertexShaderEXT = ((DeleteVertexShaderEXT)(GL.GetDelegateForExtensionMethod("glDeleteVertexShaderEXT", typeof(DeleteVertexShaderEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DepthBoundsdNV(GLdouble zmin, GLdouble zmax);
+ public static DepthBoundsdNV glDepthBoundsdNV = ((DepthBoundsdNV)(GL.GetDelegateForExtensionMethod("glDepthBoundsdNV", typeof(DepthBoundsdNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DepthBoundsEXT(GLclampd zmin, GLclampd zmax);
+ public static DepthBoundsEXT glDepthBoundsEXT = ((DepthBoundsEXT)(GL.GetDelegateForExtensionMethod("glDepthBoundsEXT", typeof(DepthBoundsEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DepthFunc(Enums.DepthFunction func);
+ public static DepthFunc glDepthFunc = ((DepthFunc)(GL.GetDelegateForExtensionMethod("glDepthFunc", typeof(DepthFunc)))) ?? new DepthFunc(Imports.DepthFunc);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DepthMask([MarshalAs(UnmanagedType.Bool)] bool flag);
+ public static DepthMask glDepthMask = ((DepthMask)(GL.GetDelegateForExtensionMethod("glDepthMask", typeof(DepthMask)))) ?? new DepthMask(Imports.DepthMask);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DepthRange(GLclampd near, GLclampd far);
+ public static DepthRange glDepthRange = ((DepthRange)(GL.GetDelegateForExtensionMethod("glDepthRange", typeof(DepthRange)))) ?? new DepthRange(Imports.DepthRange);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DepthRangedNV(GLdouble zNear, GLdouble zFar);
+ public static DepthRangedNV glDepthRangedNV = ((DepthRangedNV)(GL.GetDelegateForExtensionMethod("glDepthRangedNV", typeof(DepthRangedNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj);
+ public static DetachObjectARB glDetachObjectARB = ((DetachObjectARB)(GL.GetDelegateForExtensionMethod("glDetachObjectARB", typeof(DetachObjectARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DetachShader(GLuint program, GLuint shader);
+ public static DetachShader glDetachShader = ((DetachShader)(GL.GetDelegateForExtensionMethod("glDetachShader", typeof(DetachShader)))) ?? new DetachShader(Imports.DetachShader);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DetailTexFuncSGIS(Enums.TextureTarget target, GLsizei n, System.IntPtr points);
+ public static DetailTexFuncSGIS glDetailTexFuncSGIS = ((DetailTexFuncSGIS)(GL.GetDelegateForExtensionMethod("glDetailTexFuncSGIS", typeof(DetailTexFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Disable(Enums.EnableCap cap);
+ public static Disable glDisable = ((Disable)(GL.GetDelegateForExtensionMethod("glDisable", typeof(Disable)))) ?? new Disable(Imports.Disable);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DisableClientState(Enums.EnableCap array);
+ public static DisableClientState glDisableClientState = ((DisableClientState)(GL.GetDelegateForExtensionMethod("glDisableClientState", typeof(DisableClientState)))) ?? new DisableClientState(Imports.DisableClientState);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DisableIndexedEXT(Enums.GLenum target, GLuint index);
+ public static DisableIndexedEXT glDisableIndexedEXT = ((DisableIndexedEXT)(GL.GetDelegateForExtensionMethod("glDisableIndexedEXT", typeof(DisableIndexedEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DisableVariantClientStateEXT(GLuint id);
+ public static DisableVariantClientStateEXT glDisableVariantClientStateEXT = ((DisableVariantClientStateEXT)(GL.GetDelegateForExtensionMethod("glDisableVariantClientStateEXT", typeof(DisableVariantClientStateEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DisableVertexAttribArray(GLuint index);
+ public static DisableVertexAttribArray glDisableVertexAttribArray = ((DisableVertexAttribArray)(GL.GetDelegateForExtensionMethod("glDisableVertexAttribArray", typeof(DisableVertexAttribArray)))) ?? new DisableVertexAttribArray(Imports.DisableVertexAttribArray);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DisableVertexAttribArrayARB(GLuint index);
+ public static DisableVertexAttribArrayARB glDisableVertexAttribArrayARB = ((DisableVertexAttribArrayARB)(GL.GetDelegateForExtensionMethod("glDisableVertexAttribArrayARB", typeof(DisableVertexAttribArrayARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawArrays(Enums.BeginMode mode, GLint first, GLsizei count);
+ public static DrawArrays glDrawArrays = ((DrawArrays)(GL.GetDelegateForExtensionMethod("glDrawArrays", typeof(DrawArrays)))) ?? new DrawArrays(Imports.DrawArrays);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawArraysEXT(Enums.BeginMode mode, GLint first, GLsizei count);
+ public static DrawArraysEXT glDrawArraysEXT = ((DrawArraysEXT)(GL.GetDelegateForExtensionMethod("glDrawArraysEXT", typeof(DrawArraysEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawArraysInstancedEXT(Enums.BeginMode mode, GLint start, GLsizei count, GLsizei primcount);
+ public static DrawArraysInstancedEXT glDrawArraysInstancedEXT = ((DrawArraysInstancedEXT)(GL.GetDelegateForExtensionMethod("glDrawArraysInstancedEXT", typeof(DrawArraysInstancedEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawBuffer(Enums.DrawBufferMode mode);
+ public static DrawBuffer glDrawBuffer = ((DrawBuffer)(GL.GetDelegateForExtensionMethod("glDrawBuffer", typeof(DrawBuffer)))) ?? new DrawBuffer(Imports.DrawBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawBuffers(GLsizei n, System.IntPtr bufs);
+ public static DrawBuffers glDrawBuffers = ((DrawBuffers)(GL.GetDelegateForExtensionMethod("glDrawBuffers", typeof(DrawBuffers)))) ?? new DrawBuffers(Imports.DrawBuffers);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawBuffersARB(GLsizei n, System.IntPtr bufs);
+ public static DrawBuffersARB glDrawBuffersARB = ((DrawBuffersARB)(GL.GetDelegateForExtensionMethod("glDrawBuffersARB", typeof(DrawBuffersARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawBuffersATI(GLsizei n, System.IntPtr bufs);
+ public static DrawBuffersATI glDrawBuffersATI = ((DrawBuffersATI)(GL.GetDelegateForExtensionMethod("glDrawBuffersATI", typeof(DrawBuffersATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawElementArrayAPPLE(Enums.BeginMode mode, GLint first, GLsizei count);
+ public static DrawElementArrayAPPLE glDrawElementArrayAPPLE = ((DrawElementArrayAPPLE)(GL.GetDelegateForExtensionMethod("glDrawElementArrayAPPLE", typeof(DrawElementArrayAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawElementArrayATI(Enums.BeginMode mode, GLsizei count);
+ public static DrawElementArrayATI glDrawElementArrayATI = ((DrawElementArrayATI)(GL.GetDelegateForExtensionMethod("glDrawElementArrayATI", typeof(DrawElementArrayATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawElements(Enums.BeginMode mode, GLsizei count, Enums.GLenum type, System.IntPtr indices);
+ public static DrawElements glDrawElements = ((DrawElements)(GL.GetDelegateForExtensionMethod("glDrawElements", typeof(DrawElements)))) ?? new DrawElements(Imports.DrawElements);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawElementsInstancedEXT(Enums.BeginMode mode, GLsizei count, Enums.EXT_draw_instanced type, System.IntPtr indices, GLsizei primcount);
+ public static DrawElementsInstancedEXT glDrawElementsInstancedEXT = ((DrawElementsInstancedEXT)(GL.GetDelegateForExtensionMethod("glDrawElementsInstancedEXT", typeof(DrawElementsInstancedEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawMeshArraysSUN(Enums.BeginMode mode, GLint first, GLsizei count, GLsizei width);
+ public static DrawMeshArraysSUN glDrawMeshArraysSUN = ((DrawMeshArraysSUN)(GL.GetDelegateForExtensionMethod("glDrawMeshArraysSUN", typeof(DrawMeshArraysSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawPixels(GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ public static DrawPixels glDrawPixels = ((DrawPixels)(GL.GetDelegateForExtensionMethod("glDrawPixels", typeof(DrawPixels)))) ?? new DrawPixels(Imports.DrawPixels);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, GLint first, GLsizei count);
+ public static DrawRangeElementArrayAPPLE glDrawRangeElementArrayAPPLE = ((DrawRangeElementArrayAPPLE)(GL.GetDelegateForExtensionMethod("glDrawRangeElementArrayAPPLE", typeof(DrawRangeElementArrayAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawRangeElementArrayATI(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count);
+ public static DrawRangeElementArrayATI glDrawRangeElementArrayATI = ((DrawRangeElementArrayATI)(GL.GetDelegateForExtensionMethod("glDrawRangeElementArrayATI", typeof(DrawRangeElementArrayATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawRangeElements(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, Enums.VERSION_1_2 type, System.IntPtr indices);
+ public static DrawRangeElements glDrawRangeElements = ((DrawRangeElements)(GL.GetDelegateForExtensionMethod("glDrawRangeElements", typeof(DrawRangeElements)))) ?? new DrawRangeElements(Imports.DrawRangeElements);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void DrawRangeElementsEXT(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, Enums.EXT_draw_range_elements type, System.IntPtr indices);
+ public static DrawRangeElementsEXT glDrawRangeElementsEXT = ((DrawRangeElementsEXT)(GL.GetDelegateForExtensionMethod("glDrawRangeElementsEXT", typeof(DrawRangeElementsEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EdgeFlag([MarshalAs(UnmanagedType.Bool)] bool flag);
+ public static EdgeFlag glEdgeFlag = ((EdgeFlag)(GL.GetDelegateForExtensionMethod("glEdgeFlag", typeof(EdgeFlag)))) ?? new EdgeFlag(Imports.EdgeFlag);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EdgeFlagPointer(GLsizei stride, System.IntPtr pointer);
+ public static EdgeFlagPointer glEdgeFlagPointer = ((EdgeFlagPointer)(GL.GetDelegateForExtensionMethod("glEdgeFlagPointer", typeof(EdgeFlagPointer)))) ?? new EdgeFlagPointer(Imports.EdgeFlagPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EdgeFlagPointerEXT(GLsizei stride, GLsizei count, System.IntPtr pointer);
+ public static EdgeFlagPointerEXT glEdgeFlagPointerEXT = ((EdgeFlagPointerEXT)(GL.GetDelegateForExtensionMethod("glEdgeFlagPointerEXT", typeof(EdgeFlagPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EdgeFlagPointerListIBM(GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static EdgeFlagPointerListIBM glEdgeFlagPointerListIBM = ((EdgeFlagPointerListIBM)(GL.GetDelegateForExtensionMethod("glEdgeFlagPointerListIBM", typeof(EdgeFlagPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EdgeFlagv(System.IntPtr flag);
+ public static EdgeFlagv glEdgeFlagv = ((EdgeFlagv)(GL.GetDelegateForExtensionMethod("glEdgeFlagv", typeof(EdgeFlagv)))) ?? new EdgeFlagv(Imports.EdgeFlagv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ElementPointerAPPLE(Enums.APPLE_element_array type, System.IntPtr pointer);
+ public static ElementPointerAPPLE glElementPointerAPPLE = ((ElementPointerAPPLE)(GL.GetDelegateForExtensionMethod("glElementPointerAPPLE", typeof(ElementPointerAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ElementPointerATI(Enums.ATI_element_array type, System.IntPtr pointer);
+ public static ElementPointerATI glElementPointerATI = ((ElementPointerATI)(GL.GetDelegateForExtensionMethod("glElementPointerATI", typeof(ElementPointerATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Enable(Enums.EnableCap cap);
+ public static Enable glEnable = ((Enable)(GL.GetDelegateForExtensionMethod("glEnable", typeof(Enable)))) ?? new Enable(Imports.Enable);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EnableClientState(Enums.EnableCap array);
+ public static EnableClientState glEnableClientState = ((EnableClientState)(GL.GetDelegateForExtensionMethod("glEnableClientState", typeof(EnableClientState)))) ?? new EnableClientState(Imports.EnableClientState);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EnableIndexedEXT(Enums.GLenum target, GLuint index);
+ public static EnableIndexedEXT glEnableIndexedEXT = ((EnableIndexedEXT)(GL.GetDelegateForExtensionMethod("glEnableIndexedEXT", typeof(EnableIndexedEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EnableVariantClientStateEXT(GLuint id);
+ public static EnableVariantClientStateEXT glEnableVariantClientStateEXT = ((EnableVariantClientStateEXT)(GL.GetDelegateForExtensionMethod("glEnableVariantClientStateEXT", typeof(EnableVariantClientStateEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EnableVertexAttribArray(GLuint index);
+ public static EnableVertexAttribArray glEnableVertexAttribArray = ((EnableVertexAttribArray)(GL.GetDelegateForExtensionMethod("glEnableVertexAttribArray", typeof(EnableVertexAttribArray)))) ?? new EnableVertexAttribArray(Imports.EnableVertexAttribArray);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EnableVertexAttribArrayARB(GLuint index);
+ public static EnableVertexAttribArrayARB glEnableVertexAttribArrayARB = ((EnableVertexAttribArrayARB)(GL.GetDelegateForExtensionMethod("glEnableVertexAttribArrayARB", typeof(EnableVertexAttribArrayARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void End();
+ public static End glEnd = ((End)(GL.GetDelegateForExtensionMethod("glEnd", typeof(End)))) ?? new End(Imports.End);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EndFragmentShaderATI();
+ public static EndFragmentShaderATI glEndFragmentShaderATI = ((EndFragmentShaderATI)(GL.GetDelegateForExtensionMethod("glEndFragmentShaderATI", typeof(EndFragmentShaderATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EndList();
+ public static EndList glEndList = ((EndList)(GL.GetDelegateForExtensionMethod("glEndList", typeof(EndList)))) ?? new EndList(Imports.EndList);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EndOcclusionQueryNV();
+ public static EndOcclusionQueryNV glEndOcclusionQueryNV = ((EndOcclusionQueryNV)(GL.GetDelegateForExtensionMethod("glEndOcclusionQueryNV", typeof(EndOcclusionQueryNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EndQuery(Enums.VERSION_1_5 target);
+ public static EndQuery glEndQuery = ((EndQuery)(GL.GetDelegateForExtensionMethod("glEndQuery", typeof(EndQuery)))) ?? new EndQuery(Imports.EndQuery);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EndQueryARB(Enums.ARB_occlusion_query target);
+ public static EndQueryARB glEndQueryARB = ((EndQueryARB)(GL.GetDelegateForExtensionMethod("glEndQueryARB", typeof(EndQueryARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EndTransformFeedbackNV();
+ public static EndTransformFeedbackNV glEndTransformFeedbackNV = ((EndTransformFeedbackNV)(GL.GetDelegateForExtensionMethod("glEndTransformFeedbackNV", typeof(EndTransformFeedbackNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EndVertexShaderEXT();
+ public static EndVertexShaderEXT glEndVertexShaderEXT = ((EndVertexShaderEXT)(GL.GetDelegateForExtensionMethod("glEndVertexShaderEXT", typeof(EndVertexShaderEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord1d(GLdouble u);
+ public static EvalCoord1d glEvalCoord1d = ((EvalCoord1d)(GL.GetDelegateForExtensionMethod("glEvalCoord1d", typeof(EvalCoord1d)))) ?? new EvalCoord1d(Imports.EvalCoord1d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord1dv(System.IntPtr u);
+ public static EvalCoord1dv glEvalCoord1dv = ((EvalCoord1dv)(GL.GetDelegateForExtensionMethod("glEvalCoord1dv", typeof(EvalCoord1dv)))) ?? new EvalCoord1dv(Imports.EvalCoord1dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord1f(GLfloat u);
+ public static EvalCoord1f glEvalCoord1f = ((EvalCoord1f)(GL.GetDelegateForExtensionMethod("glEvalCoord1f", typeof(EvalCoord1f)))) ?? new EvalCoord1f(Imports.EvalCoord1f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord1fv(System.IntPtr u);
+ public static EvalCoord1fv glEvalCoord1fv = ((EvalCoord1fv)(GL.GetDelegateForExtensionMethod("glEvalCoord1fv", typeof(EvalCoord1fv)))) ?? new EvalCoord1fv(Imports.EvalCoord1fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord2d(GLdouble u, GLdouble v);
+ public static EvalCoord2d glEvalCoord2d = ((EvalCoord2d)(GL.GetDelegateForExtensionMethod("glEvalCoord2d", typeof(EvalCoord2d)))) ?? new EvalCoord2d(Imports.EvalCoord2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord2dv(System.IntPtr u);
+ public static EvalCoord2dv glEvalCoord2dv = ((EvalCoord2dv)(GL.GetDelegateForExtensionMethod("glEvalCoord2dv", typeof(EvalCoord2dv)))) ?? new EvalCoord2dv(Imports.EvalCoord2dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord2f(GLfloat u, GLfloat v);
+ public static EvalCoord2f glEvalCoord2f = ((EvalCoord2f)(GL.GetDelegateForExtensionMethod("glEvalCoord2f", typeof(EvalCoord2f)))) ?? new EvalCoord2f(Imports.EvalCoord2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalCoord2fv(System.IntPtr u);
+ public static EvalCoord2fv glEvalCoord2fv = ((EvalCoord2fv)(GL.GetDelegateForExtensionMethod("glEvalCoord2fv", typeof(EvalCoord2fv)))) ?? new EvalCoord2fv(Imports.EvalCoord2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalMapsNV(Enums.NV_evaluators target, Enums.NV_evaluators mode);
+ public static EvalMapsNV glEvalMapsNV = ((EvalMapsNV)(GL.GetDelegateForExtensionMethod("glEvalMapsNV", typeof(EvalMapsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalMesh1(Enums.MeshMode1 mode, GLint i1, GLint i2);
+ public static EvalMesh1 glEvalMesh1 = ((EvalMesh1)(GL.GetDelegateForExtensionMethod("glEvalMesh1", typeof(EvalMesh1)))) ?? new EvalMesh1(Imports.EvalMesh1);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalMesh2(Enums.MeshMode2 mode, GLint i1, GLint i2, GLint j1, GLint j2);
+ public static EvalMesh2 glEvalMesh2 = ((EvalMesh2)(GL.GetDelegateForExtensionMethod("glEvalMesh2", typeof(EvalMesh2)))) ?? new EvalMesh2(Imports.EvalMesh2);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalPoint1(GLint i);
+ public static EvalPoint1 glEvalPoint1 = ((EvalPoint1)(GL.GetDelegateForExtensionMethod("glEvalPoint1", typeof(EvalPoint1)))) ?? new EvalPoint1(Imports.EvalPoint1);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void EvalPoint2(GLint i, GLint j);
+ public static EvalPoint2 glEvalPoint2 = ((EvalPoint2)(GL.GetDelegateForExtensionMethod("glEvalPoint2", typeof(EvalPoint2)))) ?? new EvalPoint2(Imports.EvalPoint2);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ExecuteProgramNV(Enums.NV_vertex_program target, GLuint id, System.IntPtr @params);
+ public static ExecuteProgramNV glExecuteProgramNV = ((ExecuteProgramNV)(GL.GetDelegateForExtensionMethod("glExecuteProgramNV", typeof(ExecuteProgramNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ExtractComponentEXT(GLuint res, GLuint src, GLuint num);
+ public static ExtractComponentEXT glExtractComponentEXT = ((ExtractComponentEXT)(GL.GetDelegateForExtensionMethod("glExtractComponentEXT", typeof(ExtractComponentEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FeedbackBuffer(GLsizei size, Enums.FeedbackType type, [In, Out()] System.IntPtr buffer);
+ public static FeedbackBuffer glFeedbackBuffer = ((FeedbackBuffer)(GL.GetDelegateForExtensionMethod("glFeedbackBuffer", typeof(FeedbackBuffer)))) ?? new FeedbackBuffer(Imports.FeedbackBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FinalCombinerInputNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners input, Enums.NV_register_combiners mapping, Enums.NV_register_combiners componentUsage);
+ public static FinalCombinerInputNV glFinalCombinerInputNV = ((FinalCombinerInputNV)(GL.GetDelegateForExtensionMethod("glFinalCombinerInputNV", typeof(FinalCombinerInputNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Finish();
+ public static Finish glFinish = ((Finish)(GL.GetDelegateForExtensionMethod("glFinish", typeof(Finish)))) ?? new Finish(Imports.Finish);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint FinishAsyncSGIX([In, Out()] System.IntPtr markerp);
+ public static FinishAsyncSGIX glFinishAsyncSGIX = ((FinishAsyncSGIX)(GL.GetDelegateForExtensionMethod("glFinishAsyncSGIX", typeof(FinishAsyncSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FinishFenceAPPLE(GLuint fence);
+ public static FinishFenceAPPLE glFinishFenceAPPLE = ((FinishFenceAPPLE)(GL.GetDelegateForExtensionMethod("glFinishFenceAPPLE", typeof(FinishFenceAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FinishFenceNV(GLuint fence);
+ public static FinishFenceNV glFinishFenceNV = ((FinishFenceNV)(GL.GetDelegateForExtensionMethod("glFinishFenceNV", typeof(FinishFenceNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FinishObjectAPPLE(Enums.APPLE_fence @object, GLint name);
+ public static FinishObjectAPPLE glFinishObjectAPPLE = ((FinishObjectAPPLE)(GL.GetDelegateForExtensionMethod("glFinishObjectAPPLE", typeof(FinishObjectAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FinishTextureSUNX();
+ public static FinishTextureSUNX glFinishTextureSUNX = ((FinishTextureSUNX)(GL.GetDelegateForExtensionMethod("glFinishTextureSUNX", typeof(FinishTextureSUNX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Flush();
+ public static Flush glFlush = ((Flush)(GL.GetDelegateForExtensionMethod("glFlush", typeof(Flush)))) ?? new Flush(Imports.Flush);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FlushMappedBufferRangeAPPLE(Enums.GLenum target, GLintptr offset, GLsizeiptr size);
+ public static FlushMappedBufferRangeAPPLE glFlushMappedBufferRangeAPPLE = ((FlushMappedBufferRangeAPPLE)(GL.GetDelegateForExtensionMethod("glFlushMappedBufferRangeAPPLE", typeof(FlushMappedBufferRangeAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FlushPixelDataRangeNV(Enums.NV_pixel_data_range target);
+ public static FlushPixelDataRangeNV glFlushPixelDataRangeNV = ((FlushPixelDataRangeNV)(GL.GetDelegateForExtensionMethod("glFlushPixelDataRangeNV", typeof(FlushPixelDataRangeNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FlushRasterSGIX();
+ public static FlushRasterSGIX glFlushRasterSGIX = ((FlushRasterSGIX)(GL.GetDelegateForExtensionMethod("glFlushRasterSGIX", typeof(FlushRasterSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FlushVertexArrayRangeAPPLE(GLsizei length, [In, Out()] System.IntPtr pointer);
+ public static FlushVertexArrayRangeAPPLE glFlushVertexArrayRangeAPPLE = ((FlushVertexArrayRangeAPPLE)(GL.GetDelegateForExtensionMethod("glFlushVertexArrayRangeAPPLE", typeof(FlushVertexArrayRangeAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FlushVertexArrayRangeNV();
+ public static FlushVertexArrayRangeNV glFlushVertexArrayRangeNV = ((FlushVertexArrayRangeNV)(GL.GetDelegateForExtensionMethod("glFlushVertexArrayRangeNV", typeof(FlushVertexArrayRangeNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordd(GLdouble coord);
+ public static FogCoordd glFogCoordd = ((FogCoordd)(GL.GetDelegateForExtensionMethod("glFogCoordd", typeof(FogCoordd)))) ?? new FogCoordd(Imports.FogCoordd);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoorddEXT(GLdouble coord);
+ public static FogCoorddEXT glFogCoorddEXT = ((FogCoorddEXT)(GL.GetDelegateForExtensionMethod("glFogCoorddEXT", typeof(FogCoorddEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoorddv(System.IntPtr coord);
+ public static FogCoorddv glFogCoorddv = ((FogCoorddv)(GL.GetDelegateForExtensionMethod("glFogCoorddv", typeof(FogCoorddv)))) ?? new FogCoorddv(Imports.FogCoorddv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoorddvEXT(System.IntPtr coord);
+ public static FogCoorddvEXT glFogCoorddvEXT = ((FogCoorddvEXT)(GL.GetDelegateForExtensionMethod("glFogCoorddvEXT", typeof(FogCoorddvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordf(GLfloat coord);
+ public static FogCoordf glFogCoordf = ((FogCoordf)(GL.GetDelegateForExtensionMethod("glFogCoordf", typeof(FogCoordf)))) ?? new FogCoordf(Imports.FogCoordf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordfEXT(GLfloat coord);
+ public static FogCoordfEXT glFogCoordfEXT = ((FogCoordfEXT)(GL.GetDelegateForExtensionMethod("glFogCoordfEXT", typeof(FogCoordfEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordfv(System.IntPtr coord);
+ public static FogCoordfv glFogCoordfv = ((FogCoordfv)(GL.GetDelegateForExtensionMethod("glFogCoordfv", typeof(FogCoordfv)))) ?? new FogCoordfv(Imports.FogCoordfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordfvEXT(System.IntPtr coord);
+ public static FogCoordfvEXT glFogCoordfvEXT = ((FogCoordfvEXT)(GL.GetDelegateForExtensionMethod("glFogCoordfvEXT", typeof(FogCoordfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordhNV(GLhalfNV fog);
+ public static FogCoordhNV glFogCoordhNV = ((FogCoordhNV)(GL.GetDelegateForExtensionMethod("glFogCoordhNV", typeof(FogCoordhNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordhvNV(System.IntPtr fog);
+ public static FogCoordhvNV glFogCoordhvNV = ((FogCoordhvNV)(GL.GetDelegateForExtensionMethod("glFogCoordhvNV", typeof(FogCoordhvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordPointer(Enums.VERSION_1_4 type, GLsizei stride, System.IntPtr pointer);
+ public static FogCoordPointer glFogCoordPointer = ((FogCoordPointer)(GL.GetDelegateForExtensionMethod("glFogCoordPointer", typeof(FogCoordPointer)))) ?? new FogCoordPointer(Imports.FogCoordPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordPointerEXT(Enums.EXT_fog_coord type, GLsizei stride, System.IntPtr pointer);
+ public static FogCoordPointerEXT glFogCoordPointerEXT = ((FogCoordPointerEXT)(GL.GetDelegateForExtensionMethod("glFogCoordPointerEXT", typeof(FogCoordPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogCoordPointerListIBM(Enums.IBM_vertex_array_lists type, GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static FogCoordPointerListIBM glFogCoordPointerListIBM = ((FogCoordPointerListIBM)(GL.GetDelegateForExtensionMethod("glFogCoordPointerListIBM", typeof(FogCoordPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Fogf(Enums.FogParameter pname, GLfloat param);
+ public static Fogf glFogf = ((Fogf)(GL.GetDelegateForExtensionMethod("glFogf", typeof(Fogf)))) ?? new Fogf(Imports.Fogf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FogFuncSGIS(GLsizei n, System.IntPtr points);
+ public static FogFuncSGIS glFogFuncSGIS = ((FogFuncSGIS)(GL.GetDelegateForExtensionMethod("glFogFuncSGIS", typeof(FogFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Fogfv(Enums.FogParameter pname, System.IntPtr @params);
+ public static Fogfv glFogfv = ((Fogfv)(GL.GetDelegateForExtensionMethod("glFogfv", typeof(Fogfv)))) ?? new Fogfv(Imports.Fogfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Fogi(Enums.FogParameter pname, GLint param);
+ public static Fogi glFogi = ((Fogi)(GL.GetDelegateForExtensionMethod("glFogi", typeof(Fogi)))) ?? new Fogi(Imports.Fogi);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Fogiv(Enums.FogParameter pname, System.IntPtr @params);
+ public static Fogiv glFogiv = ((Fogiv)(GL.GetDelegateForExtensionMethod("glFogiv", typeof(Fogiv)))) ?? new Fogiv(Imports.Fogiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentColorMaterialSGIX(Enums.MaterialFace face, Enums.MaterialParameter mode);
+ public static FragmentColorMaterialSGIX glFragmentColorMaterialSGIX = ((FragmentColorMaterialSGIX)(GL.GetDelegateForExtensionMethod("glFragmentColorMaterialSGIX", typeof(FragmentColorMaterialSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightfSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLfloat param);
+ public static FragmentLightfSGIX glFragmentLightfSGIX = ((FragmentLightfSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightfSGIX", typeof(FragmentLightfSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, System.IntPtr @params);
+ public static FragmentLightfvSGIX glFragmentLightfvSGIX = ((FragmentLightfvSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightfvSGIX", typeof(FragmentLightfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightiSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, GLint param);
+ public static FragmentLightiSGIX glFragmentLightiSGIX = ((FragmentLightiSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightiSGIX", typeof(FragmentLightiSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, System.IntPtr @params);
+ public static FragmentLightivSGIX glFragmentLightivSGIX = ((FragmentLightivSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightivSGIX", typeof(FragmentLightivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightModelfSGIX(Enums.FragmentLightModelParameterSGIX pname, GLfloat param);
+ public static FragmentLightModelfSGIX glFragmentLightModelfSGIX = ((FragmentLightModelfSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightModelfSGIX", typeof(FragmentLightModelfSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightModelfvSGIX(Enums.FragmentLightModelParameterSGIX pname, System.IntPtr @params);
+ public static FragmentLightModelfvSGIX glFragmentLightModelfvSGIX = ((FragmentLightModelfvSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightModelfvSGIX", typeof(FragmentLightModelfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightModeliSGIX(Enums.FragmentLightModelParameterSGIX pname, GLint param);
+ public static FragmentLightModeliSGIX glFragmentLightModeliSGIX = ((FragmentLightModeliSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightModeliSGIX", typeof(FragmentLightModeliSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentLightModelivSGIX(Enums.FragmentLightModelParameterSGIX pname, System.IntPtr @params);
+ public static FragmentLightModelivSGIX glFragmentLightModelivSGIX = ((FragmentLightModelivSGIX)(GL.GetDelegateForExtensionMethod("glFragmentLightModelivSGIX", typeof(FragmentLightModelivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentMaterialfSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param);
+ public static FragmentMaterialfSGIX glFragmentMaterialfSGIX = ((FragmentMaterialfSGIX)(GL.GetDelegateForExtensionMethod("glFragmentMaterialfSGIX", typeof(FragmentMaterialfSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ public static FragmentMaterialfvSGIX glFragmentMaterialfvSGIX = ((FragmentMaterialfvSGIX)(GL.GetDelegateForExtensionMethod("glFragmentMaterialfvSGIX", typeof(FragmentMaterialfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentMaterialiSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param);
+ public static FragmentMaterialiSGIX glFragmentMaterialiSGIX = ((FragmentMaterialiSGIX)(GL.GetDelegateForExtensionMethod("glFragmentMaterialiSGIX", typeof(FragmentMaterialiSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ public static FragmentMaterialivSGIX glFragmentMaterialivSGIX = ((FragmentMaterialivSGIX)(GL.GetDelegateForExtensionMethod("glFragmentMaterialivSGIX", typeof(FragmentMaterialivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FramebufferRenderbufferEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.EXT_framebuffer_object renderbuffertarget, GLuint renderbuffer);
+ public static FramebufferRenderbufferEXT glFramebufferRenderbufferEXT = ((FramebufferRenderbufferEXT)(GL.GetDelegateForExtensionMethod("glFramebufferRenderbufferEXT", typeof(FramebufferRenderbufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FramebufferTexture1DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum textarget, GLuint texture, GLint level);
+ public static FramebufferTexture1DEXT glFramebufferTexture1DEXT = ((FramebufferTexture1DEXT)(GL.GetDelegateForExtensionMethod("glFramebufferTexture1DEXT", typeof(FramebufferTexture1DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FramebufferTexture2DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum textarget, GLuint texture, GLint level);
+ public static FramebufferTexture2DEXT glFramebufferTexture2DEXT = ((FramebufferTexture2DEXT)(GL.GetDelegateForExtensionMethod("glFramebufferTexture2DEXT", typeof(FramebufferTexture2DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FramebufferTexture3DEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum textarget, GLuint texture, GLint level, GLint zoffset);
+ public static FramebufferTexture3DEXT glFramebufferTexture3DEXT = ((FramebufferTexture3DEXT)(GL.GetDelegateForExtensionMethod("glFramebufferTexture3DEXT", typeof(FramebufferTexture3DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FramebufferTextureEXT(Enums.NV_geometry_program4 target, Enums.NV_geometry_program4 attachment, GLuint texture, GLint level);
+ public static FramebufferTextureEXT glFramebufferTextureEXT = ((FramebufferTextureEXT)(GL.GetDelegateForExtensionMethod("glFramebufferTextureEXT", typeof(FramebufferTextureEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FramebufferTextureFaceEXT(Enums.NV_geometry_program4 target, Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, Enums.TextureTarget face);
+ public static FramebufferTextureFaceEXT glFramebufferTextureFaceEXT = ((FramebufferTextureFaceEXT)(GL.GetDelegateForExtensionMethod("glFramebufferTextureFaceEXT", typeof(FramebufferTextureFaceEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FramebufferTextureLayerEXT(Enums.NV_geometry_program4 target, Enums.NV_geometry_program4 attachment, GLuint texture, GLint level, GLint layer);
+ public static FramebufferTextureLayerEXT glFramebufferTextureLayerEXT = ((FramebufferTextureLayerEXT)(GL.GetDelegateForExtensionMethod("glFramebufferTextureLayerEXT", typeof(FramebufferTextureLayerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FrameZoomSGIX(GLint factor);
+ public static FrameZoomSGIX glFrameZoomSGIX = ((FrameZoomSGIX)(GL.GetDelegateForExtensionMethod("glFrameZoomSGIX", typeof(FrameZoomSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FreeObjectBufferATI(GLuint buffer);
+ public static FreeObjectBufferATI glFreeObjectBufferATI = ((FreeObjectBufferATI)(GL.GetDelegateForExtensionMethod("glFreeObjectBufferATI", typeof(FreeObjectBufferATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void FrontFace(Enums.FrontFaceDirection mode);
+ public static FrontFace glFrontFace = ((FrontFace)(GL.GetDelegateForExtensionMethod("glFrontFace", typeof(FrontFace)))) ?? new FrontFace(Imports.FrontFace);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+ public static Frustum glFrustum = ((Frustum)(GL.GetDelegateForExtensionMethod("glFrustum", typeof(Frustum)))) ?? new Frustum(Imports.Frustum);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint GenAsyncMarkersSGIX(GLsizei range);
+ public static GenAsyncMarkersSGIX glGenAsyncMarkersSGIX = ((GenAsyncMarkersSGIX)(GL.GetDelegateForExtensionMethod("glGenAsyncMarkersSGIX", typeof(GenAsyncMarkersSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenBuffers(GLsizei n, [In, Out()] System.IntPtr buffers);
+ public static GenBuffers glGenBuffers = ((GenBuffers)(GL.GetDelegateForExtensionMethod("glGenBuffers", typeof(GenBuffers)))) ?? new GenBuffers(Imports.GenBuffers);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenBuffersARB(GLsizei n, [In, Out()] System.IntPtr buffers);
+ public static GenBuffersARB glGenBuffersARB = ((GenBuffersARB)(GL.GetDelegateForExtensionMethod("glGenBuffersARB", typeof(GenBuffersARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenerateMipmapEXT(Enums.GLenum target);
+ public static GenerateMipmapEXT glGenerateMipmapEXT = ((GenerateMipmapEXT)(GL.GetDelegateForExtensionMethod("glGenerateMipmapEXT", typeof(GenerateMipmapEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenFencesAPPLE(GLsizei n, [In, Out()] System.IntPtr fences);
+ public static GenFencesAPPLE glGenFencesAPPLE = ((GenFencesAPPLE)(GL.GetDelegateForExtensionMethod("glGenFencesAPPLE", typeof(GenFencesAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenFencesNV(GLsizei n, [In, Out()] System.IntPtr fences);
+ public static GenFencesNV glGenFencesNV = ((GenFencesNV)(GL.GetDelegateForExtensionMethod("glGenFencesNV", typeof(GenFencesNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint GenFragmentShadersATI(GLuint range);
+ public static GenFragmentShadersATI glGenFragmentShadersATI = ((GenFragmentShadersATI)(GL.GetDelegateForExtensionMethod("glGenFragmentShadersATI", typeof(GenFragmentShadersATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenFramebuffersEXT(GLsizei n, [In, Out()] System.IntPtr framebuffers);
+ public static GenFramebuffersEXT glGenFramebuffersEXT = ((GenFramebuffersEXT)(GL.GetDelegateForExtensionMethod("glGenFramebuffersEXT", typeof(GenFramebuffersEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint GenLists(GLsizei range);
+ public static GenLists glGenLists = ((GenLists)(GL.GetDelegateForExtensionMethod("glGenLists", typeof(GenLists)))) ?? new GenLists(Imports.GenLists);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenOcclusionQueriesNV(GLsizei n, [In, Out()] System.IntPtr ids);
+ public static GenOcclusionQueriesNV glGenOcclusionQueriesNV = ((GenOcclusionQueriesNV)(GL.GetDelegateForExtensionMethod("glGenOcclusionQueriesNV", typeof(GenOcclusionQueriesNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenProgramsARB(GLsizei n, [In, Out()] System.IntPtr programs);
+ public static GenProgramsARB glGenProgramsARB = ((GenProgramsARB)(GL.GetDelegateForExtensionMethod("glGenProgramsARB", typeof(GenProgramsARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenProgramsNV(GLsizei n, [In, Out()] System.IntPtr programs);
+ public static GenProgramsNV glGenProgramsNV = ((GenProgramsNV)(GL.GetDelegateForExtensionMethod("glGenProgramsNV", typeof(GenProgramsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenQueries(GLsizei n, [In, Out()] System.IntPtr ids);
+ public static GenQueries glGenQueries = ((GenQueries)(GL.GetDelegateForExtensionMethod("glGenQueries", typeof(GenQueries)))) ?? new GenQueries(Imports.GenQueries);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenQueriesARB(GLsizei n, [In, Out()] System.IntPtr ids);
+ public static GenQueriesARB glGenQueriesARB = ((GenQueriesARB)(GL.GetDelegateForExtensionMethod("glGenQueriesARB", typeof(GenQueriesARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenRenderbuffersEXT(GLsizei n, [In, Out()] System.IntPtr renderbuffers);
+ public static GenRenderbuffersEXT glGenRenderbuffersEXT = ((GenRenderbuffersEXT)(GL.GetDelegateForExtensionMethod("glGenRenderbuffersEXT", typeof(GenRenderbuffersEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint GenSymbolsEXT(Enums.EXT_vertex_shader datatype, Enums.EXT_vertex_shader storagetype, Enums.EXT_vertex_shader range, GLuint components);
+ public static GenSymbolsEXT glGenSymbolsEXT = ((GenSymbolsEXT)(GL.GetDelegateForExtensionMethod("glGenSymbolsEXT", typeof(GenSymbolsEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenTextures(GLsizei n, [In, Out()] System.IntPtr textures);
+ public static GenTextures glGenTextures = ((GenTextures)(GL.GetDelegateForExtensionMethod("glGenTextures", typeof(GenTextures)))) ?? new GenTextures(Imports.GenTextures);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenTexturesEXT(GLsizei n, [In, Out()] System.IntPtr textures);
+ public static GenTexturesEXT glGenTexturesEXT = ((GenTexturesEXT)(GL.GetDelegateForExtensionMethod("glGenTexturesEXT", typeof(GenTexturesEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GenVertexArraysAPPLE(GLsizei n, [In, Out()] System.IntPtr arrays);
+ public static GenVertexArraysAPPLE glGenVertexArraysAPPLE = ((GenVertexArraysAPPLE)(GL.GetDelegateForExtensionMethod("glGenVertexArraysAPPLE", typeof(GenVertexArraysAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint GenVertexShadersEXT(GLuint range);
+ public static GenVertexShadersEXT glGenVertexShadersEXT = ((GenVertexShadersEXT)(GL.GetDelegateForExtensionMethod("glGenVertexShadersEXT", typeof(GenVertexShadersEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name);
+ public static GetActiveAttrib glGetActiveAttrib = ((GetActiveAttrib)(GL.GetDelegateForExtensionMethod("glGetActiveAttrib", typeof(GetActiveAttrib)))) ?? new GetActiveAttrib(Imports.GetActiveAttrib);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name);
+ public static GetActiveAttribARB glGetActiveAttribARB = ((GetActiveAttribARB)(GL.GetDelegateForExtensionMethod("glGetActiveAttribARB", typeof(GetActiveAttribARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name);
+ public static GetActiveUniform glGetActiveUniform = ((GetActiveUniform)(GL.GetDelegateForExtensionMethod("glGetActiveUniform", typeof(GetActiveUniform)))) ?? new GetActiveUniform(Imports.GetActiveUniform);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name);
+ public static GetActiveUniformARB glGetActiveUniformARB = ((GetActiveUniformARB)(GL.GetDelegateForExtensionMethod("glGetActiveUniformARB", typeof(GetActiveUniformARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.IntPtr size, [In, Out()] System.IntPtr type, [In, Out()] System.Text.StringBuilder name);
+ public static GetActiveVaryingNV glGetActiveVaryingNV = ((GetActiveVaryingNV)(GL.GetDelegateForExtensionMethod("glGetActiveVaryingNV", typeof(GetActiveVaryingNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetArrayObjectfvATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetArrayObjectfvATI glGetArrayObjectfvATI = ((GetArrayObjectfvATI)(GL.GetDelegateForExtensionMethod("glGetArrayObjectfvATI", typeof(GetArrayObjectfvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetArrayObjectivATI(Enums.EnableCap array, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetArrayObjectivATI glGetArrayObjectivATI = ((GetArrayObjectivATI)(GL.GetDelegateForExtensionMethod("glGetArrayObjectivATI", typeof(GetArrayObjectivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, [In, Out()] System.IntPtr count, [In, Out()] System.IntPtr obj);
+ public static GetAttachedObjectsARB glGetAttachedObjectsARB = ((GetAttachedObjectsARB)(GL.GetDelegateForExtensionMethod("glGetAttachedObjectsARB", typeof(GetAttachedObjectsARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetAttachedShaders(GLuint program, GLsizei maxCount, [In, Out()] System.IntPtr count, [In, Out()] System.IntPtr obj);
+ public static GetAttachedShaders glGetAttachedShaders = ((GetAttachedShaders)(GL.GetDelegateForExtensionMethod("glGetAttachedShaders", typeof(GetAttachedShaders)))) ?? new GetAttachedShaders(Imports.GetAttachedShaders);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetAttribLocation(GLuint program, string name);
+ public static GetAttribLocation glGetAttribLocation = ((GetAttribLocation)(GL.GetDelegateForExtensionMethod("glGetAttribLocation", typeof(GetAttribLocation)))) ?? new GetAttribLocation(Imports.GetAttribLocation);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetAttribLocationARB(GLhandleARB programObj, string name);
+ public static GetAttribLocationARB glGetAttribLocationARB = ((GetAttribLocationARB)(GL.GetDelegateForExtensionMethod("glGetAttribLocationARB", typeof(GetAttribLocationARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBooleanIndexedvEXT(Enums.GLenum target, GLuint index, [In, Out()] System.IntPtr data);
+ public static GetBooleanIndexedvEXT glGetBooleanIndexedvEXT = ((GetBooleanIndexedvEXT)(GL.GetDelegateForExtensionMethod("glGetBooleanIndexedvEXT", typeof(GetBooleanIndexedvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBooleanv(Enums.GetPName pname, [In, Out()] System.IntPtr @params);
+ public static GetBooleanv glGetBooleanv = ((GetBooleanv)(GL.GetDelegateForExtensionMethod("glGetBooleanv", typeof(GetBooleanv)))) ?? new GetBooleanv(Imports.GetBooleanv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBufferParameteriv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params);
+ public static GetBufferParameteriv glGetBufferParameteriv = ((GetBufferParameteriv)(GL.GetDelegateForExtensionMethod("glGetBufferParameteriv", typeof(GetBufferParameteriv)))) ?? new GetBufferParameteriv(Imports.GetBufferParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBufferParameterivARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object pname, [In, Out()] System.IntPtr @params);
+ public static GetBufferParameterivARB glGetBufferParameterivARB = ((GetBufferParameterivARB)(GL.GetDelegateForExtensionMethod("glGetBufferParameterivARB", typeof(GetBufferParameterivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBufferPointerv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params);
+ public static GetBufferPointerv glGetBufferPointerv = ((GetBufferPointerv)(GL.GetDelegateForExtensionMethod("glGetBufferPointerv", typeof(GetBufferPointerv)))) ?? new GetBufferPointerv(Imports.GetBufferPointerv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBufferPointervARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object pname, [In, Out()] System.IntPtr @params);
+ public static GetBufferPointervARB glGetBufferPointervARB = ((GetBufferPointervARB)(GL.GetDelegateForExtensionMethod("glGetBufferPointervARB", typeof(GetBufferPointervARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, [In, Out()] System.IntPtr data);
+ public static GetBufferSubData glGetBufferSubData = ((GetBufferSubData)(GL.GetDelegateForExtensionMethod("glGetBufferSubData", typeof(GetBufferSubData)))) ?? new GetBufferSubData(Imports.GetBufferSubData);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetBufferSubDataARB(Enums.ARB_vertex_buffer_object target, GLintptrARB offset, GLsizeiptrARB size, [In, Out()] System.IntPtr data);
+ public static GetBufferSubDataARB glGetBufferSubDataARB = ((GetBufferSubDataARB)(GL.GetDelegateForExtensionMethod("glGetBufferSubDataARB", typeof(GetBufferSubDataARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetClipPlane(Enums.ClipPlaneName plane, [In, Out()] System.IntPtr equation);
+ public static GetClipPlane glGetClipPlane = ((GetClipPlane)(GL.GetDelegateForExtensionMethod("glGetClipPlane", typeof(GetClipPlane)))) ?? new GetClipPlane(Imports.GetClipPlane);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTable(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr table);
+ public static GetColorTable glGetColorTable = ((GetColorTable)(GL.GetDelegateForExtensionMethod("glGetColorTable", typeof(GetColorTable)))) ?? new GetColorTable(Imports.GetColorTable);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableEXT(Enums.EXT_paletted_texture target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr data);
+ public static GetColorTableEXT glGetColorTableEXT = ((GetColorTableEXT)(GL.GetDelegateForExtensionMethod("glGetColorTableEXT", typeof(GetColorTableEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetColorTableParameterfv glGetColorTableParameterfv = ((GetColorTableParameterfv)(GL.GetDelegateForExtensionMethod("glGetColorTableParameterfv", typeof(GetColorTableParameterfv)))) ?? new GetColorTableParameterfv(Imports.GetColorTableParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableParameterfvEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, [In, Out()] System.IntPtr @params);
+ public static GetColorTableParameterfvEXT glGetColorTableParameterfvEXT = ((GetColorTableParameterfvEXT)(GL.GetDelegateForExtensionMethod("glGetColorTableParameterfvEXT", typeof(GetColorTableParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableParameterfvSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, [In, Out()] System.IntPtr @params);
+ public static GetColorTableParameterfvSGI glGetColorTableParameterfvSGI = ((GetColorTableParameterfvSGI)(GL.GetDelegateForExtensionMethod("glGetColorTableParameterfvSGI", typeof(GetColorTableParameterfvSGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetColorTableParameteriv glGetColorTableParameteriv = ((GetColorTableParameteriv)(GL.GetDelegateForExtensionMethod("glGetColorTableParameteriv", typeof(GetColorTableParameteriv)))) ?? new GetColorTableParameteriv(Imports.GetColorTableParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableParameterivEXT(Enums.EXT_paletted_texture target, Enums.EXT_paletted_texture pname, [In, Out()] System.IntPtr @params);
+ public static GetColorTableParameterivEXT glGetColorTableParameterivEXT = ((GetColorTableParameterivEXT)(GL.GetDelegateForExtensionMethod("glGetColorTableParameterivEXT", typeof(GetColorTableParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableParameterivSGI(Enums.ColorTableTargetSGI target, Enums.GetColorTableParameterPNameSGI pname, [In, Out()] System.IntPtr @params);
+ public static GetColorTableParameterivSGI glGetColorTableParameterivSGI = ((GetColorTableParameterivSGI)(GL.GetDelegateForExtensionMethod("glGetColorTableParameterivSGI", typeof(GetColorTableParameterivSGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetColorTableSGI(Enums.ColorTableTargetSGI target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr table);
+ public static GetColorTableSGI glGetColorTableSGI = ((GetColorTableSGI)(GL.GetDelegateForExtensionMethod("glGetColorTableSGI", typeof(GetColorTableSGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetCombinerInputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params);
+ public static GetCombinerInputParameterfvNV glGetCombinerInputParameterfvNV = ((GetCombinerInputParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetCombinerInputParameterfvNV", typeof(GetCombinerInputParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetCombinerInputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params);
+ public static GetCombinerInputParameterivNV glGetCombinerInputParameterivNV = ((GetCombinerInputParameterivNV)(GL.GetDelegateForExtensionMethod("glGetCombinerInputParameterivNV", typeof(GetCombinerInputParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetCombinerOutputParameterfvNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params);
+ public static GetCombinerOutputParameterfvNV glGetCombinerOutputParameterfvNV = ((GetCombinerOutputParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetCombinerOutputParameterfvNV", typeof(GetCombinerOutputParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetCombinerOutputParameterivNV(Enums.NV_register_combiners stage, Enums.NV_register_combiners portion, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params);
+ public static GetCombinerOutputParameterivNV glGetCombinerOutputParameterivNV = ((GetCombinerOutputParameterivNV)(GL.GetDelegateForExtensionMethod("glGetCombinerOutputParameterivNV", typeof(GetCombinerOutputParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetCombinerStageParameterfvNV(Enums.NV_register_combiners2 stage, Enums.NV_register_combiners2 pname, [In, Out()] System.IntPtr @params);
+ public static GetCombinerStageParameterfvNV glGetCombinerStageParameterfvNV = ((GetCombinerStageParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetCombinerStageParameterfvNV", typeof(GetCombinerStageParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetCompressedTexImage(Enums.TextureTarget target, GLint level, [In, Out()] System.IntPtr img);
+ public static GetCompressedTexImage glGetCompressedTexImage = ((GetCompressedTexImage)(GL.GetDelegateForExtensionMethod("glGetCompressedTexImage", typeof(GetCompressedTexImage)))) ?? new GetCompressedTexImage(Imports.GetCompressedTexImage);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetCompressedTexImageARB(Enums.TextureTarget target, GLint level, [In, Out()] System.IntPtr img);
+ public static GetCompressedTexImageARB glGetCompressedTexImageARB = ((GetCompressedTexImageARB)(GL.GetDelegateForExtensionMethod("glGetCompressedTexImageARB", typeof(GetCompressedTexImageARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetConvolutionFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr image);
+ public static GetConvolutionFilter glGetConvolutionFilter = ((GetConvolutionFilter)(GL.GetDelegateForExtensionMethod("glGetConvolutionFilter", typeof(GetConvolutionFilter)))) ?? new GetConvolutionFilter(Imports.GetConvolutionFilter);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetConvolutionFilterEXT(Enums.ConvolutionTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr image);
+ public static GetConvolutionFilterEXT glGetConvolutionFilterEXT = ((GetConvolutionFilterEXT)(GL.GetDelegateForExtensionMethod("glGetConvolutionFilterEXT", typeof(GetConvolutionFilterEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetConvolutionParameterfv glGetConvolutionParameterfv = ((GetConvolutionParameterfv)(GL.GetDelegateForExtensionMethod("glGetConvolutionParameterfv", typeof(GetConvolutionParameterfv)))) ?? new GetConvolutionParameterfv(Imports.GetConvolutionParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetConvolutionParameterfvEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [In, Out()] System.IntPtr @params);
+ public static GetConvolutionParameterfvEXT glGetConvolutionParameterfvEXT = ((GetConvolutionParameterfvEXT)(GL.GetDelegateForExtensionMethod("glGetConvolutionParameterfvEXT", typeof(GetConvolutionParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetConvolutionParameteriv glGetConvolutionParameteriv = ((GetConvolutionParameteriv)(GL.GetDelegateForExtensionMethod("glGetConvolutionParameteriv", typeof(GetConvolutionParameteriv)))) ?? new GetConvolutionParameteriv(Imports.GetConvolutionParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetConvolutionParameterivEXT(Enums.ConvolutionTargetEXT target, Enums.ConvolutionParameterEXT pname, [In, Out()] System.IntPtr @params);
+ public static GetConvolutionParameterivEXT glGetConvolutionParameterivEXT = ((GetConvolutionParameterivEXT)(GL.GetDelegateForExtensionMethod("glGetConvolutionParameterivEXT", typeof(GetConvolutionParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetDetailTexFuncSGIS(Enums.TextureTarget target, [In, Out()] System.IntPtr points);
+ public static GetDetailTexFuncSGIS glGetDetailTexFuncSGIS = ((GetDetailTexFuncSGIS)(GL.GetDelegateForExtensionMethod("glGetDetailTexFuncSGIS", typeof(GetDetailTexFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetDoublev(Enums.GetPName pname, [In, Out()] System.IntPtr @params);
+ public static GetDoublev glGetDoublev = ((GetDoublev)(GL.GetDelegateForExtensionMethod("glGetDoublev", typeof(GetDoublev)))) ?? new GetDoublev(Imports.GetDoublev);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate Enums.GLenum GetError();
+ public static GetError glGetError = ((GetError)(GL.GetDelegateForExtensionMethod("glGetError", typeof(GetError)))) ?? new GetError(Imports.GetError);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFenceivNV(GLuint fence, Enums.NV_fence pname, [In, Out()] System.IntPtr @params);
+ public static GetFenceivNV glGetFenceivNV = ((GetFenceivNV)(GL.GetDelegateForExtensionMethod("glGetFenceivNV", typeof(GetFenceivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFinalCombinerInputParameterfvNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params);
+ public static GetFinalCombinerInputParameterfvNV glGetFinalCombinerInputParameterfvNV = ((GetFinalCombinerInputParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetFinalCombinerInputParameterfvNV", typeof(GetFinalCombinerInputParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFinalCombinerInputParameterivNV(Enums.NV_register_combiners variable, Enums.NV_register_combiners pname, [In, Out()] System.IntPtr @params);
+ public static GetFinalCombinerInputParameterivNV glGetFinalCombinerInputParameterivNV = ((GetFinalCombinerInputParameterivNV)(GL.GetDelegateForExtensionMethod("glGetFinalCombinerInputParameterivNV", typeof(GetFinalCombinerInputParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFloatv(Enums.GetPName pname, [In, Out()] System.IntPtr @params);
+ public static GetFloatv glGetFloatv = ((GetFloatv)(GL.GetDelegateForExtensionMethod("glGetFloatv", typeof(GetFloatv)))) ?? new GetFloatv(Imports.GetFloatv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFogFuncSGIS([In, Out()] System.IntPtr points);
+ public static GetFogFuncSGIS glGetFogFuncSGIS = ((GetFogFuncSGIS)(GL.GetDelegateForExtensionMethod("glGetFogFuncSGIS", typeof(GetFogFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetFragDataLocationEXT(GLuint program, string name);
+ public static GetFragDataLocationEXT glGetFragDataLocationEXT = ((GetFragDataLocationEXT)(GL.GetDelegateForExtensionMethod("glGetFragDataLocationEXT", typeof(GetFragDataLocationEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFragmentLightfvSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, [In, Out()] System.IntPtr @params);
+ public static GetFragmentLightfvSGIX glGetFragmentLightfvSGIX = ((GetFragmentLightfvSGIX)(GL.GetDelegateForExtensionMethod("glGetFragmentLightfvSGIX", typeof(GetFragmentLightfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFragmentLightivSGIX(Enums.SGIX_fragment_lighting light, Enums.SGIX_fragment_lighting pname, [In, Out()] System.IntPtr @params);
+ public static GetFragmentLightivSGIX glGetFragmentLightivSGIX = ((GetFragmentLightivSGIX)(GL.GetDelegateForExtensionMethod("glGetFragmentLightivSGIX", typeof(GetFragmentLightivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFragmentMaterialfvSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetFragmentMaterialfvSGIX glGetFragmentMaterialfvSGIX = ((GetFragmentMaterialfvSGIX)(GL.GetDelegateForExtensionMethod("glGetFragmentMaterialfvSGIX", typeof(GetFragmentMaterialfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFragmentMaterialivSGIX(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetFragmentMaterialivSGIX glGetFragmentMaterialivSGIX = ((GetFragmentMaterialivSGIX)(GL.GetDelegateForExtensionMethod("glGetFragmentMaterialivSGIX", typeof(GetFragmentMaterialivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetFramebufferAttachmentParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object attachment, Enums.GLenum pname, [In, Out()] System.IntPtr @params);
+ public static GetFramebufferAttachmentParameterivEXT glGetFramebufferAttachmentParameterivEXT = ((GetFramebufferAttachmentParameterivEXT)(GL.GetDelegateForExtensionMethod("glGetFramebufferAttachmentParameterivEXT", typeof(GetFramebufferAttachmentParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLhandleARB GetHandleARB(Enums.ARB_shader_objects pname);
+ public static GetHandleARB glGetHandleARB = ((GetHandleARB)(GL.GetDelegateForExtensionMethod("glGetHandleARB", typeof(GetHandleARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetHistogram(Enums.VERSION_1_2 target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values);
+ public static GetHistogram glGetHistogram = ((GetHistogram)(GL.GetDelegateForExtensionMethod("glGetHistogram", typeof(GetHistogram)))) ?? new GetHistogram(Imports.GetHistogram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetHistogramEXT(Enums.HistogramTargetEXT target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values);
+ public static GetHistogramEXT glGetHistogramEXT = ((GetHistogramEXT)(GL.GetDelegateForExtensionMethod("glGetHistogramEXT", typeof(GetHistogramEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetHistogramParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetHistogramParameterfv glGetHistogramParameterfv = ((GetHistogramParameterfv)(GL.GetDelegateForExtensionMethod("glGetHistogramParameterfv", typeof(GetHistogramParameterfv)))) ?? new GetHistogramParameterfv(Imports.GetHistogramParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetHistogramParameterfvEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, [In, Out()] System.IntPtr @params);
+ public static GetHistogramParameterfvEXT glGetHistogramParameterfvEXT = ((GetHistogramParameterfvEXT)(GL.GetDelegateForExtensionMethod("glGetHistogramParameterfvEXT", typeof(GetHistogramParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetHistogramParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetHistogramParameteriv glGetHistogramParameteriv = ((GetHistogramParameteriv)(GL.GetDelegateForExtensionMethod("glGetHistogramParameteriv", typeof(GetHistogramParameteriv)))) ?? new GetHistogramParameteriv(Imports.GetHistogramParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetHistogramParameterivEXT(Enums.HistogramTargetEXT target, Enums.GetHistogramParameterPNameEXT pname, [In, Out()] System.IntPtr @params);
+ public static GetHistogramParameterivEXT glGetHistogramParameterivEXT = ((GetHistogramParameterivEXT)(GL.GetDelegateForExtensionMethod("glGetHistogramParameterivEXT", typeof(GetHistogramParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, [In, Out()] System.IntPtr @params);
+ public static GetImageTransformParameterfvHP glGetImageTransformParameterfvHP = ((GetImageTransformParameterfvHP)(GL.GetDelegateForExtensionMethod("glGetImageTransformParameterfvHP", typeof(GetImageTransformParameterfvHP))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, [In, Out()] System.IntPtr @params);
+ public static GetImageTransformParameterivHP glGetImageTransformParameterivHP = ((GetImageTransformParameterivHP)(GL.GetDelegateForExtensionMethod("glGetImageTransformParameterivHP", typeof(GetImageTransformParameterivHP))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder infoLog);
+ public static GetInfoLogARB glGetInfoLogARB = ((GetInfoLogARB)(GL.GetDelegateForExtensionMethod("glGetInfoLogARB", typeof(GetInfoLogARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetInstrumentsSGIX();
+ public static GetInstrumentsSGIX glGetInstrumentsSGIX = ((GetInstrumentsSGIX)(GL.GetDelegateForExtensionMethod("glGetInstrumentsSGIX", typeof(GetInstrumentsSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetIntegerIndexedvEXT(Enums.GLenum target, GLuint index, [In, Out()] System.IntPtr data);
+ public static GetIntegerIndexedvEXT glGetIntegerIndexedvEXT = ((GetIntegerIndexedvEXT)(GL.GetDelegateForExtensionMethod("glGetIntegerIndexedvEXT", typeof(GetIntegerIndexedvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetIntegerv(Enums.GetPName pname, [In, Out()] System.IntPtr @params);
+ public static GetIntegerv glGetIntegerv = ((GetIntegerv)(GL.GetDelegateForExtensionMethod("glGetIntegerv", typeof(GetIntegerv)))) ?? new GetIntegerv(Imports.GetIntegerv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetInvariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetInvariantBooleanvEXT glGetInvariantBooleanvEXT = ((GetInvariantBooleanvEXT)(GL.GetDelegateForExtensionMethod("glGetInvariantBooleanvEXT", typeof(GetInvariantBooleanvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetInvariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetInvariantFloatvEXT glGetInvariantFloatvEXT = ((GetInvariantFloatvEXT)(GL.GetDelegateForExtensionMethod("glGetInvariantFloatvEXT", typeof(GetInvariantFloatvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetInvariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetInvariantIntegervEXT glGetInvariantIntegervEXT = ((GetInvariantIntegervEXT)(GL.GetDelegateForExtensionMethod("glGetInvariantIntegervEXT", typeof(GetInvariantIntegervEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetLightfv(Enums.LightName light, Enums.LightParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetLightfv glGetLightfv = ((GetLightfv)(GL.GetDelegateForExtensionMethod("glGetLightfv", typeof(GetLightfv)))) ?? new GetLightfv(Imports.GetLightfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetLightiv(Enums.LightName light, Enums.LightParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetLightiv glGetLightiv = ((GetLightiv)(GL.GetDelegateForExtensionMethod("glGetLightiv", typeof(GetLightiv)))) ?? new GetLightiv(Imports.GetLightiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, [In, Out()] System.IntPtr @params);
+ public static GetListParameterfvSGIX glGetListParameterfvSGIX = ((GetListParameterfvSGIX)(GL.GetDelegateForExtensionMethod("glGetListParameterfvSGIX", typeof(GetListParameterfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetListParameterivSGIX(GLuint list, Enums.ListParameterName pname, [In, Out()] System.IntPtr @params);
+ public static GetListParameterivSGIX glGetListParameterivSGIX = ((GetListParameterivSGIX)(GL.GetDelegateForExtensionMethod("glGetListParameterivSGIX", typeof(GetListParameterivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetLocalConstantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetLocalConstantBooleanvEXT glGetLocalConstantBooleanvEXT = ((GetLocalConstantBooleanvEXT)(GL.GetDelegateForExtensionMethod("glGetLocalConstantBooleanvEXT", typeof(GetLocalConstantBooleanvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetLocalConstantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetLocalConstantFloatvEXT glGetLocalConstantFloatvEXT = ((GetLocalConstantFloatvEXT)(GL.GetDelegateForExtensionMethod("glGetLocalConstantFloatvEXT", typeof(GetLocalConstantFloatvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetLocalConstantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetLocalConstantIntegervEXT glGetLocalConstantIntegervEXT = ((GetLocalConstantIntegervEXT)(GL.GetDelegateForExtensionMethod("glGetLocalConstantIntegervEXT", typeof(GetLocalConstantIntegervEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapAttribParameterfvNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params);
+ public static GetMapAttribParameterfvNV glGetMapAttribParameterfvNV = ((GetMapAttribParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetMapAttribParameterfvNV", typeof(GetMapAttribParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapAttribParameterivNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params);
+ public static GetMapAttribParameterivNV glGetMapAttribParameterivNV = ((GetMapAttribParameterivNV)(GL.GetDelegateForExtensionMethod("glGetMapAttribParameterivNV", typeof(GetMapAttribParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapControlPointsNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, [MarshalAs(UnmanagedType.Bool)] bool packed, [In, Out()] System.IntPtr points);
+ public static GetMapControlPointsNV glGetMapControlPointsNV = ((GetMapControlPointsNV)(GL.GetDelegateForExtensionMethod("glGetMapControlPointsNV", typeof(GetMapControlPointsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, [In, Out()] System.IntPtr v);
+ public static GetMapdv glGetMapdv = ((GetMapdv)(GL.GetDelegateForExtensionMethod("glGetMapdv", typeof(GetMapdv)))) ?? new GetMapdv(Imports.GetMapdv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, [In, Out()] System.IntPtr v);
+ public static GetMapfv glGetMapfv = ((GetMapfv)(GL.GetDelegateForExtensionMethod("glGetMapfv", typeof(GetMapfv)))) ?? new GetMapfv(Imports.GetMapfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, [In, Out()] System.IntPtr v);
+ public static GetMapiv glGetMapiv = ((GetMapiv)(GL.GetDelegateForExtensionMethod("glGetMapiv", typeof(GetMapiv)))) ?? new GetMapiv(Imports.GetMapiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params);
+ public static GetMapParameterfvNV glGetMapParameterfvNV = ((GetMapParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetMapParameterfvNV", typeof(GetMapParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, [In, Out()] System.IntPtr @params);
+ public static GetMapParameterivNV glGetMapParameterivNV = ((GetMapParameterivNV)(GL.GetDelegateForExtensionMethod("glGetMapParameterivNV", typeof(GetMapParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetMaterialfv glGetMaterialfv = ((GetMaterialfv)(GL.GetDelegateForExtensionMethod("glGetMaterialfv", typeof(GetMaterialfv)))) ?? new GetMaterialfv(Imports.GetMaterialfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetMaterialiv glGetMaterialiv = ((GetMaterialiv)(GL.GetDelegateForExtensionMethod("glGetMaterialiv", typeof(GetMaterialiv)))) ?? new GetMaterialiv(Imports.GetMaterialiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMinmax(Enums.VERSION_1_2 target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values);
+ public static GetMinmax glGetMinmax = ((GetMinmax)(GL.GetDelegateForExtensionMethod("glGetMinmax", typeof(GetMinmax)))) ?? new GetMinmax(Imports.GetMinmax);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMinmaxEXT(Enums.MinmaxTargetEXT target, [MarshalAs(UnmanagedType.Bool)] bool reset, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr values);
+ public static GetMinmaxEXT glGetMinmaxEXT = ((GetMinmaxEXT)(GL.GetDelegateForExtensionMethod("glGetMinmaxEXT", typeof(GetMinmaxEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMinmaxParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetMinmaxParameterfv glGetMinmaxParameterfv = ((GetMinmaxParameterfv)(GL.GetDelegateForExtensionMethod("glGetMinmaxParameterfv", typeof(GetMinmaxParameterfv)))) ?? new GetMinmaxParameterfv(Imports.GetMinmaxParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMinmaxParameterfvEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, [In, Out()] System.IntPtr @params);
+ public static GetMinmaxParameterfvEXT glGetMinmaxParameterfvEXT = ((GetMinmaxParameterfvEXT)(GL.GetDelegateForExtensionMethod("glGetMinmaxParameterfvEXT", typeof(GetMinmaxParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMinmaxParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, [In, Out()] System.IntPtr @params);
+ public static GetMinmaxParameteriv glGetMinmaxParameteriv = ((GetMinmaxParameteriv)(GL.GetDelegateForExtensionMethod("glGetMinmaxParameteriv", typeof(GetMinmaxParameteriv)))) ?? new GetMinmaxParameteriv(Imports.GetMinmaxParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetMinmaxParameterivEXT(Enums.MinmaxTargetEXT target, Enums.GetMinmaxParameterPNameEXT pname, [In, Out()] System.IntPtr @params);
+ public static GetMinmaxParameterivEXT glGetMinmaxParameterivEXT = ((GetMinmaxParameterivEXT)(GL.GetDelegateForExtensionMethod("glGetMinmaxParameterivEXT", typeof(GetMinmaxParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetObjectBufferfvATI(GLuint buffer, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetObjectBufferfvATI glGetObjectBufferfvATI = ((GetObjectBufferfvATI)(GL.GetDelegateForExtensionMethod("glGetObjectBufferfvATI", typeof(GetObjectBufferfvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetObjectBufferivATI(GLuint buffer, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetObjectBufferivATI glGetObjectBufferivATI = ((GetObjectBufferivATI)(GL.GetDelegateForExtensionMethod("glGetObjectBufferivATI", typeof(GetObjectBufferivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetObjectParameterfvARB(GLhandleARB obj, Enums.ARB_shader_objects pname, [In, Out()] System.IntPtr @params);
+ public static GetObjectParameterfvARB glGetObjectParameterfvARB = ((GetObjectParameterfvARB)(GL.GetDelegateForExtensionMethod("glGetObjectParameterfvARB", typeof(GetObjectParameterfvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetObjectParameterivARB(GLhandleARB obj, Enums.ARB_shader_objects pname, [In, Out()] System.IntPtr @params);
+ public static GetObjectParameterivARB glGetObjectParameterivARB = ((GetObjectParameterivARB)(GL.GetDelegateForExtensionMethod("glGetObjectParameterivARB", typeof(GetObjectParameterivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetOcclusionQueryivNV(GLuint id, Enums.NV_occlusion_query pname, [In, Out()] System.IntPtr @params);
+ public static GetOcclusionQueryivNV glGetOcclusionQueryivNV = ((GetOcclusionQueryivNV)(GL.GetDelegateForExtensionMethod("glGetOcclusionQueryivNV", typeof(GetOcclusionQueryivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetOcclusionQueryuivNV(GLuint id, Enums.NV_occlusion_query pname, [In, Out()] System.IntPtr @params);
+ public static GetOcclusionQueryuivNV glGetOcclusionQueryuivNV = ((GetOcclusionQueryuivNV)(GL.GetDelegateForExtensionMethod("glGetOcclusionQueryuivNV", typeof(GetOcclusionQueryuivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPixelMapfv(Enums.PixelMap map, [In, Out()] System.IntPtr values);
+ public static GetPixelMapfv glGetPixelMapfv = ((GetPixelMapfv)(GL.GetDelegateForExtensionMethod("glGetPixelMapfv", typeof(GetPixelMapfv)))) ?? new GetPixelMapfv(Imports.GetPixelMapfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPixelMapuiv(Enums.PixelMap map, [In, Out()] System.IntPtr values);
+ public static GetPixelMapuiv glGetPixelMapuiv = ((GetPixelMapuiv)(GL.GetDelegateForExtensionMethod("glGetPixelMapuiv", typeof(GetPixelMapuiv)))) ?? new GetPixelMapuiv(Imports.GetPixelMapuiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPixelMapusv(Enums.PixelMap map, [In, Out()] System.IntPtr values);
+ public static GetPixelMapusv glGetPixelMapusv = ((GetPixelMapusv)(GL.GetDelegateForExtensionMethod("glGetPixelMapusv", typeof(GetPixelMapusv)))) ?? new GetPixelMapusv(Imports.GetPixelMapusv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, [In, Out()] System.IntPtr @params);
+ public static GetPixelTexGenParameterfvSGIS glGetPixelTexGenParameterfvSGIS = ((GetPixelTexGenParameterfvSGIS)(GL.GetDelegateForExtensionMethod("glGetPixelTexGenParameterfvSGIS", typeof(GetPixelTexGenParameterfvSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, [In, Out()] System.IntPtr @params);
+ public static GetPixelTexGenParameterivSGIS glGetPixelTexGenParameterivSGIS = ((GetPixelTexGenParameterivSGIS)(GL.GetDelegateForExtensionMethod("glGetPixelTexGenParameterivSGIS", typeof(GetPixelTexGenParameterivSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPointerv(Enums.GetPointervPName pname, [In, Out()] System.IntPtr @params);
+ public static GetPointerv glGetPointerv = ((GetPointerv)(GL.GetDelegateForExtensionMethod("glGetPointerv", typeof(GetPointerv)))) ?? new GetPointerv(Imports.GetPointerv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPointervEXT(Enums.GetPointervPName pname, [In, Out()] System.IntPtr @params);
+ public static GetPointervEXT glGetPointervEXT = ((GetPointervEXT)(GL.GetDelegateForExtensionMethod("glGetPointervEXT", typeof(GetPointervEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetPolygonStipple([In, Out()] System.IntPtr mask);
+ public static GetPolygonStipple glGetPolygonStipple = ((GetPolygonStipple)(GL.GetDelegateForExtensionMethod("glGetPolygonStipple", typeof(GetPolygonStipple)))) ?? new GetPolygonStipple(Imports.GetPolygonStipple);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramEnvParameterdvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramEnvParameterdvARB glGetProgramEnvParameterdvARB = ((GetProgramEnvParameterdvARB)(GL.GetDelegateForExtensionMethod("glGetProgramEnvParameterdvARB", typeof(GetProgramEnvParameterdvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramEnvParameterfvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramEnvParameterfvARB glGetProgramEnvParameterfvARB = ((GetProgramEnvParameterfvARB)(GL.GetDelegateForExtensionMethod("glGetProgramEnvParameterfvARB", typeof(GetProgramEnvParameterfvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramEnvParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramEnvParameterIivNV glGetProgramEnvParameterIivNV = ((GetProgramEnvParameterIivNV)(GL.GetDelegateForExtensionMethod("glGetProgramEnvParameterIivNV", typeof(GetProgramEnvParameterIivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramEnvParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramEnvParameterIuivNV glGetProgramEnvParameterIuivNV = ((GetProgramEnvParameterIuivNV)(GL.GetDelegateForExtensionMethod("glGetProgramEnvParameterIuivNV", typeof(GetProgramEnvParameterIuivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramInfoLog(GLuint program, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder infoLog);
+ public static GetProgramInfoLog glGetProgramInfoLog = ((GetProgramInfoLog)(GL.GetDelegateForExtensionMethod("glGetProgramInfoLog", typeof(GetProgramInfoLog)))) ?? new GetProgramInfoLog(Imports.GetProgramInfoLog);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramiv(GLuint program, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params);
+ public static GetProgramiv glGetProgramiv = ((GetProgramiv)(GL.GetDelegateForExtensionMethod("glGetProgramiv", typeof(GetProgramiv)))) ?? new GetProgramiv(Imports.GetProgramiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramivARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetProgramivARB glGetProgramivARB = ((GetProgramivARB)(GL.GetDelegateForExtensionMethod("glGetProgramivARB", typeof(GetProgramivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramivNV(GLuint id, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetProgramivNV glGetProgramivNV = ((GetProgramivNV)(GL.GetDelegateForExtensionMethod("glGetProgramivNV", typeof(GetProgramivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramLocalParameterdvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramLocalParameterdvARB glGetProgramLocalParameterdvARB = ((GetProgramLocalParameterdvARB)(GL.GetDelegateForExtensionMethod("glGetProgramLocalParameterdvARB", typeof(GetProgramLocalParameterdvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramLocalParameterfvARB(Enums.ARB_vertex_program target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramLocalParameterfvARB glGetProgramLocalParameterfvARB = ((GetProgramLocalParameterfvARB)(GL.GetDelegateForExtensionMethod("glGetProgramLocalParameterfvARB", typeof(GetProgramLocalParameterfvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramLocalParameterIivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramLocalParameterIivNV glGetProgramLocalParameterIivNV = ((GetProgramLocalParameterIivNV)(GL.GetDelegateForExtensionMethod("glGetProgramLocalParameterIivNV", typeof(GetProgramLocalParameterIivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramLocalParameterIuivNV(Enums.NV_gpu_program4 target, GLuint index, [In, Out()] System.IntPtr @params);
+ public static GetProgramLocalParameterIuivNV glGetProgramLocalParameterIuivNV = ((GetProgramLocalParameterIuivNV)(GL.GetDelegateForExtensionMethod("glGetProgramLocalParameterIuivNV", typeof(GetProgramLocalParameterIuivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramNamedParameterdvNV(GLuint id, GLsizei len, System.IntPtr name, [In, Out()] System.IntPtr @params);
+ public static GetProgramNamedParameterdvNV glGetProgramNamedParameterdvNV = ((GetProgramNamedParameterdvNV)(GL.GetDelegateForExtensionMethod("glGetProgramNamedParameterdvNV", typeof(GetProgramNamedParameterdvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramNamedParameterfvNV(GLuint id, GLsizei len, System.IntPtr name, [In, Out()] System.IntPtr @params);
+ public static GetProgramNamedParameterfvNV glGetProgramNamedParameterfvNV = ((GetProgramNamedParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetProgramNamedParameterfvNV", typeof(GetProgramNamedParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramParameterdvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetProgramParameterdvNV glGetProgramParameterdvNV = ((GetProgramParameterdvNV)(GL.GetDelegateForExtensionMethod("glGetProgramParameterdvNV", typeof(GetProgramParameterdvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramParameterfvNV(Enums.NV_vertex_program target, GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetProgramParameterfvNV glGetProgramParameterfvNV = ((GetProgramParameterfvNV)(GL.GetDelegateForExtensionMethod("glGetProgramParameterfvNV", typeof(GetProgramParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramStringARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @string);
+ public static GetProgramStringARB glGetProgramStringARB = ((GetProgramStringARB)(GL.GetDelegateForExtensionMethod("glGetProgramStringARB", typeof(GetProgramStringARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetProgramStringNV(GLuint id, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr program);
+ public static GetProgramStringNV glGetProgramStringNV = ((GetProgramStringNV)(GL.GetDelegateForExtensionMethod("glGetProgramStringNV", typeof(GetProgramStringNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryiv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryiv glGetQueryiv = ((GetQueryiv)(GL.GetDelegateForExtensionMethod("glGetQueryiv", typeof(GetQueryiv)))) ?? new GetQueryiv(Imports.GetQueryiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryivARB(Enums.ARB_occlusion_query target, Enums.ARB_occlusion_query pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryivARB glGetQueryivARB = ((GetQueryivARB)(GL.GetDelegateForExtensionMethod("glGetQueryivARB", typeof(GetQueryivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryObjecti64vEXT(GLuint id, Enums.GLenum pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryObjecti64vEXT glGetQueryObjecti64vEXT = ((GetQueryObjecti64vEXT)(GL.GetDelegateForExtensionMethod("glGetQueryObjecti64vEXT", typeof(GetQueryObjecti64vEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryObjectiv(GLuint id, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryObjectiv glGetQueryObjectiv = ((GetQueryObjectiv)(GL.GetDelegateForExtensionMethod("glGetQueryObjectiv", typeof(GetQueryObjectiv)))) ?? new GetQueryObjectiv(Imports.GetQueryObjectiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryObjectivARB(GLuint id, Enums.ARB_occlusion_query pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryObjectivARB glGetQueryObjectivARB = ((GetQueryObjectivARB)(GL.GetDelegateForExtensionMethod("glGetQueryObjectivARB", typeof(GetQueryObjectivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryObjectui64vEXT(GLuint id, Enums.GLenum pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryObjectui64vEXT glGetQueryObjectui64vEXT = ((GetQueryObjectui64vEXT)(GL.GetDelegateForExtensionMethod("glGetQueryObjectui64vEXT", typeof(GetQueryObjectui64vEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryObjectuiv(GLuint id, Enums.VERSION_1_5 pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryObjectuiv glGetQueryObjectuiv = ((GetQueryObjectuiv)(GL.GetDelegateForExtensionMethod("glGetQueryObjectuiv", typeof(GetQueryObjectuiv)))) ?? new GetQueryObjectuiv(Imports.GetQueryObjectuiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetQueryObjectuivARB(GLuint id, Enums.ARB_occlusion_query pname, [In, Out()] System.IntPtr @params);
+ public static GetQueryObjectuivARB glGetQueryObjectuivARB = ((GetQueryObjectuivARB)(GL.GetDelegateForExtensionMethod("glGetQueryObjectuivARB", typeof(GetQueryObjectuivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetRenderbufferParameterivEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object pname, [In, Out()] System.IntPtr @params);
+ public static GetRenderbufferParameterivEXT glGetRenderbufferParameterivEXT = ((GetRenderbufferParameterivEXT)(GL.GetDelegateForExtensionMethod("glGetRenderbufferParameterivEXT", typeof(GetRenderbufferParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, [In, Out()] System.IntPtr column, [In, Out()] System.IntPtr span);
+ public static GetSeparableFilter glGetSeparableFilter = ((GetSeparableFilter)(GL.GetDelegateForExtensionMethod("glGetSeparableFilter", typeof(GetSeparableFilter)))) ?? new GetSeparableFilter(Imports.GetSeparableFilter);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetSeparableFilterEXT(Enums.SeparableTargetEXT target, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr row, [In, Out()] System.IntPtr column, [In, Out()] System.IntPtr span);
+ public static GetSeparableFilterEXT glGetSeparableFilterEXT = ((GetSeparableFilterEXT)(GL.GetDelegateForExtensionMethod("glGetSeparableFilterEXT", typeof(GetSeparableFilterEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetShaderInfoLog(GLuint shader, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder infoLog);
+ public static GetShaderInfoLog glGetShaderInfoLog = ((GetShaderInfoLog)(GL.GetDelegateForExtensionMethod("glGetShaderInfoLog", typeof(GetShaderInfoLog)))) ?? new GetShaderInfoLog(Imports.GetShaderInfoLog);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetShaderiv(GLuint shader, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params);
+ public static GetShaderiv glGetShaderiv = ((GetShaderiv)(GL.GetDelegateForExtensionMethod("glGetShaderiv", typeof(GetShaderiv)))) ?? new GetShaderiv(Imports.GetShaderiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetShaderSource(GLuint shader, GLsizei bufSize, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder source);
+ public static GetShaderSource glGetShaderSource = ((GetShaderSource)(GL.GetDelegateForExtensionMethod("glGetShaderSource", typeof(GetShaderSource)))) ?? new GetShaderSource(Imports.GetShaderSource);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, [In, Out()] System.IntPtr length, [In, Out()] System.Text.StringBuilder source);
+ public static GetShaderSourceARB glGetShaderSourceARB = ((GetShaderSourceARB)(GL.GetDelegateForExtensionMethod("glGetShaderSourceARB", typeof(GetShaderSourceARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetSharpenTexFuncSGIS(Enums.TextureTarget target, [In, Out()] System.IntPtr points);
+ public static GetSharpenTexFuncSGIS glGetSharpenTexFuncSGIS = ((GetSharpenTexFuncSGIS)(GL.GetDelegateForExtensionMethod("glGetSharpenTexFuncSGIS", typeof(GetSharpenTexFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate IntPtr GetString(Enums.StringName name);
+ public static GetString glGetString = ((GetString)(GL.GetDelegateForExtensionMethod("glGetString", typeof(GetString)))) ?? new GetString(Imports.GetString);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, [In, Out()] System.IntPtr param);
+ public static GetTexBumpParameterfvATI glGetTexBumpParameterfvATI = ((GetTexBumpParameterfvATI)(GL.GetDelegateForExtensionMethod("glGetTexBumpParameterfvATI", typeof(GetTexBumpParameterfvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, [In, Out()] System.IntPtr param);
+ public static GetTexBumpParameterivATI glGetTexBumpParameterivATI = ((GetTexBumpParameterivATI)(GL.GetDelegateForExtensionMethod("glGetTexBumpParameterivATI", typeof(GetTexBumpParameterivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexEnvfv glGetTexEnvfv = ((GetTexEnvfv)(GL.GetDelegateForExtensionMethod("glGetTexEnvfv", typeof(GetTexEnvfv)))) ?? new GetTexEnvfv(Imports.GetTexEnvfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexEnviv glGetTexEnviv = ((GetTexEnviv)(GL.GetDelegateForExtensionMethod("glGetTexEnviv", typeof(GetTexEnviv)))) ?? new GetTexEnviv(Imports.GetTexEnviv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, [In, Out()] System.IntPtr weights);
+ public static GetTexFilterFuncSGIS glGetTexFilterFuncSGIS = ((GetTexFilterFuncSGIS)(GL.GetDelegateForExtensionMethod("glGetTexFilterFuncSGIS", typeof(GetTexFilterFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexGendv glGetTexGendv = ((GetTexGendv)(GL.GetDelegateForExtensionMethod("glGetTexGendv", typeof(GetTexGendv)))) ?? new GetTexGendv(Imports.GetTexGendv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexGenfv glGetTexGenfv = ((GetTexGenfv)(GL.GetDelegateForExtensionMethod("glGetTexGenfv", typeof(GetTexGenfv)))) ?? new GetTexGenfv(Imports.GetTexGenfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexGeniv glGetTexGeniv = ((GetTexGeniv)(GL.GetDelegateForExtensionMethod("glGetTexGeniv", typeof(GetTexGeniv)))) ?? new GetTexGeniv(Imports.GetTexGeniv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexImage(Enums.TextureTarget target, GLint level, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr pixels);
+ public static GetTexImage glGetTexImage = ((GetTexImage)(GL.GetDelegateForExtensionMethod("glGetTexImage", typeof(GetTexImage)))) ?? new GetTexImage(Imports.GetTexImage);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexLevelParameterfv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexLevelParameterfv glGetTexLevelParameterfv = ((GetTexLevelParameterfv)(GL.GetDelegateForExtensionMethod("glGetTexLevelParameterfv", typeof(GetTexLevelParameterfv)))) ?? new GetTexLevelParameterfv(Imports.GetTexLevelParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexLevelParameteriv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexLevelParameteriv glGetTexLevelParameteriv = ((GetTexLevelParameteriv)(GL.GetDelegateForExtensionMethod("glGetTexLevelParameteriv", typeof(GetTexLevelParameteriv)))) ?? new GetTexLevelParameteriv(Imports.GetTexLevelParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexParameterfv glGetTexParameterfv = ((GetTexParameterfv)(GL.GetDelegateForExtensionMethod("glGetTexParameterfv", typeof(GetTexParameterfv)))) ?? new GetTexParameterfv(Imports.GetTexParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexParameterIivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexParameterIivEXT glGetTexParameterIivEXT = ((GetTexParameterIivEXT)(GL.GetDelegateForExtensionMethod("glGetTexParameterIivEXT", typeof(GetTexParameterIivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexParameterIuivEXT(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexParameterIuivEXT glGetTexParameterIuivEXT = ((GetTexParameterIuivEXT)(GL.GetDelegateForExtensionMethod("glGetTexParameterIuivEXT", typeof(GetTexParameterIuivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, [In, Out()] System.IntPtr @params);
+ public static GetTexParameteriv glGetTexParameteriv = ((GetTexParameteriv)(GL.GetDelegateForExtensionMethod("glGetTexParameteriv", typeof(GetTexParameteriv)))) ?? new GetTexParameteriv(Imports.GetTexParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTrackMatrixivNV(Enums.NV_vertex_program target, GLuint address, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetTrackMatrixivNV glGetTrackMatrixivNV = ((GetTrackMatrixivNV)(GL.GetDelegateForExtensionMethod("glGetTrackMatrixivNV", typeof(GetTrackMatrixivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetTransformFeedbackVaryingNV(GLuint program, GLuint index, [In, Out()] System.IntPtr location);
+ public static GetTransformFeedbackVaryingNV glGetTransformFeedbackVaryingNV = ((GetTransformFeedbackVaryingNV)(GL.GetDelegateForExtensionMethod("glGetTransformFeedbackVaryingNV", typeof(GetTransformFeedbackVaryingNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetUniformBufferSizeEXT(GLuint program, GLint location);
+ public static GetUniformBufferSizeEXT glGetUniformBufferSizeEXT = ((GetUniformBufferSizeEXT)(GL.GetDelegateForExtensionMethod("glGetUniformBufferSizeEXT", typeof(GetUniformBufferSizeEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetUniformfv(GLuint program, GLint location, [In, Out()] System.IntPtr @params);
+ public static GetUniformfv glGetUniformfv = ((GetUniformfv)(GL.GetDelegateForExtensionMethod("glGetUniformfv", typeof(GetUniformfv)))) ?? new GetUniformfv(Imports.GetUniformfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetUniformfvARB(GLhandleARB programObj, GLint location, [In, Out()] System.IntPtr @params);
+ public static GetUniformfvARB glGetUniformfvARB = ((GetUniformfvARB)(GL.GetDelegateForExtensionMethod("glGetUniformfvARB", typeof(GetUniformfvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetUniformiv(GLuint program, GLint location, [In, Out()] System.IntPtr @params);
+ public static GetUniformiv glGetUniformiv = ((GetUniformiv)(GL.GetDelegateForExtensionMethod("glGetUniformiv", typeof(GetUniformiv)))) ?? new GetUniformiv(Imports.GetUniformiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetUniformivARB(GLhandleARB programObj, GLint location, [In, Out()] System.IntPtr @params);
+ public static GetUniformivARB glGetUniformivARB = ((GetUniformivARB)(GL.GetDelegateForExtensionMethod("glGetUniformivARB", typeof(GetUniformivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetUniformLocation(GLuint program, string name);
+ public static GetUniformLocation glGetUniformLocation = ((GetUniformLocation)(GL.GetDelegateForExtensionMethod("glGetUniformLocation", typeof(GetUniformLocation)))) ?? new GetUniformLocation(Imports.GetUniformLocation);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetUniformLocationARB(GLhandleARB programObj, string name);
+ public static GetUniformLocationARB glGetUniformLocationARB = ((GetUniformLocationARB)(GL.GetDelegateForExtensionMethod("glGetUniformLocationARB", typeof(GetUniformLocationARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLintptr GetUniformOffsetEXT(GLuint program, GLint location);
+ public static GetUniformOffsetEXT glGetUniformOffsetEXT = ((GetUniformOffsetEXT)(GL.GetDelegateForExtensionMethod("glGetUniformOffsetEXT", typeof(GetUniformOffsetEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetUniformuivEXT(GLuint program, GLint location, [In, Out()] System.IntPtr @params);
+ public static GetUniformuivEXT glGetUniformuivEXT = ((GetUniformuivEXT)(GL.GetDelegateForExtensionMethod("glGetUniformuivEXT", typeof(GetUniformuivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVariantArrayObjectfvATI(GLuint id, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetVariantArrayObjectfvATI glGetVariantArrayObjectfvATI = ((GetVariantArrayObjectfvATI)(GL.GetDelegateForExtensionMethod("glGetVariantArrayObjectfvATI", typeof(GetVariantArrayObjectfvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVariantArrayObjectivATI(GLuint id, Enums.ATI_vertex_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetVariantArrayObjectivATI glGetVariantArrayObjectivATI = ((GetVariantArrayObjectivATI)(GL.GetDelegateForExtensionMethod("glGetVariantArrayObjectivATI", typeof(GetVariantArrayObjectivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVariantBooleanvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetVariantBooleanvEXT glGetVariantBooleanvEXT = ((GetVariantBooleanvEXT)(GL.GetDelegateForExtensionMethod("glGetVariantBooleanvEXT", typeof(GetVariantBooleanvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVariantFloatvEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetVariantFloatvEXT glGetVariantFloatvEXT = ((GetVariantFloatvEXT)(GL.GetDelegateForExtensionMethod("glGetVariantFloatvEXT", typeof(GetVariantFloatvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVariantIntegervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetVariantIntegervEXT glGetVariantIntegervEXT = ((GetVariantIntegervEXT)(GL.GetDelegateForExtensionMethod("glGetVariantIntegervEXT", typeof(GetVariantIntegervEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVariantPointervEXT(GLuint id, Enums.EXT_vertex_shader value, [In, Out()] System.IntPtr data);
+ public static GetVariantPointervEXT glGetVariantPointervEXT = ((GetVariantPointervEXT)(GL.GetDelegateForExtensionMethod("glGetVariantPointervEXT", typeof(GetVariantPointervEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint GetVaryingLocationNV(GLuint program, string name);
+ public static GetVaryingLocationNV glGetVaryingLocationNV = ((GetVaryingLocationNV)(GL.GetDelegateForExtensionMethod("glGetVaryingLocationNV", typeof(GetVaryingLocationNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribArrayObjectfvATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribArrayObjectfvATI glGetVertexAttribArrayObjectfvATI = ((GetVertexAttribArrayObjectfvATI)(GL.GetDelegateForExtensionMethod("glGetVertexAttribArrayObjectfvATI", typeof(GetVertexAttribArrayObjectfvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribArrayObjectivATI(GLuint index, Enums.ATI_vertex_attrib_array_object pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribArrayObjectivATI glGetVertexAttribArrayObjectivATI = ((GetVertexAttribArrayObjectivATI)(GL.GetDelegateForExtensionMethod("glGetVertexAttribArrayObjectivATI", typeof(GetVertexAttribArrayObjectivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribdv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribdv glGetVertexAttribdv = ((GetVertexAttribdv)(GL.GetDelegateForExtensionMethod("glGetVertexAttribdv", typeof(GetVertexAttribdv)))) ?? new GetVertexAttribdv(Imports.GetVertexAttribdv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribdvARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribdvARB glGetVertexAttribdvARB = ((GetVertexAttribdvARB)(GL.GetDelegateForExtensionMethod("glGetVertexAttribdvARB", typeof(GetVertexAttribdvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribdvNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribdvNV glGetVertexAttribdvNV = ((GetVertexAttribdvNV)(GL.GetDelegateForExtensionMethod("glGetVertexAttribdvNV", typeof(GetVertexAttribdvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribfv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribfv glGetVertexAttribfv = ((GetVertexAttribfv)(GL.GetDelegateForExtensionMethod("glGetVertexAttribfv", typeof(GetVertexAttribfv)))) ?? new GetVertexAttribfv(Imports.GetVertexAttribfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribfvARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribfvARB glGetVertexAttribfvARB = ((GetVertexAttribfvARB)(GL.GetDelegateForExtensionMethod("glGetVertexAttribfvARB", typeof(GetVertexAttribfvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribfvNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribfvNV glGetVertexAttribfvNV = ((GetVertexAttribfvNV)(GL.GetDelegateForExtensionMethod("glGetVertexAttribfvNV", typeof(GetVertexAttribfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribIivEXT(GLuint index, Enums.NV_vertex_program4 pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribIivEXT glGetVertexAttribIivEXT = ((GetVertexAttribIivEXT)(GL.GetDelegateForExtensionMethod("glGetVertexAttribIivEXT", typeof(GetVertexAttribIivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribIuivEXT(GLuint index, Enums.NV_vertex_program4 pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribIuivEXT glGetVertexAttribIuivEXT = ((GetVertexAttribIuivEXT)(GL.GetDelegateForExtensionMethod("glGetVertexAttribIuivEXT", typeof(GetVertexAttribIuivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribiv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribiv glGetVertexAttribiv = ((GetVertexAttribiv)(GL.GetDelegateForExtensionMethod("glGetVertexAttribiv", typeof(GetVertexAttribiv)))) ?? new GetVertexAttribiv(Imports.GetVertexAttribiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribivARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribivARB glGetVertexAttribivARB = ((GetVertexAttribivARB)(GL.GetDelegateForExtensionMethod("glGetVertexAttribivARB", typeof(GetVertexAttribivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribivNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr @params);
+ public static GetVertexAttribivNV glGetVertexAttribivNV = ((GetVertexAttribivNV)(GL.GetDelegateForExtensionMethod("glGetVertexAttribivNV", typeof(GetVertexAttribivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribPointerv(GLuint index, Enums.VERSION_2_0 pname, [In, Out()] System.IntPtr pointer);
+ public static GetVertexAttribPointerv glGetVertexAttribPointerv = ((GetVertexAttribPointerv)(GL.GetDelegateForExtensionMethod("glGetVertexAttribPointerv", typeof(GetVertexAttribPointerv)))) ?? new GetVertexAttribPointerv(Imports.GetVertexAttribPointerv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribPointervARB(GLuint index, Enums.ARB_vertex_program pname, [In, Out()] System.IntPtr pointer);
+ public static GetVertexAttribPointervARB glGetVertexAttribPointervARB = ((GetVertexAttribPointervARB)(GL.GetDelegateForExtensionMethod("glGetVertexAttribPointervARB", typeof(GetVertexAttribPointervARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GetVertexAttribPointervNV(GLuint index, Enums.NV_vertex_program pname, [In, Out()] System.IntPtr pointer);
+ public static GetVertexAttribPointervNV glGetVertexAttribPointervNV = ((GetVertexAttribPointervNV)(GL.GetDelegateForExtensionMethod("glGetVertexAttribPointervNV", typeof(GetVertexAttribPointervNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactorbSUN(GLbyte factor);
+ public static GlobalAlphaFactorbSUN glGlobalAlphaFactorbSUN = ((GlobalAlphaFactorbSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactorbSUN", typeof(GlobalAlphaFactorbSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactordSUN(GLdouble factor);
+ public static GlobalAlphaFactordSUN glGlobalAlphaFactordSUN = ((GlobalAlphaFactordSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactordSUN", typeof(GlobalAlphaFactordSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactorfSUN(GLfloat factor);
+ public static GlobalAlphaFactorfSUN glGlobalAlphaFactorfSUN = ((GlobalAlphaFactorfSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactorfSUN", typeof(GlobalAlphaFactorfSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactoriSUN(GLint factor);
+ public static GlobalAlphaFactoriSUN glGlobalAlphaFactoriSUN = ((GlobalAlphaFactoriSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactoriSUN", typeof(GlobalAlphaFactoriSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactorsSUN(GLshort factor);
+ public static GlobalAlphaFactorsSUN glGlobalAlphaFactorsSUN = ((GlobalAlphaFactorsSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactorsSUN", typeof(GlobalAlphaFactorsSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactorubSUN(GLubyte factor);
+ public static GlobalAlphaFactorubSUN glGlobalAlphaFactorubSUN = ((GlobalAlphaFactorubSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactorubSUN", typeof(GlobalAlphaFactorubSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactoruiSUN(GLuint factor);
+ public static GlobalAlphaFactoruiSUN glGlobalAlphaFactoruiSUN = ((GlobalAlphaFactoruiSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactoruiSUN", typeof(GlobalAlphaFactoruiSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void GlobalAlphaFactorusSUN(GLushort factor);
+ public static GlobalAlphaFactorusSUN glGlobalAlphaFactorusSUN = ((GlobalAlphaFactorusSUN)(GL.GetDelegateForExtensionMethod("glGlobalAlphaFactorusSUN", typeof(GlobalAlphaFactorusSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Hint(Enums.HintTarget target, Enums.HintMode mode);
+ public static Hint glHint = ((Hint)(GL.GetDelegateForExtensionMethod("glHint", typeof(Hint)))) ?? new Hint(Imports.Hint);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void HintPGI(Enums.PGI_misc_hints target, GLint mode);
+ public static HintPGI glHintPGI = ((HintPGI)(GL.GetDelegateForExtensionMethod("glHintPGI", typeof(HintPGI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Histogram(Enums.VERSION_1_2 target, GLsizei width, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink);
+ public static Histogram glHistogram = ((Histogram)(GL.GetDelegateForExtensionMethod("glHistogram", typeof(Histogram)))) ?? new Histogram(Imports.Histogram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void HistogramEXT(Enums.HistogramTargetEXT target, GLsizei width, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink);
+ public static HistogramEXT glHistogramEXT = ((HistogramEXT)(GL.GetDelegateForExtensionMethod("glHistogramEXT", typeof(HistogramEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void IglooInterfaceSGIX(Enums.GLenum pname, System.IntPtr @params);
+ public static IglooInterfaceSGIX glIglooInterfaceSGIX = ((IglooInterfaceSGIX)(GL.GetDelegateForExtensionMethod("glIglooInterfaceSGIX", typeof(IglooInterfaceSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ImageTransformParameterfHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLfloat param);
+ public static ImageTransformParameterfHP glImageTransformParameterfHP = ((ImageTransformParameterfHP)(GL.GetDelegateForExtensionMethod("glImageTransformParameterfHP", typeof(ImageTransformParameterfHP))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ImageTransformParameterfvHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, System.IntPtr @params);
+ public static ImageTransformParameterfvHP glImageTransformParameterfvHP = ((ImageTransformParameterfvHP)(GL.GetDelegateForExtensionMethod("glImageTransformParameterfvHP", typeof(ImageTransformParameterfvHP))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ImageTransformParameteriHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, GLint param);
+ public static ImageTransformParameteriHP glImageTransformParameteriHP = ((ImageTransformParameteriHP)(GL.GetDelegateForExtensionMethod("glImageTransformParameteriHP", typeof(ImageTransformParameteriHP))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ImageTransformParameterivHP(Enums.HP_image_transform target, Enums.HP_image_transform pname, System.IntPtr @params);
+ public static ImageTransformParameterivHP glImageTransformParameterivHP = ((ImageTransformParameterivHP)(GL.GetDelegateForExtensionMethod("glImageTransformParameterivHP", typeof(ImageTransformParameterivHP))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexd(GLdouble c);
+ public static Indexd glIndexd = ((Indexd)(GL.GetDelegateForExtensionMethod("glIndexd", typeof(Indexd)))) ?? new Indexd(Imports.Indexd);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexdv(System.IntPtr c);
+ public static Indexdv glIndexdv = ((Indexdv)(GL.GetDelegateForExtensionMethod("glIndexdv", typeof(Indexdv)))) ?? new Indexdv(Imports.Indexdv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexf(GLfloat c);
+ public static Indexf glIndexf = ((Indexf)(GL.GetDelegateForExtensionMethod("glIndexf", typeof(Indexf)))) ?? new Indexf(Imports.Indexf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void IndexFuncEXT(Enums.EXT_index_func func, GLclampf @ref);
+ public static IndexFuncEXT glIndexFuncEXT = ((IndexFuncEXT)(GL.GetDelegateForExtensionMethod("glIndexFuncEXT", typeof(IndexFuncEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexfv(System.IntPtr c);
+ public static Indexfv glIndexfv = ((Indexfv)(GL.GetDelegateForExtensionMethod("glIndexfv", typeof(Indexfv)))) ?? new Indexfv(Imports.Indexfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexi(GLint c);
+ public static Indexi glIndexi = ((Indexi)(GL.GetDelegateForExtensionMethod("glIndexi", typeof(Indexi)))) ?? new Indexi(Imports.Indexi);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexiv(System.IntPtr c);
+ public static Indexiv glIndexiv = ((Indexiv)(GL.GetDelegateForExtensionMethod("glIndexiv", typeof(Indexiv)))) ?? new Indexiv(Imports.Indexiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void IndexMask(GLuint mask);
+ public static IndexMask glIndexMask = ((IndexMask)(GL.GetDelegateForExtensionMethod("glIndexMask", typeof(IndexMask)))) ?? new IndexMask(Imports.IndexMask);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void IndexMaterialEXT(Enums.MaterialFace face, Enums.EXT_index_material mode);
+ public static IndexMaterialEXT glIndexMaterialEXT = ((IndexMaterialEXT)(GL.GetDelegateForExtensionMethod("glIndexMaterialEXT", typeof(IndexMaterialEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void IndexPointer(Enums.IndexPointerType type, GLsizei stride, System.IntPtr pointer);
+ public static IndexPointer glIndexPointer = ((IndexPointer)(GL.GetDelegateForExtensionMethod("glIndexPointer", typeof(IndexPointer)))) ?? new IndexPointer(Imports.IndexPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void IndexPointerEXT(Enums.IndexPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer);
+ public static IndexPointerEXT glIndexPointerEXT = ((IndexPointerEXT)(GL.GetDelegateForExtensionMethod("glIndexPointerEXT", typeof(IndexPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void IndexPointerListIBM(Enums.IndexPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static IndexPointerListIBM glIndexPointerListIBM = ((IndexPointerListIBM)(GL.GetDelegateForExtensionMethod("glIndexPointerListIBM", typeof(IndexPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexs(GLshort c);
+ public static Indexs glIndexs = ((Indexs)(GL.GetDelegateForExtensionMethod("glIndexs", typeof(Indexs)))) ?? new Indexs(Imports.Indexs);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexsv(System.IntPtr c);
+ public static Indexsv glIndexsv = ((Indexsv)(GL.GetDelegateForExtensionMethod("glIndexsv", typeof(Indexsv)))) ?? new Indexsv(Imports.Indexsv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexub(GLubyte c);
+ public static Indexub glIndexub = ((Indexub)(GL.GetDelegateForExtensionMethod("glIndexub", typeof(Indexub)))) ?? new Indexub(Imports.Indexub);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Indexubv(System.IntPtr c);
+ public static Indexubv glIndexubv = ((Indexubv)(GL.GetDelegateForExtensionMethod("glIndexubv", typeof(Indexubv)))) ?? new Indexubv(Imports.Indexubv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void InitNames();
+ public static InitNames glInitNames = ((InitNames)(GL.GetDelegateForExtensionMethod("glInitNames", typeof(InitNames)))) ?? new InitNames(Imports.InitNames);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void InsertComponentEXT(GLuint res, GLuint src, GLuint num);
+ public static InsertComponentEXT glInsertComponentEXT = ((InsertComponentEXT)(GL.GetDelegateForExtensionMethod("glInsertComponentEXT", typeof(InsertComponentEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void InstrumentsBufferSGIX(GLsizei size, [In, Out()] System.IntPtr buffer);
+ public static InstrumentsBufferSGIX glInstrumentsBufferSGIX = ((InstrumentsBufferSGIX)(GL.GetDelegateForExtensionMethod("glInstrumentsBufferSGIX", typeof(InstrumentsBufferSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void InterleavedArrays(Enums.InterleavedArrayFormat format, GLsizei stride, System.IntPtr pointer);
+ public static InterleavedArrays glInterleavedArrays = ((InterleavedArrays)(GL.GetDelegateForExtensionMethod("glInterleavedArrays", typeof(InterleavedArrays)))) ?? new InterleavedArrays(Imports.InterleavedArrays);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsAsyncMarkerSGIX(GLuint marker);
+ public static IsAsyncMarkerSGIX glIsAsyncMarkerSGIX = ((IsAsyncMarkerSGIX)(GL.GetDelegateForExtensionMethod("glIsAsyncMarkerSGIX", typeof(IsAsyncMarkerSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsBuffer(GLuint buffer);
+ public static IsBuffer glIsBuffer = ((IsBuffer)(GL.GetDelegateForExtensionMethod("glIsBuffer", typeof(IsBuffer)))) ?? new IsBuffer(Imports.IsBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsBufferARB(GLuint buffer);
+ public static IsBufferARB glIsBufferARB = ((IsBufferARB)(GL.GetDelegateForExtensionMethod("glIsBufferARB", typeof(IsBufferARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsEnabled(Enums.EnableCap cap);
+ public static IsEnabled glIsEnabled = ((IsEnabled)(GL.GetDelegateForExtensionMethod("glIsEnabled", typeof(IsEnabled)))) ?? new IsEnabled(Imports.IsEnabled);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsEnabledIndexedEXT(Enums.GLenum target, GLuint index);
+ public static IsEnabledIndexedEXT glIsEnabledIndexedEXT = ((IsEnabledIndexedEXT)(GL.GetDelegateForExtensionMethod("glIsEnabledIndexedEXT", typeof(IsEnabledIndexedEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsFenceAPPLE(GLuint fence);
+ public static IsFenceAPPLE glIsFenceAPPLE = ((IsFenceAPPLE)(GL.GetDelegateForExtensionMethod("glIsFenceAPPLE", typeof(IsFenceAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsFenceNV(GLuint fence);
+ public static IsFenceNV glIsFenceNV = ((IsFenceNV)(GL.GetDelegateForExtensionMethod("glIsFenceNV", typeof(IsFenceNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsFramebufferEXT(GLuint framebuffer);
+ public static IsFramebufferEXT glIsFramebufferEXT = ((IsFramebufferEXT)(GL.GetDelegateForExtensionMethod("glIsFramebufferEXT", typeof(IsFramebufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsList(GLuint list);
+ public static IsList glIsList = ((IsList)(GL.GetDelegateForExtensionMethod("glIsList", typeof(IsList)))) ?? new IsList(Imports.IsList);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsObjectBufferATI(GLuint buffer);
+ public static IsObjectBufferATI glIsObjectBufferATI = ((IsObjectBufferATI)(GL.GetDelegateForExtensionMethod("glIsObjectBufferATI", typeof(IsObjectBufferATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsOcclusionQueryNV(GLuint id);
+ public static IsOcclusionQueryNV glIsOcclusionQueryNV = ((IsOcclusionQueryNV)(GL.GetDelegateForExtensionMethod("glIsOcclusionQueryNV", typeof(IsOcclusionQueryNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsProgram(GLuint program);
+ public static IsProgram glIsProgram = ((IsProgram)(GL.GetDelegateForExtensionMethod("glIsProgram", typeof(IsProgram)))) ?? new IsProgram(Imports.IsProgram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsProgramARB(GLuint program);
+ public static IsProgramARB glIsProgramARB = ((IsProgramARB)(GL.GetDelegateForExtensionMethod("glIsProgramARB", typeof(IsProgramARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsProgramNV(GLuint id);
+ public static IsProgramNV glIsProgramNV = ((IsProgramNV)(GL.GetDelegateForExtensionMethod("glIsProgramNV", typeof(IsProgramNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsQuery(GLuint id);
+ public static IsQuery glIsQuery = ((IsQuery)(GL.GetDelegateForExtensionMethod("glIsQuery", typeof(IsQuery)))) ?? new IsQuery(Imports.IsQuery);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsQueryARB(GLuint id);
+ public static IsQueryARB glIsQueryARB = ((IsQueryARB)(GL.GetDelegateForExtensionMethod("glIsQueryARB", typeof(IsQueryARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsRenderbufferEXT(GLuint renderbuffer);
+ public static IsRenderbufferEXT glIsRenderbufferEXT = ((IsRenderbufferEXT)(GL.GetDelegateForExtensionMethod("glIsRenderbufferEXT", typeof(IsRenderbufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsShader(GLuint shader);
+ public static IsShader glIsShader = ((IsShader)(GL.GetDelegateForExtensionMethod("glIsShader", typeof(IsShader)))) ?? new IsShader(Imports.IsShader);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsTexture(GLuint texture);
+ public static IsTexture glIsTexture = ((IsTexture)(GL.GetDelegateForExtensionMethod("glIsTexture", typeof(IsTexture)))) ?? new IsTexture(Imports.IsTexture);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsTextureEXT(GLuint texture);
+ public static IsTextureEXT glIsTextureEXT = ((IsTextureEXT)(GL.GetDelegateForExtensionMethod("glIsTextureEXT", typeof(IsTextureEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsVariantEnabledEXT(GLuint id, Enums.EXT_vertex_shader cap);
+ public static IsVariantEnabledEXT glIsVariantEnabledEXT = ((IsVariantEnabledEXT)(GL.GetDelegateForExtensionMethod("glIsVariantEnabledEXT", typeof(IsVariantEnabledEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean IsVertexArrayAPPLE(GLuint array);
+ public static IsVertexArrayAPPLE glIsVertexArrayAPPLE = ((IsVertexArrayAPPLE)(GL.GetDelegateForExtensionMethod("glIsVertexArrayAPPLE", typeof(IsVertexArrayAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LightEnviSGIX(Enums.LightEnvParameterSGIX pname, GLint param);
+ public static LightEnviSGIX glLightEnviSGIX = ((LightEnviSGIX)(GL.GetDelegateForExtensionMethod("glLightEnviSGIX", typeof(LightEnviSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Lightf(Enums.LightName light, Enums.LightParameter pname, GLfloat param);
+ public static Lightf glLightf = ((Lightf)(GL.GetDelegateForExtensionMethod("glLightf", typeof(Lightf)))) ?? new Lightf(Imports.Lightf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Lightfv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params);
+ public static Lightfv glLightfv = ((Lightfv)(GL.GetDelegateForExtensionMethod("glLightfv", typeof(Lightfv)))) ?? new Lightfv(Imports.Lightfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Lighti(Enums.LightName light, Enums.LightParameter pname, GLint param);
+ public static Lighti glLighti = ((Lighti)(GL.GetDelegateForExtensionMethod("glLighti", typeof(Lighti)))) ?? new Lighti(Imports.Lighti);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Lightiv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params);
+ public static Lightiv glLightiv = ((Lightiv)(GL.GetDelegateForExtensionMethod("glLightiv", typeof(Lightiv)))) ?? new Lightiv(Imports.Lightiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LightModelf(Enums.LightModelParameter pname, GLfloat param);
+ public static LightModelf glLightModelf = ((LightModelf)(GL.GetDelegateForExtensionMethod("glLightModelf", typeof(LightModelf)))) ?? new LightModelf(Imports.LightModelf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LightModelfv(Enums.LightModelParameter pname, System.IntPtr @params);
+ public static LightModelfv glLightModelfv = ((LightModelfv)(GL.GetDelegateForExtensionMethod("glLightModelfv", typeof(LightModelfv)))) ?? new LightModelfv(Imports.LightModelfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LightModeli(Enums.LightModelParameter pname, GLint param);
+ public static LightModeli glLightModeli = ((LightModeli)(GL.GetDelegateForExtensionMethod("glLightModeli", typeof(LightModeli)))) ?? new LightModeli(Imports.LightModeli);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LightModeliv(Enums.LightModelParameter pname, System.IntPtr @params);
+ public static LightModeliv glLightModeliv = ((LightModeliv)(GL.GetDelegateForExtensionMethod("glLightModeliv", typeof(LightModeliv)))) ?? new LightModeliv(Imports.LightModeliv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LineStipple(GLint factor, GLushort pattern);
+ public static LineStipple glLineStipple = ((LineStipple)(GL.GetDelegateForExtensionMethod("glLineStipple", typeof(LineStipple)))) ?? new LineStipple(Imports.LineStipple);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LineWidth(GLfloat width);
+ public static LineWidth glLineWidth = ((LineWidth)(GL.GetDelegateForExtensionMethod("glLineWidth", typeof(LineWidth)))) ?? new LineWidth(Imports.LineWidth);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LinkProgram(GLuint program);
+ public static LinkProgram glLinkProgram = ((LinkProgram)(GL.GetDelegateForExtensionMethod("glLinkProgram", typeof(LinkProgram)))) ?? new LinkProgram(Imports.LinkProgram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LinkProgramARB(GLhandleARB programObj);
+ public static LinkProgramARB glLinkProgramARB = ((LinkProgramARB)(GL.GetDelegateForExtensionMethod("glLinkProgramARB", typeof(LinkProgramARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ListBase(GLuint @base);
+ public static ListBase glListBase = ((ListBase)(GL.GetDelegateForExtensionMethod("glListBase", typeof(ListBase)))) ?? new ListBase(Imports.ListBase);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ListParameterfSGIX(GLuint list, Enums.ListParameterName pname, GLfloat param);
+ public static ListParameterfSGIX glListParameterfSGIX = ((ListParameterfSGIX)(GL.GetDelegateForExtensionMethod("glListParameterfSGIX", typeof(ListParameterfSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ListParameterfvSGIX(GLuint list, Enums.ListParameterName pname, System.IntPtr @params);
+ public static ListParameterfvSGIX glListParameterfvSGIX = ((ListParameterfvSGIX)(GL.GetDelegateForExtensionMethod("glListParameterfvSGIX", typeof(ListParameterfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ListParameteriSGIX(GLuint list, Enums.ListParameterName pname, GLint param);
+ public static ListParameteriSGIX glListParameteriSGIX = ((ListParameteriSGIX)(GL.GetDelegateForExtensionMethod("glListParameteriSGIX", typeof(ListParameteriSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ListParameterivSGIX(GLuint list, Enums.ListParameterName pname, System.IntPtr @params);
+ public static ListParameterivSGIX glListParameterivSGIX = ((ListParameterivSGIX)(GL.GetDelegateForExtensionMethod("glListParameterivSGIX", typeof(ListParameterivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadIdentity();
+ public static LoadIdentity glLoadIdentity = ((LoadIdentity)(GL.GetDelegateForExtensionMethod("glLoadIdentity", typeof(LoadIdentity)))) ?? new LoadIdentity(Imports.LoadIdentity);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadIdentityDeformationMapSGIX(Enums.FfdMaskSGIX mask);
+ public static LoadIdentityDeformationMapSGIX glLoadIdentityDeformationMapSGIX = ((LoadIdentityDeformationMapSGIX)(GL.GetDelegateForExtensionMethod("glLoadIdentityDeformationMapSGIX", typeof(LoadIdentityDeformationMapSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadMatrixd(System.IntPtr m);
+ public static LoadMatrixd glLoadMatrixd = ((LoadMatrixd)(GL.GetDelegateForExtensionMethod("glLoadMatrixd", typeof(LoadMatrixd)))) ?? new LoadMatrixd(Imports.LoadMatrixd);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadMatrixf(System.IntPtr m);
+ public static LoadMatrixf glLoadMatrixf = ((LoadMatrixf)(GL.GetDelegateForExtensionMethod("glLoadMatrixf", typeof(LoadMatrixf)))) ?? new LoadMatrixf(Imports.LoadMatrixf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadName(GLuint name);
+ public static LoadName glLoadName = ((LoadName)(GL.GetDelegateForExtensionMethod("glLoadName", typeof(LoadName)))) ?? new LoadName(Imports.LoadName);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadProgramNV(Enums.NV_vertex_program target, GLuint id, GLsizei len, System.IntPtr program);
+ public static LoadProgramNV glLoadProgramNV = ((LoadProgramNV)(GL.GetDelegateForExtensionMethod("glLoadProgramNV", typeof(LoadProgramNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadTransposeMatrixd(System.IntPtr m);
+ public static LoadTransposeMatrixd glLoadTransposeMatrixd = ((LoadTransposeMatrixd)(GL.GetDelegateForExtensionMethod("glLoadTransposeMatrixd", typeof(LoadTransposeMatrixd)))) ?? new LoadTransposeMatrixd(Imports.LoadTransposeMatrixd);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadTransposeMatrixdARB(System.IntPtr m);
+ public static LoadTransposeMatrixdARB glLoadTransposeMatrixdARB = ((LoadTransposeMatrixdARB)(GL.GetDelegateForExtensionMethod("glLoadTransposeMatrixdARB", typeof(LoadTransposeMatrixdARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadTransposeMatrixf(System.IntPtr m);
+ public static LoadTransposeMatrixf glLoadTransposeMatrixf = ((LoadTransposeMatrixf)(GL.GetDelegateForExtensionMethod("glLoadTransposeMatrixf", typeof(LoadTransposeMatrixf)))) ?? new LoadTransposeMatrixf(Imports.LoadTransposeMatrixf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LoadTransposeMatrixfARB(System.IntPtr m);
+ public static LoadTransposeMatrixfARB glLoadTransposeMatrixfARB = ((LoadTransposeMatrixfARB)(GL.GetDelegateForExtensionMethod("glLoadTransposeMatrixfARB", typeof(LoadTransposeMatrixfARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LockArraysEXT(GLint first, GLsizei count);
+ public static LockArraysEXT glLockArraysEXT = ((LockArraysEXT)(GL.GetDelegateForExtensionMethod("glLockArraysEXT", typeof(LockArraysEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void LogicOp(Enums.LogicOp opcode);
+ public static LogicOp glLogicOp = ((LogicOp)(GL.GetDelegateForExtensionMethod("glLogicOp", typeof(LogicOp)))) ?? new LogicOp(Imports.LogicOp);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Map1d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, System.IntPtr points);
+ public static Map1d glMap1d = ((Map1d)(GL.GetDelegateForExtensionMethod("glMap1d", typeof(Map1d)))) ?? new Map1d(Imports.Map1d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Map1f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, System.IntPtr points);
+ public static Map1f glMap1f = ((Map1f)(GL.GetDelegateForExtensionMethod("glMap1f", typeof(Map1f)))) ?? new Map1f(Imports.Map1f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Map2d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, System.IntPtr points);
+ public static Map2d glMap2d = ((Map2d)(GL.GetDelegateForExtensionMethod("glMap2d", typeof(Map2d)))) ?? new Map2d(Imports.Map2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Map2f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, System.IntPtr points);
+ public static Map2f glMap2f = ((Map2f)(GL.GetDelegateForExtensionMethod("glMap2f", typeof(Map2f)))) ?? new Map2f(Imports.Map2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate IntPtr MapBuffer(Enums.VERSION_1_5 target, Enums.VERSION_1_5 access);
+ public static MapBuffer glMapBuffer = ((MapBuffer)(GL.GetDelegateForExtensionMethod("glMapBuffer", typeof(MapBuffer)))) ?? new MapBuffer(Imports.MapBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate IntPtr MapBufferARB(Enums.ARB_vertex_buffer_object target, Enums.ARB_vertex_buffer_object access);
+ public static MapBufferARB glMapBufferARB = ((MapBufferARB)(GL.GetDelegateForExtensionMethod("glMapBufferARB", typeof(MapBufferARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MapControlPointsNV(Enums.NV_evaluators target, GLuint index, Enums.NV_evaluators type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, [MarshalAs(UnmanagedType.Bool)] bool packed, System.IntPtr points);
+ public static MapControlPointsNV glMapControlPointsNV = ((MapControlPointsNV)(GL.GetDelegateForExtensionMethod("glMapControlPointsNV", typeof(MapControlPointsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MapGrid1d(GLint un, GLdouble u1, GLdouble u2);
+ public static MapGrid1d glMapGrid1d = ((MapGrid1d)(GL.GetDelegateForExtensionMethod("glMapGrid1d", typeof(MapGrid1d)))) ?? new MapGrid1d(Imports.MapGrid1d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MapGrid1f(GLint un, GLfloat u1, GLfloat u2);
+ public static MapGrid1f glMapGrid1f = ((MapGrid1f)(GL.GetDelegateForExtensionMethod("glMapGrid1f", typeof(MapGrid1f)))) ?? new MapGrid1f(Imports.MapGrid1f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+ public static MapGrid2d glMapGrid2d = ((MapGrid2d)(GL.GetDelegateForExtensionMethod("glMapGrid2d", typeof(MapGrid2d)))) ?? new MapGrid2d(Imports.MapGrid2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+ public static MapGrid2f glMapGrid2f = ((MapGrid2f)(GL.GetDelegateForExtensionMethod("glMapGrid2f", typeof(MapGrid2f)))) ?? new MapGrid2f(Imports.MapGrid2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate IntPtr MapObjectBufferATI(GLuint buffer);
+ public static MapObjectBufferATI glMapObjectBufferATI = ((MapObjectBufferATI)(GL.GetDelegateForExtensionMethod("glMapObjectBufferATI", typeof(MapObjectBufferATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MapParameterfvNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, System.IntPtr @params);
+ public static MapParameterfvNV glMapParameterfvNV = ((MapParameterfvNV)(GL.GetDelegateForExtensionMethod("glMapParameterfvNV", typeof(MapParameterfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MapParameterivNV(Enums.NV_evaluators target, Enums.NV_evaluators pname, System.IntPtr @params);
+ public static MapParameterivNV glMapParameterivNV = ((MapParameterivNV)(GL.GetDelegateForExtensionMethod("glMapParameterivNV", typeof(MapParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param);
+ public static Materialf glMaterialf = ((Materialf)(GL.GetDelegateForExtensionMethod("glMaterialf", typeof(Materialf)))) ?? new Materialf(Imports.Materialf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ public static Materialfv glMaterialfv = ((Materialfv)(GL.GetDelegateForExtensionMethod("glMaterialfv", typeof(Materialfv)))) ?? new Materialfv(Imports.Materialfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param);
+ public static Materiali glMateriali = ((Materiali)(GL.GetDelegateForExtensionMethod("glMateriali", typeof(Materiali)))) ?? new Materiali(Imports.Materiali);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ public static Materialiv glMaterialiv = ((Materialiv)(GL.GetDelegateForExtensionMethod("glMaterialiv", typeof(Materialiv)))) ?? new Materialiv(Imports.Materialiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MatrixIndexPointerARB(GLint size, Enums.ARB_matrix_palette type, GLsizei stride, System.IntPtr pointer);
+ public static MatrixIndexPointerARB glMatrixIndexPointerARB = ((MatrixIndexPointerARB)(GL.GetDelegateForExtensionMethod("glMatrixIndexPointerARB", typeof(MatrixIndexPointerARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MatrixIndexubvARB(GLint size, System.IntPtr indices);
+ public static MatrixIndexubvARB glMatrixIndexubvARB = ((MatrixIndexubvARB)(GL.GetDelegateForExtensionMethod("glMatrixIndexubvARB", typeof(MatrixIndexubvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MatrixIndexuivARB(GLint size, System.IntPtr indices);
+ public static MatrixIndexuivARB glMatrixIndexuivARB = ((MatrixIndexuivARB)(GL.GetDelegateForExtensionMethod("glMatrixIndexuivARB", typeof(MatrixIndexuivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MatrixIndexusvARB(GLint size, System.IntPtr indices);
+ public static MatrixIndexusvARB glMatrixIndexusvARB = ((MatrixIndexusvARB)(GL.GetDelegateForExtensionMethod("glMatrixIndexusvARB", typeof(MatrixIndexusvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MatrixMode(Enums.MatrixMode mode);
+ public static MatrixMode glMatrixMode = ((MatrixMode)(GL.GetDelegateForExtensionMethod("glMatrixMode", typeof(MatrixMode)))) ?? new MatrixMode(Imports.MatrixMode);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Minmax(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink);
+ public static Minmax glMinmax = ((Minmax)(GL.GetDelegateForExtensionMethod("glMinmax", typeof(Minmax)))) ?? new Minmax(Imports.Minmax);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MinmaxEXT(Enums.MinmaxTargetEXT target, Enums.PixelInternalFormat internalformat, [MarshalAs(UnmanagedType.Bool)] bool sink);
+ public static MinmaxEXT glMinmaxEXT = ((MinmaxEXT)(GL.GetDelegateForExtensionMethod("glMinmaxEXT", typeof(MinmaxEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiDrawArrays(Enums.BeginMode mode, [In, Out()] System.IntPtr first, [In, Out()] System.IntPtr count, GLsizei primcount);
+ public static MultiDrawArrays glMultiDrawArrays = ((MultiDrawArrays)(GL.GetDelegateForExtensionMethod("glMultiDrawArrays", typeof(MultiDrawArrays)))) ?? new MultiDrawArrays(Imports.MultiDrawArrays);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiDrawArraysEXT(Enums.BeginMode mode, [In, Out()] System.IntPtr first, [In, Out()] System.IntPtr count, GLsizei primcount);
+ public static MultiDrawArraysEXT glMultiDrawArraysEXT = ((MultiDrawArraysEXT)(GL.GetDelegateForExtensionMethod("glMultiDrawArraysEXT", typeof(MultiDrawArraysEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiDrawElementArrayAPPLE(Enums.BeginMode mode, System.IntPtr first, System.IntPtr count, GLsizei primcount);
+ public static MultiDrawElementArrayAPPLE glMultiDrawElementArrayAPPLE = ((MultiDrawElementArrayAPPLE)(GL.GetDelegateForExtensionMethod("glMultiDrawElementArrayAPPLE", typeof(MultiDrawElementArrayAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiDrawElements(Enums.BeginMode mode, System.IntPtr count, Enums.VERSION_1_4 type, System.IntPtr indices, GLsizei primcount);
+ public static MultiDrawElements glMultiDrawElements = ((MultiDrawElements)(GL.GetDelegateForExtensionMethod("glMultiDrawElements", typeof(MultiDrawElements)))) ?? new MultiDrawElements(Imports.MultiDrawElements);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiDrawElementsEXT(Enums.BeginMode mode, System.IntPtr count, Enums.EXT_multi_draw_arrays type, System.IntPtr indices, GLsizei primcount);
+ public static MultiDrawElementsEXT glMultiDrawElementsEXT = ((MultiDrawElementsEXT)(GL.GetDelegateForExtensionMethod("glMultiDrawElementsEXT", typeof(MultiDrawElementsEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiDrawRangeElementArrayAPPLE(Enums.BeginMode mode, GLuint start, GLuint end, System.IntPtr first, System.IntPtr count, GLsizei primcount);
+ public static MultiDrawRangeElementArrayAPPLE glMultiDrawRangeElementArrayAPPLE = ((MultiDrawRangeElementArrayAPPLE)(GL.GetDelegateForExtensionMethod("glMultiDrawRangeElementArrayAPPLE", typeof(MultiDrawRangeElementArrayAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiModeDrawArraysIBM(System.IntPtr mode, System.IntPtr first, System.IntPtr count, GLsizei primcount, GLint modestride);
+ public static MultiModeDrawArraysIBM glMultiModeDrawArraysIBM = ((MultiModeDrawArraysIBM)(GL.GetDelegateForExtensionMethod("glMultiModeDrawArraysIBM", typeof(MultiModeDrawArraysIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiModeDrawElementsIBM(System.IntPtr mode, System.IntPtr count, Enums.IBM_multimode_draw_arrays type, System.IntPtr indices, GLsizei primcount, GLint modestride);
+ public static MultiModeDrawElementsIBM glMultiModeDrawElementsIBM = ((MultiModeDrawElementsIBM)(GL.GetDelegateForExtensionMethod("glMultiModeDrawElementsIBM", typeof(MultiModeDrawElementsIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1d(Enums.VERSION_1_3 target, GLdouble s);
+ public static MultiTexCoord1d glMultiTexCoord1d = ((MultiTexCoord1d)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1d", typeof(MultiTexCoord1d)))) ?? new MultiTexCoord1d(Imports.MultiTexCoord1d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1dARB(Enums.ARB_multitexture target, GLdouble s);
+ public static MultiTexCoord1dARB glMultiTexCoord1dARB = ((MultiTexCoord1dARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1dARB", typeof(MultiTexCoord1dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord1dv glMultiTexCoord1dv = ((MultiTexCoord1dv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1dv", typeof(MultiTexCoord1dv)))) ?? new MultiTexCoord1dv(Imports.MultiTexCoord1dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1dvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord1dvARB glMultiTexCoord1dvARB = ((MultiTexCoord1dvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1dvARB", typeof(MultiTexCoord1dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1f(Enums.VERSION_1_3 target, GLfloat s);
+ public static MultiTexCoord1f glMultiTexCoord1f = ((MultiTexCoord1f)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1f", typeof(MultiTexCoord1f)))) ?? new MultiTexCoord1f(Imports.MultiTexCoord1f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1fARB(Enums.ARB_multitexture target, GLfloat s);
+ public static MultiTexCoord1fARB glMultiTexCoord1fARB = ((MultiTexCoord1fARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1fARB", typeof(MultiTexCoord1fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord1fv glMultiTexCoord1fv = ((MultiTexCoord1fv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1fv", typeof(MultiTexCoord1fv)))) ?? new MultiTexCoord1fv(Imports.MultiTexCoord1fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1fvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord1fvARB glMultiTexCoord1fvARB = ((MultiTexCoord1fvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1fvARB", typeof(MultiTexCoord1fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1hNV(Enums.NV_half_float target, GLhalfNV s);
+ public static MultiTexCoord1hNV glMultiTexCoord1hNV = ((MultiTexCoord1hNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1hNV", typeof(MultiTexCoord1hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1hvNV(Enums.NV_half_float target, System.IntPtr v);
+ public static MultiTexCoord1hvNV glMultiTexCoord1hvNV = ((MultiTexCoord1hvNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1hvNV", typeof(MultiTexCoord1hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1i(Enums.VERSION_1_3 target, GLint s);
+ public static MultiTexCoord1i glMultiTexCoord1i = ((MultiTexCoord1i)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1i", typeof(MultiTexCoord1i)))) ?? new MultiTexCoord1i(Imports.MultiTexCoord1i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1iARB(Enums.ARB_multitexture target, GLint s);
+ public static MultiTexCoord1iARB glMultiTexCoord1iARB = ((MultiTexCoord1iARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1iARB", typeof(MultiTexCoord1iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord1iv glMultiTexCoord1iv = ((MultiTexCoord1iv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1iv", typeof(MultiTexCoord1iv)))) ?? new MultiTexCoord1iv(Imports.MultiTexCoord1iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1ivARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord1ivARB glMultiTexCoord1ivARB = ((MultiTexCoord1ivARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1ivARB", typeof(MultiTexCoord1ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1s(Enums.VERSION_1_3 target, GLshort s);
+ public static MultiTexCoord1s glMultiTexCoord1s = ((MultiTexCoord1s)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1s", typeof(MultiTexCoord1s)))) ?? new MultiTexCoord1s(Imports.MultiTexCoord1s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1sARB(Enums.ARB_multitexture target, GLshort s);
+ public static MultiTexCoord1sARB glMultiTexCoord1sARB = ((MultiTexCoord1sARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1sARB", typeof(MultiTexCoord1sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord1sv glMultiTexCoord1sv = ((MultiTexCoord1sv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1sv", typeof(MultiTexCoord1sv)))) ?? new MultiTexCoord1sv(Imports.MultiTexCoord1sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord1svARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord1svARB glMultiTexCoord1svARB = ((MultiTexCoord1svARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord1svARB", typeof(MultiTexCoord1svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t);
+ public static MultiTexCoord2d glMultiTexCoord2d = ((MultiTexCoord2d)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2d", typeof(MultiTexCoord2d)))) ?? new MultiTexCoord2d(Imports.MultiTexCoord2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2dARB(Enums.ARB_multitexture target, GLdouble s, GLdouble t);
+ public static MultiTexCoord2dARB glMultiTexCoord2dARB = ((MultiTexCoord2dARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2dARB", typeof(MultiTexCoord2dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord2dv glMultiTexCoord2dv = ((MultiTexCoord2dv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2dv", typeof(MultiTexCoord2dv)))) ?? new MultiTexCoord2dv(Imports.MultiTexCoord2dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2dvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord2dvARB glMultiTexCoord2dvARB = ((MultiTexCoord2dvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2dvARB", typeof(MultiTexCoord2dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t);
+ public static MultiTexCoord2f glMultiTexCoord2f = ((MultiTexCoord2f)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2f", typeof(MultiTexCoord2f)))) ?? new MultiTexCoord2f(Imports.MultiTexCoord2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2fARB(Enums.ARB_multitexture target, GLfloat s, GLfloat t);
+ public static MultiTexCoord2fARB glMultiTexCoord2fARB = ((MultiTexCoord2fARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2fARB", typeof(MultiTexCoord2fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord2fv glMultiTexCoord2fv = ((MultiTexCoord2fv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2fv", typeof(MultiTexCoord2fv)))) ?? new MultiTexCoord2fv(Imports.MultiTexCoord2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2fvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord2fvARB glMultiTexCoord2fvARB = ((MultiTexCoord2fvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2fvARB", typeof(MultiTexCoord2fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2hNV(Enums.NV_half_float target, GLhalfNV s, GLhalfNV t);
+ public static MultiTexCoord2hNV glMultiTexCoord2hNV = ((MultiTexCoord2hNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2hNV", typeof(MultiTexCoord2hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2hvNV(Enums.NV_half_float target, System.IntPtr v);
+ public static MultiTexCoord2hvNV glMultiTexCoord2hvNV = ((MultiTexCoord2hvNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2hvNV", typeof(MultiTexCoord2hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2i(Enums.VERSION_1_3 target, GLint s, GLint t);
+ public static MultiTexCoord2i glMultiTexCoord2i = ((MultiTexCoord2i)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2i", typeof(MultiTexCoord2i)))) ?? new MultiTexCoord2i(Imports.MultiTexCoord2i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2iARB(Enums.ARB_multitexture target, GLint s, GLint t);
+ public static MultiTexCoord2iARB glMultiTexCoord2iARB = ((MultiTexCoord2iARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2iARB", typeof(MultiTexCoord2iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord2iv glMultiTexCoord2iv = ((MultiTexCoord2iv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2iv", typeof(MultiTexCoord2iv)))) ?? new MultiTexCoord2iv(Imports.MultiTexCoord2iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2ivARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord2ivARB glMultiTexCoord2ivARB = ((MultiTexCoord2ivARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2ivARB", typeof(MultiTexCoord2ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2s(Enums.VERSION_1_3 target, GLshort s, GLshort t);
+ public static MultiTexCoord2s glMultiTexCoord2s = ((MultiTexCoord2s)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2s", typeof(MultiTexCoord2s)))) ?? new MultiTexCoord2s(Imports.MultiTexCoord2s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2sARB(Enums.ARB_multitexture target, GLshort s, GLshort t);
+ public static MultiTexCoord2sARB glMultiTexCoord2sARB = ((MultiTexCoord2sARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2sARB", typeof(MultiTexCoord2sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord2sv glMultiTexCoord2sv = ((MultiTexCoord2sv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2sv", typeof(MultiTexCoord2sv)))) ?? new MultiTexCoord2sv(Imports.MultiTexCoord2sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord2svARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord2svARB glMultiTexCoord2svARB = ((MultiTexCoord2svARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord2svARB", typeof(MultiTexCoord2svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r);
+ public static MultiTexCoord3d glMultiTexCoord3d = ((MultiTexCoord3d)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3d", typeof(MultiTexCoord3d)))) ?? new MultiTexCoord3d(Imports.MultiTexCoord3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3dARB(Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r);
+ public static MultiTexCoord3dARB glMultiTexCoord3dARB = ((MultiTexCoord3dARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3dARB", typeof(MultiTexCoord3dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord3dv glMultiTexCoord3dv = ((MultiTexCoord3dv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3dv", typeof(MultiTexCoord3dv)))) ?? new MultiTexCoord3dv(Imports.MultiTexCoord3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3dvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord3dvARB glMultiTexCoord3dvARB = ((MultiTexCoord3dvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3dvARB", typeof(MultiTexCoord3dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r);
+ public static MultiTexCoord3f glMultiTexCoord3f = ((MultiTexCoord3f)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3f", typeof(MultiTexCoord3f)))) ?? new MultiTexCoord3f(Imports.MultiTexCoord3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3fARB(Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r);
+ public static MultiTexCoord3fARB glMultiTexCoord3fARB = ((MultiTexCoord3fARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3fARB", typeof(MultiTexCoord3fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord3fv glMultiTexCoord3fv = ((MultiTexCoord3fv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3fv", typeof(MultiTexCoord3fv)))) ?? new MultiTexCoord3fv(Imports.MultiTexCoord3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3fvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord3fvARB glMultiTexCoord3fvARB = ((MultiTexCoord3fvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3fvARB", typeof(MultiTexCoord3fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3hNV(Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r);
+ public static MultiTexCoord3hNV glMultiTexCoord3hNV = ((MultiTexCoord3hNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3hNV", typeof(MultiTexCoord3hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3hvNV(Enums.NV_half_float target, System.IntPtr v);
+ public static MultiTexCoord3hvNV glMultiTexCoord3hvNV = ((MultiTexCoord3hvNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3hvNV", typeof(MultiTexCoord3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3i(Enums.VERSION_1_3 target, GLint s, GLint t, GLint r);
+ public static MultiTexCoord3i glMultiTexCoord3i = ((MultiTexCoord3i)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3i", typeof(MultiTexCoord3i)))) ?? new MultiTexCoord3i(Imports.MultiTexCoord3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3iARB(Enums.ARB_multitexture target, GLint s, GLint t, GLint r);
+ public static MultiTexCoord3iARB glMultiTexCoord3iARB = ((MultiTexCoord3iARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3iARB", typeof(MultiTexCoord3iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord3iv glMultiTexCoord3iv = ((MultiTexCoord3iv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3iv", typeof(MultiTexCoord3iv)))) ?? new MultiTexCoord3iv(Imports.MultiTexCoord3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3ivARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord3ivARB glMultiTexCoord3ivARB = ((MultiTexCoord3ivARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3ivARB", typeof(MultiTexCoord3ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3s(Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r);
+ public static MultiTexCoord3s glMultiTexCoord3s = ((MultiTexCoord3s)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3s", typeof(MultiTexCoord3s)))) ?? new MultiTexCoord3s(Imports.MultiTexCoord3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3sARB(Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r);
+ public static MultiTexCoord3sARB glMultiTexCoord3sARB = ((MultiTexCoord3sARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3sARB", typeof(MultiTexCoord3sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord3sv glMultiTexCoord3sv = ((MultiTexCoord3sv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3sv", typeof(MultiTexCoord3sv)))) ?? new MultiTexCoord3sv(Imports.MultiTexCoord3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord3svARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord3svARB glMultiTexCoord3svARB = ((MultiTexCoord3svARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord3svARB", typeof(MultiTexCoord3svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+ public static MultiTexCoord4d glMultiTexCoord4d = ((MultiTexCoord4d)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4d", typeof(MultiTexCoord4d)))) ?? new MultiTexCoord4d(Imports.MultiTexCoord4d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4dARB(Enums.ARB_multitexture target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+ public static MultiTexCoord4dARB glMultiTexCoord4dARB = ((MultiTexCoord4dARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4dARB", typeof(MultiTexCoord4dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord4dv glMultiTexCoord4dv = ((MultiTexCoord4dv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4dv", typeof(MultiTexCoord4dv)))) ?? new MultiTexCoord4dv(Imports.MultiTexCoord4dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4dvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord4dvARB glMultiTexCoord4dvARB = ((MultiTexCoord4dvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4dvARB", typeof(MultiTexCoord4dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+ public static MultiTexCoord4f glMultiTexCoord4f = ((MultiTexCoord4f)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4f", typeof(MultiTexCoord4f)))) ?? new MultiTexCoord4f(Imports.MultiTexCoord4f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4fARB(Enums.ARB_multitexture target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+ public static MultiTexCoord4fARB glMultiTexCoord4fARB = ((MultiTexCoord4fARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4fARB", typeof(MultiTexCoord4fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord4fv glMultiTexCoord4fv = ((MultiTexCoord4fv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4fv", typeof(MultiTexCoord4fv)))) ?? new MultiTexCoord4fv(Imports.MultiTexCoord4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4fvARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord4fvARB glMultiTexCoord4fvARB = ((MultiTexCoord4fvARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4fvARB", typeof(MultiTexCoord4fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4hNV(Enums.NV_half_float target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+ public static MultiTexCoord4hNV glMultiTexCoord4hNV = ((MultiTexCoord4hNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4hNV", typeof(MultiTexCoord4hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4hvNV(Enums.NV_half_float target, System.IntPtr v);
+ public static MultiTexCoord4hvNV glMultiTexCoord4hvNV = ((MultiTexCoord4hvNV)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4hvNV", typeof(MultiTexCoord4hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4i(Enums.VERSION_1_3 target, GLint s, GLint t, GLint r, GLint q);
+ public static MultiTexCoord4i glMultiTexCoord4i = ((MultiTexCoord4i)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4i", typeof(MultiTexCoord4i)))) ?? new MultiTexCoord4i(Imports.MultiTexCoord4i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4iARB(Enums.ARB_multitexture target, GLint s, GLint t, GLint r, GLint q);
+ public static MultiTexCoord4iARB glMultiTexCoord4iARB = ((MultiTexCoord4iARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4iARB", typeof(MultiTexCoord4iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord4iv glMultiTexCoord4iv = ((MultiTexCoord4iv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4iv", typeof(MultiTexCoord4iv)))) ?? new MultiTexCoord4iv(Imports.MultiTexCoord4iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4ivARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord4ivARB glMultiTexCoord4ivARB = ((MultiTexCoord4ivARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4ivARB", typeof(MultiTexCoord4ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4s(Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r, GLshort q);
+ public static MultiTexCoord4s glMultiTexCoord4s = ((MultiTexCoord4s)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4s", typeof(MultiTexCoord4s)))) ?? new MultiTexCoord4s(Imports.MultiTexCoord4s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4sARB(Enums.ARB_multitexture target, GLshort s, GLshort t, GLshort r, GLshort q);
+ public static MultiTexCoord4sARB glMultiTexCoord4sARB = ((MultiTexCoord4sARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4sARB", typeof(MultiTexCoord4sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ public static MultiTexCoord4sv glMultiTexCoord4sv = ((MultiTexCoord4sv)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4sv", typeof(MultiTexCoord4sv)))) ?? new MultiTexCoord4sv(Imports.MultiTexCoord4sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultiTexCoord4svARB(Enums.ARB_multitexture target, System.IntPtr v);
+ public static MultiTexCoord4svARB glMultiTexCoord4svARB = ((MultiTexCoord4svARB)(GL.GetDelegateForExtensionMethod("glMultiTexCoord4svARB", typeof(MultiTexCoord4svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultMatrixd(System.IntPtr m);
+ public static MultMatrixd glMultMatrixd = ((MultMatrixd)(GL.GetDelegateForExtensionMethod("glMultMatrixd", typeof(MultMatrixd)))) ?? new MultMatrixd(Imports.MultMatrixd);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultMatrixf(System.IntPtr m);
+ public static MultMatrixf glMultMatrixf = ((MultMatrixf)(GL.GetDelegateForExtensionMethod("glMultMatrixf", typeof(MultMatrixf)))) ?? new MultMatrixf(Imports.MultMatrixf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultTransposeMatrixd(System.IntPtr m);
+ public static MultTransposeMatrixd glMultTransposeMatrixd = ((MultTransposeMatrixd)(GL.GetDelegateForExtensionMethod("glMultTransposeMatrixd", typeof(MultTransposeMatrixd)))) ?? new MultTransposeMatrixd(Imports.MultTransposeMatrixd);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultTransposeMatrixdARB(System.IntPtr m);
+ public static MultTransposeMatrixdARB glMultTransposeMatrixdARB = ((MultTransposeMatrixdARB)(GL.GetDelegateForExtensionMethod("glMultTransposeMatrixdARB", typeof(MultTransposeMatrixdARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultTransposeMatrixf(System.IntPtr m);
+ public static MultTransposeMatrixf glMultTransposeMatrixf = ((MultTransposeMatrixf)(GL.GetDelegateForExtensionMethod("glMultTransposeMatrixf", typeof(MultTransposeMatrixf)))) ?? new MultTransposeMatrixf(Imports.MultTransposeMatrixf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void MultTransposeMatrixfARB(System.IntPtr m);
+ public static MultTransposeMatrixfARB glMultTransposeMatrixfARB = ((MultTransposeMatrixfARB)(GL.GetDelegateForExtensionMethod("glMultTransposeMatrixfARB", typeof(MultTransposeMatrixfARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NewList(GLuint list, Enums.ListMode mode);
+ public static NewList glNewList = ((NewList)(GL.GetDelegateForExtensionMethod("glNewList", typeof(NewList)))) ?? new NewList(Imports.NewList);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLuint NewObjectBufferATI(GLsizei size, System.IntPtr pointer, Enums.ATI_vertex_array_object usage);
+ public static NewObjectBufferATI glNewObjectBufferATI = ((NewObjectBufferATI)(GL.GetDelegateForExtensionMethod("glNewObjectBufferATI", typeof(NewObjectBufferATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3b(GLbyte nx, GLbyte ny, GLbyte nz);
+ public static Normal3b glNormal3b = ((Normal3b)(GL.GetDelegateForExtensionMethod("glNormal3b", typeof(Normal3b)))) ?? new Normal3b(Imports.Normal3b);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3bv(System.IntPtr v);
+ public static Normal3bv glNormal3bv = ((Normal3bv)(GL.GetDelegateForExtensionMethod("glNormal3bv", typeof(Normal3bv)))) ?? new Normal3bv(Imports.Normal3bv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3d(GLdouble nx, GLdouble ny, GLdouble nz);
+ public static Normal3d glNormal3d = ((Normal3d)(GL.GetDelegateForExtensionMethod("glNormal3d", typeof(Normal3d)))) ?? new Normal3d(Imports.Normal3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3dv(System.IntPtr v);
+ public static Normal3dv glNormal3dv = ((Normal3dv)(GL.GetDelegateForExtensionMethod("glNormal3dv", typeof(Normal3dv)))) ?? new Normal3dv(Imports.Normal3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz);
+ public static Normal3f glNormal3f = ((Normal3f)(GL.GetDelegateForExtensionMethod("glNormal3f", typeof(Normal3f)))) ?? new Normal3f(Imports.Normal3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3fv(System.IntPtr v);
+ public static Normal3fv glNormal3fv = ((Normal3fv)(GL.GetDelegateForExtensionMethod("glNormal3fv", typeof(Normal3fv)))) ?? new Normal3fv(Imports.Normal3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+ public static Normal3fVertex3fSUN glNormal3fVertex3fSUN = ((Normal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glNormal3fVertex3fSUN", typeof(Normal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3fVertex3fvSUN(System.IntPtr n, System.IntPtr v);
+ public static Normal3fVertex3fvSUN glNormal3fVertex3fvSUN = ((Normal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glNormal3fVertex3fvSUN", typeof(Normal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz);
+ public static Normal3hNV glNormal3hNV = ((Normal3hNV)(GL.GetDelegateForExtensionMethod("glNormal3hNV", typeof(Normal3hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3hvNV(System.IntPtr v);
+ public static Normal3hvNV glNormal3hvNV = ((Normal3hvNV)(GL.GetDelegateForExtensionMethod("glNormal3hvNV", typeof(Normal3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3i(GLint nx, GLint ny, GLint nz);
+ public static Normal3i glNormal3i = ((Normal3i)(GL.GetDelegateForExtensionMethod("glNormal3i", typeof(Normal3i)))) ?? new Normal3i(Imports.Normal3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3iv(System.IntPtr v);
+ public static Normal3iv glNormal3iv = ((Normal3iv)(GL.GetDelegateForExtensionMethod("glNormal3iv", typeof(Normal3iv)))) ?? new Normal3iv(Imports.Normal3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3s(GLshort nx, GLshort ny, GLshort nz);
+ public static Normal3s glNormal3s = ((Normal3s)(GL.GetDelegateForExtensionMethod("glNormal3s", typeof(Normal3s)))) ?? new Normal3s(Imports.Normal3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Normal3sv(System.IntPtr v);
+ public static Normal3sv glNormal3sv = ((Normal3sv)(GL.GetDelegateForExtensionMethod("glNormal3sv", typeof(Normal3sv)))) ?? new Normal3sv(Imports.Normal3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalPointer(Enums.NormalPointerType type, GLsizei stride, System.IntPtr pointer);
+ public static NormalPointer glNormalPointer = ((NormalPointer)(GL.GetDelegateForExtensionMethod("glNormalPointer", typeof(NormalPointer)))) ?? new NormalPointer(Imports.NormalPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalPointerEXT(Enums.NormalPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer);
+ public static NormalPointerEXT glNormalPointerEXT = ((NormalPointerEXT)(GL.GetDelegateForExtensionMethod("glNormalPointerEXT", typeof(NormalPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalPointerListIBM(Enums.NormalPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static NormalPointerListIBM glNormalPointerListIBM = ((NormalPointerListIBM)(GL.GetDelegateForExtensionMethod("glNormalPointerListIBM", typeof(NormalPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalPointervINTEL(Enums.NormalPointerType type, System.IntPtr pointer);
+ public static NormalPointervINTEL glNormalPointervINTEL = ((NormalPointervINTEL)(GL.GetDelegateForExtensionMethod("glNormalPointervINTEL", typeof(NormalPointervINTEL))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3bATI(Enums.ATI_vertex_streams stream, GLbyte nx, GLbyte ny, GLbyte nz);
+ public static NormalStream3bATI glNormalStream3bATI = ((NormalStream3bATI)(GL.GetDelegateForExtensionMethod("glNormalStream3bATI", typeof(NormalStream3bATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3bvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static NormalStream3bvATI glNormalStream3bvATI = ((NormalStream3bvATI)(GL.GetDelegateForExtensionMethod("glNormalStream3bvATI", typeof(NormalStream3bvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3dATI(Enums.ATI_vertex_streams stream, GLdouble nx, GLdouble ny, GLdouble nz);
+ public static NormalStream3dATI glNormalStream3dATI = ((NormalStream3dATI)(GL.GetDelegateForExtensionMethod("glNormalStream3dATI", typeof(NormalStream3dATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static NormalStream3dvATI glNormalStream3dvATI = ((NormalStream3dvATI)(GL.GetDelegateForExtensionMethod("glNormalStream3dvATI", typeof(NormalStream3dvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3fATI(Enums.ATI_vertex_streams stream, GLfloat nx, GLfloat ny, GLfloat nz);
+ public static NormalStream3fATI glNormalStream3fATI = ((NormalStream3fATI)(GL.GetDelegateForExtensionMethod("glNormalStream3fATI", typeof(NormalStream3fATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static NormalStream3fvATI glNormalStream3fvATI = ((NormalStream3fvATI)(GL.GetDelegateForExtensionMethod("glNormalStream3fvATI", typeof(NormalStream3fvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3iATI(Enums.ATI_vertex_streams stream, GLint nx, GLint ny, GLint nz);
+ public static NormalStream3iATI glNormalStream3iATI = ((NormalStream3iATI)(GL.GetDelegateForExtensionMethod("glNormalStream3iATI", typeof(NormalStream3iATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static NormalStream3ivATI glNormalStream3ivATI = ((NormalStream3ivATI)(GL.GetDelegateForExtensionMethod("glNormalStream3ivATI", typeof(NormalStream3ivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3sATI(Enums.ATI_vertex_streams stream, GLshort nx, GLshort ny, GLshort nz);
+ public static NormalStream3sATI glNormalStream3sATI = ((NormalStream3sATI)(GL.GetDelegateForExtensionMethod("glNormalStream3sATI", typeof(NormalStream3sATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void NormalStream3svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static NormalStream3svATI glNormalStream3svATI = ((NormalStream3svATI)(GL.GetDelegateForExtensionMethod("glNormalStream3svATI", typeof(NormalStream3svATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+ public static Ortho glOrtho = ((Ortho)(GL.GetDelegateForExtensionMethod("glOrtho", typeof(Ortho)))) ?? new Ortho(Imports.Ortho);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PassTexCoordATI(GLuint dst, GLuint coord, Enums.ATI_fragment_shader swizzle);
+ public static PassTexCoordATI glPassTexCoordATI = ((PassTexCoordATI)(GL.GetDelegateForExtensionMethod("glPassTexCoordATI", typeof(PassTexCoordATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PassThrough(GLfloat token);
+ public static PassThrough glPassThrough = ((PassThrough)(GL.GetDelegateForExtensionMethod("glPassThrough", typeof(PassThrough)))) ?? new PassThrough(Imports.PassThrough);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelDataRangeNV(Enums.NV_pixel_data_range target, GLsizei length, [In, Out()] System.IntPtr pointer);
+ public static PixelDataRangeNV glPixelDataRangeNV = ((PixelDataRangeNV)(GL.GetDelegateForExtensionMethod("glPixelDataRangeNV", typeof(PixelDataRangeNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelMapfv(Enums.PixelMap map, GLint mapsize, System.IntPtr values);
+ public static PixelMapfv glPixelMapfv = ((PixelMapfv)(GL.GetDelegateForExtensionMethod("glPixelMapfv", typeof(PixelMapfv)))) ?? new PixelMapfv(Imports.PixelMapfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelMapuiv(Enums.PixelMap map, GLint mapsize, System.IntPtr values);
+ public static PixelMapuiv glPixelMapuiv = ((PixelMapuiv)(GL.GetDelegateForExtensionMethod("glPixelMapuiv", typeof(PixelMapuiv)))) ?? new PixelMapuiv(Imports.PixelMapuiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelMapusv(Enums.PixelMap map, GLint mapsize, System.IntPtr values);
+ public static PixelMapusv glPixelMapusv = ((PixelMapusv)(GL.GetDelegateForExtensionMethod("glPixelMapusv", typeof(PixelMapusv)))) ?? new PixelMapusv(Imports.PixelMapusv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelStoref(Enums.PixelStoreParameter pname, GLfloat param);
+ public static PixelStoref glPixelStoref = ((PixelStoref)(GL.GetDelegateForExtensionMethod("glPixelStoref", typeof(PixelStoref)))) ?? new PixelStoref(Imports.PixelStoref);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelStorei(Enums.PixelStoreParameter pname, GLint param);
+ public static PixelStorei glPixelStorei = ((PixelStorei)(GL.GetDelegateForExtensionMethod("glPixelStorei", typeof(PixelStorei)))) ?? new PixelStorei(Imports.PixelStorei);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTexGenParameterfSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLfloat param);
+ public static PixelTexGenParameterfSGIS glPixelTexGenParameterfSGIS = ((PixelTexGenParameterfSGIS)(GL.GetDelegateForExtensionMethod("glPixelTexGenParameterfSGIS", typeof(PixelTexGenParameterfSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTexGenParameterfvSGIS(Enums.PixelTexGenParameterNameSGIS pname, System.IntPtr @params);
+ public static PixelTexGenParameterfvSGIS glPixelTexGenParameterfvSGIS = ((PixelTexGenParameterfvSGIS)(GL.GetDelegateForExtensionMethod("glPixelTexGenParameterfvSGIS", typeof(PixelTexGenParameterfvSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTexGenParameteriSGIS(Enums.PixelTexGenParameterNameSGIS pname, GLint param);
+ public static PixelTexGenParameteriSGIS glPixelTexGenParameteriSGIS = ((PixelTexGenParameteriSGIS)(GL.GetDelegateForExtensionMethod("glPixelTexGenParameteriSGIS", typeof(PixelTexGenParameteriSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTexGenParameterivSGIS(Enums.PixelTexGenParameterNameSGIS pname, System.IntPtr @params);
+ public static PixelTexGenParameterivSGIS glPixelTexGenParameterivSGIS = ((PixelTexGenParameterivSGIS)(GL.GetDelegateForExtensionMethod("glPixelTexGenParameterivSGIS", typeof(PixelTexGenParameterivSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTexGenSGIX(Enums.SGIX_pixel_texture mode);
+ public static PixelTexGenSGIX glPixelTexGenSGIX = ((PixelTexGenSGIX)(GL.GetDelegateForExtensionMethod("glPixelTexGenSGIX", typeof(PixelTexGenSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTransferf(Enums.PixelTransferParameter pname, GLfloat param);
+ public static PixelTransferf glPixelTransferf = ((PixelTransferf)(GL.GetDelegateForExtensionMethod("glPixelTransferf", typeof(PixelTransferf)))) ?? new PixelTransferf(Imports.PixelTransferf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTransferi(Enums.PixelTransferParameter pname, GLint param);
+ public static PixelTransferi glPixelTransferi = ((PixelTransferi)(GL.GetDelegateForExtensionMethod("glPixelTransferi", typeof(PixelTransferi)))) ?? new PixelTransferi(Imports.PixelTransferi);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTransformParameterfEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, GLfloat param);
+ public static PixelTransformParameterfEXT glPixelTransformParameterfEXT = ((PixelTransformParameterfEXT)(GL.GetDelegateForExtensionMethod("glPixelTransformParameterfEXT", typeof(PixelTransformParameterfEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTransformParameterfvEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, System.IntPtr @params);
+ public static PixelTransformParameterfvEXT glPixelTransformParameterfvEXT = ((PixelTransformParameterfvEXT)(GL.GetDelegateForExtensionMethod("glPixelTransformParameterfvEXT", typeof(PixelTransformParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTransformParameteriEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, GLint param);
+ public static PixelTransformParameteriEXT glPixelTransformParameteriEXT = ((PixelTransformParameteriEXT)(GL.GetDelegateForExtensionMethod("glPixelTransformParameteriEXT", typeof(PixelTransformParameteriEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelTransformParameterivEXT(Enums.EXT_pixel_transform target, Enums.EXT_pixel_transform pname, System.IntPtr @params);
+ public static PixelTransformParameterivEXT glPixelTransformParameterivEXT = ((PixelTransformParameterivEXT)(GL.GetDelegateForExtensionMethod("glPixelTransformParameterivEXT", typeof(PixelTransformParameterivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PixelZoom(GLfloat xfactor, GLfloat yfactor);
+ public static PixelZoom glPixelZoom = ((PixelZoom)(GL.GetDelegateForExtensionMethod("glPixelZoom", typeof(PixelZoom)))) ?? new PixelZoom(Imports.PixelZoom);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PNTrianglesfATI(Enums.ATI_pn_triangles pname, GLfloat param);
+ public static PNTrianglesfATI glPNTrianglesfATI = ((PNTrianglesfATI)(GL.GetDelegateForExtensionMethod("glPNTrianglesfATI", typeof(PNTrianglesfATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PNTrianglesiATI(Enums.ATI_pn_triangles pname, GLint param);
+ public static PNTrianglesiATI glPNTrianglesiATI = ((PNTrianglesiATI)(GL.GetDelegateForExtensionMethod("glPNTrianglesiATI", typeof(PNTrianglesiATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterf(Enums.VERSION_1_4 pname, GLfloat param);
+ public static PointParameterf glPointParameterf = ((PointParameterf)(GL.GetDelegateForExtensionMethod("glPointParameterf", typeof(PointParameterf)))) ?? new PointParameterf(Imports.PointParameterf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterfARB(Enums.ARB_point_parameters pname, GLfloat param);
+ public static PointParameterfARB glPointParameterfARB = ((PointParameterfARB)(GL.GetDelegateForExtensionMethod("glPointParameterfARB", typeof(PointParameterfARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterfEXT(Enums.EXT_point_parameters pname, GLfloat param);
+ public static PointParameterfEXT glPointParameterfEXT = ((PointParameterfEXT)(GL.GetDelegateForExtensionMethod("glPointParameterfEXT", typeof(PointParameterfEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterfSGIS(Enums.SGIS_point_parameters pname, GLfloat param);
+ public static PointParameterfSGIS glPointParameterfSGIS = ((PointParameterfSGIS)(GL.GetDelegateForExtensionMethod("glPointParameterfSGIS", typeof(PointParameterfSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterfv(Enums.VERSION_1_4 pname, System.IntPtr @params);
+ public static PointParameterfv glPointParameterfv = ((PointParameterfv)(GL.GetDelegateForExtensionMethod("glPointParameterfv", typeof(PointParameterfv)))) ?? new PointParameterfv(Imports.PointParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterfvARB(Enums.ARB_point_parameters pname, System.IntPtr @params);
+ public static PointParameterfvARB glPointParameterfvARB = ((PointParameterfvARB)(GL.GetDelegateForExtensionMethod("glPointParameterfvARB", typeof(PointParameterfvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterfvEXT(Enums.EXT_point_parameters pname, System.IntPtr @params);
+ public static PointParameterfvEXT glPointParameterfvEXT = ((PointParameterfvEXT)(GL.GetDelegateForExtensionMethod("glPointParameterfvEXT", typeof(PointParameterfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterfvSGIS(Enums.SGIS_point_parameters pname, System.IntPtr @params);
+ public static PointParameterfvSGIS glPointParameterfvSGIS = ((PointParameterfvSGIS)(GL.GetDelegateForExtensionMethod("glPointParameterfvSGIS", typeof(PointParameterfvSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameteri(Enums.VERSION_1_4 pname, GLint param);
+ public static PointParameteri glPointParameteri = ((PointParameteri)(GL.GetDelegateForExtensionMethod("glPointParameteri", typeof(PointParameteri)))) ?? new PointParameteri(Imports.PointParameteri);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameteriNV(Enums.NV_point_sprite pname, GLint param);
+ public static PointParameteriNV glPointParameteriNV = ((PointParameteriNV)(GL.GetDelegateForExtensionMethod("glPointParameteriNV", typeof(PointParameteriNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameteriv(Enums.VERSION_1_4 pname, System.IntPtr @params);
+ public static PointParameteriv glPointParameteriv = ((PointParameteriv)(GL.GetDelegateForExtensionMethod("glPointParameteriv", typeof(PointParameteriv)))) ?? new PointParameteriv(Imports.PointParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointParameterivNV(Enums.NV_point_sprite pname, System.IntPtr @params);
+ public static PointParameterivNV glPointParameterivNV = ((PointParameterivNV)(GL.GetDelegateForExtensionMethod("glPointParameterivNV", typeof(PointParameterivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PointSize(GLfloat size);
+ public static PointSize glPointSize = ((PointSize)(GL.GetDelegateForExtensionMethod("glPointSize", typeof(PointSize)))) ?? new PointSize(Imports.PointSize);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint PollAsyncSGIX([In, Out()] System.IntPtr markerp);
+ public static PollAsyncSGIX glPollAsyncSGIX = ((PollAsyncSGIX)(GL.GetDelegateForExtensionMethod("glPollAsyncSGIX", typeof(PollAsyncSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint PollInstrumentsSGIX([In, Out()] System.IntPtr marker_p);
+ public static PollInstrumentsSGIX glPollInstrumentsSGIX = ((PollInstrumentsSGIX)(GL.GetDelegateForExtensionMethod("glPollInstrumentsSGIX", typeof(PollInstrumentsSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode);
+ public static PolygonMode glPolygonMode = ((PolygonMode)(GL.GetDelegateForExtensionMethod("glPolygonMode", typeof(PolygonMode)))) ?? new PolygonMode(Imports.PolygonMode);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PolygonOffset(GLfloat factor, GLfloat units);
+ public static PolygonOffset glPolygonOffset = ((PolygonOffset)(GL.GetDelegateForExtensionMethod("glPolygonOffset", typeof(PolygonOffset)))) ?? new PolygonOffset(Imports.PolygonOffset);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PolygonOffsetEXT(GLfloat factor, GLfloat bias);
+ public static PolygonOffsetEXT glPolygonOffsetEXT = ((PolygonOffsetEXT)(GL.GetDelegateForExtensionMethod("glPolygonOffsetEXT", typeof(PolygonOffsetEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PolygonStipple(System.IntPtr mask);
+ public static PolygonStipple glPolygonStipple = ((PolygonStipple)(GL.GetDelegateForExtensionMethod("glPolygonStipple", typeof(PolygonStipple)))) ?? new PolygonStipple(Imports.PolygonStipple);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PopAttrib();
+ public static PopAttrib glPopAttrib = ((PopAttrib)(GL.GetDelegateForExtensionMethod("glPopAttrib", typeof(PopAttrib)))) ?? new PopAttrib(Imports.PopAttrib);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PopClientAttrib();
+ public static PopClientAttrib glPopClientAttrib = ((PopClientAttrib)(GL.GetDelegateForExtensionMethod("glPopClientAttrib", typeof(PopClientAttrib)))) ?? new PopClientAttrib(Imports.PopClientAttrib);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PopMatrix();
+ public static PopMatrix glPopMatrix = ((PopMatrix)(GL.GetDelegateForExtensionMethod("glPopMatrix", typeof(PopMatrix)))) ?? new PopMatrix(Imports.PopMatrix);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PopName();
+ public static PopName glPopName = ((PopName)(GL.GetDelegateForExtensionMethod("glPopName", typeof(PopName)))) ?? new PopName(Imports.PopName);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PrimitiveRestartIndexNV(GLuint index);
+ public static PrimitiveRestartIndexNV glPrimitiveRestartIndexNV = ((PrimitiveRestartIndexNV)(GL.GetDelegateForExtensionMethod("glPrimitiveRestartIndexNV", typeof(PrimitiveRestartIndexNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PrimitiveRestartNV();
+ public static PrimitiveRestartNV glPrimitiveRestartNV = ((PrimitiveRestartNV)(GL.GetDelegateForExtensionMethod("glPrimitiveRestartNV", typeof(PrimitiveRestartNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PrioritizeTextures(GLsizei n, System.IntPtr textures, System.IntPtr priorities);
+ public static PrioritizeTextures glPrioritizeTextures = ((PrioritizeTextures)(GL.GetDelegateForExtensionMethod("glPrioritizeTextures", typeof(PrioritizeTextures)))) ?? new PrioritizeTextures(Imports.PrioritizeTextures);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PrioritizeTexturesEXT(GLsizei n, System.IntPtr textures, System.IntPtr priorities);
+ public static PrioritizeTexturesEXT glPrioritizeTexturesEXT = ((PrioritizeTexturesEXT)(GL.GetDelegateForExtensionMethod("glPrioritizeTexturesEXT", typeof(PrioritizeTexturesEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramBufferParametersfvNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramBufferParametersfvNV glProgramBufferParametersfvNV = ((ProgramBufferParametersfvNV)(GL.GetDelegateForExtensionMethod("glProgramBufferParametersfvNV", typeof(ProgramBufferParametersfvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramBufferParametersIivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramBufferParametersIivNV glProgramBufferParametersIivNV = ((ProgramBufferParametersIivNV)(GL.GetDelegateForExtensionMethod("glProgramBufferParametersIivNV", typeof(ProgramBufferParametersIivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramBufferParametersIuivNV(Enums.NV_parameter_buffer_object target, GLuint buffer, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramBufferParametersIuivNV glProgramBufferParametersIuivNV = ((ProgramBufferParametersIuivNV)(GL.GetDelegateForExtensionMethod("glProgramBufferParametersIuivNV", typeof(ProgramBufferParametersIuivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameter4dARB(Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static ProgramEnvParameter4dARB glProgramEnvParameter4dARB = ((ProgramEnvParameter4dARB)(GL.GetDelegateForExtensionMethod("glProgramEnvParameter4dARB", typeof(ProgramEnvParameter4dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params);
+ public static ProgramEnvParameter4dvARB glProgramEnvParameter4dvARB = ((ProgramEnvParameter4dvARB)(GL.GetDelegateForExtensionMethod("glProgramEnvParameter4dvARB", typeof(ProgramEnvParameter4dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameter4fARB(Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static ProgramEnvParameter4fARB glProgramEnvParameter4fARB = ((ProgramEnvParameter4fARB)(GL.GetDelegateForExtensionMethod("glProgramEnvParameter4fARB", typeof(ProgramEnvParameter4fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params);
+ public static ProgramEnvParameter4fvARB glProgramEnvParameter4fvARB = ((ProgramEnvParameter4fvARB)(GL.GetDelegateForExtensionMethod("glProgramEnvParameter4fvARB", typeof(ProgramEnvParameter4fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameterI4iNV(Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+ public static ProgramEnvParameterI4iNV glProgramEnvParameterI4iNV = ((ProgramEnvParameterI4iNV)(GL.GetDelegateForExtensionMethod("glProgramEnvParameterI4iNV", typeof(ProgramEnvParameterI4iNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params);
+ public static ProgramEnvParameterI4ivNV glProgramEnvParameterI4ivNV = ((ProgramEnvParameterI4ivNV)(GL.GetDelegateForExtensionMethod("glProgramEnvParameterI4ivNV", typeof(ProgramEnvParameterI4ivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameterI4uiNV(Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+ public static ProgramEnvParameterI4uiNV glProgramEnvParameterI4uiNV = ((ProgramEnvParameterI4uiNV)(GL.GetDelegateForExtensionMethod("glProgramEnvParameterI4uiNV", typeof(ProgramEnvParameterI4uiNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params);
+ public static ProgramEnvParameterI4uivNV glProgramEnvParameterI4uivNV = ((ProgramEnvParameterI4uivNV)(GL.GetDelegateForExtensionMethod("glProgramEnvParameterI4uivNV", typeof(ProgramEnvParameterI4uivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramEnvParameters4fvEXT glProgramEnvParameters4fvEXT = ((ProgramEnvParameters4fvEXT)(GL.GetDelegateForExtensionMethod("glProgramEnvParameters4fvEXT", typeof(ProgramEnvParameters4fvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramEnvParametersI4ivNV glProgramEnvParametersI4ivNV = ((ProgramEnvParametersI4ivNV)(GL.GetDelegateForExtensionMethod("glProgramEnvParametersI4ivNV", typeof(ProgramEnvParametersI4ivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramEnvParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramEnvParametersI4uivNV glProgramEnvParametersI4uivNV = ((ProgramEnvParametersI4uivNV)(GL.GetDelegateForExtensionMethod("glProgramEnvParametersI4uivNV", typeof(ProgramEnvParametersI4uivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameter4dARB(Enums.ARB_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static ProgramLocalParameter4dARB glProgramLocalParameter4dARB = ((ProgramLocalParameter4dARB)(GL.GetDelegateForExtensionMethod("glProgramLocalParameter4dARB", typeof(ProgramLocalParameter4dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameter4dvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params);
+ public static ProgramLocalParameter4dvARB glProgramLocalParameter4dvARB = ((ProgramLocalParameter4dvARB)(GL.GetDelegateForExtensionMethod("glProgramLocalParameter4dvARB", typeof(ProgramLocalParameter4dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameter4fARB(Enums.ARB_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static ProgramLocalParameter4fARB glProgramLocalParameter4fARB = ((ProgramLocalParameter4fARB)(GL.GetDelegateForExtensionMethod("glProgramLocalParameter4fARB", typeof(ProgramLocalParameter4fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameter4fvARB(Enums.ARB_vertex_program target, GLuint index, System.IntPtr @params);
+ public static ProgramLocalParameter4fvARB glProgramLocalParameter4fvARB = ((ProgramLocalParameter4fvARB)(GL.GetDelegateForExtensionMethod("glProgramLocalParameter4fvARB", typeof(ProgramLocalParameter4fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameterI4iNV(Enums.NV_gpu_program4 target, GLuint index, GLint x, GLint y, GLint z, GLint w);
+ public static ProgramLocalParameterI4iNV glProgramLocalParameterI4iNV = ((ProgramLocalParameterI4iNV)(GL.GetDelegateForExtensionMethod("glProgramLocalParameterI4iNV", typeof(ProgramLocalParameterI4iNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameterI4ivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params);
+ public static ProgramLocalParameterI4ivNV glProgramLocalParameterI4ivNV = ((ProgramLocalParameterI4ivNV)(GL.GetDelegateForExtensionMethod("glProgramLocalParameterI4ivNV", typeof(ProgramLocalParameterI4ivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameterI4uiNV(Enums.NV_gpu_program4 target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+ public static ProgramLocalParameterI4uiNV glProgramLocalParameterI4uiNV = ((ProgramLocalParameterI4uiNV)(GL.GetDelegateForExtensionMethod("glProgramLocalParameterI4uiNV", typeof(ProgramLocalParameterI4uiNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameterI4uivNV(Enums.NV_gpu_program4 target, GLuint index, System.IntPtr @params);
+ public static ProgramLocalParameterI4uivNV glProgramLocalParameterI4uivNV = ((ProgramLocalParameterI4uivNV)(GL.GetDelegateForExtensionMethod("glProgramLocalParameterI4uivNV", typeof(ProgramLocalParameterI4uivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParameters4fvEXT(Enums.EXT_gpu_program_parameters target, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramLocalParameters4fvEXT glProgramLocalParameters4fvEXT = ((ProgramLocalParameters4fvEXT)(GL.GetDelegateForExtensionMethod("glProgramLocalParameters4fvEXT", typeof(ProgramLocalParameters4fvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParametersI4ivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramLocalParametersI4ivNV glProgramLocalParametersI4ivNV = ((ProgramLocalParametersI4ivNV)(GL.GetDelegateForExtensionMethod("glProgramLocalParametersI4ivNV", typeof(ProgramLocalParametersI4ivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramLocalParametersI4uivNV(Enums.NV_gpu_program4 target, GLuint index, GLsizei count, System.IntPtr @params);
+ public static ProgramLocalParametersI4uivNV glProgramLocalParametersI4uivNV = ((ProgramLocalParametersI4uivNV)(GL.GetDelegateForExtensionMethod("glProgramLocalParametersI4uivNV", typeof(ProgramLocalParametersI4uivNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramNamedParameter4dNV(GLuint id, GLsizei len, System.IntPtr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static ProgramNamedParameter4dNV glProgramNamedParameter4dNV = ((ProgramNamedParameter4dNV)(GL.GetDelegateForExtensionMethod("glProgramNamedParameter4dNV", typeof(ProgramNamedParameter4dNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramNamedParameter4dvNV(GLuint id, GLsizei len, System.IntPtr name, System.IntPtr v);
+ public static ProgramNamedParameter4dvNV glProgramNamedParameter4dvNV = ((ProgramNamedParameter4dvNV)(GL.GetDelegateForExtensionMethod("glProgramNamedParameter4dvNV", typeof(ProgramNamedParameter4dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramNamedParameter4fNV(GLuint id, GLsizei len, System.IntPtr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static ProgramNamedParameter4fNV glProgramNamedParameter4fNV = ((ProgramNamedParameter4fNV)(GL.GetDelegateForExtensionMethod("glProgramNamedParameter4fNV", typeof(ProgramNamedParameter4fNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramNamedParameter4fvNV(GLuint id, GLsizei len, System.IntPtr name, System.IntPtr v);
+ public static ProgramNamedParameter4fvNV glProgramNamedParameter4fvNV = ((ProgramNamedParameter4fvNV)(GL.GetDelegateForExtensionMethod("glProgramNamedParameter4fvNV", typeof(ProgramNamedParameter4fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramParameter4dNV(Enums.NV_vertex_program target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static ProgramParameter4dNV glProgramParameter4dNV = ((ProgramParameter4dNV)(GL.GetDelegateForExtensionMethod("glProgramParameter4dNV", typeof(ProgramParameter4dNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramParameter4dvNV(Enums.NV_vertex_program target, GLuint index, System.IntPtr v);
+ public static ProgramParameter4dvNV glProgramParameter4dvNV = ((ProgramParameter4dvNV)(GL.GetDelegateForExtensionMethod("glProgramParameter4dvNV", typeof(ProgramParameter4dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramParameter4fNV(Enums.NV_vertex_program target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static ProgramParameter4fNV glProgramParameter4fNV = ((ProgramParameter4fNV)(GL.GetDelegateForExtensionMethod("glProgramParameter4fNV", typeof(ProgramParameter4fNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramParameter4fvNV(Enums.NV_vertex_program target, GLuint index, System.IntPtr v);
+ public static ProgramParameter4fvNV glProgramParameter4fvNV = ((ProgramParameter4fvNV)(GL.GetDelegateForExtensionMethod("glProgramParameter4fvNV", typeof(ProgramParameter4fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramParameteriEXT(GLuint program, Enums.EXT_geometry_shader4 pname, GLint value);
+ public static ProgramParameteriEXT glProgramParameteriEXT = ((ProgramParameteriEXT)(GL.GetDelegateForExtensionMethod("glProgramParameteriEXT", typeof(ProgramParameteriEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramParameters4dvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, System.IntPtr v);
+ public static ProgramParameters4dvNV glProgramParameters4dvNV = ((ProgramParameters4dvNV)(GL.GetDelegateForExtensionMethod("glProgramParameters4dvNV", typeof(ProgramParameters4dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramParameters4fvNV(Enums.NV_vertex_program target, GLuint index, GLuint count, System.IntPtr v);
+ public static ProgramParameters4fvNV glProgramParameters4fvNV = ((ProgramParameters4fvNV)(GL.GetDelegateForExtensionMethod("glProgramParameters4fvNV", typeof(ProgramParameters4fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramStringARB(Enums.ARB_vertex_program target, Enums.ARB_vertex_program format, GLsizei len, System.IntPtr @string);
+ public static ProgramStringARB glProgramStringARB = ((ProgramStringARB)(GL.GetDelegateForExtensionMethod("glProgramStringARB", typeof(ProgramStringARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ProgramVertexLimitNV(Enums.NV_geometry_program4 target, GLint limit);
+ public static ProgramVertexLimitNV glProgramVertexLimitNV = ((ProgramVertexLimitNV)(GL.GetDelegateForExtensionMethod("glProgramVertexLimitNV", typeof(ProgramVertexLimitNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PushAttrib(Enums.AttribMask mask);
+ public static PushAttrib glPushAttrib = ((PushAttrib)(GL.GetDelegateForExtensionMethod("glPushAttrib", typeof(PushAttrib)))) ?? new PushAttrib(Imports.PushAttrib);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PushClientAttrib(Enums.ClientAttribMask mask);
+ public static PushClientAttrib glPushClientAttrib = ((PushClientAttrib)(GL.GetDelegateForExtensionMethod("glPushClientAttrib", typeof(PushClientAttrib)))) ?? new PushClientAttrib(Imports.PushClientAttrib);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PushMatrix();
+ public static PushMatrix glPushMatrix = ((PushMatrix)(GL.GetDelegateForExtensionMethod("glPushMatrix", typeof(PushMatrix)))) ?? new PushMatrix(Imports.PushMatrix);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void PushName(GLuint name);
+ public static PushName glPushName = ((PushName)(GL.GetDelegateForExtensionMethod("glPushName", typeof(PushName)))) ?? new PushName(Imports.PushName);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2d(GLdouble x, GLdouble y);
+ public static RasterPos2d glRasterPos2d = ((RasterPos2d)(GL.GetDelegateForExtensionMethod("glRasterPos2d", typeof(RasterPos2d)))) ?? new RasterPos2d(Imports.RasterPos2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2dv(System.IntPtr v);
+ public static RasterPos2dv glRasterPos2dv = ((RasterPos2dv)(GL.GetDelegateForExtensionMethod("glRasterPos2dv", typeof(RasterPos2dv)))) ?? new RasterPos2dv(Imports.RasterPos2dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2f(GLfloat x, GLfloat y);
+ public static RasterPos2f glRasterPos2f = ((RasterPos2f)(GL.GetDelegateForExtensionMethod("glRasterPos2f", typeof(RasterPos2f)))) ?? new RasterPos2f(Imports.RasterPos2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2fv(System.IntPtr v);
+ public static RasterPos2fv glRasterPos2fv = ((RasterPos2fv)(GL.GetDelegateForExtensionMethod("glRasterPos2fv", typeof(RasterPos2fv)))) ?? new RasterPos2fv(Imports.RasterPos2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2i(GLint x, GLint y);
+ public static RasterPos2i glRasterPos2i = ((RasterPos2i)(GL.GetDelegateForExtensionMethod("glRasterPos2i", typeof(RasterPos2i)))) ?? new RasterPos2i(Imports.RasterPos2i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2iv(System.IntPtr v);
+ public static RasterPos2iv glRasterPos2iv = ((RasterPos2iv)(GL.GetDelegateForExtensionMethod("glRasterPos2iv", typeof(RasterPos2iv)))) ?? new RasterPos2iv(Imports.RasterPos2iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2s(GLshort x, GLshort y);
+ public static RasterPos2s glRasterPos2s = ((RasterPos2s)(GL.GetDelegateForExtensionMethod("glRasterPos2s", typeof(RasterPos2s)))) ?? new RasterPos2s(Imports.RasterPos2s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos2sv(System.IntPtr v);
+ public static RasterPos2sv glRasterPos2sv = ((RasterPos2sv)(GL.GetDelegateForExtensionMethod("glRasterPos2sv", typeof(RasterPos2sv)))) ?? new RasterPos2sv(Imports.RasterPos2sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3d(GLdouble x, GLdouble y, GLdouble z);
+ public static RasterPos3d glRasterPos3d = ((RasterPos3d)(GL.GetDelegateForExtensionMethod("glRasterPos3d", typeof(RasterPos3d)))) ?? new RasterPos3d(Imports.RasterPos3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3dv(System.IntPtr v);
+ public static RasterPos3dv glRasterPos3dv = ((RasterPos3dv)(GL.GetDelegateForExtensionMethod("glRasterPos3dv", typeof(RasterPos3dv)))) ?? new RasterPos3dv(Imports.RasterPos3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3f(GLfloat x, GLfloat y, GLfloat z);
+ public static RasterPos3f glRasterPos3f = ((RasterPos3f)(GL.GetDelegateForExtensionMethod("glRasterPos3f", typeof(RasterPos3f)))) ?? new RasterPos3f(Imports.RasterPos3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3fv(System.IntPtr v);
+ public static RasterPos3fv glRasterPos3fv = ((RasterPos3fv)(GL.GetDelegateForExtensionMethod("glRasterPos3fv", typeof(RasterPos3fv)))) ?? new RasterPos3fv(Imports.RasterPos3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3i(GLint x, GLint y, GLint z);
+ public static RasterPos3i glRasterPos3i = ((RasterPos3i)(GL.GetDelegateForExtensionMethod("glRasterPos3i", typeof(RasterPos3i)))) ?? new RasterPos3i(Imports.RasterPos3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3iv(System.IntPtr v);
+ public static RasterPos3iv glRasterPos3iv = ((RasterPos3iv)(GL.GetDelegateForExtensionMethod("glRasterPos3iv", typeof(RasterPos3iv)))) ?? new RasterPos3iv(Imports.RasterPos3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3s(GLshort x, GLshort y, GLshort z);
+ public static RasterPos3s glRasterPos3s = ((RasterPos3s)(GL.GetDelegateForExtensionMethod("glRasterPos3s", typeof(RasterPos3s)))) ?? new RasterPos3s(Imports.RasterPos3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos3sv(System.IntPtr v);
+ public static RasterPos3sv glRasterPos3sv = ((RasterPos3sv)(GL.GetDelegateForExtensionMethod("glRasterPos3sv", typeof(RasterPos3sv)))) ?? new RasterPos3sv(Imports.RasterPos3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static RasterPos4d glRasterPos4d = ((RasterPos4d)(GL.GetDelegateForExtensionMethod("glRasterPos4d", typeof(RasterPos4d)))) ?? new RasterPos4d(Imports.RasterPos4d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4dv(System.IntPtr v);
+ public static RasterPos4dv glRasterPos4dv = ((RasterPos4dv)(GL.GetDelegateForExtensionMethod("glRasterPos4dv", typeof(RasterPos4dv)))) ?? new RasterPos4dv(Imports.RasterPos4dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static RasterPos4f glRasterPos4f = ((RasterPos4f)(GL.GetDelegateForExtensionMethod("glRasterPos4f", typeof(RasterPos4f)))) ?? new RasterPos4f(Imports.RasterPos4f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4fv(System.IntPtr v);
+ public static RasterPos4fv glRasterPos4fv = ((RasterPos4fv)(GL.GetDelegateForExtensionMethod("glRasterPos4fv", typeof(RasterPos4fv)))) ?? new RasterPos4fv(Imports.RasterPos4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4i(GLint x, GLint y, GLint z, GLint w);
+ public static RasterPos4i glRasterPos4i = ((RasterPos4i)(GL.GetDelegateForExtensionMethod("glRasterPos4i", typeof(RasterPos4i)))) ?? new RasterPos4i(Imports.RasterPos4i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4iv(System.IntPtr v);
+ public static RasterPos4iv glRasterPos4iv = ((RasterPos4iv)(GL.GetDelegateForExtensionMethod("glRasterPos4iv", typeof(RasterPos4iv)))) ?? new RasterPos4iv(Imports.RasterPos4iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
+ public static RasterPos4s glRasterPos4s = ((RasterPos4s)(GL.GetDelegateForExtensionMethod("glRasterPos4s", typeof(RasterPos4s)))) ?? new RasterPos4s(Imports.RasterPos4s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RasterPos4sv(System.IntPtr v);
+ public static RasterPos4sv glRasterPos4sv = ((RasterPos4sv)(GL.GetDelegateForExtensionMethod("glRasterPos4sv", typeof(RasterPos4sv)))) ?? new RasterPos4sv(Imports.RasterPos4sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReadBuffer(Enums.ReadBufferMode mode);
+ public static ReadBuffer glReadBuffer = ((ReadBuffer)(GL.GetDelegateForExtensionMethod("glReadBuffer", typeof(ReadBuffer)))) ?? new ReadBuffer(Imports.ReadBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReadInstrumentsSGIX(GLint marker);
+ public static ReadInstrumentsSGIX glReadInstrumentsSGIX = ((ReadInstrumentsSGIX)(GL.GetDelegateForExtensionMethod("glReadInstrumentsSGIX", typeof(ReadInstrumentsSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, [In, Out()] System.IntPtr pixels);
+ public static ReadPixels glReadPixels = ((ReadPixels)(GL.GetDelegateForExtensionMethod("glReadPixels", typeof(ReadPixels)))) ?? new ReadPixels(Imports.ReadPixels);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+ public static Rectd glRectd = ((Rectd)(GL.GetDelegateForExtensionMethod("glRectd", typeof(Rectd)))) ?? new Rectd(Imports.Rectd);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rectdv(System.IntPtr v1, System.IntPtr v2);
+ public static Rectdv glRectdv = ((Rectdv)(GL.GetDelegateForExtensionMethod("glRectdv", typeof(Rectdv)))) ?? new Rectdv(Imports.Rectdv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+ public static Rectf glRectf = ((Rectf)(GL.GetDelegateForExtensionMethod("glRectf", typeof(Rectf)))) ?? new Rectf(Imports.Rectf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rectfv(System.IntPtr v1, System.IntPtr v2);
+ public static Rectfv glRectfv = ((Rectfv)(GL.GetDelegateForExtensionMethod("glRectfv", typeof(Rectfv)))) ?? new Rectfv(Imports.Rectfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Recti(GLint x1, GLint y1, GLint x2, GLint y2);
+ public static Recti glRecti = ((Recti)(GL.GetDelegateForExtensionMethod("glRecti", typeof(Recti)))) ?? new Recti(Imports.Recti);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rectiv(System.IntPtr v1, System.IntPtr v2);
+ public static Rectiv glRectiv = ((Rectiv)(GL.GetDelegateForExtensionMethod("glRectiv", typeof(Rectiv)))) ?? new Rectiv(Imports.Rectiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+ public static Rects glRects = ((Rects)(GL.GetDelegateForExtensionMethod("glRects", typeof(Rects)))) ?? new Rects(Imports.Rects);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rectsv(System.IntPtr v1, System.IntPtr v2);
+ public static Rectsv glRectsv = ((Rectsv)(GL.GetDelegateForExtensionMethod("glRectsv", typeof(Rectsv)))) ?? new Rectsv(Imports.Rectsv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReferencePlaneSGIX(System.IntPtr equation);
+ public static ReferencePlaneSGIX glReferencePlaneSGIX = ((ReferencePlaneSGIX)(GL.GetDelegateForExtensionMethod("glReferencePlaneSGIX", typeof(ReferencePlaneSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RenderbufferStorageEXT(Enums.EXT_framebuffer_object target, Enums.EXT_framebuffer_object internalformat, GLsizei width, GLsizei height);
+ public static RenderbufferStorageEXT glRenderbufferStorageEXT = ((RenderbufferStorageEXT)(GL.GetDelegateForExtensionMethod("glRenderbufferStorageEXT", typeof(RenderbufferStorageEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RenderbufferStorageMultisampleCoverageNV(Enums.NV_framebuffer_multisample_coverage target, GLsizei coverageSamples, GLsizei colorSamples, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height);
+ public static RenderbufferStorageMultisampleCoverageNV glRenderbufferStorageMultisampleCoverageNV = ((RenderbufferStorageMultisampleCoverageNV)(GL.GetDelegateForExtensionMethod("glRenderbufferStorageMultisampleCoverageNV", typeof(RenderbufferStorageMultisampleCoverageNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RenderbufferStorageMultisampleEXT(Enums.GLenum target, GLsizei samples, Enums.GLenum internalformat, GLsizei width, GLsizei height);
+ public static RenderbufferStorageMultisampleEXT glRenderbufferStorageMultisampleEXT = ((RenderbufferStorageMultisampleEXT)(GL.GetDelegateForExtensionMethod("glRenderbufferStorageMultisampleEXT", typeof(RenderbufferStorageMultisampleEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLint RenderMode(Enums.RenderingMode mode);
+ public static RenderMode glRenderMode = ((RenderMode)(GL.GetDelegateForExtensionMethod("glRenderMode", typeof(RenderMode)))) ?? new RenderMode(Imports.RenderMode);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodePointerSUN(Enums.SUN_triangle_list type, GLsizei stride, System.IntPtr pointer);
+ public static ReplacementCodePointerSUN glReplacementCodePointerSUN = ((ReplacementCodePointerSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodePointerSUN", typeof(ReplacementCodePointerSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeubSUN(GLubyte code);
+ public static ReplacementCodeubSUN glReplacementCodeubSUN = ((ReplacementCodeubSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeubSUN", typeof(ReplacementCodeubSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeubvSUN(System.IntPtr code);
+ public static ReplacementCodeubvSUN glReplacementCodeubvSUN = ((ReplacementCodeubvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeubvSUN", typeof(ReplacementCodeubvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+ public static ReplacementCodeuiColor3fVertex3fSUN glReplacementCodeuiColor3fVertex3fSUN = ((ReplacementCodeuiColor3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiColor3fVertex3fSUN", typeof(ReplacementCodeuiColor3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiColor3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr v);
+ public static ReplacementCodeuiColor3fVertex3fvSUN glReplacementCodeuiColor3fVertex3fvSUN = ((ReplacementCodeuiColor3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiColor3fVertex3fvSUN", typeof(ReplacementCodeuiColor3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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 static ReplacementCodeuiColor4fNormal3fVertex3fSUN glReplacementCodeuiColor4fNormal3fVertex3fSUN = ((ReplacementCodeuiColor4fNormal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiColor4fNormal3fVertex3fSUN", typeof(ReplacementCodeuiColor4fNormal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr n, System.IntPtr v);
+ public static ReplacementCodeuiColor4fNormal3fVertex3fvSUN glReplacementCodeuiColor4fNormal3fVertex3fvSUN = ((ReplacementCodeuiColor4fNormal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiColor4fNormal3fVertex3fvSUN", typeof(ReplacementCodeuiColor4fNormal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+ public static ReplacementCodeuiColor4ubVertex3fSUN glReplacementCodeuiColor4ubVertex3fSUN = ((ReplacementCodeuiColor4ubVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiColor4ubVertex3fSUN", typeof(ReplacementCodeuiColor4ubVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiColor4ubVertex3fvSUN(System.IntPtr rc, System.IntPtr c, System.IntPtr v);
+ public static ReplacementCodeuiColor4ubVertex3fvSUN glReplacementCodeuiColor4ubVertex3fvSUN = ((ReplacementCodeuiColor4ubVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiColor4ubVertex3fvSUN", typeof(ReplacementCodeuiColor4ubVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+ public static ReplacementCodeuiNormal3fVertex3fSUN glReplacementCodeuiNormal3fVertex3fSUN = ((ReplacementCodeuiNormal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiNormal3fVertex3fSUN", typeof(ReplacementCodeuiNormal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr n, System.IntPtr v);
+ public static ReplacementCodeuiNormal3fVertex3fvSUN glReplacementCodeuiNormal3fVertex3fvSUN = ((ReplacementCodeuiNormal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiNormal3fVertex3fvSUN", typeof(ReplacementCodeuiNormal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiSUN(GLuint code);
+ public static ReplacementCodeuiSUN glReplacementCodeuiSUN = ((ReplacementCodeuiSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiSUN", typeof(ReplacementCodeuiSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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 static ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = ((ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN", typeof(ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v);
+ public static ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = ((ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+ public static ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = ((ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN", typeof(ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr n, System.IntPtr v);
+ public static ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = ((ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN", typeof(ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+ public static ReplacementCodeuiTexCoord2fVertex3fSUN glReplacementCodeuiTexCoord2fVertex3fSUN = ((ReplacementCodeuiTexCoord2fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiTexCoord2fVertex3fSUN", typeof(ReplacementCodeuiTexCoord2fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiTexCoord2fVertex3fvSUN(System.IntPtr rc, System.IntPtr tc, System.IntPtr v);
+ public static ReplacementCodeuiTexCoord2fVertex3fvSUN glReplacementCodeuiTexCoord2fVertex3fvSUN = ((ReplacementCodeuiTexCoord2fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiTexCoord2fVertex3fvSUN", typeof(ReplacementCodeuiTexCoord2fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z);
+ public static ReplacementCodeuiVertex3fSUN glReplacementCodeuiVertex3fSUN = ((ReplacementCodeuiVertex3fSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiVertex3fSUN", typeof(ReplacementCodeuiVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuiVertex3fvSUN(System.IntPtr rc, System.IntPtr v);
+ public static ReplacementCodeuiVertex3fvSUN glReplacementCodeuiVertex3fvSUN = ((ReplacementCodeuiVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuiVertex3fvSUN", typeof(ReplacementCodeuiVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeuivSUN(System.IntPtr code);
+ public static ReplacementCodeuivSUN glReplacementCodeuivSUN = ((ReplacementCodeuivSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeuivSUN", typeof(ReplacementCodeuivSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeusSUN(GLushort code);
+ public static ReplacementCodeusSUN glReplacementCodeusSUN = ((ReplacementCodeusSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeusSUN", typeof(ReplacementCodeusSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ReplacementCodeusvSUN(System.IntPtr code);
+ public static ReplacementCodeusvSUN glReplacementCodeusvSUN = ((ReplacementCodeusvSUN)(GL.GetDelegateForExtensionMethod("glReplacementCodeusvSUN", typeof(ReplacementCodeusvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void RequestResidentProgramsNV(GLsizei n, System.IntPtr programs);
+ public static RequestResidentProgramsNV glRequestResidentProgramsNV = ((RequestResidentProgramsNV)(GL.GetDelegateForExtensionMethod("glRequestResidentProgramsNV", typeof(RequestResidentProgramsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ResetHistogram(Enums.VERSION_1_2 target);
+ public static ResetHistogram glResetHistogram = ((ResetHistogram)(GL.GetDelegateForExtensionMethod("glResetHistogram", typeof(ResetHistogram)))) ?? new ResetHistogram(Imports.ResetHistogram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ResetHistogramEXT(Enums.HistogramTargetEXT target);
+ public static ResetHistogramEXT glResetHistogramEXT = ((ResetHistogramEXT)(GL.GetDelegateForExtensionMethod("glResetHistogramEXT", typeof(ResetHistogramEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ResetMinmax(Enums.VERSION_1_2 target);
+ public static ResetMinmax glResetMinmax = ((ResetMinmax)(GL.GetDelegateForExtensionMethod("glResetMinmax", typeof(ResetMinmax)))) ?? new ResetMinmax(Imports.ResetMinmax);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ResetMinmaxEXT(Enums.MinmaxTargetEXT target);
+ public static ResetMinmaxEXT glResetMinmaxEXT = ((ResetMinmaxEXT)(GL.GetDelegateForExtensionMethod("glResetMinmaxEXT", typeof(ResetMinmaxEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ResizeBuffersMESA();
+ public static ResizeBuffersMESA glResizeBuffersMESA = ((ResizeBuffersMESA)(GL.GetDelegateForExtensionMethod("glResizeBuffersMESA", typeof(ResizeBuffersMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+ public static Rotated glRotated = ((Rotated)(GL.GetDelegateForExtensionMethod("glRotated", typeof(Rotated)))) ?? new Rotated(Imports.Rotated);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+ public static Rotatef glRotatef = ((Rotatef)(GL.GetDelegateForExtensionMethod("glRotatef", typeof(Rotatef)))) ?? new Rotatef(Imports.Rotatef);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SampleCoverage(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert);
+ public static SampleCoverage glSampleCoverage = ((SampleCoverage)(GL.GetDelegateForExtensionMethod("glSampleCoverage", typeof(SampleCoverage)))) ?? new SampleCoverage(Imports.SampleCoverage);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SampleCoverageARB(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert);
+ public static SampleCoverageARB glSampleCoverageARB = ((SampleCoverageARB)(GL.GetDelegateForExtensionMethod("glSampleCoverageARB", typeof(SampleCoverageARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SampleMapATI(GLuint dst, GLuint interp, Enums.ATI_fragment_shader swizzle);
+ public static SampleMapATI glSampleMapATI = ((SampleMapATI)(GL.GetDelegateForExtensionMethod("glSampleMapATI", typeof(SampleMapATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SampleMaskEXT(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert);
+ public static SampleMaskEXT glSampleMaskEXT = ((SampleMaskEXT)(GL.GetDelegateForExtensionMethod("glSampleMaskEXT", typeof(SampleMaskEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SampleMaskSGIS(GLclampf value, [MarshalAs(UnmanagedType.Bool)] bool invert);
+ public static SampleMaskSGIS glSampleMaskSGIS = ((SampleMaskSGIS)(GL.GetDelegateForExtensionMethod("glSampleMaskSGIS", typeof(SampleMaskSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SamplePatternEXT(Enums.EXT_multisample pattern);
+ public static SamplePatternEXT glSamplePatternEXT = ((SamplePatternEXT)(GL.GetDelegateForExtensionMethod("glSamplePatternEXT", typeof(SamplePatternEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SamplePatternSGIS(Enums.SamplePatternSGIS pattern);
+ public static SamplePatternSGIS glSamplePatternSGIS = ((SamplePatternSGIS)(GL.GetDelegateForExtensionMethod("glSamplePatternSGIS", typeof(SamplePatternSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Scaled(GLdouble x, GLdouble y, GLdouble z);
+ public static Scaled glScaled = ((Scaled)(GL.GetDelegateForExtensionMethod("glScaled", typeof(Scaled)))) ?? new Scaled(Imports.Scaled);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Scalef(GLfloat x, GLfloat y, GLfloat z);
+ public static Scalef glScalef = ((Scalef)(GL.GetDelegateForExtensionMethod("glScalef", typeof(Scalef)))) ?? new Scalef(Imports.Scalef);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Scissor(GLint x, GLint y, GLsizei width, GLsizei height);
+ public static Scissor glScissor = ((Scissor)(GL.GetDelegateForExtensionMethod("glScissor", typeof(Scissor)))) ?? new Scissor(Imports.Scissor);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
+ public static SecondaryColor3b glSecondaryColor3b = ((SecondaryColor3b)(GL.GetDelegateForExtensionMethod("glSecondaryColor3b", typeof(SecondaryColor3b)))) ?? new SecondaryColor3b(Imports.SecondaryColor3b);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);
+ public static SecondaryColor3bEXT glSecondaryColor3bEXT = ((SecondaryColor3bEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3bEXT", typeof(SecondaryColor3bEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3bv(System.IntPtr v);
+ public static SecondaryColor3bv glSecondaryColor3bv = ((SecondaryColor3bv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3bv", typeof(SecondaryColor3bv)))) ?? new SecondaryColor3bv(Imports.SecondaryColor3bv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3bvEXT(System.IntPtr v);
+ public static SecondaryColor3bvEXT glSecondaryColor3bvEXT = ((SecondaryColor3bvEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3bvEXT", typeof(SecondaryColor3bvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
+ public static SecondaryColor3d glSecondaryColor3d = ((SecondaryColor3d)(GL.GetDelegateForExtensionMethod("glSecondaryColor3d", typeof(SecondaryColor3d)))) ?? new SecondaryColor3d(Imports.SecondaryColor3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue);
+ public static SecondaryColor3dEXT glSecondaryColor3dEXT = ((SecondaryColor3dEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3dEXT", typeof(SecondaryColor3dEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3dv(System.IntPtr v);
+ public static SecondaryColor3dv glSecondaryColor3dv = ((SecondaryColor3dv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3dv", typeof(SecondaryColor3dv)))) ?? new SecondaryColor3dv(Imports.SecondaryColor3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3dvEXT(System.IntPtr v);
+ public static SecondaryColor3dvEXT glSecondaryColor3dvEXT = ((SecondaryColor3dvEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3dvEXT", typeof(SecondaryColor3dvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
+ public static SecondaryColor3f glSecondaryColor3f = ((SecondaryColor3f)(GL.GetDelegateForExtensionMethod("glSecondaryColor3f", typeof(SecondaryColor3f)))) ?? new SecondaryColor3f(Imports.SecondaryColor3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue);
+ public static SecondaryColor3fEXT glSecondaryColor3fEXT = ((SecondaryColor3fEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3fEXT", typeof(SecondaryColor3fEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3fv(System.IntPtr v);
+ public static SecondaryColor3fv glSecondaryColor3fv = ((SecondaryColor3fv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3fv", typeof(SecondaryColor3fv)))) ?? new SecondaryColor3fv(Imports.SecondaryColor3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3fvEXT(System.IntPtr v);
+ public static SecondaryColor3fvEXT glSecondaryColor3fvEXT = ((SecondaryColor3fvEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3fvEXT", typeof(SecondaryColor3fvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue);
+ public static SecondaryColor3hNV glSecondaryColor3hNV = ((SecondaryColor3hNV)(GL.GetDelegateForExtensionMethod("glSecondaryColor3hNV", typeof(SecondaryColor3hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3hvNV(System.IntPtr v);
+ public static SecondaryColor3hvNV glSecondaryColor3hvNV = ((SecondaryColor3hvNV)(GL.GetDelegateForExtensionMethod("glSecondaryColor3hvNV", typeof(SecondaryColor3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3i(GLint red, GLint green, GLint blue);
+ public static SecondaryColor3i glSecondaryColor3i = ((SecondaryColor3i)(GL.GetDelegateForExtensionMethod("glSecondaryColor3i", typeof(SecondaryColor3i)))) ?? new SecondaryColor3i(Imports.SecondaryColor3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3iEXT(GLint red, GLint green, GLint blue);
+ public static SecondaryColor3iEXT glSecondaryColor3iEXT = ((SecondaryColor3iEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3iEXT", typeof(SecondaryColor3iEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3iv(System.IntPtr v);
+ public static SecondaryColor3iv glSecondaryColor3iv = ((SecondaryColor3iv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3iv", typeof(SecondaryColor3iv)))) ?? new SecondaryColor3iv(Imports.SecondaryColor3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3ivEXT(System.IntPtr v);
+ public static SecondaryColor3ivEXT glSecondaryColor3ivEXT = ((SecondaryColor3ivEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3ivEXT", typeof(SecondaryColor3ivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3s(GLshort red, GLshort green, GLshort blue);
+ public static SecondaryColor3s glSecondaryColor3s = ((SecondaryColor3s)(GL.GetDelegateForExtensionMethod("glSecondaryColor3s", typeof(SecondaryColor3s)))) ?? new SecondaryColor3s(Imports.SecondaryColor3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue);
+ public static SecondaryColor3sEXT glSecondaryColor3sEXT = ((SecondaryColor3sEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3sEXT", typeof(SecondaryColor3sEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3sv(System.IntPtr v);
+ public static SecondaryColor3sv glSecondaryColor3sv = ((SecondaryColor3sv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3sv", typeof(SecondaryColor3sv)))) ?? new SecondaryColor3sv(Imports.SecondaryColor3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3svEXT(System.IntPtr v);
+ public static SecondaryColor3svEXT glSecondaryColor3svEXT = ((SecondaryColor3svEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3svEXT", typeof(SecondaryColor3svEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
+ public static SecondaryColor3ub glSecondaryColor3ub = ((SecondaryColor3ub)(GL.GetDelegateForExtensionMethod("glSecondaryColor3ub", typeof(SecondaryColor3ub)))) ?? new SecondaryColor3ub(Imports.SecondaryColor3ub);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue);
+ public static SecondaryColor3ubEXT glSecondaryColor3ubEXT = ((SecondaryColor3ubEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3ubEXT", typeof(SecondaryColor3ubEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3ubv(System.IntPtr v);
+ public static SecondaryColor3ubv glSecondaryColor3ubv = ((SecondaryColor3ubv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3ubv", typeof(SecondaryColor3ubv)))) ?? new SecondaryColor3ubv(Imports.SecondaryColor3ubv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3ubvEXT(System.IntPtr v);
+ public static SecondaryColor3ubvEXT glSecondaryColor3ubvEXT = ((SecondaryColor3ubvEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3ubvEXT", typeof(SecondaryColor3ubvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
+ public static SecondaryColor3ui glSecondaryColor3ui = ((SecondaryColor3ui)(GL.GetDelegateForExtensionMethod("glSecondaryColor3ui", typeof(SecondaryColor3ui)))) ?? new SecondaryColor3ui(Imports.SecondaryColor3ui);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue);
+ public static SecondaryColor3uiEXT glSecondaryColor3uiEXT = ((SecondaryColor3uiEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3uiEXT", typeof(SecondaryColor3uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3uiv(System.IntPtr v);
+ public static SecondaryColor3uiv glSecondaryColor3uiv = ((SecondaryColor3uiv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3uiv", typeof(SecondaryColor3uiv)))) ?? new SecondaryColor3uiv(Imports.SecondaryColor3uiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3uivEXT(System.IntPtr v);
+ public static SecondaryColor3uivEXT glSecondaryColor3uivEXT = ((SecondaryColor3uivEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3uivEXT", typeof(SecondaryColor3uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3us(GLushort red, GLushort green, GLushort blue);
+ public static SecondaryColor3us glSecondaryColor3us = ((SecondaryColor3us)(GL.GetDelegateForExtensionMethod("glSecondaryColor3us", typeof(SecondaryColor3us)))) ?? new SecondaryColor3us(Imports.SecondaryColor3us);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);
+ public static SecondaryColor3usEXT glSecondaryColor3usEXT = ((SecondaryColor3usEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3usEXT", typeof(SecondaryColor3usEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3usv(System.IntPtr v);
+ public static SecondaryColor3usv glSecondaryColor3usv = ((SecondaryColor3usv)(GL.GetDelegateForExtensionMethod("glSecondaryColor3usv", typeof(SecondaryColor3usv)))) ?? new SecondaryColor3usv(Imports.SecondaryColor3usv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColor3usvEXT(System.IntPtr v);
+ public static SecondaryColor3usvEXT glSecondaryColor3usvEXT = ((SecondaryColor3usvEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColor3usvEXT", typeof(SecondaryColor3usvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer);
+ public static SecondaryColorPointer glSecondaryColorPointer = ((SecondaryColorPointer)(GL.GetDelegateForExtensionMethod("glSecondaryColorPointer", typeof(SecondaryColorPointer)))) ?? new SecondaryColorPointer(Imports.SecondaryColorPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColorPointerEXT(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer);
+ public static SecondaryColorPointerEXT glSecondaryColorPointerEXT = ((SecondaryColorPointerEXT)(GL.GetDelegateForExtensionMethod("glSecondaryColorPointerEXT", typeof(SecondaryColorPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SecondaryColorPointerListIBM(GLint size, Enums.IBM_vertex_array_lists type, GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static SecondaryColorPointerListIBM glSecondaryColorPointerListIBM = ((SecondaryColorPointerListIBM)(GL.GetDelegateForExtensionMethod("glSecondaryColorPointerListIBM", typeof(SecondaryColorPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SelectBuffer(GLsizei size, [In, Out()] System.IntPtr buffer);
+ public static SelectBuffer glSelectBuffer = ((SelectBuffer)(GL.GetDelegateForExtensionMethod("glSelectBuffer", typeof(SelectBuffer)))) ?? new SelectBuffer(Imports.SelectBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SeparableFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, System.IntPtr column);
+ public static SeparableFilter2D glSeparableFilter2D = ((SeparableFilter2D)(GL.GetDelegateForExtensionMethod("glSeparableFilter2D", typeof(SeparableFilter2D)))) ?? new SeparableFilter2D(Imports.SeparableFilter2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SeparableFilter2DEXT(Enums.SeparableTargetEXT target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, System.IntPtr column);
+ public static SeparableFilter2DEXT glSeparableFilter2DEXT = ((SeparableFilter2DEXT)(GL.GetDelegateForExtensionMethod("glSeparableFilter2DEXT", typeof(SeparableFilter2DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SetFenceAPPLE(GLuint fence);
+ public static SetFenceAPPLE glSetFenceAPPLE = ((SetFenceAPPLE)(GL.GetDelegateForExtensionMethod("glSetFenceAPPLE", typeof(SetFenceAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SetFenceNV(GLuint fence, Enums.NV_fence condition);
+ public static SetFenceNV glSetFenceNV = ((SetFenceNV)(GL.GetDelegateForExtensionMethod("glSetFenceNV", typeof(SetFenceNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SetFragmentShaderConstantATI(GLuint dst, System.IntPtr value);
+ public static SetFragmentShaderConstantATI glSetFragmentShaderConstantATI = ((SetFragmentShaderConstantATI)(GL.GetDelegateForExtensionMethod("glSetFragmentShaderConstantATI", typeof(SetFragmentShaderConstantATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SetInvariantEXT(GLuint id, Enums.EXT_vertex_shader type, System.IntPtr addr);
+ public static SetInvariantEXT glSetInvariantEXT = ((SetInvariantEXT)(GL.GetDelegateForExtensionMethod("glSetInvariantEXT", typeof(SetInvariantEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SetLocalConstantEXT(GLuint id, Enums.EXT_vertex_shader type, System.IntPtr addr);
+ public static SetLocalConstantEXT glSetLocalConstantEXT = ((SetLocalConstantEXT)(GL.GetDelegateForExtensionMethod("glSetLocalConstantEXT", typeof(SetLocalConstantEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ShadeModel(Enums.ShadingModel mode);
+ public static ShadeModel glShadeModel = ((ShadeModel)(GL.GetDelegateForExtensionMethod("glShadeModel", typeof(ShadeModel)))) ?? new ShadeModel(Imports.ShadeModel);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ShaderOp1EXT(Enums.EXT_vertex_shader op, GLuint res, GLuint arg1);
+ public static ShaderOp1EXT glShaderOp1EXT = ((ShaderOp1EXT)(GL.GetDelegateForExtensionMethod("glShaderOp1EXT", typeof(ShaderOp1EXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ShaderOp2EXT(Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2);
+ public static ShaderOp2EXT glShaderOp2EXT = ((ShaderOp2EXT)(GL.GetDelegateForExtensionMethod("glShaderOp2EXT", typeof(ShaderOp2EXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ShaderOp3EXT(Enums.EXT_vertex_shader op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3);
+ public static ShaderOp3EXT glShaderOp3EXT = ((ShaderOp3EXT)(GL.GetDelegateForExtensionMethod("glShaderOp3EXT", typeof(ShaderOp3EXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ShaderSource(GLuint shader, GLsizei count, string[] @string, System.IntPtr length);
+ public static ShaderSource glShaderSource = ((ShaderSource)(GL.GetDelegateForExtensionMethod("glShaderSource", typeof(ShaderSource)))) ?? new ShaderSource(Imports.ShaderSource);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ShaderSourceARB(GLhandleARB shaderObj, GLsizei count, string[] @string, System.IntPtr length);
+ public static ShaderSourceARB glShaderSourceARB = ((ShaderSourceARB)(GL.GetDelegateForExtensionMethod("glShaderSourceARB", typeof(ShaderSourceARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SharpenTexFuncSGIS(Enums.TextureTarget target, GLsizei n, System.IntPtr points);
+ public static SharpenTexFuncSGIS glSharpenTexFuncSGIS = ((SharpenTexFuncSGIS)(GL.GetDelegateForExtensionMethod("glSharpenTexFuncSGIS", typeof(SharpenTexFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SpriteParameterfSGIX(Enums.SGIX_sprite pname, GLfloat param);
+ public static SpriteParameterfSGIX glSpriteParameterfSGIX = ((SpriteParameterfSGIX)(GL.GetDelegateForExtensionMethod("glSpriteParameterfSGIX", typeof(SpriteParameterfSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SpriteParameterfvSGIX(Enums.SGIX_sprite pname, System.IntPtr @params);
+ public static SpriteParameterfvSGIX glSpriteParameterfvSGIX = ((SpriteParameterfvSGIX)(GL.GetDelegateForExtensionMethod("glSpriteParameterfvSGIX", typeof(SpriteParameterfvSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SpriteParameteriSGIX(Enums.SGIX_sprite pname, GLint param);
+ public static SpriteParameteriSGIX glSpriteParameteriSGIX = ((SpriteParameteriSGIX)(GL.GetDelegateForExtensionMethod("glSpriteParameteriSGIX", typeof(SpriteParameteriSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SpriteParameterivSGIX(Enums.SGIX_sprite pname, System.IntPtr @params);
+ public static SpriteParameterivSGIX glSpriteParameterivSGIX = ((SpriteParameterivSGIX)(GL.GetDelegateForExtensionMethod("glSpriteParameterivSGIX", typeof(SpriteParameterivSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StartInstrumentsSGIX();
+ public static StartInstrumentsSGIX glStartInstrumentsSGIX = ((StartInstrumentsSGIX)(GL.GetDelegateForExtensionMethod("glStartInstrumentsSGIX", typeof(StartInstrumentsSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag);
+ public static StencilClearTagEXT glStencilClearTagEXT = ((StencilClearTagEXT)(GL.GetDelegateForExtensionMethod("glStencilClearTagEXT", typeof(StencilClearTagEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilFunc(Enums.StencilFunction func, GLint @ref, GLuint mask);
+ public static StencilFunc glStencilFunc = ((StencilFunc)(GL.GetDelegateForExtensionMethod("glStencilFunc", typeof(StencilFunc)))) ?? new StencilFunc(Imports.StencilFunc);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilFuncSeparate(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint @ref, GLuint mask);
+ public static StencilFuncSeparate glStencilFuncSeparate = ((StencilFuncSeparate)(GL.GetDelegateForExtensionMethod("glStencilFuncSeparate", typeof(StencilFuncSeparate)))) ?? new StencilFuncSeparate(Imports.StencilFuncSeparate);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilFuncSeparateATI(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint @ref, GLuint mask);
+ public static StencilFuncSeparateATI glStencilFuncSeparateATI = ((StencilFuncSeparateATI)(GL.GetDelegateForExtensionMethod("glStencilFuncSeparateATI", typeof(StencilFuncSeparateATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilMask(GLuint mask);
+ public static StencilMask glStencilMask = ((StencilMask)(GL.GetDelegateForExtensionMethod("glStencilMask", typeof(StencilMask)))) ?? new StencilMask(Imports.StencilMask);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilMaskSeparate(Enums.VERSION_2_0 face, GLuint mask);
+ public static StencilMaskSeparate glStencilMaskSeparate = ((StencilMaskSeparate)(GL.GetDelegateForExtensionMethod("glStencilMaskSeparate", typeof(StencilMaskSeparate)))) ?? new StencilMaskSeparate(Imports.StencilMaskSeparate);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass);
+ public static StencilOp glStencilOp = ((StencilOp)(GL.GetDelegateForExtensionMethod("glStencilOp", typeof(StencilOp)))) ?? new StencilOp(Imports.StencilOp);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilOpSeparate(Enums.VERSION_2_0 face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass);
+ public static StencilOpSeparate glStencilOpSeparate = ((StencilOpSeparate)(GL.GetDelegateForExtensionMethod("glStencilOpSeparate", typeof(StencilOpSeparate)))) ?? new StencilOpSeparate(Imports.StencilOpSeparate);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StencilOpSeparateATI(Enums.ATI_separate_stencil face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass);
+ public static StencilOpSeparateATI glStencilOpSeparateATI = ((StencilOpSeparateATI)(GL.GetDelegateForExtensionMethod("glStencilOpSeparateATI", typeof(StencilOpSeparateATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StopInstrumentsSGIX(GLint marker);
+ public static StopInstrumentsSGIX glStopInstrumentsSGIX = ((StopInstrumentsSGIX)(GL.GetDelegateForExtensionMethod("glStopInstrumentsSGIX", typeof(StopInstrumentsSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void StringMarkerGREMEDY(GLsizei len, System.IntPtr @string);
+ public static StringMarkerGREMEDY glStringMarkerGREMEDY = ((StringMarkerGREMEDY)(GL.GetDelegateForExtensionMethod("glStringMarkerGREMEDY", typeof(StringMarkerGREMEDY))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void SwizzleEXT(GLuint res, GLuint @in, Enums.EXT_vertex_shader outX, Enums.EXT_vertex_shader outY, Enums.EXT_vertex_shader outZ, Enums.EXT_vertex_shader outW);
+ public static SwizzleEXT glSwizzleEXT = ((SwizzleEXT)(GL.GetDelegateForExtensionMethod("glSwizzleEXT", typeof(SwizzleEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TagSampleBufferSGIX();
+ public static TagSampleBufferSGIX glTagSampleBufferSGIX = ((TagSampleBufferSGIX)(GL.GetDelegateForExtensionMethod("glTagSampleBufferSGIX", typeof(TagSampleBufferSGIX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz);
+ public static Tangent3bEXT glTangent3bEXT = ((Tangent3bEXT)(GL.GetDelegateForExtensionMethod("glTangent3bEXT", typeof(Tangent3bEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3bvEXT(System.IntPtr v);
+ public static Tangent3bvEXT glTangent3bvEXT = ((Tangent3bvEXT)(GL.GetDelegateForExtensionMethod("glTangent3bvEXT", typeof(Tangent3bvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz);
+ public static Tangent3dEXT glTangent3dEXT = ((Tangent3dEXT)(GL.GetDelegateForExtensionMethod("glTangent3dEXT", typeof(Tangent3dEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3dvEXT(System.IntPtr v);
+ public static Tangent3dvEXT glTangent3dvEXT = ((Tangent3dvEXT)(GL.GetDelegateForExtensionMethod("glTangent3dvEXT", typeof(Tangent3dvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz);
+ public static Tangent3fEXT glTangent3fEXT = ((Tangent3fEXT)(GL.GetDelegateForExtensionMethod("glTangent3fEXT", typeof(Tangent3fEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3fvEXT(System.IntPtr v);
+ public static Tangent3fvEXT glTangent3fvEXT = ((Tangent3fvEXT)(GL.GetDelegateForExtensionMethod("glTangent3fvEXT", typeof(Tangent3fvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3iEXT(GLint tx, GLint ty, GLint tz);
+ public static Tangent3iEXT glTangent3iEXT = ((Tangent3iEXT)(GL.GetDelegateForExtensionMethod("glTangent3iEXT", typeof(Tangent3iEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3ivEXT(System.IntPtr v);
+ public static Tangent3ivEXT glTangent3ivEXT = ((Tangent3ivEXT)(GL.GetDelegateForExtensionMethod("glTangent3ivEXT", typeof(Tangent3ivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3sEXT(GLshort tx, GLshort ty, GLshort tz);
+ public static Tangent3sEXT glTangent3sEXT = ((Tangent3sEXT)(GL.GetDelegateForExtensionMethod("glTangent3sEXT", typeof(Tangent3sEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Tangent3svEXT(System.IntPtr v);
+ public static Tangent3svEXT glTangent3svEXT = ((Tangent3svEXT)(GL.GetDelegateForExtensionMethod("glTangent3svEXT", typeof(Tangent3svEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TangentPointerEXT(Enums.EXT_coordinate_frame type, GLsizei stride, System.IntPtr pointer);
+ public static TangentPointerEXT glTangentPointerEXT = ((TangentPointerEXT)(GL.GetDelegateForExtensionMethod("glTangentPointerEXT", typeof(TangentPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TbufferMask3DFX(GLuint mask);
+ public static TbufferMask3DFX glTbufferMask3DFX = ((TbufferMask3DFX)(GL.GetDelegateForExtensionMethod("glTbufferMask3DFX", typeof(TbufferMask3DFX))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean TestFenceAPPLE(GLuint fence);
+ public static TestFenceAPPLE glTestFenceAPPLE = ((TestFenceAPPLE)(GL.GetDelegateForExtensionMethod("glTestFenceAPPLE", typeof(TestFenceAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean TestFenceNV(GLuint fence);
+ public static TestFenceNV glTestFenceNV = ((TestFenceNV)(GL.GetDelegateForExtensionMethod("glTestFenceNV", typeof(TestFenceNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean TestObjectAPPLE(Enums.APPLE_fence @object, GLuint name);
+ public static TestObjectAPPLE glTestObjectAPPLE = ((TestObjectAPPLE)(GL.GetDelegateForExtensionMethod("glTestObjectAPPLE", typeof(TestObjectAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexBufferEXT(Enums.TextureTarget target, Enums.GLenum internalformat, GLuint buffer);
+ public static TexBufferEXT glTexBufferEXT = ((TexBufferEXT)(GL.GetDelegateForExtensionMethod("glTexBufferEXT", typeof(TexBufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexBumpParameterfvATI(Enums.ATI_envmap_bumpmap pname, System.IntPtr param);
+ public static TexBumpParameterfvATI glTexBumpParameterfvATI = ((TexBumpParameterfvATI)(GL.GetDelegateForExtensionMethod("glTexBumpParameterfvATI", typeof(TexBumpParameterfvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexBumpParameterivATI(Enums.ATI_envmap_bumpmap pname, System.IntPtr param);
+ public static TexBumpParameterivATI glTexBumpParameterivATI = ((TexBumpParameterivATI)(GL.GetDelegateForExtensionMethod("glTexBumpParameterivATI", typeof(TexBumpParameterivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1d(GLdouble s);
+ public static TexCoord1d glTexCoord1d = ((TexCoord1d)(GL.GetDelegateForExtensionMethod("glTexCoord1d", typeof(TexCoord1d)))) ?? new TexCoord1d(Imports.TexCoord1d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1dv(System.IntPtr v);
+ public static TexCoord1dv glTexCoord1dv = ((TexCoord1dv)(GL.GetDelegateForExtensionMethod("glTexCoord1dv", typeof(TexCoord1dv)))) ?? new TexCoord1dv(Imports.TexCoord1dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1f(GLfloat s);
+ public static TexCoord1f glTexCoord1f = ((TexCoord1f)(GL.GetDelegateForExtensionMethod("glTexCoord1f", typeof(TexCoord1f)))) ?? new TexCoord1f(Imports.TexCoord1f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1fv(System.IntPtr v);
+ public static TexCoord1fv glTexCoord1fv = ((TexCoord1fv)(GL.GetDelegateForExtensionMethod("glTexCoord1fv", typeof(TexCoord1fv)))) ?? new TexCoord1fv(Imports.TexCoord1fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1hNV(GLhalfNV s);
+ public static TexCoord1hNV glTexCoord1hNV = ((TexCoord1hNV)(GL.GetDelegateForExtensionMethod("glTexCoord1hNV", typeof(TexCoord1hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1hvNV(System.IntPtr v);
+ public static TexCoord1hvNV glTexCoord1hvNV = ((TexCoord1hvNV)(GL.GetDelegateForExtensionMethod("glTexCoord1hvNV", typeof(TexCoord1hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1i(GLint s);
+ public static TexCoord1i glTexCoord1i = ((TexCoord1i)(GL.GetDelegateForExtensionMethod("glTexCoord1i", typeof(TexCoord1i)))) ?? new TexCoord1i(Imports.TexCoord1i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1iv(System.IntPtr v);
+ public static TexCoord1iv glTexCoord1iv = ((TexCoord1iv)(GL.GetDelegateForExtensionMethod("glTexCoord1iv", typeof(TexCoord1iv)))) ?? new TexCoord1iv(Imports.TexCoord1iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1s(GLshort s);
+ public static TexCoord1s glTexCoord1s = ((TexCoord1s)(GL.GetDelegateForExtensionMethod("glTexCoord1s", typeof(TexCoord1s)))) ?? new TexCoord1s(Imports.TexCoord1s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord1sv(System.IntPtr v);
+ public static TexCoord1sv glTexCoord1sv = ((TexCoord1sv)(GL.GetDelegateForExtensionMethod("glTexCoord1sv", typeof(TexCoord1sv)))) ?? new TexCoord1sv(Imports.TexCoord1sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2d(GLdouble s, GLdouble t);
+ public static TexCoord2d glTexCoord2d = ((TexCoord2d)(GL.GetDelegateForExtensionMethod("glTexCoord2d", typeof(TexCoord2d)))) ?? new TexCoord2d(Imports.TexCoord2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2dv(System.IntPtr v);
+ public static TexCoord2dv glTexCoord2dv = ((TexCoord2dv)(GL.GetDelegateForExtensionMethod("glTexCoord2dv", typeof(TexCoord2dv)))) ?? new TexCoord2dv(Imports.TexCoord2dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2f(GLfloat s, GLfloat t);
+ public static TexCoord2f glTexCoord2f = ((TexCoord2f)(GL.GetDelegateForExtensionMethod("glTexCoord2f", typeof(TexCoord2f)))) ?? new TexCoord2f(Imports.TexCoord2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z);
+ public static TexCoord2fColor3fVertex3fSUN glTexCoord2fColor3fVertex3fSUN = ((TexCoord2fColor3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fColor3fVertex3fSUN", typeof(TexCoord2fColor3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fColor3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr v);
+ public static TexCoord2fColor3fVertex3fvSUN glTexCoord2fColor3fVertex3fvSUN = ((TexCoord2fColor3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fColor3fVertex3fvSUN", typeof(TexCoord2fColor3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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 static TexCoord2fColor4fNormal3fVertex3fSUN glTexCoord2fColor4fNormal3fVertex3fSUN = ((TexCoord2fColor4fNormal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fColor4fNormal3fVertex3fSUN", typeof(TexCoord2fColor4fNormal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fColor4fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v);
+ public static TexCoord2fColor4fNormal3fVertex3fvSUN glTexCoord2fColor4fNormal3fVertex3fvSUN = ((TexCoord2fColor4fNormal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fColor4fNormal3fVertex3fvSUN", typeof(TexCoord2fColor4fNormal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z);
+ public static TexCoord2fColor4ubVertex3fSUN glTexCoord2fColor4ubVertex3fSUN = ((TexCoord2fColor4ubVertex3fSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fColor4ubVertex3fSUN", typeof(TexCoord2fColor4ubVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fColor4ubVertex3fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr v);
+ public static TexCoord2fColor4ubVertex3fvSUN glTexCoord2fColor4ubVertex3fvSUN = ((TexCoord2fColor4ubVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fColor4ubVertex3fvSUN", typeof(TexCoord2fColor4ubVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z);
+ public static TexCoord2fNormal3fVertex3fSUN glTexCoord2fNormal3fVertex3fSUN = ((TexCoord2fNormal3fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fNormal3fVertex3fSUN", typeof(TexCoord2fNormal3fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fNormal3fVertex3fvSUN(System.IntPtr tc, System.IntPtr n, System.IntPtr v);
+ public static TexCoord2fNormal3fVertex3fvSUN glTexCoord2fNormal3fVertex3fvSUN = ((TexCoord2fNormal3fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fNormal3fVertex3fvSUN", typeof(TexCoord2fNormal3fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fv(System.IntPtr v);
+ public static TexCoord2fv glTexCoord2fv = ((TexCoord2fv)(GL.GetDelegateForExtensionMethod("glTexCoord2fv", typeof(TexCoord2fv)))) ?? new TexCoord2fv(Imports.TexCoord2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z);
+ public static TexCoord2fVertex3fSUN glTexCoord2fVertex3fSUN = ((TexCoord2fVertex3fSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fVertex3fSUN", typeof(TexCoord2fVertex3fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2fVertex3fvSUN(System.IntPtr tc, System.IntPtr v);
+ public static TexCoord2fVertex3fvSUN glTexCoord2fVertex3fvSUN = ((TexCoord2fVertex3fvSUN)(GL.GetDelegateForExtensionMethod("glTexCoord2fVertex3fvSUN", typeof(TexCoord2fVertex3fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2hNV(GLhalfNV s, GLhalfNV t);
+ public static TexCoord2hNV glTexCoord2hNV = ((TexCoord2hNV)(GL.GetDelegateForExtensionMethod("glTexCoord2hNV", typeof(TexCoord2hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2hvNV(System.IntPtr v);
+ public static TexCoord2hvNV glTexCoord2hvNV = ((TexCoord2hvNV)(GL.GetDelegateForExtensionMethod("glTexCoord2hvNV", typeof(TexCoord2hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2i(GLint s, GLint t);
+ public static TexCoord2i glTexCoord2i = ((TexCoord2i)(GL.GetDelegateForExtensionMethod("glTexCoord2i", typeof(TexCoord2i)))) ?? new TexCoord2i(Imports.TexCoord2i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2iv(System.IntPtr v);
+ public static TexCoord2iv glTexCoord2iv = ((TexCoord2iv)(GL.GetDelegateForExtensionMethod("glTexCoord2iv", typeof(TexCoord2iv)))) ?? new TexCoord2iv(Imports.TexCoord2iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2s(GLshort s, GLshort t);
+ public static TexCoord2s glTexCoord2s = ((TexCoord2s)(GL.GetDelegateForExtensionMethod("glTexCoord2s", typeof(TexCoord2s)))) ?? new TexCoord2s(Imports.TexCoord2s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord2sv(System.IntPtr v);
+ public static TexCoord2sv glTexCoord2sv = ((TexCoord2sv)(GL.GetDelegateForExtensionMethod("glTexCoord2sv", typeof(TexCoord2sv)))) ?? new TexCoord2sv(Imports.TexCoord2sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3d(GLdouble s, GLdouble t, GLdouble r);
+ public static TexCoord3d glTexCoord3d = ((TexCoord3d)(GL.GetDelegateForExtensionMethod("glTexCoord3d", typeof(TexCoord3d)))) ?? new TexCoord3d(Imports.TexCoord3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3dv(System.IntPtr v);
+ public static TexCoord3dv glTexCoord3dv = ((TexCoord3dv)(GL.GetDelegateForExtensionMethod("glTexCoord3dv", typeof(TexCoord3dv)))) ?? new TexCoord3dv(Imports.TexCoord3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3f(GLfloat s, GLfloat t, GLfloat r);
+ public static TexCoord3f glTexCoord3f = ((TexCoord3f)(GL.GetDelegateForExtensionMethod("glTexCoord3f", typeof(TexCoord3f)))) ?? new TexCoord3f(Imports.TexCoord3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3fv(System.IntPtr v);
+ public static TexCoord3fv glTexCoord3fv = ((TexCoord3fv)(GL.GetDelegateForExtensionMethod("glTexCoord3fv", typeof(TexCoord3fv)))) ?? new TexCoord3fv(Imports.TexCoord3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r);
+ public static TexCoord3hNV glTexCoord3hNV = ((TexCoord3hNV)(GL.GetDelegateForExtensionMethod("glTexCoord3hNV", typeof(TexCoord3hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3hvNV(System.IntPtr v);
+ public static TexCoord3hvNV glTexCoord3hvNV = ((TexCoord3hvNV)(GL.GetDelegateForExtensionMethod("glTexCoord3hvNV", typeof(TexCoord3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3i(GLint s, GLint t, GLint r);
+ public static TexCoord3i glTexCoord3i = ((TexCoord3i)(GL.GetDelegateForExtensionMethod("glTexCoord3i", typeof(TexCoord3i)))) ?? new TexCoord3i(Imports.TexCoord3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3iv(System.IntPtr v);
+ public static TexCoord3iv glTexCoord3iv = ((TexCoord3iv)(GL.GetDelegateForExtensionMethod("glTexCoord3iv", typeof(TexCoord3iv)))) ?? new TexCoord3iv(Imports.TexCoord3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3s(GLshort s, GLshort t, GLshort r);
+ public static TexCoord3s glTexCoord3s = ((TexCoord3s)(GL.GetDelegateForExtensionMethod("glTexCoord3s", typeof(TexCoord3s)))) ?? new TexCoord3s(Imports.TexCoord3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord3sv(System.IntPtr v);
+ public static TexCoord3sv glTexCoord3sv = ((TexCoord3sv)(GL.GetDelegateForExtensionMethod("glTexCoord3sv", typeof(TexCoord3sv)))) ?? new TexCoord3sv(Imports.TexCoord3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+ public static TexCoord4d glTexCoord4d = ((TexCoord4d)(GL.GetDelegateForExtensionMethod("glTexCoord4d", typeof(TexCoord4d)))) ?? new TexCoord4d(Imports.TexCoord4d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4dv(System.IntPtr v);
+ public static TexCoord4dv glTexCoord4dv = ((TexCoord4dv)(GL.GetDelegateForExtensionMethod("glTexCoord4dv", typeof(TexCoord4dv)))) ?? new TexCoord4dv(Imports.TexCoord4dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+ public static TexCoord4f glTexCoord4f = ((TexCoord4f)(GL.GetDelegateForExtensionMethod("glTexCoord4f", typeof(TexCoord4f)))) ?? new TexCoord4f(Imports.TexCoord4f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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 static TexCoord4fColor4fNormal3fVertex4fSUN glTexCoord4fColor4fNormal3fVertex4fSUN = ((TexCoord4fColor4fNormal3fVertex4fSUN)(GL.GetDelegateForExtensionMethod("glTexCoord4fColor4fNormal3fVertex4fSUN", typeof(TexCoord4fColor4fNormal3fVertex4fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4fColor4fNormal3fVertex4fvSUN(System.IntPtr tc, System.IntPtr c, System.IntPtr n, System.IntPtr v);
+ public static TexCoord4fColor4fNormal3fVertex4fvSUN glTexCoord4fColor4fNormal3fVertex4fvSUN = ((TexCoord4fColor4fNormal3fVertex4fvSUN)(GL.GetDelegateForExtensionMethod("glTexCoord4fColor4fNormal3fVertex4fvSUN", typeof(TexCoord4fColor4fNormal3fVertex4fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4fv(System.IntPtr v);
+ public static TexCoord4fv glTexCoord4fv = ((TexCoord4fv)(GL.GetDelegateForExtensionMethod("glTexCoord4fv", typeof(TexCoord4fv)))) ?? new TexCoord4fv(Imports.TexCoord4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static TexCoord4fVertex4fSUN glTexCoord4fVertex4fSUN = ((TexCoord4fVertex4fSUN)(GL.GetDelegateForExtensionMethod("glTexCoord4fVertex4fSUN", typeof(TexCoord4fVertex4fSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4fVertex4fvSUN(System.IntPtr tc, System.IntPtr v);
+ public static TexCoord4fVertex4fvSUN glTexCoord4fVertex4fvSUN = ((TexCoord4fVertex4fvSUN)(GL.GetDelegateForExtensionMethod("glTexCoord4fVertex4fvSUN", typeof(TexCoord4fVertex4fvSUN))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q);
+ public static TexCoord4hNV glTexCoord4hNV = ((TexCoord4hNV)(GL.GetDelegateForExtensionMethod("glTexCoord4hNV", typeof(TexCoord4hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4hvNV(System.IntPtr v);
+ public static TexCoord4hvNV glTexCoord4hvNV = ((TexCoord4hvNV)(GL.GetDelegateForExtensionMethod("glTexCoord4hvNV", typeof(TexCoord4hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4i(GLint s, GLint t, GLint r, GLint q);
+ public static TexCoord4i glTexCoord4i = ((TexCoord4i)(GL.GetDelegateForExtensionMethod("glTexCoord4i", typeof(TexCoord4i)))) ?? new TexCoord4i(Imports.TexCoord4i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4iv(System.IntPtr v);
+ public static TexCoord4iv glTexCoord4iv = ((TexCoord4iv)(GL.GetDelegateForExtensionMethod("glTexCoord4iv", typeof(TexCoord4iv)))) ?? new TexCoord4iv(Imports.TexCoord4iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
+ public static TexCoord4s glTexCoord4s = ((TexCoord4s)(GL.GetDelegateForExtensionMethod("glTexCoord4s", typeof(TexCoord4s)))) ?? new TexCoord4s(Imports.TexCoord4s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoord4sv(System.IntPtr v);
+ public static TexCoord4sv glTexCoord4sv = ((TexCoord4sv)(GL.GetDelegateForExtensionMethod("glTexCoord4sv", typeof(TexCoord4sv)))) ?? new TexCoord4sv(Imports.TexCoord4sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoordPointer(GLint size, Enums.TexCoordPointerType type, GLsizei stride, System.IntPtr pointer);
+ public static TexCoordPointer glTexCoordPointer = ((TexCoordPointer)(GL.GetDelegateForExtensionMethod("glTexCoordPointer", typeof(TexCoordPointer)))) ?? new TexCoordPointer(Imports.TexCoordPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoordPointerEXT(GLint size, Enums.TexCoordPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer);
+ public static TexCoordPointerEXT glTexCoordPointerEXT = ((TexCoordPointerEXT)(GL.GetDelegateForExtensionMethod("glTexCoordPointerEXT", typeof(TexCoordPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoordPointerListIBM(GLint size, Enums.TexCoordPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static TexCoordPointerListIBM glTexCoordPointerListIBM = ((TexCoordPointerListIBM)(GL.GetDelegateForExtensionMethod("glTexCoordPointerListIBM", typeof(TexCoordPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexCoordPointervINTEL(GLint size, Enums.VertexPointerType type, System.IntPtr pointer);
+ public static TexCoordPointervINTEL glTexCoordPointervINTEL = ((TexCoordPointervINTEL)(GL.GetDelegateForExtensionMethod("glTexCoordPointervINTEL", typeof(TexCoordPointervINTEL))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLfloat param);
+ public static TexEnvf glTexEnvf = ((TexEnvf)(GL.GetDelegateForExtensionMethod("glTexEnvf", typeof(TexEnvf)))) ?? new TexEnvf(Imports.TexEnvf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params);
+ public static TexEnvfv glTexEnvfv = ((TexEnvfv)(GL.GetDelegateForExtensionMethod("glTexEnvfv", typeof(TexEnvfv)))) ?? new TexEnvfv(Imports.TexEnvfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLint param);
+ public static TexEnvi glTexEnvi = ((TexEnvi)(GL.GetDelegateForExtensionMethod("glTexEnvi", typeof(TexEnvi)))) ?? new TexEnvi(Imports.TexEnvi);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params);
+ public static TexEnviv glTexEnviv = ((TexEnviv)(GL.GetDelegateForExtensionMethod("glTexEnviv", typeof(TexEnviv)))) ?? new TexEnviv(Imports.TexEnviv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexFilterFuncSGIS(Enums.TextureTarget target, Enums.SGIS_texture_filter4 filter, GLsizei n, System.IntPtr weights);
+ public static TexFilterFuncSGIS glTexFilterFuncSGIS = ((TexFilterFuncSGIS)(GL.GetDelegateForExtensionMethod("glTexFilterFuncSGIS", typeof(TexFilterFuncSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLdouble param);
+ public static TexGend glTexGend = ((TexGend)(GL.GetDelegateForExtensionMethod("glTexGend", typeof(TexGend)))) ?? new TexGend(Imports.TexGend);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ public static TexGendv glTexGendv = ((TexGendv)(GL.GetDelegateForExtensionMethod("glTexGendv", typeof(TexGendv)))) ?? new TexGendv(Imports.TexGendv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLfloat param);
+ public static TexGenf glTexGenf = ((TexGenf)(GL.GetDelegateForExtensionMethod("glTexGenf", typeof(TexGenf)))) ?? new TexGenf(Imports.TexGenf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ public static TexGenfv glTexGenfv = ((TexGenfv)(GL.GetDelegateForExtensionMethod("glTexGenfv", typeof(TexGenfv)))) ?? new TexGenfv(Imports.TexGenfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLint param);
+ public static TexGeni glTexGeni = ((TexGeni)(GL.GetDelegateForExtensionMethod("glTexGeni", typeof(TexGeni)))) ?? new TexGeni(Imports.TexGeni);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ public static TexGeniv glTexGeniv = ((TexGeniv)(GL.GetDelegateForExtensionMethod("glTexGeniv", typeof(TexGeniv)))) ?? new TexGeniv(Imports.TexGeniv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexImage1D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ public static TexImage1D glTexImage1D = ((TexImage1D)(GL.GetDelegateForExtensionMethod("glTexImage1D", typeof(TexImage1D)))) ?? new TexImage1D(Imports.TexImage1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexImage2D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ public static TexImage2D glTexImage2D = ((TexImage2D)(GL.GetDelegateForExtensionMethod("glTexImage2D", typeof(TexImage2D)))) ?? new TexImage2D(Imports.TexImage2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr pixels);
+ public static TexImage3D glTexImage3D = ((TexImage3D)(GL.GetDelegateForExtensionMethod("glTexImage3D", typeof(TexImage3D)))) ?? new TexImage3D(Imports.TexImage3D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr pixels);
+ public static TexImage3DEXT glTexImage3DEXT = ((TexImage3DEXT)(GL.GetDelegateForExtensionMethod("glTexImage3DEXT", typeof(TexImage3DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr pixels);
+ public static TexImage4DSGIS glTexImage4DSGIS = ((TexImage4DSGIS)(GL.GetDelegateForExtensionMethod("glTexImage4DSGIS", typeof(TexImage4DSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, GLfloat param);
+ public static TexParameterf glTexParameterf = ((TexParameterf)(GL.GetDelegateForExtensionMethod("glTexParameterf", typeof(TexParameterf)))) ?? new TexParameterf(Imports.TexParameterf);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params);
+ public static TexParameterfv glTexParameterfv = ((TexParameterfv)(GL.GetDelegateForExtensionMethod("glTexParameterfv", typeof(TexParameterfv)))) ?? new TexParameterfv(Imports.TexParameterfv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, GLint param);
+ public static TexParameteri glTexParameteri = ((TexParameteri)(GL.GetDelegateForExtensionMethod("glTexParameteri", typeof(TexParameteri)))) ?? new TexParameteri(Imports.TexParameteri);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexParameterIivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params);
+ public static TexParameterIivEXT glTexParameterIivEXT = ((TexParameterIivEXT)(GL.GetDelegateForExtensionMethod("glTexParameterIivEXT", typeof(TexParameterIivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexParameterIuivEXT(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params);
+ public static TexParameterIuivEXT glTexParameterIuivEXT = ((TexParameterIuivEXT)(GL.GetDelegateForExtensionMethod("glTexParameterIuivEXT", typeof(TexParameterIuivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params);
+ public static TexParameteriv glTexParameteriv = ((TexParameteriv)(GL.GetDelegateForExtensionMethod("glTexParameteriv", typeof(TexParameteriv)))) ?? new TexParameteriv(Imports.TexParameteriv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ public static TexSubImage1D glTexSubImage1D = ((TexSubImage1D)(GL.GetDelegateForExtensionMethod("glTexSubImage1D", typeof(TexSubImage1D)))) ?? new TexSubImage1D(Imports.TexSubImage1D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexSubImage1DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ public static TexSubImage1DEXT glTexSubImage1DEXT = ((TexSubImage1DEXT)(GL.GetDelegateForExtensionMethod("glTexSubImage1DEXT", typeof(TexSubImage1DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ public static TexSubImage2D glTexSubImage2D = ((TexSubImage2D)(GL.GetDelegateForExtensionMethod("glTexSubImage2D", typeof(TexSubImage2D)))) ?? new TexSubImage2D(Imports.TexSubImage2D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TexSubImage2DEXT(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ public static TexSubImage2DEXT glTexSubImage2DEXT = ((TexSubImage2DEXT)(GL.GetDelegateForExtensionMethod("glTexSubImage2DEXT", typeof(TexSubImage2DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr pixels);
+ public static TexSubImage3D glTexSubImage3D = ((TexSubImage3D)(GL.GetDelegateForExtensionMethod("glTexSubImage3D", typeof(TexSubImage3D)))) ?? new TexSubImage3D(Imports.TexSubImage3D);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr pixels);
+ public static TexSubImage3DEXT glTexSubImage3DEXT = ((TexSubImage3DEXT)(GL.GetDelegateForExtensionMethod("glTexSubImage3DEXT", typeof(TexSubImage3DEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ 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, System.IntPtr pixels);
+ public static TexSubImage4DSGIS glTexSubImage4DSGIS = ((TexSubImage4DSGIS)(GL.GetDelegateForExtensionMethod("glTexSubImage4DSGIS", typeof(TexSubImage4DSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TextureColorMaskSGIS([MarshalAs(UnmanagedType.Bool)] bool red, [MarshalAs(UnmanagedType.Bool)] bool green, [MarshalAs(UnmanagedType.Bool)] bool blue, [MarshalAs(UnmanagedType.Bool)] bool alpha);
+ public static TextureColorMaskSGIS glTextureColorMaskSGIS = ((TextureColorMaskSGIS)(GL.GetDelegateForExtensionMethod("glTextureColorMaskSGIS", typeof(TextureColorMaskSGIS))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TextureLightEXT(Enums.EXT_light_texture pname);
+ public static TextureLightEXT glTextureLightEXT = ((TextureLightEXT)(GL.GetDelegateForExtensionMethod("glTextureLightEXT", typeof(TextureLightEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TextureMaterialEXT(Enums.MaterialFace face, Enums.MaterialParameter mode);
+ public static TextureMaterialEXT glTextureMaterialEXT = ((TextureMaterialEXT)(GL.GetDelegateForExtensionMethod("glTextureMaterialEXT", typeof(TextureMaterialEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TextureNormalEXT(Enums.EXT_texture_perturb_normal mode);
+ public static TextureNormalEXT glTextureNormalEXT = ((TextureNormalEXT)(GL.GetDelegateForExtensionMethod("glTextureNormalEXT", typeof(TextureNormalEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TrackMatrixNV(Enums.NV_vertex_program target, GLuint address, Enums.NV_vertex_program matrix, Enums.NV_vertex_program transform);
+ public static TrackMatrixNV glTrackMatrixNV = ((TrackMatrixNV)(GL.GetDelegateForExtensionMethod("glTrackMatrixNV", typeof(TrackMatrixNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TransformFeedbackAttribsNV(GLuint count, System.IntPtr attribs, Enums.GLenum bufferMode);
+ public static TransformFeedbackAttribsNV glTransformFeedbackAttribsNV = ((TransformFeedbackAttribsNV)(GL.GetDelegateForExtensionMethod("glTransformFeedbackAttribsNV", typeof(TransformFeedbackAttribsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void TransformFeedbackVaryingsNV(GLuint program, GLsizei count, System.IntPtr locations, Enums.GLenum bufferMode);
+ public static TransformFeedbackVaryingsNV glTransformFeedbackVaryingsNV = ((TransformFeedbackVaryingsNV)(GL.GetDelegateForExtensionMethod("glTransformFeedbackVaryingsNV", typeof(TransformFeedbackVaryingsNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Translated(GLdouble x, GLdouble y, GLdouble z);
+ public static Translated glTranslated = ((Translated)(GL.GetDelegateForExtensionMethod("glTranslated", typeof(Translated)))) ?? new Translated(Imports.Translated);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Translatef(GLfloat x, GLfloat y, GLfloat z);
+ public static Translatef glTranslatef = ((Translatef)(GL.GetDelegateForExtensionMethod("glTranslatef", typeof(Translatef)))) ?? new Translatef(Imports.Translatef);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1f(GLint location, GLfloat v0);
+ public static Uniform1f glUniform1f = ((Uniform1f)(GL.GetDelegateForExtensionMethod("glUniform1f", typeof(Uniform1f)))) ?? new Uniform1f(Imports.Uniform1f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1fARB(GLint location, GLfloat v0);
+ public static Uniform1fARB glUniform1fARB = ((Uniform1fARB)(GL.GetDelegateForExtensionMethod("glUniform1fARB", typeof(Uniform1fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1fv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform1fv glUniform1fv = ((Uniform1fv)(GL.GetDelegateForExtensionMethod("glUniform1fv", typeof(Uniform1fv)))) ?? new Uniform1fv(Imports.Uniform1fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1fvARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform1fvARB glUniform1fvARB = ((Uniform1fvARB)(GL.GetDelegateForExtensionMethod("glUniform1fvARB", typeof(Uniform1fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1i(GLint location, GLint v0);
+ public static Uniform1i glUniform1i = ((Uniform1i)(GL.GetDelegateForExtensionMethod("glUniform1i", typeof(Uniform1i)))) ?? new Uniform1i(Imports.Uniform1i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1iARB(GLint location, GLint v0);
+ public static Uniform1iARB glUniform1iARB = ((Uniform1iARB)(GL.GetDelegateForExtensionMethod("glUniform1iARB", typeof(Uniform1iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1iv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform1iv glUniform1iv = ((Uniform1iv)(GL.GetDelegateForExtensionMethod("glUniform1iv", typeof(Uniform1iv)))) ?? new Uniform1iv(Imports.Uniform1iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1ivARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform1ivARB glUniform1ivARB = ((Uniform1ivARB)(GL.GetDelegateForExtensionMethod("glUniform1ivARB", typeof(Uniform1ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1uiEXT(GLint location, GLuint v0);
+ public static Uniform1uiEXT glUniform1uiEXT = ((Uniform1uiEXT)(GL.GetDelegateForExtensionMethod("glUniform1uiEXT", typeof(Uniform1uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform1uivEXT(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform1uivEXT glUniform1uivEXT = ((Uniform1uivEXT)(GL.GetDelegateForExtensionMethod("glUniform1uivEXT", typeof(Uniform1uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2f(GLint location, GLfloat v0, GLfloat v1);
+ public static Uniform2f glUniform2f = ((Uniform2f)(GL.GetDelegateForExtensionMethod("glUniform2f", typeof(Uniform2f)))) ?? new Uniform2f(Imports.Uniform2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2fARB(GLint location, GLfloat v0, GLfloat v1);
+ public static Uniform2fARB glUniform2fARB = ((Uniform2fARB)(GL.GetDelegateForExtensionMethod("glUniform2fARB", typeof(Uniform2fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2fv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform2fv glUniform2fv = ((Uniform2fv)(GL.GetDelegateForExtensionMethod("glUniform2fv", typeof(Uniform2fv)))) ?? new Uniform2fv(Imports.Uniform2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2fvARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform2fvARB glUniform2fvARB = ((Uniform2fvARB)(GL.GetDelegateForExtensionMethod("glUniform2fvARB", typeof(Uniform2fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2i(GLint location, GLint v0, GLint v1);
+ public static Uniform2i glUniform2i = ((Uniform2i)(GL.GetDelegateForExtensionMethod("glUniform2i", typeof(Uniform2i)))) ?? new Uniform2i(Imports.Uniform2i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2iARB(GLint location, GLint v0, GLint v1);
+ public static Uniform2iARB glUniform2iARB = ((Uniform2iARB)(GL.GetDelegateForExtensionMethod("glUniform2iARB", typeof(Uniform2iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2iv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform2iv glUniform2iv = ((Uniform2iv)(GL.GetDelegateForExtensionMethod("glUniform2iv", typeof(Uniform2iv)))) ?? new Uniform2iv(Imports.Uniform2iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2ivARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform2ivARB glUniform2ivARB = ((Uniform2ivARB)(GL.GetDelegateForExtensionMethod("glUniform2ivARB", typeof(Uniform2ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2uiEXT(GLint location, GLuint v0, GLuint v1);
+ public static Uniform2uiEXT glUniform2uiEXT = ((Uniform2uiEXT)(GL.GetDelegateForExtensionMethod("glUniform2uiEXT", typeof(Uniform2uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform2uivEXT(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform2uivEXT glUniform2uivEXT = ((Uniform2uivEXT)(GL.GetDelegateForExtensionMethod("glUniform2uivEXT", typeof(Uniform2uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ public static Uniform3f glUniform3f = ((Uniform3f)(GL.GetDelegateForExtensionMethod("glUniform3f", typeof(Uniform3f)))) ?? new Uniform3f(Imports.Uniform3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ public static Uniform3fARB glUniform3fARB = ((Uniform3fARB)(GL.GetDelegateForExtensionMethod("glUniform3fARB", typeof(Uniform3fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3fv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform3fv glUniform3fv = ((Uniform3fv)(GL.GetDelegateForExtensionMethod("glUniform3fv", typeof(Uniform3fv)))) ?? new Uniform3fv(Imports.Uniform3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3fvARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform3fvARB glUniform3fvARB = ((Uniform3fvARB)(GL.GetDelegateForExtensionMethod("glUniform3fvARB", typeof(Uniform3fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+ public static Uniform3i glUniform3i = ((Uniform3i)(GL.GetDelegateForExtensionMethod("glUniform3i", typeof(Uniform3i)))) ?? new Uniform3i(Imports.Uniform3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3iARB(GLint location, GLint v0, GLint v1, GLint v2);
+ public static Uniform3iARB glUniform3iARB = ((Uniform3iARB)(GL.GetDelegateForExtensionMethod("glUniform3iARB", typeof(Uniform3iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3iv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform3iv glUniform3iv = ((Uniform3iv)(GL.GetDelegateForExtensionMethod("glUniform3iv", typeof(Uniform3iv)))) ?? new Uniform3iv(Imports.Uniform3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3ivARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform3ivARB glUniform3ivARB = ((Uniform3ivARB)(GL.GetDelegateForExtensionMethod("glUniform3ivARB", typeof(Uniform3ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2);
+ public static Uniform3uiEXT glUniform3uiEXT = ((Uniform3uiEXT)(GL.GetDelegateForExtensionMethod("glUniform3uiEXT", typeof(Uniform3uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform3uivEXT(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform3uivEXT glUniform3uivEXT = ((Uniform3uivEXT)(GL.GetDelegateForExtensionMethod("glUniform3uivEXT", typeof(Uniform3uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ public static Uniform4f glUniform4f = ((Uniform4f)(GL.GetDelegateForExtensionMethod("glUniform4f", typeof(Uniform4f)))) ?? new Uniform4f(Imports.Uniform4f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ public static Uniform4fARB glUniform4fARB = ((Uniform4fARB)(GL.GetDelegateForExtensionMethod("glUniform4fARB", typeof(Uniform4fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4fv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform4fv glUniform4fv = ((Uniform4fv)(GL.GetDelegateForExtensionMethod("glUniform4fv", typeof(Uniform4fv)))) ?? new Uniform4fv(Imports.Uniform4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4fvARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform4fvARB glUniform4fvARB = ((Uniform4fvARB)(GL.GetDelegateForExtensionMethod("glUniform4fvARB", typeof(Uniform4fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ public static Uniform4i glUniform4i = ((Uniform4i)(GL.GetDelegateForExtensionMethod("glUniform4i", typeof(Uniform4i)))) ?? new Uniform4i(Imports.Uniform4i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ public static Uniform4iARB glUniform4iARB = ((Uniform4iARB)(GL.GetDelegateForExtensionMethod("glUniform4iARB", typeof(Uniform4iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4iv(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform4iv glUniform4iv = ((Uniform4iv)(GL.GetDelegateForExtensionMethod("glUniform4iv", typeof(Uniform4iv)))) ?? new Uniform4iv(Imports.Uniform4iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4ivARB(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform4ivARB glUniform4ivARB = ((Uniform4ivARB)(GL.GetDelegateForExtensionMethod("glUniform4ivARB", typeof(Uniform4ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ public static Uniform4uiEXT glUniform4uiEXT = ((Uniform4uiEXT)(GL.GetDelegateForExtensionMethod("glUniform4uiEXT", typeof(Uniform4uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Uniform4uivEXT(GLint location, GLsizei count, System.IntPtr value);
+ public static Uniform4uivEXT glUniform4uivEXT = ((Uniform4uivEXT)(GL.GetDelegateForExtensionMethod("glUniform4uivEXT", typeof(Uniform4uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformBufferEXT(GLuint program, GLint location, GLuint buffer);
+ public static UniformBufferEXT glUniformBufferEXT = ((UniformBufferEXT)(GL.GetDelegateForExtensionMethod("glUniformBufferEXT", typeof(UniformBufferEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix2fv glUniformMatrix2fv = ((UniformMatrix2fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix2fv", typeof(UniformMatrix2fv)))) ?? new UniformMatrix2fv(Imports.UniformMatrix2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix2fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix2fvARB glUniformMatrix2fvARB = ((UniformMatrix2fvARB)(GL.GetDelegateForExtensionMethod("glUniformMatrix2fvARB", typeof(UniformMatrix2fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix2x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix2x3fv glUniformMatrix2x3fv = ((UniformMatrix2x3fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix2x3fv", typeof(UniformMatrix2x3fv)))) ?? new UniformMatrix2x3fv(Imports.UniformMatrix2x3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix2x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix2x4fv glUniformMatrix2x4fv = ((UniformMatrix2x4fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix2x4fv", typeof(UniformMatrix2x4fv)))) ?? new UniformMatrix2x4fv(Imports.UniformMatrix2x4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix3fv glUniformMatrix3fv = ((UniformMatrix3fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix3fv", typeof(UniformMatrix3fv)))) ?? new UniformMatrix3fv(Imports.UniformMatrix3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix3fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix3fvARB glUniformMatrix3fvARB = ((UniformMatrix3fvARB)(GL.GetDelegateForExtensionMethod("glUniformMatrix3fvARB", typeof(UniformMatrix3fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix3x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix3x2fv glUniformMatrix3x2fv = ((UniformMatrix3x2fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix3x2fv", typeof(UniformMatrix3x2fv)))) ?? new UniformMatrix3x2fv(Imports.UniformMatrix3x2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix3x4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix3x4fv glUniformMatrix3x4fv = ((UniformMatrix3x4fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix3x4fv", typeof(UniformMatrix3x4fv)))) ?? new UniformMatrix3x4fv(Imports.UniformMatrix3x4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix4fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix4fv glUniformMatrix4fv = ((UniformMatrix4fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix4fv", typeof(UniformMatrix4fv)))) ?? new UniformMatrix4fv(Imports.UniformMatrix4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix4fvARB(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix4fvARB glUniformMatrix4fvARB = ((UniformMatrix4fvARB)(GL.GetDelegateForExtensionMethod("glUniformMatrix4fvARB", typeof(UniformMatrix4fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix4x2fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix4x2fv glUniformMatrix4x2fv = ((UniformMatrix4x2fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix4x2fv", typeof(UniformMatrix4x2fv)))) ?? new UniformMatrix4x2fv(Imports.UniformMatrix4x2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UniformMatrix4x3fv(GLint location, GLsizei count, [MarshalAs(UnmanagedType.Bool)] bool transpose, System.IntPtr value);
+ public static UniformMatrix4x3fv glUniformMatrix4x3fv = ((UniformMatrix4x3fv)(GL.GetDelegateForExtensionMethod("glUniformMatrix4x3fv", typeof(UniformMatrix4x3fv)))) ?? new UniformMatrix4x3fv(Imports.UniformMatrix4x3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UnlockArraysEXT();
+ public static UnlockArraysEXT glUnlockArraysEXT = ((UnlockArraysEXT)(GL.GetDelegateForExtensionMethod("glUnlockArraysEXT", typeof(UnlockArraysEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean UnmapBuffer(Enums.VERSION_1_5 target);
+ public static UnmapBuffer glUnmapBuffer = ((UnmapBuffer)(GL.GetDelegateForExtensionMethod("glUnmapBuffer", typeof(UnmapBuffer)))) ?? new UnmapBuffer(Imports.UnmapBuffer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate GLboolean UnmapBufferARB(Enums.ARB_vertex_buffer_object target);
+ public static UnmapBufferARB glUnmapBufferARB = ((UnmapBufferARB)(GL.GetDelegateForExtensionMethod("glUnmapBufferARB", typeof(UnmapBufferARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UnmapObjectBufferATI(GLuint buffer);
+ public static UnmapObjectBufferATI glUnmapObjectBufferATI = ((UnmapObjectBufferATI)(GL.GetDelegateForExtensionMethod("glUnmapObjectBufferATI", typeof(UnmapObjectBufferATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, System.IntPtr pointer, Enums.ATI_vertex_array_object preserve);
+ public static UpdateObjectBufferATI glUpdateObjectBufferATI = ((UpdateObjectBufferATI)(GL.GetDelegateForExtensionMethod("glUpdateObjectBufferATI", typeof(UpdateObjectBufferATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UseProgram(GLuint program);
+ public static UseProgram glUseProgram = ((UseProgram)(GL.GetDelegateForExtensionMethod("glUseProgram", typeof(UseProgram)))) ?? new UseProgram(Imports.UseProgram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void UseProgramObjectARB(GLhandleARB programObj);
+ public static UseProgramObjectARB glUseProgramObjectARB = ((UseProgramObjectARB)(GL.GetDelegateForExtensionMethod("glUseProgramObjectARB", typeof(UseProgramObjectARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ValidateProgram(GLuint program);
+ public static ValidateProgram glValidateProgram = ((ValidateProgram)(GL.GetDelegateForExtensionMethod("glValidateProgram", typeof(ValidateProgram)))) ?? new ValidateProgram(Imports.ValidateProgram);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void ValidateProgramARB(GLhandleARB programObj);
+ public static ValidateProgramARB glValidateProgramARB = ((ValidateProgramARB)(GL.GetDelegateForExtensionMethod("glValidateProgramARB", typeof(ValidateProgramARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantArrayObjectATI(GLuint id, Enums.ATI_vertex_array_object type, GLsizei stride, GLuint buffer, GLuint offset);
+ public static VariantArrayObjectATI glVariantArrayObjectATI = ((VariantArrayObjectATI)(GL.GetDelegateForExtensionMethod("glVariantArrayObjectATI", typeof(VariantArrayObjectATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantbvEXT(GLuint id, System.IntPtr addr);
+ public static VariantbvEXT glVariantbvEXT = ((VariantbvEXT)(GL.GetDelegateForExtensionMethod("glVariantbvEXT", typeof(VariantbvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantdvEXT(GLuint id, System.IntPtr addr);
+ public static VariantdvEXT glVariantdvEXT = ((VariantdvEXT)(GL.GetDelegateForExtensionMethod("glVariantdvEXT", typeof(VariantdvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantfvEXT(GLuint id, System.IntPtr addr);
+ public static VariantfvEXT glVariantfvEXT = ((VariantfvEXT)(GL.GetDelegateForExtensionMethod("glVariantfvEXT", typeof(VariantfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantivEXT(GLuint id, System.IntPtr addr);
+ public static VariantivEXT glVariantivEXT = ((VariantivEXT)(GL.GetDelegateForExtensionMethod("glVariantivEXT", typeof(VariantivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantPointerEXT(GLuint id, Enums.EXT_vertex_shader type, GLuint stride, System.IntPtr addr);
+ public static VariantPointerEXT glVariantPointerEXT = ((VariantPointerEXT)(GL.GetDelegateForExtensionMethod("glVariantPointerEXT", typeof(VariantPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantsvEXT(GLuint id, System.IntPtr addr);
+ public static VariantsvEXT glVariantsvEXT = ((VariantsvEXT)(GL.GetDelegateForExtensionMethod("glVariantsvEXT", typeof(VariantsvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantubvEXT(GLuint id, System.IntPtr addr);
+ public static VariantubvEXT glVariantubvEXT = ((VariantubvEXT)(GL.GetDelegateForExtensionMethod("glVariantubvEXT", typeof(VariantubvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantuivEXT(GLuint id, System.IntPtr addr);
+ public static VariantuivEXT glVariantuivEXT = ((VariantuivEXT)(GL.GetDelegateForExtensionMethod("glVariantuivEXT", typeof(VariantuivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VariantusvEXT(GLuint id, System.IntPtr addr);
+ public static VariantusvEXT glVariantusvEXT = ((VariantusvEXT)(GL.GetDelegateForExtensionMethod("glVariantusvEXT", typeof(VariantusvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2d(GLdouble x, GLdouble y);
+ public static Vertex2d glVertex2d = ((Vertex2d)(GL.GetDelegateForExtensionMethod("glVertex2d", typeof(Vertex2d)))) ?? new Vertex2d(Imports.Vertex2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2dv(System.IntPtr v);
+ public static Vertex2dv glVertex2dv = ((Vertex2dv)(GL.GetDelegateForExtensionMethod("glVertex2dv", typeof(Vertex2dv)))) ?? new Vertex2dv(Imports.Vertex2dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2f(GLfloat x, GLfloat y);
+ public static Vertex2f glVertex2f = ((Vertex2f)(GL.GetDelegateForExtensionMethod("glVertex2f", typeof(Vertex2f)))) ?? new Vertex2f(Imports.Vertex2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2fv(System.IntPtr v);
+ public static Vertex2fv glVertex2fv = ((Vertex2fv)(GL.GetDelegateForExtensionMethod("glVertex2fv", typeof(Vertex2fv)))) ?? new Vertex2fv(Imports.Vertex2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2hNV(GLhalfNV x, GLhalfNV y);
+ public static Vertex2hNV glVertex2hNV = ((Vertex2hNV)(GL.GetDelegateForExtensionMethod("glVertex2hNV", typeof(Vertex2hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2hvNV(System.IntPtr v);
+ public static Vertex2hvNV glVertex2hvNV = ((Vertex2hvNV)(GL.GetDelegateForExtensionMethod("glVertex2hvNV", typeof(Vertex2hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2i(GLint x, GLint y);
+ public static Vertex2i glVertex2i = ((Vertex2i)(GL.GetDelegateForExtensionMethod("glVertex2i", typeof(Vertex2i)))) ?? new Vertex2i(Imports.Vertex2i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2iv(System.IntPtr v);
+ public static Vertex2iv glVertex2iv = ((Vertex2iv)(GL.GetDelegateForExtensionMethod("glVertex2iv", typeof(Vertex2iv)))) ?? new Vertex2iv(Imports.Vertex2iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2s(GLshort x, GLshort y);
+ public static Vertex2s glVertex2s = ((Vertex2s)(GL.GetDelegateForExtensionMethod("glVertex2s", typeof(Vertex2s)))) ?? new Vertex2s(Imports.Vertex2s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex2sv(System.IntPtr v);
+ public static Vertex2sv glVertex2sv = ((Vertex2sv)(GL.GetDelegateForExtensionMethod("glVertex2sv", typeof(Vertex2sv)))) ?? new Vertex2sv(Imports.Vertex2sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3d(GLdouble x, GLdouble y, GLdouble z);
+ public static Vertex3d glVertex3d = ((Vertex3d)(GL.GetDelegateForExtensionMethod("glVertex3d", typeof(Vertex3d)))) ?? new Vertex3d(Imports.Vertex3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3dv(System.IntPtr v);
+ public static Vertex3dv glVertex3dv = ((Vertex3dv)(GL.GetDelegateForExtensionMethod("glVertex3dv", typeof(Vertex3dv)))) ?? new Vertex3dv(Imports.Vertex3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3f(GLfloat x, GLfloat y, GLfloat z);
+ public static Vertex3f glVertex3f = ((Vertex3f)(GL.GetDelegateForExtensionMethod("glVertex3f", typeof(Vertex3f)))) ?? new Vertex3f(Imports.Vertex3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3fv(System.IntPtr v);
+ public static Vertex3fv glVertex3fv = ((Vertex3fv)(GL.GetDelegateForExtensionMethod("glVertex3fv", typeof(Vertex3fv)))) ?? new Vertex3fv(Imports.Vertex3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z);
+ public static Vertex3hNV glVertex3hNV = ((Vertex3hNV)(GL.GetDelegateForExtensionMethod("glVertex3hNV", typeof(Vertex3hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3hvNV(System.IntPtr v);
+ public static Vertex3hvNV glVertex3hvNV = ((Vertex3hvNV)(GL.GetDelegateForExtensionMethod("glVertex3hvNV", typeof(Vertex3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3i(GLint x, GLint y, GLint z);
+ public static Vertex3i glVertex3i = ((Vertex3i)(GL.GetDelegateForExtensionMethod("glVertex3i", typeof(Vertex3i)))) ?? new Vertex3i(Imports.Vertex3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3iv(System.IntPtr v);
+ public static Vertex3iv glVertex3iv = ((Vertex3iv)(GL.GetDelegateForExtensionMethod("glVertex3iv", typeof(Vertex3iv)))) ?? new Vertex3iv(Imports.Vertex3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3s(GLshort x, GLshort y, GLshort z);
+ public static Vertex3s glVertex3s = ((Vertex3s)(GL.GetDelegateForExtensionMethod("glVertex3s", typeof(Vertex3s)))) ?? new Vertex3s(Imports.Vertex3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex3sv(System.IntPtr v);
+ public static Vertex3sv glVertex3sv = ((Vertex3sv)(GL.GetDelegateForExtensionMethod("glVertex3sv", typeof(Vertex3sv)))) ?? new Vertex3sv(Imports.Vertex3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static Vertex4d glVertex4d = ((Vertex4d)(GL.GetDelegateForExtensionMethod("glVertex4d", typeof(Vertex4d)))) ?? new Vertex4d(Imports.Vertex4d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4dv(System.IntPtr v);
+ public static Vertex4dv glVertex4dv = ((Vertex4dv)(GL.GetDelegateForExtensionMethod("glVertex4dv", typeof(Vertex4dv)))) ?? new Vertex4dv(Imports.Vertex4dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static Vertex4f glVertex4f = ((Vertex4f)(GL.GetDelegateForExtensionMethod("glVertex4f", typeof(Vertex4f)))) ?? new Vertex4f(Imports.Vertex4f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4fv(System.IntPtr v);
+ public static Vertex4fv glVertex4fv = ((Vertex4fv)(GL.GetDelegateForExtensionMethod("glVertex4fv", typeof(Vertex4fv)))) ?? new Vertex4fv(Imports.Vertex4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+ public static Vertex4hNV glVertex4hNV = ((Vertex4hNV)(GL.GetDelegateForExtensionMethod("glVertex4hNV", typeof(Vertex4hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4hvNV(System.IntPtr v);
+ public static Vertex4hvNV glVertex4hvNV = ((Vertex4hvNV)(GL.GetDelegateForExtensionMethod("glVertex4hvNV", typeof(Vertex4hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4i(GLint x, GLint y, GLint z, GLint w);
+ public static Vertex4i glVertex4i = ((Vertex4i)(GL.GetDelegateForExtensionMethod("glVertex4i", typeof(Vertex4i)))) ?? new Vertex4i(Imports.Vertex4i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4iv(System.IntPtr v);
+ public static Vertex4iv glVertex4iv = ((Vertex4iv)(GL.GetDelegateForExtensionMethod("glVertex4iv", typeof(Vertex4iv)))) ?? new Vertex4iv(Imports.Vertex4iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
+ public static Vertex4s glVertex4s = ((Vertex4s)(GL.GetDelegateForExtensionMethod("glVertex4s", typeof(Vertex4s)))) ?? new Vertex4s(Imports.Vertex4s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Vertex4sv(System.IntPtr v);
+ public static Vertex4sv glVertex4sv = ((Vertex4sv)(GL.GetDelegateForExtensionMethod("glVertex4sv", typeof(Vertex4sv)))) ?? new Vertex4sv(Imports.Vertex4sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexArrayParameteriAPPLE(Enums.APPLE_vertex_array_range pname, GLint param);
+ public static VertexArrayParameteriAPPLE glVertexArrayParameteriAPPLE = ((VertexArrayParameteriAPPLE)(GL.GetDelegateForExtensionMethod("glVertexArrayParameteriAPPLE", typeof(VertexArrayParameteriAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexArrayRangeAPPLE(GLsizei length, [In, Out()] System.IntPtr pointer);
+ public static VertexArrayRangeAPPLE glVertexArrayRangeAPPLE = ((VertexArrayRangeAPPLE)(GL.GetDelegateForExtensionMethod("glVertexArrayRangeAPPLE", typeof(VertexArrayRangeAPPLE))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexArrayRangeNV(GLsizei length, System.IntPtr pointer);
+ public static VertexArrayRangeNV glVertexArrayRangeNV = ((VertexArrayRangeNV)(GL.GetDelegateForExtensionMethod("glVertexArrayRangeNV", typeof(VertexArrayRangeNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1d(GLuint index, GLdouble x);
+ public static VertexAttrib1d glVertexAttrib1d = ((VertexAttrib1d)(GL.GetDelegateForExtensionMethod("glVertexAttrib1d", typeof(VertexAttrib1d)))) ?? new VertexAttrib1d(Imports.VertexAttrib1d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1dARB(GLuint index, GLdouble x);
+ public static VertexAttrib1dARB glVertexAttrib1dARB = ((VertexAttrib1dARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib1dARB", typeof(VertexAttrib1dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1dNV(GLuint index, GLdouble x);
+ public static VertexAttrib1dNV glVertexAttrib1dNV = ((VertexAttrib1dNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1dNV", typeof(VertexAttrib1dNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1dv(GLuint index, System.IntPtr v);
+ public static VertexAttrib1dv glVertexAttrib1dv = ((VertexAttrib1dv)(GL.GetDelegateForExtensionMethod("glVertexAttrib1dv", typeof(VertexAttrib1dv)))) ?? new VertexAttrib1dv(Imports.VertexAttrib1dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1dvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib1dvARB glVertexAttrib1dvARB = ((VertexAttrib1dvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib1dvARB", typeof(VertexAttrib1dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1dvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib1dvNV glVertexAttrib1dvNV = ((VertexAttrib1dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1dvNV", typeof(VertexAttrib1dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1f(GLuint index, GLfloat x);
+ public static VertexAttrib1f glVertexAttrib1f = ((VertexAttrib1f)(GL.GetDelegateForExtensionMethod("glVertexAttrib1f", typeof(VertexAttrib1f)))) ?? new VertexAttrib1f(Imports.VertexAttrib1f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1fARB(GLuint index, GLfloat x);
+ public static VertexAttrib1fARB glVertexAttrib1fARB = ((VertexAttrib1fARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib1fARB", typeof(VertexAttrib1fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1fNV(GLuint index, GLfloat x);
+ public static VertexAttrib1fNV glVertexAttrib1fNV = ((VertexAttrib1fNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1fNV", typeof(VertexAttrib1fNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1fv(GLuint index, System.IntPtr v);
+ public static VertexAttrib1fv glVertexAttrib1fv = ((VertexAttrib1fv)(GL.GetDelegateForExtensionMethod("glVertexAttrib1fv", typeof(VertexAttrib1fv)))) ?? new VertexAttrib1fv(Imports.VertexAttrib1fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1fvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib1fvARB glVertexAttrib1fvARB = ((VertexAttrib1fvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib1fvARB", typeof(VertexAttrib1fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1fvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib1fvNV glVertexAttrib1fvNV = ((VertexAttrib1fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1fvNV", typeof(VertexAttrib1fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1hNV(GLuint index, GLhalfNV x);
+ public static VertexAttrib1hNV glVertexAttrib1hNV = ((VertexAttrib1hNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1hNV", typeof(VertexAttrib1hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1hvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib1hvNV glVertexAttrib1hvNV = ((VertexAttrib1hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1hvNV", typeof(VertexAttrib1hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1s(GLuint index, GLshort x);
+ public static VertexAttrib1s glVertexAttrib1s = ((VertexAttrib1s)(GL.GetDelegateForExtensionMethod("glVertexAttrib1s", typeof(VertexAttrib1s)))) ?? new VertexAttrib1s(Imports.VertexAttrib1s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1sARB(GLuint index, GLshort x);
+ public static VertexAttrib1sARB glVertexAttrib1sARB = ((VertexAttrib1sARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib1sARB", typeof(VertexAttrib1sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1sNV(GLuint index, GLshort x);
+ public static VertexAttrib1sNV glVertexAttrib1sNV = ((VertexAttrib1sNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1sNV", typeof(VertexAttrib1sNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1sv(GLuint index, System.IntPtr v);
+ public static VertexAttrib1sv glVertexAttrib1sv = ((VertexAttrib1sv)(GL.GetDelegateForExtensionMethod("glVertexAttrib1sv", typeof(VertexAttrib1sv)))) ?? new VertexAttrib1sv(Imports.VertexAttrib1sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1svARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib1svARB glVertexAttrib1svARB = ((VertexAttrib1svARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib1svARB", typeof(VertexAttrib1svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib1svNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib1svNV glVertexAttrib1svNV = ((VertexAttrib1svNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib1svNV", typeof(VertexAttrib1svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
+ public static VertexAttrib2d glVertexAttrib2d = ((VertexAttrib2d)(GL.GetDelegateForExtensionMethod("glVertexAttrib2d", typeof(VertexAttrib2d)))) ?? new VertexAttrib2d(Imports.VertexAttrib2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y);
+ public static VertexAttrib2dARB glVertexAttrib2dARB = ((VertexAttrib2dARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib2dARB", typeof(VertexAttrib2dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);
+ public static VertexAttrib2dNV glVertexAttrib2dNV = ((VertexAttrib2dNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2dNV", typeof(VertexAttrib2dNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2dv(GLuint index, System.IntPtr v);
+ public static VertexAttrib2dv glVertexAttrib2dv = ((VertexAttrib2dv)(GL.GetDelegateForExtensionMethod("glVertexAttrib2dv", typeof(VertexAttrib2dv)))) ?? new VertexAttrib2dv(Imports.VertexAttrib2dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2dvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib2dvARB glVertexAttrib2dvARB = ((VertexAttrib2dvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib2dvARB", typeof(VertexAttrib2dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2dvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib2dvNV glVertexAttrib2dvNV = ((VertexAttrib2dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2dvNV", typeof(VertexAttrib2dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
+ public static VertexAttrib2f glVertexAttrib2f = ((VertexAttrib2f)(GL.GetDelegateForExtensionMethod("glVertexAttrib2f", typeof(VertexAttrib2f)))) ?? new VertexAttrib2f(Imports.VertexAttrib2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y);
+ public static VertexAttrib2fARB glVertexAttrib2fARB = ((VertexAttrib2fARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib2fARB", typeof(VertexAttrib2fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);
+ public static VertexAttrib2fNV glVertexAttrib2fNV = ((VertexAttrib2fNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2fNV", typeof(VertexAttrib2fNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2fv(GLuint index, System.IntPtr v);
+ public static VertexAttrib2fv glVertexAttrib2fv = ((VertexAttrib2fv)(GL.GetDelegateForExtensionMethod("glVertexAttrib2fv", typeof(VertexAttrib2fv)))) ?? new VertexAttrib2fv(Imports.VertexAttrib2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2fvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib2fvARB glVertexAttrib2fvARB = ((VertexAttrib2fvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib2fvARB", typeof(VertexAttrib2fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2fvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib2fvNV glVertexAttrib2fvNV = ((VertexAttrib2fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2fvNV", typeof(VertexAttrib2fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y);
+ public static VertexAttrib2hNV glVertexAttrib2hNV = ((VertexAttrib2hNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2hNV", typeof(VertexAttrib2hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2hvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib2hvNV glVertexAttrib2hvNV = ((VertexAttrib2hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2hvNV", typeof(VertexAttrib2hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2s(GLuint index, GLshort x, GLshort y);
+ public static VertexAttrib2s glVertexAttrib2s = ((VertexAttrib2s)(GL.GetDelegateForExtensionMethod("glVertexAttrib2s", typeof(VertexAttrib2s)))) ?? new VertexAttrib2s(Imports.VertexAttrib2s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2sARB(GLuint index, GLshort x, GLshort y);
+ public static VertexAttrib2sARB glVertexAttrib2sARB = ((VertexAttrib2sARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib2sARB", typeof(VertexAttrib2sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2sNV(GLuint index, GLshort x, GLshort y);
+ public static VertexAttrib2sNV glVertexAttrib2sNV = ((VertexAttrib2sNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2sNV", typeof(VertexAttrib2sNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2sv(GLuint index, System.IntPtr v);
+ public static VertexAttrib2sv glVertexAttrib2sv = ((VertexAttrib2sv)(GL.GetDelegateForExtensionMethod("glVertexAttrib2sv", typeof(VertexAttrib2sv)))) ?? new VertexAttrib2sv(Imports.VertexAttrib2sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2svARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib2svARB glVertexAttrib2svARB = ((VertexAttrib2svARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib2svARB", typeof(VertexAttrib2svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib2svNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib2svNV glVertexAttrib2svNV = ((VertexAttrib2svNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib2svNV", typeof(VertexAttrib2svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+ public static VertexAttrib3d glVertexAttrib3d = ((VertexAttrib3d)(GL.GetDelegateForExtensionMethod("glVertexAttrib3d", typeof(VertexAttrib3d)))) ?? new VertexAttrib3d(Imports.VertexAttrib3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+ public static VertexAttrib3dARB glVertexAttrib3dARB = ((VertexAttrib3dARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib3dARB", typeof(VertexAttrib3dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+ public static VertexAttrib3dNV glVertexAttrib3dNV = ((VertexAttrib3dNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3dNV", typeof(VertexAttrib3dNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3dv(GLuint index, System.IntPtr v);
+ public static VertexAttrib3dv glVertexAttrib3dv = ((VertexAttrib3dv)(GL.GetDelegateForExtensionMethod("glVertexAttrib3dv", typeof(VertexAttrib3dv)))) ?? new VertexAttrib3dv(Imports.VertexAttrib3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3dvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib3dvARB glVertexAttrib3dvARB = ((VertexAttrib3dvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib3dvARB", typeof(VertexAttrib3dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3dvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib3dvNV glVertexAttrib3dvNV = ((VertexAttrib3dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3dvNV", typeof(VertexAttrib3dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+ public static VertexAttrib3f glVertexAttrib3f = ((VertexAttrib3f)(GL.GetDelegateForExtensionMethod("glVertexAttrib3f", typeof(VertexAttrib3f)))) ?? new VertexAttrib3f(Imports.VertexAttrib3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+ public static VertexAttrib3fARB glVertexAttrib3fARB = ((VertexAttrib3fARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib3fARB", typeof(VertexAttrib3fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+ public static VertexAttrib3fNV glVertexAttrib3fNV = ((VertexAttrib3fNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3fNV", typeof(VertexAttrib3fNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3fv(GLuint index, System.IntPtr v);
+ public static VertexAttrib3fv glVertexAttrib3fv = ((VertexAttrib3fv)(GL.GetDelegateForExtensionMethod("glVertexAttrib3fv", typeof(VertexAttrib3fv)))) ?? new VertexAttrib3fv(Imports.VertexAttrib3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3fvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib3fvARB glVertexAttrib3fvARB = ((VertexAttrib3fvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib3fvARB", typeof(VertexAttrib3fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3fvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib3fvNV glVertexAttrib3fvNV = ((VertexAttrib3fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3fvNV", typeof(VertexAttrib3fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z);
+ public static VertexAttrib3hNV glVertexAttrib3hNV = ((VertexAttrib3hNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3hNV", typeof(VertexAttrib3hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3hvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib3hvNV glVertexAttrib3hvNV = ((VertexAttrib3hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3hvNV", typeof(VertexAttrib3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
+ public static VertexAttrib3s glVertexAttrib3s = ((VertexAttrib3s)(GL.GetDelegateForExtensionMethod("glVertexAttrib3s", typeof(VertexAttrib3s)))) ?? new VertexAttrib3s(Imports.VertexAttrib3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z);
+ public static VertexAttrib3sARB glVertexAttrib3sARB = ((VertexAttrib3sARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib3sARB", typeof(VertexAttrib3sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);
+ public static VertexAttrib3sNV glVertexAttrib3sNV = ((VertexAttrib3sNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3sNV", typeof(VertexAttrib3sNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3sv(GLuint index, System.IntPtr v);
+ public static VertexAttrib3sv glVertexAttrib3sv = ((VertexAttrib3sv)(GL.GetDelegateForExtensionMethod("glVertexAttrib3sv", typeof(VertexAttrib3sv)))) ?? new VertexAttrib3sv(Imports.VertexAttrib3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3svARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib3svARB glVertexAttrib3svARB = ((VertexAttrib3svARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib3svARB", typeof(VertexAttrib3svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib3svNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib3svNV glVertexAttrib3svNV = ((VertexAttrib3svNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib3svNV", typeof(VertexAttrib3svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4bv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4bv glVertexAttrib4bv = ((VertexAttrib4bv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4bv", typeof(VertexAttrib4bv)))) ?? new VertexAttrib4bv(Imports.VertexAttrib4bv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4bvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4bvARB glVertexAttrib4bvARB = ((VertexAttrib4bvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4bvARB", typeof(VertexAttrib4bvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static VertexAttrib4d glVertexAttrib4d = ((VertexAttrib4d)(GL.GetDelegateForExtensionMethod("glVertexAttrib4d", typeof(VertexAttrib4d)))) ?? new VertexAttrib4d(Imports.VertexAttrib4d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static VertexAttrib4dARB glVertexAttrib4dARB = ((VertexAttrib4dARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4dARB", typeof(VertexAttrib4dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static VertexAttrib4dNV glVertexAttrib4dNV = ((VertexAttrib4dNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4dNV", typeof(VertexAttrib4dNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4dv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4dv glVertexAttrib4dv = ((VertexAttrib4dv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4dv", typeof(VertexAttrib4dv)))) ?? new VertexAttrib4dv(Imports.VertexAttrib4dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4dvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4dvARB glVertexAttrib4dvARB = ((VertexAttrib4dvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4dvARB", typeof(VertexAttrib4dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4dvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib4dvNV glVertexAttrib4dvNV = ((VertexAttrib4dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4dvNV", typeof(VertexAttrib4dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static VertexAttrib4f glVertexAttrib4f = ((VertexAttrib4f)(GL.GetDelegateForExtensionMethod("glVertexAttrib4f", typeof(VertexAttrib4f)))) ?? new VertexAttrib4f(Imports.VertexAttrib4f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static VertexAttrib4fARB glVertexAttrib4fARB = ((VertexAttrib4fARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4fARB", typeof(VertexAttrib4fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static VertexAttrib4fNV glVertexAttrib4fNV = ((VertexAttrib4fNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4fNV", typeof(VertexAttrib4fNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4fv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4fv glVertexAttrib4fv = ((VertexAttrib4fv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4fv", typeof(VertexAttrib4fv)))) ?? new VertexAttrib4fv(Imports.VertexAttrib4fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4fvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4fvARB glVertexAttrib4fvARB = ((VertexAttrib4fvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4fvARB", typeof(VertexAttrib4fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4fvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib4fvNV glVertexAttrib4fvNV = ((VertexAttrib4fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4fvNV", typeof(VertexAttrib4fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w);
+ public static VertexAttrib4hNV glVertexAttrib4hNV = ((VertexAttrib4hNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4hNV", typeof(VertexAttrib4hNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4hvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib4hvNV glVertexAttrib4hvNV = ((VertexAttrib4hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4hvNV", typeof(VertexAttrib4hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4iv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4iv glVertexAttrib4iv = ((VertexAttrib4iv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4iv", typeof(VertexAttrib4iv)))) ?? new VertexAttrib4iv(Imports.VertexAttrib4iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4ivARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4ivARB glVertexAttrib4ivARB = ((VertexAttrib4ivARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4ivARB", typeof(VertexAttrib4ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4Nbv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4Nbv glVertexAttrib4Nbv = ((VertexAttrib4Nbv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4Nbv", typeof(VertexAttrib4Nbv)))) ?? new VertexAttrib4Nbv(Imports.VertexAttrib4Nbv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4NbvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4NbvARB glVertexAttrib4NbvARB = ((VertexAttrib4NbvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4NbvARB", typeof(VertexAttrib4NbvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4Niv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4Niv glVertexAttrib4Niv = ((VertexAttrib4Niv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4Niv", typeof(VertexAttrib4Niv)))) ?? new VertexAttrib4Niv(Imports.VertexAttrib4Niv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4NivARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4NivARB glVertexAttrib4NivARB = ((VertexAttrib4NivARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4NivARB", typeof(VertexAttrib4NivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4Nsv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4Nsv glVertexAttrib4Nsv = ((VertexAttrib4Nsv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4Nsv", typeof(VertexAttrib4Nsv)))) ?? new VertexAttrib4Nsv(Imports.VertexAttrib4Nsv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4NsvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4NsvARB glVertexAttrib4NsvARB = ((VertexAttrib4NsvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4NsvARB", typeof(VertexAttrib4NsvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+ public static VertexAttrib4Nub glVertexAttrib4Nub = ((VertexAttrib4Nub)(GL.GetDelegateForExtensionMethod("glVertexAttrib4Nub", typeof(VertexAttrib4Nub)))) ?? new VertexAttrib4Nub(Imports.VertexAttrib4Nub);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+ public static VertexAttrib4NubARB glVertexAttrib4NubARB = ((VertexAttrib4NubARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4NubARB", typeof(VertexAttrib4NubARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4Nubv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4Nubv glVertexAttrib4Nubv = ((VertexAttrib4Nubv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4Nubv", typeof(VertexAttrib4Nubv)))) ?? new VertexAttrib4Nubv(Imports.VertexAttrib4Nubv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4NubvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4NubvARB glVertexAttrib4NubvARB = ((VertexAttrib4NubvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4NubvARB", typeof(VertexAttrib4NubvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4Nuiv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4Nuiv glVertexAttrib4Nuiv = ((VertexAttrib4Nuiv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4Nuiv", typeof(VertexAttrib4Nuiv)))) ?? new VertexAttrib4Nuiv(Imports.VertexAttrib4Nuiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4NuivARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4NuivARB glVertexAttrib4NuivARB = ((VertexAttrib4NuivARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4NuivARB", typeof(VertexAttrib4NuivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4Nusv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4Nusv glVertexAttrib4Nusv = ((VertexAttrib4Nusv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4Nusv", typeof(VertexAttrib4Nusv)))) ?? new VertexAttrib4Nusv(Imports.VertexAttrib4Nusv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4NusvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4NusvARB glVertexAttrib4NusvARB = ((VertexAttrib4NusvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4NusvARB", typeof(VertexAttrib4NusvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+ public static VertexAttrib4s glVertexAttrib4s = ((VertexAttrib4s)(GL.GetDelegateForExtensionMethod("glVertexAttrib4s", typeof(VertexAttrib4s)))) ?? new VertexAttrib4s(Imports.VertexAttrib4s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+ public static VertexAttrib4sARB glVertexAttrib4sARB = ((VertexAttrib4sARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4sARB", typeof(VertexAttrib4sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+ public static VertexAttrib4sNV glVertexAttrib4sNV = ((VertexAttrib4sNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4sNV", typeof(VertexAttrib4sNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4sv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4sv glVertexAttrib4sv = ((VertexAttrib4sv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4sv", typeof(VertexAttrib4sv)))) ?? new VertexAttrib4sv(Imports.VertexAttrib4sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4svARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4svARB glVertexAttrib4svARB = ((VertexAttrib4svARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4svARB", typeof(VertexAttrib4svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4svNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib4svNV glVertexAttrib4svNV = ((VertexAttrib4svNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4svNV", typeof(VertexAttrib4svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+ public static VertexAttrib4ubNV glVertexAttrib4ubNV = ((VertexAttrib4ubNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4ubNV", typeof(VertexAttrib4ubNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4ubv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4ubv glVertexAttrib4ubv = ((VertexAttrib4ubv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4ubv", typeof(VertexAttrib4ubv)))) ?? new VertexAttrib4ubv(Imports.VertexAttrib4ubv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4ubvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4ubvARB glVertexAttrib4ubvARB = ((VertexAttrib4ubvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4ubvARB", typeof(VertexAttrib4ubvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4ubvNV(GLuint index, System.IntPtr v);
+ public static VertexAttrib4ubvNV glVertexAttrib4ubvNV = ((VertexAttrib4ubvNV)(GL.GetDelegateForExtensionMethod("glVertexAttrib4ubvNV", typeof(VertexAttrib4ubvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4uiv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4uiv glVertexAttrib4uiv = ((VertexAttrib4uiv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4uiv", typeof(VertexAttrib4uiv)))) ?? new VertexAttrib4uiv(Imports.VertexAttrib4uiv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4uivARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4uivARB glVertexAttrib4uivARB = ((VertexAttrib4uivARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4uivARB", typeof(VertexAttrib4uivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4usv(GLuint index, System.IntPtr v);
+ public static VertexAttrib4usv glVertexAttrib4usv = ((VertexAttrib4usv)(GL.GetDelegateForExtensionMethod("glVertexAttrib4usv", typeof(VertexAttrib4usv)))) ?? new VertexAttrib4usv(Imports.VertexAttrib4usv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttrib4usvARB(GLuint index, System.IntPtr v);
+ public static VertexAttrib4usvARB glVertexAttrib4usvARB = ((VertexAttrib4usvARB)(GL.GetDelegateForExtensionMethod("glVertexAttrib4usvARB", typeof(VertexAttrib4usvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribArrayObjectATI(GLuint index, GLint size, Enums.ATI_vertex_attrib_array_object type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, GLuint buffer, GLuint offset);
+ public static VertexAttribArrayObjectATI glVertexAttribArrayObjectATI = ((VertexAttribArrayObjectATI)(GL.GetDelegateForExtensionMethod("glVertexAttribArrayObjectATI", typeof(VertexAttribArrayObjectATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI1iEXT(GLuint index, GLint x);
+ public static VertexAttribI1iEXT glVertexAttribI1iEXT = ((VertexAttribI1iEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI1iEXT", typeof(VertexAttribI1iEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI1ivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI1ivEXT glVertexAttribI1ivEXT = ((VertexAttribI1ivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI1ivEXT", typeof(VertexAttribI1ivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI1uiEXT(GLuint index, GLuint x);
+ public static VertexAttribI1uiEXT glVertexAttribI1uiEXT = ((VertexAttribI1uiEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI1uiEXT", typeof(VertexAttribI1uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI1uivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI1uivEXT glVertexAttribI1uivEXT = ((VertexAttribI1uivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI1uivEXT", typeof(VertexAttribI1uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI2iEXT(GLuint index, GLint x, GLint y);
+ public static VertexAttribI2iEXT glVertexAttribI2iEXT = ((VertexAttribI2iEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI2iEXT", typeof(VertexAttribI2iEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI2ivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI2ivEXT glVertexAttribI2ivEXT = ((VertexAttribI2ivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI2ivEXT", typeof(VertexAttribI2ivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y);
+ public static VertexAttribI2uiEXT glVertexAttribI2uiEXT = ((VertexAttribI2uiEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI2uiEXT", typeof(VertexAttribI2uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI2uivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI2uivEXT glVertexAttribI2uivEXT = ((VertexAttribI2uivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI2uivEXT", typeof(VertexAttribI2uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z);
+ public static VertexAttribI3iEXT glVertexAttribI3iEXT = ((VertexAttribI3iEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI3iEXT", typeof(VertexAttribI3iEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI3ivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI3ivEXT glVertexAttribI3ivEXT = ((VertexAttribI3ivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI3ivEXT", typeof(VertexAttribI3ivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z);
+ public static VertexAttribI3uiEXT glVertexAttribI3uiEXT = ((VertexAttribI3uiEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI3uiEXT", typeof(VertexAttribI3uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI3uivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI3uivEXT glVertexAttribI3uivEXT = ((VertexAttribI3uivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI3uivEXT", typeof(VertexAttribI3uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4bvEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI4bvEXT glVertexAttribI4bvEXT = ((VertexAttribI4bvEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4bvEXT", typeof(VertexAttribI4bvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w);
+ public static VertexAttribI4iEXT glVertexAttribI4iEXT = ((VertexAttribI4iEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4iEXT", typeof(VertexAttribI4iEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4ivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI4ivEXT glVertexAttribI4ivEXT = ((VertexAttribI4ivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4ivEXT", typeof(VertexAttribI4ivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4svEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI4svEXT glVertexAttribI4svEXT = ((VertexAttribI4svEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4svEXT", typeof(VertexAttribI4svEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4ubvEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI4ubvEXT glVertexAttribI4ubvEXT = ((VertexAttribI4ubvEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4ubvEXT", typeof(VertexAttribI4ubvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+ public static VertexAttribI4uiEXT glVertexAttribI4uiEXT = ((VertexAttribI4uiEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4uiEXT", typeof(VertexAttribI4uiEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4uivEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI4uivEXT glVertexAttribI4uivEXT = ((VertexAttribI4uivEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4uivEXT", typeof(VertexAttribI4uivEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribI4usvEXT(GLuint index, System.IntPtr v);
+ public static VertexAttribI4usvEXT glVertexAttribI4usvEXT = ((VertexAttribI4usvEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribI4usvEXT", typeof(VertexAttribI4usvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribIPointerEXT(GLuint index, GLint size, Enums.NV_vertex_program4 type, GLsizei stride, System.IntPtr pointer);
+ public static VertexAttribIPointerEXT glVertexAttribIPointerEXT = ((VertexAttribIPointerEXT)(GL.GetDelegateForExtensionMethod("glVertexAttribIPointerEXT", typeof(VertexAttribIPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribPointer(GLuint index, GLint size, Enums.VERSION_2_0 type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, System.IntPtr pointer);
+ public static VertexAttribPointer glVertexAttribPointer = ((VertexAttribPointer)(GL.GetDelegateForExtensionMethod("glVertexAttribPointer", typeof(VertexAttribPointer)))) ?? new VertexAttribPointer(Imports.VertexAttribPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribPointerARB(GLuint index, GLint size, Enums.ARB_vertex_program type, [MarshalAs(UnmanagedType.Bool)] bool normalized, GLsizei stride, System.IntPtr pointer);
+ public static VertexAttribPointerARB glVertexAttribPointerARB = ((VertexAttribPointerARB)(GL.GetDelegateForExtensionMethod("glVertexAttribPointerARB", typeof(VertexAttribPointerARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribPointerNV(GLuint index, GLint fsize, Enums.NV_vertex_program type, GLsizei stride, System.IntPtr pointer);
+ public static VertexAttribPointerNV glVertexAttribPointerNV = ((VertexAttribPointerNV)(GL.GetDelegateForExtensionMethod("glVertexAttribPointerNV", typeof(VertexAttribPointerNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs1dvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs1dvNV glVertexAttribs1dvNV = ((VertexAttribs1dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs1dvNV", typeof(VertexAttribs1dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs1fvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs1fvNV glVertexAttribs1fvNV = ((VertexAttribs1fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs1fvNV", typeof(VertexAttribs1fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs1hvNV(GLuint index, GLsizei n, System.IntPtr v);
+ public static VertexAttribs1hvNV glVertexAttribs1hvNV = ((VertexAttribs1hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs1hvNV", typeof(VertexAttribs1hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs1svNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs1svNV glVertexAttribs1svNV = ((VertexAttribs1svNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs1svNV", typeof(VertexAttribs1svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs2dvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs2dvNV glVertexAttribs2dvNV = ((VertexAttribs2dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs2dvNV", typeof(VertexAttribs2dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs2fvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs2fvNV glVertexAttribs2fvNV = ((VertexAttribs2fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs2fvNV", typeof(VertexAttribs2fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs2hvNV(GLuint index, GLsizei n, System.IntPtr v);
+ public static VertexAttribs2hvNV glVertexAttribs2hvNV = ((VertexAttribs2hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs2hvNV", typeof(VertexAttribs2hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs2svNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs2svNV glVertexAttribs2svNV = ((VertexAttribs2svNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs2svNV", typeof(VertexAttribs2svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs3dvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs3dvNV glVertexAttribs3dvNV = ((VertexAttribs3dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs3dvNV", typeof(VertexAttribs3dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs3fvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs3fvNV glVertexAttribs3fvNV = ((VertexAttribs3fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs3fvNV", typeof(VertexAttribs3fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs3hvNV(GLuint index, GLsizei n, System.IntPtr v);
+ public static VertexAttribs3hvNV glVertexAttribs3hvNV = ((VertexAttribs3hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs3hvNV", typeof(VertexAttribs3hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs3svNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs3svNV glVertexAttribs3svNV = ((VertexAttribs3svNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs3svNV", typeof(VertexAttribs3svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs4dvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs4dvNV glVertexAttribs4dvNV = ((VertexAttribs4dvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs4dvNV", typeof(VertexAttribs4dvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs4fvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs4fvNV glVertexAttribs4fvNV = ((VertexAttribs4fvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs4fvNV", typeof(VertexAttribs4fvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs4hvNV(GLuint index, GLsizei n, System.IntPtr v);
+ public static VertexAttribs4hvNV glVertexAttribs4hvNV = ((VertexAttribs4hvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs4hvNV", typeof(VertexAttribs4hvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs4svNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs4svNV glVertexAttribs4svNV = ((VertexAttribs4svNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs4svNV", typeof(VertexAttribs4svNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexAttribs4ubvNV(GLuint index, GLsizei count, System.IntPtr v);
+ public static VertexAttribs4ubvNV glVertexAttribs4ubvNV = ((VertexAttribs4ubvNV)(GL.GetDelegateForExtensionMethod("glVertexAttribs4ubvNV", typeof(VertexAttribs4ubvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexBlendARB(GLint count);
+ public static VertexBlendARB glVertexBlendARB = ((VertexBlendARB)(GL.GetDelegateForExtensionMethod("glVertexBlendARB", typeof(VertexBlendARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexBlendEnvfATI(Enums.ATI_vertex_streams pname, GLfloat param);
+ public static VertexBlendEnvfATI glVertexBlendEnvfATI = ((VertexBlendEnvfATI)(GL.GetDelegateForExtensionMethod("glVertexBlendEnvfATI", typeof(VertexBlendEnvfATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexBlendEnviATI(Enums.ATI_vertex_streams pname, GLint param);
+ public static VertexBlendEnviATI glVertexBlendEnviATI = ((VertexBlendEnviATI)(GL.GetDelegateForExtensionMethod("glVertexBlendEnviATI", typeof(VertexBlendEnviATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexPointer(GLint size, Enums.VertexPointerType type, GLsizei stride, System.IntPtr pointer);
+ public static VertexPointer glVertexPointer = ((VertexPointer)(GL.GetDelegateForExtensionMethod("glVertexPointer", typeof(VertexPointer)))) ?? new VertexPointer(Imports.VertexPointer);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexPointerEXT(GLint size, Enums.VertexPointerType type, GLsizei stride, GLsizei count, System.IntPtr pointer);
+ public static VertexPointerEXT glVertexPointerEXT = ((VertexPointerEXT)(GL.GetDelegateForExtensionMethod("glVertexPointerEXT", typeof(VertexPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexPointerListIBM(GLint size, Enums.VertexPointerType type, GLint stride, System.IntPtr pointer, GLint ptrstride);
+ public static VertexPointerListIBM glVertexPointerListIBM = ((VertexPointerListIBM)(GL.GetDelegateForExtensionMethod("glVertexPointerListIBM", typeof(VertexPointerListIBM))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexPointervINTEL(GLint size, Enums.VertexPointerType type, System.IntPtr pointer);
+ public static VertexPointervINTEL glVertexPointervINTEL = ((VertexPointervINTEL)(GL.GetDelegateForExtensionMethod("glVertexPointervINTEL", typeof(VertexPointervINTEL))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1dATI(Enums.ATI_vertex_streams stream, GLdouble x);
+ public static VertexStream1dATI glVertexStream1dATI = ((VertexStream1dATI)(GL.GetDelegateForExtensionMethod("glVertexStream1dATI", typeof(VertexStream1dATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream1dvATI glVertexStream1dvATI = ((VertexStream1dvATI)(GL.GetDelegateForExtensionMethod("glVertexStream1dvATI", typeof(VertexStream1dvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1fATI(Enums.ATI_vertex_streams stream, GLfloat x);
+ public static VertexStream1fATI glVertexStream1fATI = ((VertexStream1fATI)(GL.GetDelegateForExtensionMethod("glVertexStream1fATI", typeof(VertexStream1fATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream1fvATI glVertexStream1fvATI = ((VertexStream1fvATI)(GL.GetDelegateForExtensionMethod("glVertexStream1fvATI", typeof(VertexStream1fvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1iATI(Enums.ATI_vertex_streams stream, GLint x);
+ public static VertexStream1iATI glVertexStream1iATI = ((VertexStream1iATI)(GL.GetDelegateForExtensionMethod("glVertexStream1iATI", typeof(VertexStream1iATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream1ivATI glVertexStream1ivATI = ((VertexStream1ivATI)(GL.GetDelegateForExtensionMethod("glVertexStream1ivATI", typeof(VertexStream1ivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1sATI(Enums.ATI_vertex_streams stream, GLshort x);
+ public static VertexStream1sATI glVertexStream1sATI = ((VertexStream1sATI)(GL.GetDelegateForExtensionMethod("glVertexStream1sATI", typeof(VertexStream1sATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream1svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream1svATI glVertexStream1svATI = ((VertexStream1svATI)(GL.GetDelegateForExtensionMethod("glVertexStream1svATI", typeof(VertexStream1svATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2dATI(Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y);
+ public static VertexStream2dATI glVertexStream2dATI = ((VertexStream2dATI)(GL.GetDelegateForExtensionMethod("glVertexStream2dATI", typeof(VertexStream2dATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream2dvATI glVertexStream2dvATI = ((VertexStream2dvATI)(GL.GetDelegateForExtensionMethod("glVertexStream2dvATI", typeof(VertexStream2dvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2fATI(Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y);
+ public static VertexStream2fATI glVertexStream2fATI = ((VertexStream2fATI)(GL.GetDelegateForExtensionMethod("glVertexStream2fATI", typeof(VertexStream2fATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream2fvATI glVertexStream2fvATI = ((VertexStream2fvATI)(GL.GetDelegateForExtensionMethod("glVertexStream2fvATI", typeof(VertexStream2fvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2iATI(Enums.ATI_vertex_streams stream, GLint x, GLint y);
+ public static VertexStream2iATI glVertexStream2iATI = ((VertexStream2iATI)(GL.GetDelegateForExtensionMethod("glVertexStream2iATI", typeof(VertexStream2iATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream2ivATI glVertexStream2ivATI = ((VertexStream2ivATI)(GL.GetDelegateForExtensionMethod("glVertexStream2ivATI", typeof(VertexStream2ivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2sATI(Enums.ATI_vertex_streams stream, GLshort x, GLshort y);
+ public static VertexStream2sATI glVertexStream2sATI = ((VertexStream2sATI)(GL.GetDelegateForExtensionMethod("glVertexStream2sATI", typeof(VertexStream2sATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream2svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream2svATI glVertexStream2svATI = ((VertexStream2svATI)(GL.GetDelegateForExtensionMethod("glVertexStream2svATI", typeof(VertexStream2svATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3dATI(Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z);
+ public static VertexStream3dATI glVertexStream3dATI = ((VertexStream3dATI)(GL.GetDelegateForExtensionMethod("glVertexStream3dATI", typeof(VertexStream3dATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream3dvATI glVertexStream3dvATI = ((VertexStream3dvATI)(GL.GetDelegateForExtensionMethod("glVertexStream3dvATI", typeof(VertexStream3dvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3fATI(Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z);
+ public static VertexStream3fATI glVertexStream3fATI = ((VertexStream3fATI)(GL.GetDelegateForExtensionMethod("glVertexStream3fATI", typeof(VertexStream3fATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream3fvATI glVertexStream3fvATI = ((VertexStream3fvATI)(GL.GetDelegateForExtensionMethod("glVertexStream3fvATI", typeof(VertexStream3fvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3iATI(Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z);
+ public static VertexStream3iATI glVertexStream3iATI = ((VertexStream3iATI)(GL.GetDelegateForExtensionMethod("glVertexStream3iATI", typeof(VertexStream3iATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream3ivATI glVertexStream3ivATI = ((VertexStream3ivATI)(GL.GetDelegateForExtensionMethod("glVertexStream3ivATI", typeof(VertexStream3ivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3sATI(Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z);
+ public static VertexStream3sATI glVertexStream3sATI = ((VertexStream3sATI)(GL.GetDelegateForExtensionMethod("glVertexStream3sATI", typeof(VertexStream3sATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream3svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream3svATI glVertexStream3svATI = ((VertexStream3svATI)(GL.GetDelegateForExtensionMethod("glVertexStream3svATI", typeof(VertexStream3svATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4dATI(Enums.ATI_vertex_streams stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static VertexStream4dATI glVertexStream4dATI = ((VertexStream4dATI)(GL.GetDelegateForExtensionMethod("glVertexStream4dATI", typeof(VertexStream4dATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4dvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream4dvATI glVertexStream4dvATI = ((VertexStream4dvATI)(GL.GetDelegateForExtensionMethod("glVertexStream4dvATI", typeof(VertexStream4dvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4fATI(Enums.ATI_vertex_streams stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static VertexStream4fATI glVertexStream4fATI = ((VertexStream4fATI)(GL.GetDelegateForExtensionMethod("glVertexStream4fATI", typeof(VertexStream4fATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4fvATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream4fvATI glVertexStream4fvATI = ((VertexStream4fvATI)(GL.GetDelegateForExtensionMethod("glVertexStream4fvATI", typeof(VertexStream4fvATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4iATI(Enums.ATI_vertex_streams stream, GLint x, GLint y, GLint z, GLint w);
+ public static VertexStream4iATI glVertexStream4iATI = ((VertexStream4iATI)(GL.GetDelegateForExtensionMethod("glVertexStream4iATI", typeof(VertexStream4iATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4ivATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream4ivATI glVertexStream4ivATI = ((VertexStream4ivATI)(GL.GetDelegateForExtensionMethod("glVertexStream4ivATI", typeof(VertexStream4ivATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4sATI(Enums.ATI_vertex_streams stream, GLshort x, GLshort y, GLshort z, GLshort w);
+ public static VertexStream4sATI glVertexStream4sATI = ((VertexStream4sATI)(GL.GetDelegateForExtensionMethod("glVertexStream4sATI", typeof(VertexStream4sATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexStream4svATI(Enums.ATI_vertex_streams stream, System.IntPtr coords);
+ public static VertexStream4svATI glVertexStream4svATI = ((VertexStream4svATI)(GL.GetDelegateForExtensionMethod("glVertexStream4svATI", typeof(VertexStream4svATI))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexWeightfEXT(GLfloat weight);
+ public static VertexWeightfEXT glVertexWeightfEXT = ((VertexWeightfEXT)(GL.GetDelegateForExtensionMethod("glVertexWeightfEXT", typeof(VertexWeightfEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexWeightfvEXT(System.IntPtr weight);
+ public static VertexWeightfvEXT glVertexWeightfvEXT = ((VertexWeightfvEXT)(GL.GetDelegateForExtensionMethod("glVertexWeightfvEXT", typeof(VertexWeightfvEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexWeighthNV(GLhalfNV weight);
+ public static VertexWeighthNV glVertexWeighthNV = ((VertexWeighthNV)(GL.GetDelegateForExtensionMethod("glVertexWeighthNV", typeof(VertexWeighthNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexWeighthvNV(System.IntPtr weight);
+ public static VertexWeighthvNV glVertexWeighthvNV = ((VertexWeighthvNV)(GL.GetDelegateForExtensionMethod("glVertexWeighthvNV", typeof(VertexWeighthvNV))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void VertexWeightPointerEXT(GLsizei size, Enums.EXT_vertex_weighting type, GLsizei stride, System.IntPtr pointer);
+ public static VertexWeightPointerEXT glVertexWeightPointerEXT = ((VertexWeightPointerEXT)(GL.GetDelegateForExtensionMethod("glVertexWeightPointerEXT", typeof(VertexWeightPointerEXT))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
+ public static Viewport glViewport = ((Viewport)(GL.GetDelegateForExtensionMethod("glViewport", typeof(Viewport)))) ?? new Viewport(Imports.Viewport);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightbvARB(GLint size, System.IntPtr weights);
+ public static WeightbvARB glWeightbvARB = ((WeightbvARB)(GL.GetDelegateForExtensionMethod("glWeightbvARB", typeof(WeightbvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightdvARB(GLint size, System.IntPtr weights);
+ public static WeightdvARB glWeightdvARB = ((WeightdvARB)(GL.GetDelegateForExtensionMethod("glWeightdvARB", typeof(WeightdvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightfvARB(GLint size, System.IntPtr weights);
+ public static WeightfvARB glWeightfvARB = ((WeightfvARB)(GL.GetDelegateForExtensionMethod("glWeightfvARB", typeof(WeightfvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightivARB(GLint size, System.IntPtr weights);
+ public static WeightivARB glWeightivARB = ((WeightivARB)(GL.GetDelegateForExtensionMethod("glWeightivARB", typeof(WeightivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightPointerARB(GLint size, Enums.ARB_vertex_blend type, GLsizei stride, System.IntPtr pointer);
+ public static WeightPointerARB glWeightPointerARB = ((WeightPointerARB)(GL.GetDelegateForExtensionMethod("glWeightPointerARB", typeof(WeightPointerARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightsvARB(GLint size, System.IntPtr weights);
+ public static WeightsvARB glWeightsvARB = ((WeightsvARB)(GL.GetDelegateForExtensionMethod("glWeightsvARB", typeof(WeightsvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightubvARB(GLint size, System.IntPtr weights);
+ public static WeightubvARB glWeightubvARB = ((WeightubvARB)(GL.GetDelegateForExtensionMethod("glWeightubvARB", typeof(WeightubvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightuivARB(GLint size, System.IntPtr weights);
+ public static WeightuivARB glWeightuivARB = ((WeightuivARB)(GL.GetDelegateForExtensionMethod("glWeightuivARB", typeof(WeightuivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WeightusvARB(GLint size, System.IntPtr weights);
+ public static WeightusvARB glWeightusvARB = ((WeightusvARB)(GL.GetDelegateForExtensionMethod("glWeightusvARB", typeof(WeightusvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2d(GLdouble x, GLdouble y);
+ public static WindowPos2d glWindowPos2d = ((WindowPos2d)(GL.GetDelegateForExtensionMethod("glWindowPos2d", typeof(WindowPos2d)))) ?? new WindowPos2d(Imports.WindowPos2d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2dARB(GLdouble x, GLdouble y);
+ public static WindowPos2dARB glWindowPos2dARB = ((WindowPos2dARB)(GL.GetDelegateForExtensionMethod("glWindowPos2dARB", typeof(WindowPos2dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2dMESA(GLdouble x, GLdouble y);
+ public static WindowPos2dMESA glWindowPos2dMESA = ((WindowPos2dMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2dMESA", typeof(WindowPos2dMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2dv(System.IntPtr v);
+ public static WindowPos2dv glWindowPos2dv = ((WindowPos2dv)(GL.GetDelegateForExtensionMethod("glWindowPos2dv", typeof(WindowPos2dv)))) ?? new WindowPos2dv(Imports.WindowPos2dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2dvARB(System.IntPtr v);
+ public static WindowPos2dvARB glWindowPos2dvARB = ((WindowPos2dvARB)(GL.GetDelegateForExtensionMethod("glWindowPos2dvARB", typeof(WindowPos2dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2dvMESA(System.IntPtr v);
+ public static WindowPos2dvMESA glWindowPos2dvMESA = ((WindowPos2dvMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2dvMESA", typeof(WindowPos2dvMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2f(GLfloat x, GLfloat y);
+ public static WindowPos2f glWindowPos2f = ((WindowPos2f)(GL.GetDelegateForExtensionMethod("glWindowPos2f", typeof(WindowPos2f)))) ?? new WindowPos2f(Imports.WindowPos2f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2fARB(GLfloat x, GLfloat y);
+ public static WindowPos2fARB glWindowPos2fARB = ((WindowPos2fARB)(GL.GetDelegateForExtensionMethod("glWindowPos2fARB", typeof(WindowPos2fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2fMESA(GLfloat x, GLfloat y);
+ public static WindowPos2fMESA glWindowPos2fMESA = ((WindowPos2fMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2fMESA", typeof(WindowPos2fMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2fv(System.IntPtr v);
+ public static WindowPos2fv glWindowPos2fv = ((WindowPos2fv)(GL.GetDelegateForExtensionMethod("glWindowPos2fv", typeof(WindowPos2fv)))) ?? new WindowPos2fv(Imports.WindowPos2fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2fvARB(System.IntPtr v);
+ public static WindowPos2fvARB glWindowPos2fvARB = ((WindowPos2fvARB)(GL.GetDelegateForExtensionMethod("glWindowPos2fvARB", typeof(WindowPos2fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2fvMESA(System.IntPtr v);
+ public static WindowPos2fvMESA glWindowPos2fvMESA = ((WindowPos2fvMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2fvMESA", typeof(WindowPos2fvMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2i(GLint x, GLint y);
+ public static WindowPos2i glWindowPos2i = ((WindowPos2i)(GL.GetDelegateForExtensionMethod("glWindowPos2i", typeof(WindowPos2i)))) ?? new WindowPos2i(Imports.WindowPos2i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2iARB(GLint x, GLint y);
+ public static WindowPos2iARB glWindowPos2iARB = ((WindowPos2iARB)(GL.GetDelegateForExtensionMethod("glWindowPos2iARB", typeof(WindowPos2iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2iMESA(GLint x, GLint y);
+ public static WindowPos2iMESA glWindowPos2iMESA = ((WindowPos2iMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2iMESA", typeof(WindowPos2iMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2iv(System.IntPtr v);
+ public static WindowPos2iv glWindowPos2iv = ((WindowPos2iv)(GL.GetDelegateForExtensionMethod("glWindowPos2iv", typeof(WindowPos2iv)))) ?? new WindowPos2iv(Imports.WindowPos2iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2ivARB(System.IntPtr v);
+ public static WindowPos2ivARB glWindowPos2ivARB = ((WindowPos2ivARB)(GL.GetDelegateForExtensionMethod("glWindowPos2ivARB", typeof(WindowPos2ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2ivMESA(System.IntPtr v);
+ public static WindowPos2ivMESA glWindowPos2ivMESA = ((WindowPos2ivMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2ivMESA", typeof(WindowPos2ivMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2s(GLshort x, GLshort y);
+ public static WindowPos2s glWindowPos2s = ((WindowPos2s)(GL.GetDelegateForExtensionMethod("glWindowPos2s", typeof(WindowPos2s)))) ?? new WindowPos2s(Imports.WindowPos2s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2sARB(GLshort x, GLshort y);
+ public static WindowPos2sARB glWindowPos2sARB = ((WindowPos2sARB)(GL.GetDelegateForExtensionMethod("glWindowPos2sARB", typeof(WindowPos2sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2sMESA(GLshort x, GLshort y);
+ public static WindowPos2sMESA glWindowPos2sMESA = ((WindowPos2sMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2sMESA", typeof(WindowPos2sMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2sv(System.IntPtr v);
+ public static WindowPos2sv glWindowPos2sv = ((WindowPos2sv)(GL.GetDelegateForExtensionMethod("glWindowPos2sv", typeof(WindowPos2sv)))) ?? new WindowPos2sv(Imports.WindowPos2sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2svARB(System.IntPtr v);
+ public static WindowPos2svARB glWindowPos2svARB = ((WindowPos2svARB)(GL.GetDelegateForExtensionMethod("glWindowPos2svARB", typeof(WindowPos2svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos2svMESA(System.IntPtr v);
+ public static WindowPos2svMESA glWindowPos2svMESA = ((WindowPos2svMESA)(GL.GetDelegateForExtensionMethod("glWindowPos2svMESA", typeof(WindowPos2svMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3d(GLdouble x, GLdouble y, GLdouble z);
+ public static WindowPos3d glWindowPos3d = ((WindowPos3d)(GL.GetDelegateForExtensionMethod("glWindowPos3d", typeof(WindowPos3d)))) ?? new WindowPos3d(Imports.WindowPos3d);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3dARB(GLdouble x, GLdouble y, GLdouble z);
+ public static WindowPos3dARB glWindowPos3dARB = ((WindowPos3dARB)(GL.GetDelegateForExtensionMethod("glWindowPos3dARB", typeof(WindowPos3dARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z);
+ public static WindowPos3dMESA glWindowPos3dMESA = ((WindowPos3dMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3dMESA", typeof(WindowPos3dMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3dv(System.IntPtr v);
+ public static WindowPos3dv glWindowPos3dv = ((WindowPos3dv)(GL.GetDelegateForExtensionMethod("glWindowPos3dv", typeof(WindowPos3dv)))) ?? new WindowPos3dv(Imports.WindowPos3dv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3dvARB(System.IntPtr v);
+ public static WindowPos3dvARB glWindowPos3dvARB = ((WindowPos3dvARB)(GL.GetDelegateForExtensionMethod("glWindowPos3dvARB", typeof(WindowPos3dvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3dvMESA(System.IntPtr v);
+ public static WindowPos3dvMESA glWindowPos3dvMESA = ((WindowPos3dvMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3dvMESA", typeof(WindowPos3dvMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3f(GLfloat x, GLfloat y, GLfloat z);
+ public static WindowPos3f glWindowPos3f = ((WindowPos3f)(GL.GetDelegateForExtensionMethod("glWindowPos3f", typeof(WindowPos3f)))) ?? new WindowPos3f(Imports.WindowPos3f);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3fARB(GLfloat x, GLfloat y, GLfloat z);
+ public static WindowPos3fARB glWindowPos3fARB = ((WindowPos3fARB)(GL.GetDelegateForExtensionMethod("glWindowPos3fARB", typeof(WindowPos3fARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z);
+ public static WindowPos3fMESA glWindowPos3fMESA = ((WindowPos3fMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3fMESA", typeof(WindowPos3fMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3fv(System.IntPtr v);
+ public static WindowPos3fv glWindowPos3fv = ((WindowPos3fv)(GL.GetDelegateForExtensionMethod("glWindowPos3fv", typeof(WindowPos3fv)))) ?? new WindowPos3fv(Imports.WindowPos3fv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3fvARB(System.IntPtr v);
+ public static WindowPos3fvARB glWindowPos3fvARB = ((WindowPos3fvARB)(GL.GetDelegateForExtensionMethod("glWindowPos3fvARB", typeof(WindowPos3fvARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3fvMESA(System.IntPtr v);
+ public static WindowPos3fvMESA glWindowPos3fvMESA = ((WindowPos3fvMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3fvMESA", typeof(WindowPos3fvMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3i(GLint x, GLint y, GLint z);
+ public static WindowPos3i glWindowPos3i = ((WindowPos3i)(GL.GetDelegateForExtensionMethod("glWindowPos3i", typeof(WindowPos3i)))) ?? new WindowPos3i(Imports.WindowPos3i);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3iARB(GLint x, GLint y, GLint z);
+ public static WindowPos3iARB glWindowPos3iARB = ((WindowPos3iARB)(GL.GetDelegateForExtensionMethod("glWindowPos3iARB", typeof(WindowPos3iARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3iMESA(GLint x, GLint y, GLint z);
+ public static WindowPos3iMESA glWindowPos3iMESA = ((WindowPos3iMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3iMESA", typeof(WindowPos3iMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3iv(System.IntPtr v);
+ public static WindowPos3iv glWindowPos3iv = ((WindowPos3iv)(GL.GetDelegateForExtensionMethod("glWindowPos3iv", typeof(WindowPos3iv)))) ?? new WindowPos3iv(Imports.WindowPos3iv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3ivARB(System.IntPtr v);
+ public static WindowPos3ivARB glWindowPos3ivARB = ((WindowPos3ivARB)(GL.GetDelegateForExtensionMethod("glWindowPos3ivARB", typeof(WindowPos3ivARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3ivMESA(System.IntPtr v);
+ public static WindowPos3ivMESA glWindowPos3ivMESA = ((WindowPos3ivMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3ivMESA", typeof(WindowPos3ivMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3s(GLshort x, GLshort y, GLshort z);
+ public static WindowPos3s glWindowPos3s = ((WindowPos3s)(GL.GetDelegateForExtensionMethod("glWindowPos3s", typeof(WindowPos3s)))) ?? new WindowPos3s(Imports.WindowPos3s);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3sARB(GLshort x, GLshort y, GLshort z);
+ public static WindowPos3sARB glWindowPos3sARB = ((WindowPos3sARB)(GL.GetDelegateForExtensionMethod("glWindowPos3sARB", typeof(WindowPos3sARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3sMESA(GLshort x, GLshort y, GLshort z);
+ public static WindowPos3sMESA glWindowPos3sMESA = ((WindowPos3sMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3sMESA", typeof(WindowPos3sMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3sv(System.IntPtr v);
+ public static WindowPos3sv glWindowPos3sv = ((WindowPos3sv)(GL.GetDelegateForExtensionMethod("glWindowPos3sv", typeof(WindowPos3sv)))) ?? new WindowPos3sv(Imports.WindowPos3sv);
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3svARB(System.IntPtr v);
+ public static WindowPos3svARB glWindowPos3svARB = ((WindowPos3svARB)(GL.GetDelegateForExtensionMethod("glWindowPos3svARB", typeof(WindowPos3svARB))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos3svMESA(System.IntPtr v);
+ public static WindowPos3svMESA glWindowPos3svMESA = ((WindowPos3svMESA)(GL.GetDelegateForExtensionMethod("glWindowPos3svMESA", typeof(WindowPos3svMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ public static WindowPos4dMESA glWindowPos4dMESA = ((WindowPos4dMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4dMESA", typeof(WindowPos4dMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4dvMESA(System.IntPtr v);
+ public static WindowPos4dvMESA glWindowPos4dvMESA = ((WindowPos4dvMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4dvMESA", typeof(WindowPos4dvMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ public static WindowPos4fMESA glWindowPos4fMESA = ((WindowPos4fMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4fMESA", typeof(WindowPos4fMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4fvMESA(System.IntPtr v);
+ public static WindowPos4fvMESA glWindowPos4fvMESA = ((WindowPos4fvMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4fvMESA", typeof(WindowPos4fvMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w);
+ public static WindowPos4iMESA glWindowPos4iMESA = ((WindowPos4iMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4iMESA", typeof(WindowPos4iMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4ivMESA(System.IntPtr v);
+ public static WindowPos4ivMESA glWindowPos4ivMESA = ((WindowPos4ivMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4ivMESA", typeof(WindowPos4ivMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w);
+ public static WindowPos4sMESA glWindowPos4sMESA = ((WindowPos4sMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4sMESA", typeof(WindowPos4sMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WindowPos4svMESA(System.IntPtr v);
+ public static WindowPos4svMESA glWindowPos4svMESA = ((WindowPos4svMESA)(GL.GetDelegateForExtensionMethod("glWindowPos4svMESA", typeof(WindowPos4svMESA))));
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ public delegate void WriteMaskEXT(GLuint res, GLuint @in, Enums.EXT_vertex_shader outX, Enums.EXT_vertex_shader outY, Enums.EXT_vertex_shader outZ, Enums.EXT_vertex_shader outW);
+ public static WriteMaskEXT glWriteMaskEXT = ((WriteMaskEXT)(GL.GetDelegateForExtensionMethod("glWriteMaskEXT", typeof(WriteMaskEXT))));
+ static Delegates()
+ {
+ }
+ }
+ #endregion
+ #region Imports
+ internal class Imports
+ {
+ static Imports()
+ {
+ }
+ #region Accum
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glAccum", ExactSpelling = true)]
+ public extern static void Accum(Enums.AccumOp op, GLfloat value);
+ #endregion
+
+ #region ActiveTexture
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glActiveTexture", ExactSpelling = true)]
+ public extern static void ActiveTexture(Enums.VERSION_1_3 texture);
+ #endregion
+
+ #region AlphaFunc
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glAlphaFunc", ExactSpelling = true)]
+ public extern static void AlphaFunc(Enums.AlphaFunction func, GLclampf @ref);
+ #endregion
+
+ #region AreTexturesResident
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glAreTexturesResident", ExactSpelling = true)]
+ public extern static GLboolean AreTexturesResident(GLsizei n, System.IntPtr textures, System.IntPtr residences);
+ #endregion
+
+ #region ArrayElement
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glArrayElement", ExactSpelling = true)]
+ public extern static void ArrayElement(GLint i);
+ #endregion
+
+ #region AttachShader
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glAttachShader", ExactSpelling = true)]
+ public extern static void AttachShader(GLuint program, GLuint shader);
+ #endregion
+
+ #region Begin
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBegin", ExactSpelling = true)]
+ public extern static void Begin(Enums.BeginMode mode);
+ #endregion
+
+ #region BeginQuery
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBeginQuery", ExactSpelling = true)]
+ public extern static void BeginQuery(Enums.VERSION_1_5 target, GLuint id);
+ #endregion
+
+ #region BindAttribLocation
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBindAttribLocation", ExactSpelling = true)]
+ public extern static void BindAttribLocation(GLuint program, GLuint index, System.String name);
+ #endregion
+
+ #region BindBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBindBuffer", ExactSpelling = true)]
+ public extern static void BindBuffer(Enums.VERSION_1_5 target, GLuint buffer);
+ #endregion
+
+ #region BindTexture
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBindTexture", ExactSpelling = true)]
+ public extern static void BindTexture(Enums.TextureTarget target, GLuint texture);
+ #endregion
+
+ #region Bitmap
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBitmap", ExactSpelling = true)]
+ public extern static void Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, System.IntPtr bitmap);
+ #endregion
+
+ #region BlendColor
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBlendColor", ExactSpelling = true)]
+ public extern static void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+ #endregion
+
+ #region BlendEquation
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBlendEquation", ExactSpelling = true)]
+ public extern static void BlendEquation(Enums.VERSION_1_2 mode);
+ #endregion
+
+ #region BlendEquationSeparate
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBlendEquationSeparate", ExactSpelling = true)]
+ public extern static void BlendEquationSeparate(Enums.BlendEquationModeEXT modeRGB, Enums.BlendEquationModeEXT modeAlpha);
+ #endregion
+
+ #region BlendFunc
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBlendFunc", ExactSpelling = true)]
+ public extern static void BlendFunc(Enums.BlendingFactorSrc sfactor, Enums.BlendingFactorDest dfactor);
+ #endregion
+
+ #region BlendFuncSeparate
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBlendFuncSeparate", ExactSpelling = true)]
+ public extern static void BlendFuncSeparate(Enums.VERSION_1_4 sfactorRGB, Enums.VERSION_1_4 dfactorRGB, Enums.VERSION_1_4 sfactorAlpha, Enums.VERSION_1_4 dfactorAlpha);
+ #endregion
+
+ #region BufferData
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBufferData", ExactSpelling = true)]
+ public extern static void BufferData(Enums.VERSION_1_5 target, GLsizeiptr size, System.IntPtr data, Enums.VERSION_1_5 usage);
+ #endregion
+
+ #region BufferSubData
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glBufferSubData", ExactSpelling = true)]
+ public extern static void BufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, System.IntPtr data);
+ #endregion
+
+ #region CallList
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCallList", ExactSpelling = true)]
+ public extern static void CallList(GLuint list);
+ #endregion
+
+ #region CallLists
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCallLists", ExactSpelling = true)]
+ public extern static void CallLists(GLsizei n, Enums.ListNameType type, System.IntPtr lists);
+ #endregion
+
+ #region Clear
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClear", ExactSpelling = true)]
+ public extern static void Clear(Enums.ClearBufferMask mask);
+ #endregion
+
+ #region ClearAccum
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClearAccum", ExactSpelling = true)]
+ public extern static void ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ #endregion
+
+ #region ClearColor
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClearColor", ExactSpelling = true)]
+ public extern static void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+ #endregion
+
+ #region ClearDepth
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClearDepth", ExactSpelling = true)]
+ public extern static void ClearDepth(GLclampd depth);
+ #endregion
+
+ #region ClearIndex
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClearIndex", ExactSpelling = true)]
+ public extern static void ClearIndex(GLfloat c);
+ #endregion
+
+ #region ClearStencil
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClearStencil", ExactSpelling = true)]
+ public extern static void ClearStencil(GLint s);
+ #endregion
+
+ #region ClientActiveTexture
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClientActiveTexture", ExactSpelling = true)]
+ public extern static void ClientActiveTexture(Enums.VERSION_1_3 texture);
+ #endregion
+
+ #region ClipPlane
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glClipPlane", ExactSpelling = true)]
+ public extern static void ClipPlane(Enums.ClipPlaneName plane, System.IntPtr equation);
+ #endregion
+
+ #region Color3b
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3b", ExactSpelling = true)]
+ public extern static void Color3b(GLbyte red, GLbyte green, GLbyte blue);
+ #endregion
+
+ #region Color3bv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3bv", ExactSpelling = true)]
+ public extern static void Color3bv(System.IntPtr v);
+ #endregion
+
+ #region Color3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3d", ExactSpelling = true)]
+ public extern static void Color3d(GLdouble red, GLdouble green, GLdouble blue);
+ #endregion
+
+ #region Color3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3dv", ExactSpelling = true)]
+ public extern static void Color3dv(System.IntPtr v);
+ #endregion
+
+ #region Color3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3f", ExactSpelling = true)]
+ public extern static void Color3f(GLfloat red, GLfloat green, GLfloat blue);
+ #endregion
+
+ #region Color3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3fv", ExactSpelling = true)]
+ public extern static void Color3fv(System.IntPtr v);
+ #endregion
+
+ #region Color3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3i", ExactSpelling = true)]
+ public extern static void Color3i(GLint red, GLint green, GLint blue);
+ #endregion
+
+ #region Color3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3iv", ExactSpelling = true)]
+ public extern static void Color3iv(System.IntPtr v);
+ #endregion
+
+ #region Color3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3s", ExactSpelling = true)]
+ public extern static void Color3s(GLshort red, GLshort green, GLshort blue);
+ #endregion
+
+ #region Color3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3sv", ExactSpelling = true)]
+ public extern static void Color3sv(System.IntPtr v);
+ #endregion
+
+ #region Color3ub
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3ub", ExactSpelling = true)]
+ public extern static void Color3ub(GLubyte red, GLubyte green, GLubyte blue);
+ #endregion
+
+ #region Color3ubv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3ubv", ExactSpelling = true)]
+ public extern static void Color3ubv(System.IntPtr v);
+ #endregion
+
+ #region Color3ui
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3ui", ExactSpelling = true)]
+ public extern static void Color3ui(GLuint red, GLuint green, GLuint blue);
+ #endregion
+
+ #region Color3uiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3uiv", ExactSpelling = true)]
+ public extern static void Color3uiv(System.IntPtr v);
+ #endregion
+
+ #region Color3us
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3us", ExactSpelling = true)]
+ public extern static void Color3us(GLushort red, GLushort green, GLushort blue);
+ #endregion
+
+ #region Color3usv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor3usv", ExactSpelling = true)]
+ public extern static void Color3usv(System.IntPtr v);
+ #endregion
+
+ #region Color4b
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4b", ExactSpelling = true)]
+ public extern static void Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
+ #endregion
+
+ #region Color4bv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4bv", ExactSpelling = true)]
+ public extern static void Color4bv(System.IntPtr v);
+ #endregion
+
+ #region Color4d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4d", ExactSpelling = true)]
+ public extern static void Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
+ #endregion
+
+ #region Color4dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4dv", ExactSpelling = true)]
+ public extern static void Color4dv(System.IntPtr v);
+ #endregion
+
+ #region Color4f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4f", ExactSpelling = true)]
+ public extern static void Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+ #endregion
+
+ #region Color4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4fv", ExactSpelling = true)]
+ public extern static void Color4fv(System.IntPtr v);
+ #endregion
+
+ #region Color4i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4i", ExactSpelling = true)]
+ public extern static void Color4i(GLint red, GLint green, GLint blue, GLint alpha);
+ #endregion
+
+ #region Color4iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4iv", ExactSpelling = true)]
+ public extern static void Color4iv(System.IntPtr v);
+ #endregion
+
+ #region Color4s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4s", ExactSpelling = true)]
+ public extern static void Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);
+ #endregion
+
+ #region Color4sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4sv", ExactSpelling = true)]
+ public extern static void Color4sv(System.IntPtr v);
+ #endregion
+
+ #region Color4ub
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4ub", ExactSpelling = true)]
+ public extern static void Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
+ #endregion
+
+ #region Color4ubv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4ubv", ExactSpelling = true)]
+ public extern static void Color4ubv(System.IntPtr v);
+ #endregion
+
+ #region Color4ui
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4ui", ExactSpelling = true)]
+ public extern static void Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);
+ #endregion
+
+ #region Color4uiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4uiv", ExactSpelling = true)]
+ public extern static void Color4uiv(System.IntPtr v);
+ #endregion
+
+ #region Color4us
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4us", ExactSpelling = true)]
+ public extern static void Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);
+ #endregion
+
+ #region Color4usv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColor4usv", ExactSpelling = true)]
+ public extern static void Color4usv(System.IntPtr v);
+ #endregion
+
+ #region ColorMask
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColorMask", ExactSpelling = true)]
+ public extern static void ColorMask(System.Boolean red, System.Boolean green, System.Boolean blue, System.Boolean alpha);
+ #endregion
+
+ #region ColorMaterial
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColorMaterial", ExactSpelling = true)]
+ public extern static void ColorMaterial(Enums.MaterialFace face, Enums.ColorMaterialParameter mode);
+ #endregion
+
+ #region ColorPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColorPointer", ExactSpelling = true)]
+ public extern static void ColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region ColorSubTable
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColorSubTable", ExactSpelling = true)]
+ public extern static void ColorSubTable(Enums.VERSION_1_2 target, GLsizei start, GLsizei count, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr data);
+ #endregion
+
+ #region ColorTable
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColorTable", ExactSpelling = true)]
+ public extern static void ColorTable(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table);
+ #endregion
+
+ #region ColorTableParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColorTableParameterfv", ExactSpelling = true)]
+ public extern static void ColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region ColorTableParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glColorTableParameteriv", ExactSpelling = true)]
+ public extern static void ColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region CompileShader
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCompileShader", ExactSpelling = true)]
+ public extern static void CompileShader(GLuint shader);
+ #endregion
+
+ #region CompressedTexImage1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCompressedTexImage1D", ExactSpelling = true)]
+ public extern static void CompressedTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLint border, GLsizei imageSize, System.IntPtr data);
+ #endregion
+
+ #region CompressedTexImage2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCompressedTexImage2D", ExactSpelling = true)]
+ public extern static void CompressedTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, System.IntPtr data);
+ #endregion
+
+ #region CompressedTexImage3D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCompressedTexImage3D", ExactSpelling = true)]
+ public extern static void CompressedTexImage3D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, System.IntPtr data);
+ #endregion
+
+ #region CompressedTexSubImage1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCompressedTexSubImage1D", ExactSpelling = true)]
+ public extern static void CompressedTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data);
+ #endregion
+
+ #region CompressedTexSubImage2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCompressedTexSubImage2D", ExactSpelling = true)]
+ public extern static void CompressedTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data);
+ #endregion
+
+ #region CompressedTexSubImage3D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCompressedTexSubImage3D", ExactSpelling = true)]
+ public extern static void CompressedTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, Enums.PixelFormat format, GLsizei imageSize, System.IntPtr data);
+ #endregion
+
+ #region ConvolutionFilter1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glConvolutionFilter1D", ExactSpelling = true)]
+ public extern static void ConvolutionFilter1D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image);
+ #endregion
+
+ #region ConvolutionFilter2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glConvolutionFilter2D", ExactSpelling = true)]
+ public extern static void ConvolutionFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image);
+ #endregion
+
+ #region ConvolutionParameterf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glConvolutionParameterf", ExactSpelling = true)]
+ public extern static void ConvolutionParameterf(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLfloat @params);
+ #endregion
+
+ #region ConvolutionParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glConvolutionParameterfv", ExactSpelling = true)]
+ public extern static void ConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region ConvolutionParameteri
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glConvolutionParameteri", ExactSpelling = true)]
+ public extern static void ConvolutionParameteri(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, GLint @params);
+ #endregion
+
+ #region ConvolutionParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glConvolutionParameteriv", ExactSpelling = true)]
+ public extern static void ConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region CopyColorSubTable
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyColorSubTable", ExactSpelling = true)]
+ public extern static void CopyColorSubTable(Enums.VERSION_1_2 target, GLsizei start, GLint x, GLint y, GLsizei width);
+ #endregion
+
+ #region CopyColorTable
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyColorTable", ExactSpelling = true)]
+ public extern static void CopyColorTable(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+ #endregion
+
+ #region CopyConvolutionFilter1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyConvolutionFilter1D", ExactSpelling = true)]
+ public extern static void CopyConvolutionFilter1D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width);
+ #endregion
+
+ #region CopyConvolutionFilter2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyConvolutionFilter2D", ExactSpelling = true)]
+ public extern static void CopyConvolutionFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
+ #endregion
+
+ #region CopyPixels
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyPixels", ExactSpelling = true)]
+ public extern static void CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelCopyType type);
+ #endregion
+
+ #region CopyTexImage1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyTexImage1D", ExactSpelling = true)]
+ public extern static void CopyTexImage1D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLint border);
+ #endregion
+
+ #region CopyTexImage2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyTexImage2D", ExactSpelling = true)]
+ public extern static void CopyTexImage2D(Enums.TextureTarget target, GLint level, Enums.PixelInternalFormat internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
+ #endregion
+
+ #region CopyTexSubImage1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyTexSubImage1D", ExactSpelling = true)]
+ public extern static void CopyTexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
+ #endregion
+
+ #region CopyTexSubImage2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyTexSubImage2D", ExactSpelling = true)]
+ public extern static void CopyTexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ #endregion
+
+ #region CopyTexSubImage3D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCopyTexSubImage3D", ExactSpelling = true)]
+ public extern static void CopyTexSubImage3D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
+ #endregion
+
+ #region CreateProgram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCreateProgram", ExactSpelling = true)]
+ public extern static GLuint CreateProgram();
+ #endregion
+
+ #region CreateShader
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCreateShader", ExactSpelling = true)]
+ public extern static GLuint CreateShader(Enums.VERSION_2_0 type);
+ #endregion
+
+ #region CullFace
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glCullFace", ExactSpelling = true)]
+ public extern static void CullFace(Enums.CullFaceMode mode);
+ #endregion
+
+ #region DeleteBuffers
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDeleteBuffers", ExactSpelling = true)]
+ public extern static void DeleteBuffers(GLsizei n, System.IntPtr buffers);
+ #endregion
+
+ #region DeleteLists
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDeleteLists", ExactSpelling = true)]
+ public extern static void DeleteLists(GLuint list, GLsizei range);
+ #endregion
+
+ #region DeleteProgram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDeleteProgram", ExactSpelling = true)]
+ public extern static void DeleteProgram(GLuint program);
+ #endregion
+
+ #region DeleteQueries
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDeleteQueries", ExactSpelling = true)]
+ public extern static void DeleteQueries(GLsizei n, System.IntPtr ids);
+ #endregion
+
+ #region DeleteShader
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDeleteShader", ExactSpelling = true)]
+ public extern static void DeleteShader(GLuint shader);
+ #endregion
+
+ #region DeleteTextures
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDeleteTextures", ExactSpelling = true)]
+ public extern static void DeleteTextures(GLsizei n, System.IntPtr textures);
+ #endregion
+
+ #region DepthFunc
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDepthFunc", ExactSpelling = true)]
+ public extern static void DepthFunc(Enums.DepthFunction func);
+ #endregion
+
+ #region DepthMask
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDepthMask", ExactSpelling = true)]
+ public extern static void DepthMask(System.Boolean flag);
+ #endregion
+
+ #region DepthRange
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDepthRange", ExactSpelling = true)]
+ public extern static void DepthRange(GLclampd near, GLclampd far);
+ #endregion
+
+ #region DetachShader
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDetachShader", ExactSpelling = true)]
+ public extern static void DetachShader(GLuint program, GLuint shader);
+ #endregion
+
+ #region Disable
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDisable", ExactSpelling = true)]
+ public extern static void Disable(Enums.EnableCap cap);
+ #endregion
+
+ #region DisableClientState
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDisableClientState", ExactSpelling = true)]
+ public extern static void DisableClientState(Enums.EnableCap array);
+ #endregion
+
+ #region DisableVertexAttribArray
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDisableVertexAttribArray", ExactSpelling = true)]
+ public extern static void DisableVertexAttribArray(GLuint index);
+ #endregion
+
+ #region DrawArrays
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDrawArrays", ExactSpelling = true)]
+ public extern static void DrawArrays(Enums.BeginMode mode, GLint first, GLsizei count);
+ #endregion
+
+ #region DrawBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDrawBuffer", ExactSpelling = true)]
+ public extern static void DrawBuffer(Enums.DrawBufferMode mode);
+ #endregion
+
+ #region DrawBuffers
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDrawBuffers", ExactSpelling = true)]
+ public extern static void DrawBuffers(GLsizei n, System.IntPtr bufs);
+ #endregion
+
+ #region DrawElements
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDrawElements", ExactSpelling = true)]
+ public extern static void DrawElements(Enums.BeginMode mode, GLsizei count, Enums.GLenum type, System.IntPtr indices);
+ #endregion
+
+ #region DrawPixels
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDrawPixels", ExactSpelling = true)]
+ public extern static void DrawPixels(GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region DrawRangeElements
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glDrawRangeElements", ExactSpelling = true)]
+ public extern static void DrawRangeElements(Enums.BeginMode mode, GLuint start, GLuint end, GLsizei count, Enums.VERSION_1_2 type, System.IntPtr indices);
+ #endregion
+
+ #region EdgeFlag
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEdgeFlag", ExactSpelling = true)]
+ public extern static void EdgeFlag(System.Boolean flag);
+ #endregion
+
+ #region EdgeFlagPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEdgeFlagPointer", ExactSpelling = true)]
+ public extern static void EdgeFlagPointer(GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region EdgeFlagv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEdgeFlagv", ExactSpelling = true)]
+ public extern static void EdgeFlagv(System.IntPtr flag);
+ #endregion
+
+ #region Enable
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEnable", ExactSpelling = true)]
+ public extern static void Enable(Enums.EnableCap cap);
+ #endregion
+
+ #region EnableClientState
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEnableClientState", ExactSpelling = true)]
+ public extern static void EnableClientState(Enums.EnableCap array);
+ #endregion
+
+ #region EnableVertexAttribArray
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEnableVertexAttribArray", ExactSpelling = true)]
+ public extern static void EnableVertexAttribArray(GLuint index);
+ #endregion
+
+ #region End
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEnd", ExactSpelling = true)]
+ public extern static void End();
+ #endregion
+
+ #region EndList
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEndList", ExactSpelling = true)]
+ public extern static void EndList();
+ #endregion
+
+ #region EndQuery
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEndQuery", ExactSpelling = true)]
+ public extern static void EndQuery(Enums.VERSION_1_5 target);
+ #endregion
+
+ #region EvalCoord1d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord1d", ExactSpelling = true)]
+ public extern static void EvalCoord1d(GLdouble u);
+ #endregion
+
+ #region EvalCoord1dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord1dv", ExactSpelling = true)]
+ public extern static void EvalCoord1dv(System.IntPtr u);
+ #endregion
+
+ #region EvalCoord1f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord1f", ExactSpelling = true)]
+ public extern static void EvalCoord1f(GLfloat u);
+ #endregion
+
+ #region EvalCoord1fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord1fv", ExactSpelling = true)]
+ public extern static void EvalCoord1fv(System.IntPtr u);
+ #endregion
+
+ #region EvalCoord2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord2d", ExactSpelling = true)]
+ public extern static void EvalCoord2d(GLdouble u, GLdouble v);
+ #endregion
+
+ #region EvalCoord2dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord2dv", ExactSpelling = true)]
+ public extern static void EvalCoord2dv(System.IntPtr u);
+ #endregion
+
+ #region EvalCoord2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord2f", ExactSpelling = true)]
+ public extern static void EvalCoord2f(GLfloat u, GLfloat v);
+ #endregion
+
+ #region EvalCoord2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalCoord2fv", ExactSpelling = true)]
+ public extern static void EvalCoord2fv(System.IntPtr u);
+ #endregion
+
+ #region EvalMesh1
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalMesh1", ExactSpelling = true)]
+ public extern static void EvalMesh1(Enums.MeshMode1 mode, GLint i1, GLint i2);
+ #endregion
+
+ #region EvalMesh2
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalMesh2", ExactSpelling = true)]
+ public extern static void EvalMesh2(Enums.MeshMode2 mode, GLint i1, GLint i2, GLint j1, GLint j2);
+ #endregion
+
+ #region EvalPoint1
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalPoint1", ExactSpelling = true)]
+ public extern static void EvalPoint1(GLint i);
+ #endregion
+
+ #region EvalPoint2
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glEvalPoint2", ExactSpelling = true)]
+ public extern static void EvalPoint2(GLint i, GLint j);
+ #endregion
+
+ #region FeedbackBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFeedbackBuffer", ExactSpelling = true)]
+ public extern static void FeedbackBuffer(GLsizei size, Enums.FeedbackType type, System.IntPtr buffer);
+ #endregion
+
+ #region Finish
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFinish", ExactSpelling = true)]
+ public extern static void Finish();
+ #endregion
+
+ #region Flush
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFlush", ExactSpelling = true)]
+ public extern static void Flush();
+ #endregion
+
+ #region FogCoordd
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogCoordd", ExactSpelling = true)]
+ public extern static void FogCoordd(GLdouble coord);
+ #endregion
+
+ #region FogCoorddv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogCoorddv", ExactSpelling = true)]
+ public extern static void FogCoorddv(System.IntPtr coord);
+ #endregion
+
+ #region FogCoordf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogCoordf", ExactSpelling = true)]
+ public extern static void FogCoordf(GLfloat coord);
+ #endregion
+
+ #region FogCoordfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogCoordfv", ExactSpelling = true)]
+ public extern static void FogCoordfv(System.IntPtr coord);
+ #endregion
+
+ #region FogCoordPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogCoordPointer", ExactSpelling = true)]
+ public extern static void FogCoordPointer(Enums.VERSION_1_4 type, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region Fogf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogf", ExactSpelling = true)]
+ public extern static void Fogf(Enums.FogParameter pname, GLfloat param);
+ #endregion
+
+ #region Fogfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogfv", ExactSpelling = true)]
+ public extern static void Fogfv(Enums.FogParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region Fogi
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogi", ExactSpelling = true)]
+ public extern static void Fogi(Enums.FogParameter pname, GLint param);
+ #endregion
+
+ #region Fogiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFogiv", ExactSpelling = true)]
+ public extern static void Fogiv(Enums.FogParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region FrontFace
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFrontFace", ExactSpelling = true)]
+ public extern static void FrontFace(Enums.FrontFaceDirection mode);
+ #endregion
+
+ #region Frustum
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glFrustum", ExactSpelling = true)]
+ public extern static void Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+ #endregion
+
+ #region GenBuffers
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGenBuffers", ExactSpelling = true)]
+ public extern static void GenBuffers(GLsizei n, System.IntPtr buffers);
+ #endregion
+
+ #region GenLists
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGenLists", ExactSpelling = true)]
+ public extern static GLuint GenLists(GLsizei range);
+ #endregion
+
+ #region GenQueries
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGenQueries", ExactSpelling = true)]
+ public extern static void GenQueries(GLsizei n, System.IntPtr ids);
+ #endregion
+
+ #region GenTextures
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGenTextures", ExactSpelling = true)]
+ public extern static void GenTextures(GLsizei n, System.IntPtr textures);
+ #endregion
+
+ #region GetActiveAttrib
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetActiveAttrib", ExactSpelling = true)]
+ public extern static void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, System.IntPtr length, System.IntPtr size, System.IntPtr type, System.Text.StringBuilder name);
+ #endregion
+
+ #region GetActiveUniform
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetActiveUniform", ExactSpelling = true)]
+ public extern static void GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, System.IntPtr length, System.IntPtr size, System.IntPtr type, System.Text.StringBuilder name);
+ #endregion
+
+ #region GetAttachedShaders
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetAttachedShaders", ExactSpelling = true)]
+ public extern static void GetAttachedShaders(GLuint program, GLsizei maxCount, System.IntPtr count, System.IntPtr obj);
+ #endregion
+
+ #region GetAttribLocation
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetAttribLocation", ExactSpelling = true)]
+ public extern static GLint GetAttribLocation(GLuint program, System.String name);
+ #endregion
+
+ #region GetBooleanv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetBooleanv", ExactSpelling = true)]
+ public extern static void GetBooleanv(Enums.GetPName pname, System.IntPtr @params);
+ #endregion
+
+ #region GetBufferParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetBufferParameteriv", ExactSpelling = true)]
+ public extern static void GetBufferParameteriv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetBufferPointerv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetBufferPointerv", ExactSpelling = true)]
+ public extern static void GetBufferPointerv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetBufferSubData
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetBufferSubData", ExactSpelling = true)]
+ public extern static void GetBufferSubData(Enums.VERSION_1_5 target, GLintptr offset, GLsizeiptr size, System.IntPtr data);
+ #endregion
+
+ #region GetClipPlane
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetClipPlane", ExactSpelling = true)]
+ public extern static void GetClipPlane(Enums.ClipPlaneName plane, System.IntPtr equation);
+ #endregion
+
+ #region GetColorTable
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetColorTable", ExactSpelling = true)]
+ public extern static void GetColorTable(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr table);
+ #endregion
+
+ #region GetColorTableParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetColorTableParameterfv", ExactSpelling = true)]
+ public extern static void GetColorTableParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetColorTableParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetColorTableParameteriv", ExactSpelling = true)]
+ public extern static void GetColorTableParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetCompressedTexImage
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetCompressedTexImage", ExactSpelling = true)]
+ public extern static void GetCompressedTexImage(Enums.TextureTarget target, GLint level, System.IntPtr img);
+ #endregion
+
+ #region GetConvolutionFilter
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetConvolutionFilter", ExactSpelling = true)]
+ public extern static void GetConvolutionFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr image);
+ #endregion
+
+ #region GetConvolutionParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetConvolutionParameterfv", ExactSpelling = true)]
+ public extern static void GetConvolutionParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetConvolutionParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetConvolutionParameteriv", ExactSpelling = true)]
+ public extern static void GetConvolutionParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetDoublev
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetDoublev", ExactSpelling = true)]
+ public extern static void GetDoublev(Enums.GetPName pname, System.IntPtr @params);
+ #endregion
+
+ #region GetError
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetError", ExactSpelling = true)]
+ public extern static Enums.GLenum GetError();
+ #endregion
+
+ #region GetFloatv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetFloatv", ExactSpelling = true)]
+ public extern static void GetFloatv(Enums.GetPName pname, System.IntPtr @params);
+ #endregion
+
+ #region GetHistogram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetHistogram", ExactSpelling = true)]
+ public extern static void GetHistogram(Enums.VERSION_1_2 target, System.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr values);
+ #endregion
+
+ #region GetHistogramParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetHistogramParameterfv", ExactSpelling = true)]
+ public extern static void GetHistogramParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetHistogramParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetHistogramParameteriv", ExactSpelling = true)]
+ public extern static void GetHistogramParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetIntegerv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetIntegerv", ExactSpelling = true)]
+ public extern static void GetIntegerv(Enums.GetPName pname, System.IntPtr @params);
+ #endregion
+
+ #region GetLightfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetLightfv", ExactSpelling = true)]
+ public extern static void GetLightfv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetLightiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetLightiv", ExactSpelling = true)]
+ public extern static void GetLightiv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetMapdv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMapdv", ExactSpelling = true)]
+ public extern static void GetMapdv(Enums.MapTarget target, Enums.GetMapQuery query, System.IntPtr v);
+ #endregion
+
+ #region GetMapfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMapfv", ExactSpelling = true)]
+ public extern static void GetMapfv(Enums.MapTarget target, Enums.GetMapQuery query, System.IntPtr v);
+ #endregion
+
+ #region GetMapiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMapiv", ExactSpelling = true)]
+ public extern static void GetMapiv(Enums.MapTarget target, Enums.GetMapQuery query, System.IntPtr v);
+ #endregion
+
+ #region GetMaterialfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMaterialfv", ExactSpelling = true)]
+ public extern static void GetMaterialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetMaterialiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMaterialiv", ExactSpelling = true)]
+ public extern static void GetMaterialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetMinmax
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMinmax", ExactSpelling = true)]
+ public extern static void GetMinmax(Enums.VERSION_1_2 target, System.Boolean reset, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr values);
+ #endregion
+
+ #region GetMinmaxParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMinmaxParameterfv", ExactSpelling = true)]
+ public extern static void GetMinmaxParameterfv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetMinmaxParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetMinmaxParameteriv", ExactSpelling = true)]
+ public extern static void GetMinmaxParameteriv(Enums.VERSION_1_2 target, Enums.VERSION_1_2 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetPixelMapfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetPixelMapfv", ExactSpelling = true)]
+ public extern static void GetPixelMapfv(Enums.PixelMap map, System.IntPtr values);
+ #endregion
+
+ #region GetPixelMapuiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetPixelMapuiv", ExactSpelling = true)]
+ public extern static void GetPixelMapuiv(Enums.PixelMap map, System.IntPtr values);
+ #endregion
+
+ #region GetPixelMapusv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetPixelMapusv", ExactSpelling = true)]
+ public extern static void GetPixelMapusv(Enums.PixelMap map, System.IntPtr values);
+ #endregion
+
+ #region GetPointerv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetPointerv", ExactSpelling = true)]
+ public extern static void GetPointerv(Enums.GetPointervPName pname, System.IntPtr @params);
+ #endregion
+
+ #region GetPolygonStipple
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetPolygonStipple", ExactSpelling = true)]
+ public extern static void GetPolygonStipple(System.IntPtr mask);
+ #endregion
+
+ #region GetProgramInfoLog
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetProgramInfoLog", ExactSpelling = true)]
+ public extern static void GetProgramInfoLog(GLuint program, GLsizei bufSize, System.IntPtr length, System.Text.StringBuilder infoLog);
+ #endregion
+
+ #region GetProgramiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetProgramiv", ExactSpelling = true)]
+ public extern static void GetProgramiv(GLuint program, Enums.VERSION_2_0 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetQueryiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetQueryiv", ExactSpelling = true)]
+ public extern static void GetQueryiv(Enums.VERSION_1_5 target, Enums.VERSION_1_5 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetQueryObjectiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetQueryObjectiv", ExactSpelling = true)]
+ public extern static void GetQueryObjectiv(GLuint id, Enums.VERSION_1_5 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetQueryObjectuiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetQueryObjectuiv", ExactSpelling = true)]
+ public extern static void GetQueryObjectuiv(GLuint id, Enums.VERSION_1_5 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetSeparableFilter
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetSeparableFilter", ExactSpelling = true)]
+ public extern static void GetSeparableFilter(Enums.VERSION_1_2 target, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, System.IntPtr column, System.IntPtr span);
+ #endregion
+
+ #region GetShaderInfoLog
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetShaderInfoLog", ExactSpelling = true)]
+ public extern static void GetShaderInfoLog(GLuint shader, GLsizei bufSize, System.IntPtr length, System.Text.StringBuilder infoLog);
+ #endregion
+
+ #region GetShaderiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetShaderiv", ExactSpelling = true)]
+ public extern static void GetShaderiv(GLuint shader, Enums.VERSION_2_0 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetShaderSource
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetShaderSource", ExactSpelling = true)]
+ public extern static void GetShaderSource(GLuint shader, GLsizei bufSize, System.IntPtr length, System.Text.StringBuilder source);
+ #endregion
+
+ #region GetString
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetString", ExactSpelling = true)]
+ public extern static IntPtr GetString(Enums.StringName name);
+ #endregion
+
+ #region GetTexEnvfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexEnvfv", ExactSpelling = true)]
+ public extern static void GetTexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexEnviv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexEnviv", ExactSpelling = true)]
+ public extern static void GetTexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexGendv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexGendv", ExactSpelling = true)]
+ public extern static void GetTexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexGenfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexGenfv", ExactSpelling = true)]
+ public extern static void GetTexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexGeniv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexGeniv", ExactSpelling = true)]
+ public extern static void GetTexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexImage
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexImage", ExactSpelling = true)]
+ public extern static void GetTexImage(Enums.TextureTarget target, GLint level, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region GetTexLevelParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexLevelParameterfv", ExactSpelling = true)]
+ public extern static void GetTexLevelParameterfv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexLevelParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexLevelParameteriv", ExactSpelling = true)]
+ public extern static void GetTexLevelParameteriv(Enums.TextureTarget target, GLint level, Enums.GetTextureParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexParameterfv", ExactSpelling = true)]
+ public extern static void GetTexParameterfv(Enums.TextureTarget target, Enums.GetTextureParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetTexParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetTexParameteriv", ExactSpelling = true)]
+ public extern static void GetTexParameteriv(Enums.TextureTarget target, Enums.GetTextureParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region GetUniformfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetUniformfv", ExactSpelling = true)]
+ public extern static void GetUniformfv(GLuint program, GLint location, System.IntPtr @params);
+ #endregion
+
+ #region GetUniformiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetUniformiv", ExactSpelling = true)]
+ public extern static void GetUniformiv(GLuint program, GLint location, System.IntPtr @params);
+ #endregion
+
+ #region GetUniformLocation
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetUniformLocation", ExactSpelling = true)]
+ public extern static GLint GetUniformLocation(GLuint program, System.String name);
+ #endregion
+
+ #region GetVertexAttribdv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetVertexAttribdv", ExactSpelling = true)]
+ public extern static void GetVertexAttribdv(GLuint index, Enums.VERSION_2_0 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetVertexAttribfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetVertexAttribfv", ExactSpelling = true)]
+ public extern static void GetVertexAttribfv(GLuint index, Enums.VERSION_2_0 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetVertexAttribiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetVertexAttribiv", ExactSpelling = true)]
+ public extern static void GetVertexAttribiv(GLuint index, Enums.VERSION_2_0 pname, System.IntPtr @params);
+ #endregion
+
+ #region GetVertexAttribPointerv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glGetVertexAttribPointerv", ExactSpelling = true)]
+ public extern static void GetVertexAttribPointerv(GLuint index, Enums.VERSION_2_0 pname, System.IntPtr pointer);
+ #endregion
+
+ #region Hint
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glHint", ExactSpelling = true)]
+ public extern static void Hint(Enums.HintTarget target, Enums.HintMode mode);
+ #endregion
+
+ #region Histogram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glHistogram", ExactSpelling = true)]
+ public extern static void Histogram(Enums.VERSION_1_2 target, GLsizei width, Enums.PixelInternalFormat internalformat, System.Boolean sink);
+ #endregion
+
+ #region Indexd
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexd", ExactSpelling = true)]
+ public extern static void Indexd(GLdouble c);
+ #endregion
+
+ #region Indexdv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexdv", ExactSpelling = true)]
+ public extern static void Indexdv(System.IntPtr c);
+ #endregion
+
+ #region Indexf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexf", ExactSpelling = true)]
+ public extern static void Indexf(GLfloat c);
+ #endregion
+
+ #region Indexfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexfv", ExactSpelling = true)]
+ public extern static void Indexfv(System.IntPtr c);
+ #endregion
+
+ #region Indexi
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexi", ExactSpelling = true)]
+ public extern static void Indexi(GLint c);
+ #endregion
+
+ #region Indexiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexiv", ExactSpelling = true)]
+ public extern static void Indexiv(System.IntPtr c);
+ #endregion
+
+ #region IndexMask
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexMask", ExactSpelling = true)]
+ public extern static void IndexMask(GLuint mask);
+ #endregion
+
+ #region IndexPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexPointer", ExactSpelling = true)]
+ public extern static void IndexPointer(Enums.IndexPointerType type, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region Indexs
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexs", ExactSpelling = true)]
+ public extern static void Indexs(GLshort c);
+ #endregion
+
+ #region Indexsv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexsv", ExactSpelling = true)]
+ public extern static void Indexsv(System.IntPtr c);
+ #endregion
+
+ #region Indexub
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexub", ExactSpelling = true)]
+ public extern static void Indexub(GLubyte c);
+ #endregion
+
+ #region Indexubv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIndexubv", ExactSpelling = true)]
+ public extern static void Indexubv(System.IntPtr c);
+ #endregion
+
+ #region InitNames
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glInitNames", ExactSpelling = true)]
+ public extern static void InitNames();
+ #endregion
+
+ #region InterleavedArrays
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glInterleavedArrays", ExactSpelling = true)]
+ public extern static void InterleavedArrays(Enums.InterleavedArrayFormat format, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region IsBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIsBuffer", ExactSpelling = true)]
+ public extern static GLboolean IsBuffer(GLuint buffer);
+ #endregion
+
+ #region IsEnabled
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIsEnabled", ExactSpelling = true)]
+ public extern static GLboolean IsEnabled(Enums.EnableCap cap);
+ #endregion
+
+ #region IsList
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIsList", ExactSpelling = true)]
+ public extern static GLboolean IsList(GLuint list);
+ #endregion
+
+ #region IsProgram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIsProgram", ExactSpelling = true)]
+ public extern static GLboolean IsProgram(GLuint program);
+ #endregion
+
+ #region IsQuery
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIsQuery", ExactSpelling = true)]
+ public extern static GLboolean IsQuery(GLuint id);
+ #endregion
+
+ #region IsShader
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIsShader", ExactSpelling = true)]
+ public extern static GLboolean IsShader(GLuint shader);
+ #endregion
+
+ #region IsTexture
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glIsTexture", ExactSpelling = true)]
+ public extern static GLboolean IsTexture(GLuint texture);
+ #endregion
+
+ #region Lightf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLightf", ExactSpelling = true)]
+ public extern static void Lightf(Enums.LightName light, Enums.LightParameter pname, GLfloat param);
+ #endregion
+
+ #region Lightfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLightfv", ExactSpelling = true)]
+ public extern static void Lightfv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region Lighti
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLighti", ExactSpelling = true)]
+ public extern static void Lighti(Enums.LightName light, Enums.LightParameter pname, GLint param);
+ #endregion
+
+ #region Lightiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLightiv", ExactSpelling = true)]
+ public extern static void Lightiv(Enums.LightName light, Enums.LightParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region LightModelf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLightModelf", ExactSpelling = true)]
+ public extern static void LightModelf(Enums.LightModelParameter pname, GLfloat param);
+ #endregion
+
+ #region LightModelfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLightModelfv", ExactSpelling = true)]
+ public extern static void LightModelfv(Enums.LightModelParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region LightModeli
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLightModeli", ExactSpelling = true)]
+ public extern static void LightModeli(Enums.LightModelParameter pname, GLint param);
+ #endregion
+
+ #region LightModeliv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLightModeliv", ExactSpelling = true)]
+ public extern static void LightModeliv(Enums.LightModelParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region LineStipple
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLineStipple", ExactSpelling = true)]
+ public extern static void LineStipple(GLint factor, GLushort pattern);
+ #endregion
+
+ #region LineWidth
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLineWidth", ExactSpelling = true)]
+ public extern static void LineWidth(GLfloat width);
+ #endregion
+
+ #region LinkProgram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLinkProgram", ExactSpelling = true)]
+ public extern static void LinkProgram(GLuint program);
+ #endregion
+
+ #region ListBase
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glListBase", ExactSpelling = true)]
+ public extern static void ListBase(GLuint @base);
+ #endregion
+
+ #region LoadIdentity
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLoadIdentity", ExactSpelling = true)]
+ public extern static void LoadIdentity();
+ #endregion
+
+ #region LoadMatrixd
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLoadMatrixd", ExactSpelling = true)]
+ public extern static void LoadMatrixd(System.IntPtr m);
+ #endregion
+
+ #region LoadMatrixf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLoadMatrixf", ExactSpelling = true)]
+ public extern static void LoadMatrixf(System.IntPtr m);
+ #endregion
+
+ #region LoadName
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLoadName", ExactSpelling = true)]
+ public extern static void LoadName(GLuint name);
+ #endregion
+
+ #region LoadTransposeMatrixd
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLoadTransposeMatrixd", ExactSpelling = true)]
+ public extern static void LoadTransposeMatrixd(System.IntPtr m);
+ #endregion
+
+ #region LoadTransposeMatrixf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLoadTransposeMatrixf", ExactSpelling = true)]
+ public extern static void LoadTransposeMatrixf(System.IntPtr m);
+ #endregion
+
+ #region LogicOp
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glLogicOp", ExactSpelling = true)]
+ public extern static void LogicOp(Enums.LogicOp opcode);
+ #endregion
+
+ #region Map1d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMap1d", ExactSpelling = true)]
+ public extern static void Map1d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint stride, GLint order, System.IntPtr points);
+ #endregion
+
+ #region Map1f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMap1f", ExactSpelling = true)]
+ public extern static void Map1f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint stride, GLint order, System.IntPtr points);
+ #endregion
+
+ #region Map2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMap2d", ExactSpelling = true)]
+ public extern static void Map2d(Enums.MapTarget target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, System.IntPtr points);
+ #endregion
+
+ #region Map2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMap2f", ExactSpelling = true)]
+ public extern static void Map2f(Enums.MapTarget target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, System.IntPtr points);
+ #endregion
+
+ #region MapBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMapBuffer", ExactSpelling = true)]
+ public extern static IntPtr MapBuffer(Enums.VERSION_1_5 target, Enums.VERSION_1_5 access);
+ #endregion
+
+ #region MapGrid1d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMapGrid1d", ExactSpelling = true)]
+ public extern static void MapGrid1d(GLint un, GLdouble u1, GLdouble u2);
+ #endregion
+
+ #region MapGrid1f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMapGrid1f", ExactSpelling = true)]
+ public extern static void MapGrid1f(GLint un, GLfloat u1, GLfloat u2);
+ #endregion
+
+ #region MapGrid2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMapGrid2d", ExactSpelling = true)]
+ public extern static void MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
+ #endregion
+
+ #region MapGrid2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMapGrid2f", ExactSpelling = true)]
+ public extern static void MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
+ #endregion
+
+ #region Materialf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMaterialf", ExactSpelling = true)]
+ public extern static void Materialf(Enums.MaterialFace face, Enums.MaterialParameter pname, GLfloat param);
+ #endregion
+
+ #region Materialfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMaterialfv", ExactSpelling = true)]
+ public extern static void Materialfv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region Materiali
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMateriali", ExactSpelling = true)]
+ public extern static void Materiali(Enums.MaterialFace face, Enums.MaterialParameter pname, GLint param);
+ #endregion
+
+ #region Materialiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMaterialiv", ExactSpelling = true)]
+ public extern static void Materialiv(Enums.MaterialFace face, Enums.MaterialParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region MatrixMode
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMatrixMode", ExactSpelling = true)]
+ public extern static void MatrixMode(Enums.MatrixMode mode);
+ #endregion
+
+ #region Minmax
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMinmax", ExactSpelling = true)]
+ public extern static void Minmax(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, System.Boolean sink);
+ #endregion
+
+ #region MultiDrawArrays
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiDrawArrays", ExactSpelling = true)]
+ public extern static void MultiDrawArrays(Enums.BeginMode mode, System.IntPtr first, System.IntPtr count, GLsizei primcount);
+ #endregion
+
+ #region MultiDrawElements
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiDrawElements", ExactSpelling = true)]
+ public extern static void MultiDrawElements(Enums.BeginMode mode, System.IntPtr count, Enums.VERSION_1_4 type, System.IntPtr indices, GLsizei primcount);
+ #endregion
+
+ #region MultiTexCoord1d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1d", ExactSpelling = true)]
+ public extern static void MultiTexCoord1d(Enums.VERSION_1_3 target, GLdouble s);
+ #endregion
+
+ #region MultiTexCoord1dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1dv", ExactSpelling = true)]
+ public extern static void MultiTexCoord1dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord1f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1f", ExactSpelling = true)]
+ public extern static void MultiTexCoord1f(Enums.VERSION_1_3 target, GLfloat s);
+ #endregion
+
+ #region MultiTexCoord1fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1fv", ExactSpelling = true)]
+ public extern static void MultiTexCoord1fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord1i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1i", ExactSpelling = true)]
+ public extern static void MultiTexCoord1i(Enums.VERSION_1_3 target, GLint s);
+ #endregion
+
+ #region MultiTexCoord1iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1iv", ExactSpelling = true)]
+ public extern static void MultiTexCoord1iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord1s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1s", ExactSpelling = true)]
+ public extern static void MultiTexCoord1s(Enums.VERSION_1_3 target, GLshort s);
+ #endregion
+
+ #region MultiTexCoord1sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord1sv", ExactSpelling = true)]
+ public extern static void MultiTexCoord1sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2d", ExactSpelling = true)]
+ public extern static void MultiTexCoord2d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t);
+ #endregion
+
+ #region MultiTexCoord2dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2dv", ExactSpelling = true)]
+ public extern static void MultiTexCoord2dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2f", ExactSpelling = true)]
+ public extern static void MultiTexCoord2f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t);
+ #endregion
+
+ #region MultiTexCoord2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2fv", ExactSpelling = true)]
+ public extern static void MultiTexCoord2fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord2i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2i", ExactSpelling = true)]
+ public extern static void MultiTexCoord2i(Enums.VERSION_1_3 target, GLint s, GLint t);
+ #endregion
+
+ #region MultiTexCoord2iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2iv", ExactSpelling = true)]
+ public extern static void MultiTexCoord2iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord2s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2s", ExactSpelling = true)]
+ public extern static void MultiTexCoord2s(Enums.VERSION_1_3 target, GLshort s, GLshort t);
+ #endregion
+
+ #region MultiTexCoord2sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord2sv", ExactSpelling = true)]
+ public extern static void MultiTexCoord2sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3d", ExactSpelling = true)]
+ public extern static void MultiTexCoord3d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r);
+ #endregion
+
+ #region MultiTexCoord3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3dv", ExactSpelling = true)]
+ public extern static void MultiTexCoord3dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3f", ExactSpelling = true)]
+ public extern static void MultiTexCoord3f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r);
+ #endregion
+
+ #region MultiTexCoord3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3fv", ExactSpelling = true)]
+ public extern static void MultiTexCoord3fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3i", ExactSpelling = true)]
+ public extern static void MultiTexCoord3i(Enums.VERSION_1_3 target, GLint s, GLint t, GLint r);
+ #endregion
+
+ #region MultiTexCoord3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3iv", ExactSpelling = true)]
+ public extern static void MultiTexCoord3iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3s", ExactSpelling = true)]
+ public extern static void MultiTexCoord3s(Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r);
+ #endregion
+
+ #region MultiTexCoord3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord3sv", ExactSpelling = true)]
+ public extern static void MultiTexCoord3sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord4d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4d", ExactSpelling = true)]
+ public extern static void MultiTexCoord4d(Enums.VERSION_1_3 target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+ #endregion
+
+ #region MultiTexCoord4dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4dv", ExactSpelling = true)]
+ public extern static void MultiTexCoord4dv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord4f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4f", ExactSpelling = true)]
+ public extern static void MultiTexCoord4f(Enums.VERSION_1_3 target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+ #endregion
+
+ #region MultiTexCoord4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4fv", ExactSpelling = true)]
+ public extern static void MultiTexCoord4fv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord4i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4i", ExactSpelling = true)]
+ public extern static void MultiTexCoord4i(Enums.VERSION_1_3 target, GLint s, GLint t, GLint r, GLint q);
+ #endregion
+
+ #region MultiTexCoord4iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4iv", ExactSpelling = true)]
+ public extern static void MultiTexCoord4iv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultiTexCoord4s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4s", ExactSpelling = true)]
+ public extern static void MultiTexCoord4s(Enums.VERSION_1_3 target, GLshort s, GLshort t, GLshort r, GLshort q);
+ #endregion
+
+ #region MultiTexCoord4sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultiTexCoord4sv", ExactSpelling = true)]
+ public extern static void MultiTexCoord4sv(Enums.VERSION_1_3 target, System.IntPtr v);
+ #endregion
+
+ #region MultMatrixd
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultMatrixd", ExactSpelling = true)]
+ public extern static void MultMatrixd(System.IntPtr m);
+ #endregion
+
+ #region MultMatrixf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultMatrixf", ExactSpelling = true)]
+ public extern static void MultMatrixf(System.IntPtr m);
+ #endregion
+
+ #region MultTransposeMatrixd
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultTransposeMatrixd", ExactSpelling = true)]
+ public extern static void MultTransposeMatrixd(System.IntPtr m);
+ #endregion
+
+ #region MultTransposeMatrixf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glMultTransposeMatrixf", ExactSpelling = true)]
+ public extern static void MultTransposeMatrixf(System.IntPtr m);
+ #endregion
+
+ #region NewList
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNewList", ExactSpelling = true)]
+ public extern static void NewList(GLuint list, Enums.ListMode mode);
+ #endregion
+
+ #region Normal3b
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3b", ExactSpelling = true)]
+ public extern static void Normal3b(GLbyte nx, GLbyte ny, GLbyte nz);
+ #endregion
+
+ #region Normal3bv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3bv", ExactSpelling = true)]
+ public extern static void Normal3bv(System.IntPtr v);
+ #endregion
+
+ #region Normal3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3d", ExactSpelling = true)]
+ public extern static void Normal3d(GLdouble nx, GLdouble ny, GLdouble nz);
+ #endregion
+
+ #region Normal3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3dv", ExactSpelling = true)]
+ public extern static void Normal3dv(System.IntPtr v);
+ #endregion
+
+ #region Normal3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3f", ExactSpelling = true)]
+ public extern static void Normal3f(GLfloat nx, GLfloat ny, GLfloat nz);
+ #endregion
+
+ #region Normal3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3fv", ExactSpelling = true)]
+ public extern static void Normal3fv(System.IntPtr v);
+ #endregion
+
+ #region Normal3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3i", ExactSpelling = true)]
+ public extern static void Normal3i(GLint nx, GLint ny, GLint nz);
+ #endregion
+
+ #region Normal3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3iv", ExactSpelling = true)]
+ public extern static void Normal3iv(System.IntPtr v);
+ #endregion
+
+ #region Normal3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3s", ExactSpelling = true)]
+ public extern static void Normal3s(GLshort nx, GLshort ny, GLshort nz);
+ #endregion
+
+ #region Normal3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormal3sv", ExactSpelling = true)]
+ public extern static void Normal3sv(System.IntPtr v);
+ #endregion
+
+ #region NormalPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glNormalPointer", ExactSpelling = true)]
+ public extern static void NormalPointer(Enums.NormalPointerType type, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region Ortho
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glOrtho", ExactSpelling = true)]
+ public extern static void Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
+ #endregion
+
+ #region PassThrough
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPassThrough", ExactSpelling = true)]
+ public extern static void PassThrough(GLfloat token);
+ #endregion
+
+ #region PixelMapfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelMapfv", ExactSpelling = true)]
+ public extern static void PixelMapfv(Enums.PixelMap map, GLint mapsize, System.IntPtr values);
+ #endregion
+
+ #region PixelMapuiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelMapuiv", ExactSpelling = true)]
+ public extern static void PixelMapuiv(Enums.PixelMap map, GLint mapsize, System.IntPtr values);
+ #endregion
+
+ #region PixelMapusv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelMapusv", ExactSpelling = true)]
+ public extern static void PixelMapusv(Enums.PixelMap map, GLint mapsize, System.IntPtr values);
+ #endregion
+
+ #region PixelStoref
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelStoref", ExactSpelling = true)]
+ public extern static void PixelStoref(Enums.PixelStoreParameter pname, GLfloat param);
+ #endregion
+
+ #region PixelStorei
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelStorei", ExactSpelling = true)]
+ public extern static void PixelStorei(Enums.PixelStoreParameter pname, GLint param);
+ #endregion
+
+ #region PixelTransferf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelTransferf", ExactSpelling = true)]
+ public extern static void PixelTransferf(Enums.PixelTransferParameter pname, GLfloat param);
+ #endregion
+
+ #region PixelTransferi
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelTransferi", ExactSpelling = true)]
+ public extern static void PixelTransferi(Enums.PixelTransferParameter pname, GLint param);
+ #endregion
+
+ #region PixelZoom
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPixelZoom", ExactSpelling = true)]
+ public extern static void PixelZoom(GLfloat xfactor, GLfloat yfactor);
+ #endregion
+
+ #region PointParameterf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPointParameterf", ExactSpelling = true)]
+ public extern static void PointParameterf(Enums.VERSION_1_4 pname, GLfloat param);
+ #endregion
+
+ #region PointParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPointParameterfv", ExactSpelling = true)]
+ public extern static void PointParameterfv(Enums.VERSION_1_4 pname, System.IntPtr @params);
+ #endregion
+
+ #region PointParameteri
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPointParameteri", ExactSpelling = true)]
+ public extern static void PointParameteri(Enums.VERSION_1_4 pname, GLint param);
+ #endregion
+
+ #region PointParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPointParameteriv", ExactSpelling = true)]
+ public extern static void PointParameteriv(Enums.VERSION_1_4 pname, System.IntPtr @params);
+ #endregion
+
+ #region PointSize
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPointSize", ExactSpelling = true)]
+ public extern static void PointSize(GLfloat size);
+ #endregion
+
+ #region PolygonMode
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPolygonMode", ExactSpelling = true)]
+ public extern static void PolygonMode(Enums.MaterialFace face, Enums.PolygonMode mode);
+ #endregion
+
+ #region PolygonOffset
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPolygonOffset", ExactSpelling = true)]
+ public extern static void PolygonOffset(GLfloat factor, GLfloat units);
+ #endregion
+
+ #region PolygonStipple
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPolygonStipple", ExactSpelling = true)]
+ public extern static void PolygonStipple(System.IntPtr mask);
+ #endregion
+
+ #region PopAttrib
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPopAttrib", ExactSpelling = true)]
+ public extern static void PopAttrib();
+ #endregion
+
+ #region PopClientAttrib
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPopClientAttrib", ExactSpelling = true)]
+ public extern static void PopClientAttrib();
+ #endregion
+
+ #region PopMatrix
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPopMatrix", ExactSpelling = true)]
+ public extern static void PopMatrix();
+ #endregion
+
+ #region PopName
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPopName", ExactSpelling = true)]
+ public extern static void PopName();
+ #endregion
+
+ #region PrioritizeTextures
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPrioritizeTextures", ExactSpelling = true)]
+ public extern static void PrioritizeTextures(GLsizei n, System.IntPtr textures, System.IntPtr priorities);
+ #endregion
+
+ #region PushAttrib
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPushAttrib", ExactSpelling = true)]
+ public extern static void PushAttrib(Enums.AttribMask mask);
+ #endregion
+
+ #region PushClientAttrib
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPushClientAttrib", ExactSpelling = true)]
+ public extern static void PushClientAttrib(Enums.ClientAttribMask mask);
+ #endregion
+
+ #region PushMatrix
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPushMatrix", ExactSpelling = true)]
+ public extern static void PushMatrix();
+ #endregion
+
+ #region PushName
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glPushName", ExactSpelling = true)]
+ public extern static void PushName(GLuint name);
+ #endregion
+
+ #region RasterPos2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2d", ExactSpelling = true)]
+ public extern static void RasterPos2d(GLdouble x, GLdouble y);
+ #endregion
+
+ #region RasterPos2dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2dv", ExactSpelling = true)]
+ public extern static void RasterPos2dv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2f", ExactSpelling = true)]
+ public extern static void RasterPos2f(GLfloat x, GLfloat y);
+ #endregion
+
+ #region RasterPos2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2fv", ExactSpelling = true)]
+ public extern static void RasterPos2fv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos2i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2i", ExactSpelling = true)]
+ public extern static void RasterPos2i(GLint x, GLint y);
+ #endregion
+
+ #region RasterPos2iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2iv", ExactSpelling = true)]
+ public extern static void RasterPos2iv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos2s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2s", ExactSpelling = true)]
+ public extern static void RasterPos2s(GLshort x, GLshort y);
+ #endregion
+
+ #region RasterPos2sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos2sv", ExactSpelling = true)]
+ public extern static void RasterPos2sv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3d", ExactSpelling = true)]
+ public extern static void RasterPos3d(GLdouble x, GLdouble y, GLdouble z);
+ #endregion
+
+ #region RasterPos3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3dv", ExactSpelling = true)]
+ public extern static void RasterPos3dv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3f", ExactSpelling = true)]
+ public extern static void RasterPos3f(GLfloat x, GLfloat y, GLfloat z);
+ #endregion
+
+ #region RasterPos3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3fv", ExactSpelling = true)]
+ public extern static void RasterPos3fv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3i", ExactSpelling = true)]
+ public extern static void RasterPos3i(GLint x, GLint y, GLint z);
+ #endregion
+
+ #region RasterPos3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3iv", ExactSpelling = true)]
+ public extern static void RasterPos3iv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3s", ExactSpelling = true)]
+ public extern static void RasterPos3s(GLshort x, GLshort y, GLshort z);
+ #endregion
+
+ #region RasterPos3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos3sv", ExactSpelling = true)]
+ public extern static void RasterPos3sv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos4d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4d", ExactSpelling = true)]
+ public extern static void RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ #endregion
+
+ #region RasterPos4dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4dv", ExactSpelling = true)]
+ public extern static void RasterPos4dv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos4f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4f", ExactSpelling = true)]
+ public extern static void RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ #endregion
+
+ #region RasterPos4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4fv", ExactSpelling = true)]
+ public extern static void RasterPos4fv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos4i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4i", ExactSpelling = true)]
+ public extern static void RasterPos4i(GLint x, GLint y, GLint z, GLint w);
+ #endregion
+
+ #region RasterPos4iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4iv", ExactSpelling = true)]
+ public extern static void RasterPos4iv(System.IntPtr v);
+ #endregion
+
+ #region RasterPos4s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4s", ExactSpelling = true)]
+ public extern static void RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);
+ #endregion
+
+ #region RasterPos4sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRasterPos4sv", ExactSpelling = true)]
+ public extern static void RasterPos4sv(System.IntPtr v);
+ #endregion
+
+ #region ReadBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glReadBuffer", ExactSpelling = true)]
+ public extern static void ReadBuffer(Enums.ReadBufferMode mode);
+ #endregion
+
+ #region ReadPixels
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glReadPixels", ExactSpelling = true)]
+ public extern static void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region Rectd
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRectd", ExactSpelling = true)]
+ public extern static void Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
+ #endregion
+
+ #region Rectdv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRectdv", ExactSpelling = true)]
+ public extern static void Rectdv(System.IntPtr v1, System.IntPtr v2);
+ #endregion
+
+ #region Rectf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRectf", ExactSpelling = true)]
+ public extern static void Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
+ #endregion
+
+ #region Rectfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRectfv", ExactSpelling = true)]
+ public extern static void Rectfv(System.IntPtr v1, System.IntPtr v2);
+ #endregion
+
+ #region Recti
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRecti", ExactSpelling = true)]
+ public extern static void Recti(GLint x1, GLint y1, GLint x2, GLint y2);
+ #endregion
+
+ #region Rectiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRectiv", ExactSpelling = true)]
+ public extern static void Rectiv(System.IntPtr v1, System.IntPtr v2);
+ #endregion
+
+ #region Rects
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRects", ExactSpelling = true)]
+ public extern static void Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
+ #endregion
+
+ #region Rectsv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRectsv", ExactSpelling = true)]
+ public extern static void Rectsv(System.IntPtr v1, System.IntPtr v2);
+ #endregion
+
+ #region RenderMode
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRenderMode", ExactSpelling = true)]
+ public extern static GLint RenderMode(Enums.RenderingMode mode);
+ #endregion
+
+ #region ResetHistogram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glResetHistogram", ExactSpelling = true)]
+ public extern static void ResetHistogram(Enums.VERSION_1_2 target);
+ #endregion
+
+ #region ResetMinmax
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glResetMinmax", ExactSpelling = true)]
+ public extern static void ResetMinmax(Enums.VERSION_1_2 target);
+ #endregion
+
+ #region Rotated
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRotated", ExactSpelling = true)]
+ public extern static void Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
+ #endregion
+
+ #region Rotatef
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glRotatef", ExactSpelling = true)]
+ public extern static void Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
+ #endregion
+
+ #region SampleCoverage
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSampleCoverage", ExactSpelling = true)]
+ public extern static void SampleCoverage(GLclampf value, System.Boolean invert);
+ #endregion
+
+ #region Scaled
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glScaled", ExactSpelling = true)]
+ public extern static void Scaled(GLdouble x, GLdouble y, GLdouble z);
+ #endregion
+
+ #region Scalef
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glScalef", ExactSpelling = true)]
+ public extern static void Scalef(GLfloat x, GLfloat y, GLfloat z);
+ #endregion
+
+ #region Scissor
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glScissor", ExactSpelling = true)]
+ public extern static void Scissor(GLint x, GLint y, GLsizei width, GLsizei height);
+ #endregion
+
+ #region SecondaryColor3b
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3b", ExactSpelling = true)]
+ public extern static void SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
+ #endregion
+
+ #region SecondaryColor3bv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3bv", ExactSpelling = true)]
+ public extern static void SecondaryColor3bv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColor3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3d", ExactSpelling = true)]
+ public extern static void SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
+ #endregion
+
+ #region SecondaryColor3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3dv", ExactSpelling = true)]
+ public extern static void SecondaryColor3dv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColor3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3f", ExactSpelling = true)]
+ public extern static void SecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
+ #endregion
+
+ #region SecondaryColor3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3fv", ExactSpelling = true)]
+ public extern static void SecondaryColor3fv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColor3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3i", ExactSpelling = true)]
+ public extern static void SecondaryColor3i(GLint red, GLint green, GLint blue);
+ #endregion
+
+ #region SecondaryColor3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3iv", ExactSpelling = true)]
+ public extern static void SecondaryColor3iv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColor3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3s", ExactSpelling = true)]
+ public extern static void SecondaryColor3s(GLshort red, GLshort green, GLshort blue);
+ #endregion
+
+ #region SecondaryColor3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3sv", ExactSpelling = true)]
+ public extern static void SecondaryColor3sv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColor3ub
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3ub", ExactSpelling = true)]
+ public extern static void SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
+ #endregion
+
+ #region SecondaryColor3ubv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3ubv", ExactSpelling = true)]
+ public extern static void SecondaryColor3ubv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColor3ui
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3ui", ExactSpelling = true)]
+ public extern static void SecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
+ #endregion
+
+ #region SecondaryColor3uiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3uiv", ExactSpelling = true)]
+ public extern static void SecondaryColor3uiv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColor3us
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3us", ExactSpelling = true)]
+ public extern static void SecondaryColor3us(GLushort red, GLushort green, GLushort blue);
+ #endregion
+
+ #region SecondaryColor3usv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColor3usv", ExactSpelling = true)]
+ public extern static void SecondaryColor3usv(System.IntPtr v);
+ #endregion
+
+ #region SecondaryColorPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSecondaryColorPointer", ExactSpelling = true)]
+ public extern static void SecondaryColorPointer(GLint size, Enums.ColorPointerType type, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region SelectBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSelectBuffer", ExactSpelling = true)]
+ public extern static void SelectBuffer(GLsizei size, System.IntPtr buffer);
+ #endregion
+
+ #region SeparableFilter2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glSeparableFilter2D", ExactSpelling = true)]
+ public extern static void SeparableFilter2D(Enums.VERSION_1_2 target, Enums.PixelInternalFormat internalformat, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr row, System.IntPtr column);
+ #endregion
+
+ #region ShadeModel
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glShadeModel", ExactSpelling = true)]
+ public extern static void ShadeModel(Enums.ShadingModel mode);
+ #endregion
+
+ #region ShaderSource
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glShaderSource", ExactSpelling = true)]
+ public extern static void ShaderSource(GLuint shader, GLsizei count, System.String[] @string, System.IntPtr length);
+ #endregion
+
+ #region StencilFunc
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glStencilFunc", ExactSpelling = true)]
+ public extern static void StencilFunc(Enums.StencilFunction func, GLint @ref, GLuint mask);
+ #endregion
+
+ #region StencilFuncSeparate
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glStencilFuncSeparate", ExactSpelling = true)]
+ public extern static void StencilFuncSeparate(Enums.StencilFunction frontfunc, Enums.StencilFunction backfunc, GLint @ref, GLuint mask);
+ #endregion
+
+ #region StencilMask
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glStencilMask", ExactSpelling = true)]
+ public extern static void StencilMask(GLuint mask);
+ #endregion
+
+ #region StencilMaskSeparate
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glStencilMaskSeparate", ExactSpelling = true)]
+ public extern static void StencilMaskSeparate(Enums.VERSION_2_0 face, GLuint mask);
+ #endregion
+
+ #region StencilOp
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glStencilOp", ExactSpelling = true)]
+ public extern static void StencilOp(Enums.StencilOp fail, Enums.StencilOp zfail, Enums.StencilOp zpass);
+ #endregion
+
+ #region StencilOpSeparate
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glStencilOpSeparate", ExactSpelling = true)]
+ public extern static void StencilOpSeparate(Enums.VERSION_2_0 face, Enums.StencilOp sfail, Enums.StencilOp dpfail, Enums.StencilOp dppass);
+ #endregion
+
+ #region TexCoord1d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1d", ExactSpelling = true)]
+ public extern static void TexCoord1d(GLdouble s);
+ #endregion
+
+ #region TexCoord1dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1dv", ExactSpelling = true)]
+ public extern static void TexCoord1dv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord1f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1f", ExactSpelling = true)]
+ public extern static void TexCoord1f(GLfloat s);
+ #endregion
+
+ #region TexCoord1fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1fv", ExactSpelling = true)]
+ public extern static void TexCoord1fv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord1i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1i", ExactSpelling = true)]
+ public extern static void TexCoord1i(GLint s);
+ #endregion
+
+ #region TexCoord1iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1iv", ExactSpelling = true)]
+ public extern static void TexCoord1iv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord1s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1s", ExactSpelling = true)]
+ public extern static void TexCoord1s(GLshort s);
+ #endregion
+
+ #region TexCoord1sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord1sv", ExactSpelling = true)]
+ public extern static void TexCoord1sv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2d", ExactSpelling = true)]
+ public extern static void TexCoord2d(GLdouble s, GLdouble t);
+ #endregion
+
+ #region TexCoord2dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2dv", ExactSpelling = true)]
+ public extern static void TexCoord2dv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2f", ExactSpelling = true)]
+ public extern static void TexCoord2f(GLfloat s, GLfloat t);
+ #endregion
+
+ #region TexCoord2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2fv", ExactSpelling = true)]
+ public extern static void TexCoord2fv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord2i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2i", ExactSpelling = true)]
+ public extern static void TexCoord2i(GLint s, GLint t);
+ #endregion
+
+ #region TexCoord2iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2iv", ExactSpelling = true)]
+ public extern static void TexCoord2iv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord2s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2s", ExactSpelling = true)]
+ public extern static void TexCoord2s(GLshort s, GLshort t);
+ #endregion
+
+ #region TexCoord2sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord2sv", ExactSpelling = true)]
+ public extern static void TexCoord2sv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3d", ExactSpelling = true)]
+ public extern static void TexCoord3d(GLdouble s, GLdouble t, GLdouble r);
+ #endregion
+
+ #region TexCoord3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3dv", ExactSpelling = true)]
+ public extern static void TexCoord3dv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3f", ExactSpelling = true)]
+ public extern static void TexCoord3f(GLfloat s, GLfloat t, GLfloat r);
+ #endregion
+
+ #region TexCoord3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3fv", ExactSpelling = true)]
+ public extern static void TexCoord3fv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3i", ExactSpelling = true)]
+ public extern static void TexCoord3i(GLint s, GLint t, GLint r);
+ #endregion
+
+ #region TexCoord3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3iv", ExactSpelling = true)]
+ public extern static void TexCoord3iv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3s", ExactSpelling = true)]
+ public extern static void TexCoord3s(GLshort s, GLshort t, GLshort r);
+ #endregion
+
+ #region TexCoord3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord3sv", ExactSpelling = true)]
+ public extern static void TexCoord3sv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord4d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4d", ExactSpelling = true)]
+ public extern static void TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
+ #endregion
+
+ #region TexCoord4dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4dv", ExactSpelling = true)]
+ public extern static void TexCoord4dv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord4f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4f", ExactSpelling = true)]
+ public extern static void TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
+ #endregion
+
+ #region TexCoord4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4fv", ExactSpelling = true)]
+ public extern static void TexCoord4fv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord4i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4i", ExactSpelling = true)]
+ public extern static void TexCoord4i(GLint s, GLint t, GLint r, GLint q);
+ #endregion
+
+ #region TexCoord4iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4iv", ExactSpelling = true)]
+ public extern static void TexCoord4iv(System.IntPtr v);
+ #endregion
+
+ #region TexCoord4s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4s", ExactSpelling = true)]
+ public extern static void TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);
+ #endregion
+
+ #region TexCoord4sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoord4sv", ExactSpelling = true)]
+ public extern static void TexCoord4sv(System.IntPtr v);
+ #endregion
+
+ #region TexCoordPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexCoordPointer", ExactSpelling = true)]
+ public extern static void TexCoordPointer(GLint size, Enums.TexCoordPointerType type, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region TexEnvf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexEnvf", ExactSpelling = true)]
+ public extern static void TexEnvf(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLfloat param);
+ #endregion
+
+ #region TexEnvfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexEnvfv", ExactSpelling = true)]
+ public extern static void TexEnvfv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region TexEnvi
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexEnvi", ExactSpelling = true)]
+ public extern static void TexEnvi(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, GLint param);
+ #endregion
+
+ #region TexEnviv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexEnviv", ExactSpelling = true)]
+ public extern static void TexEnviv(Enums.TextureEnvTarget target, Enums.TextureEnvParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region TexGend
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexGend", ExactSpelling = true)]
+ public extern static void TexGend(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLdouble param);
+ #endregion
+
+ #region TexGendv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexGendv", ExactSpelling = true)]
+ public extern static void TexGendv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region TexGenf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexGenf", ExactSpelling = true)]
+ public extern static void TexGenf(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLfloat param);
+ #endregion
+
+ #region TexGenfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexGenfv", ExactSpelling = true)]
+ public extern static void TexGenfv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region TexGeni
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexGeni", ExactSpelling = true)]
+ public extern static void TexGeni(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, GLint param);
+ #endregion
+
+ #region TexGeniv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexGeniv", ExactSpelling = true)]
+ public extern static void TexGeniv(Enums.TextureCoordName coord, Enums.TextureGenParameter pname, System.IntPtr @params);
+ #endregion
+
+ #region TexImage1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexImage1D", ExactSpelling = true)]
+ public extern static void TexImage1D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region TexImage2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexImage2D", ExactSpelling = true)]
+ public extern static void TexImage2D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region TexImage3D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexImage3D", ExactSpelling = true)]
+ public extern static void TexImage3D(Enums.TextureTarget target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region TexParameterf
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexParameterf", ExactSpelling = true)]
+ public extern static void TexParameterf(Enums.TextureTarget target, Enums.TextureParameterName pname, GLfloat param);
+ #endregion
+
+ #region TexParameterfv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexParameterfv", ExactSpelling = true)]
+ public extern static void TexParameterfv(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params);
+ #endregion
+
+ #region TexParameteri
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexParameteri", ExactSpelling = true)]
+ public extern static void TexParameteri(Enums.TextureTarget target, Enums.TextureParameterName pname, GLint param);
+ #endregion
+
+ #region TexParameteriv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexParameteriv", ExactSpelling = true)]
+ public extern static void TexParameteriv(Enums.TextureTarget target, Enums.TextureParameterName pname, System.IntPtr @params);
+ #endregion
+
+ #region TexSubImage1D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexSubImage1D", ExactSpelling = true)]
+ public extern static void TexSubImage1D(Enums.TextureTarget target, GLint level, GLint xoffset, GLsizei width, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region TexSubImage2D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexSubImage2D", ExactSpelling = true)]
+ public extern static void TexSubImage2D(Enums.TextureTarget target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, Enums.PixelFormat format, Enums.PixelType type, System.IntPtr pixels);
+ #endregion
+
+ #region TexSubImage3D
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTexSubImage3D", ExactSpelling = true)]
+ public extern static 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, System.IntPtr pixels);
+ #endregion
+
+ #region Translated
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTranslated", ExactSpelling = true)]
+ public extern static void Translated(GLdouble x, GLdouble y, GLdouble z);
+ #endregion
+
+ #region Translatef
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glTranslatef", ExactSpelling = true)]
+ public extern static void Translatef(GLfloat x, GLfloat y, GLfloat z);
+ #endregion
+
+ #region Uniform1f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform1f", ExactSpelling = true)]
+ public extern static void Uniform1f(GLint location, GLfloat v0);
+ #endregion
+
+ #region Uniform1fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform1fv", ExactSpelling = true)]
+ public extern static void Uniform1fv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region Uniform1i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform1i", ExactSpelling = true)]
+ public extern static void Uniform1i(GLint location, GLint v0);
+ #endregion
+
+ #region Uniform1iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform1iv", ExactSpelling = true)]
+ public extern static void Uniform1iv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region Uniform2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform2f", ExactSpelling = true)]
+ public extern static void Uniform2f(GLint location, GLfloat v0, GLfloat v1);
+ #endregion
+
+ #region Uniform2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform2fv", ExactSpelling = true)]
+ public extern static void Uniform2fv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region Uniform2i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform2i", ExactSpelling = true)]
+ public extern static void Uniform2i(GLint location, GLint v0, GLint v1);
+ #endregion
+
+ #region Uniform2iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform2iv", ExactSpelling = true)]
+ public extern static void Uniform2iv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region Uniform3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform3f", ExactSpelling = true)]
+ public extern static void Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ #endregion
+
+ #region Uniform3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform3fv", ExactSpelling = true)]
+ public extern static void Uniform3fv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region Uniform3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform3i", ExactSpelling = true)]
+ public extern static void Uniform3i(GLint location, GLint v0, GLint v1, GLint v2);
+ #endregion
+
+ #region Uniform3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform3iv", ExactSpelling = true)]
+ public extern static void Uniform3iv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region Uniform4f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform4f", ExactSpelling = true)]
+ public extern static void Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ #endregion
+
+ #region Uniform4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform4fv", ExactSpelling = true)]
+ public extern static void Uniform4fv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region Uniform4i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform4i", ExactSpelling = true)]
+ public extern static void Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ #endregion
+
+ #region Uniform4iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniform4iv", ExactSpelling = true)]
+ public extern static void Uniform4iv(GLint location, GLsizei count, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix2fv", ExactSpelling = true)]
+ public extern static void UniformMatrix2fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix2x3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix2x3fv", ExactSpelling = true)]
+ public extern static void UniformMatrix2x3fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix2x4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix2x4fv", ExactSpelling = true)]
+ public extern static void UniformMatrix2x4fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix3fv", ExactSpelling = true)]
+ public extern static void UniformMatrix3fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix3x2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix3x2fv", ExactSpelling = true)]
+ public extern static void UniformMatrix3x2fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix3x4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix3x4fv", ExactSpelling = true)]
+ public extern static void UniformMatrix3x4fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix4fv", ExactSpelling = true)]
+ public extern static void UniformMatrix4fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix4x2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix4x2fv", ExactSpelling = true)]
+ public extern static void UniformMatrix4x2fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UniformMatrix4x3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUniformMatrix4x3fv", ExactSpelling = true)]
+ public extern static void UniformMatrix4x3fv(GLint location, GLsizei count, System.Boolean transpose, System.IntPtr value);
+ #endregion
+
+ #region UnmapBuffer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUnmapBuffer", ExactSpelling = true)]
+ public extern static GLboolean UnmapBuffer(Enums.VERSION_1_5 target);
+ #endregion
+
+ #region UseProgram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glUseProgram", ExactSpelling = true)]
+ public extern static void UseProgram(GLuint program);
+ #endregion
+
+ #region ValidateProgram
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glValidateProgram", ExactSpelling = true)]
+ public extern static void ValidateProgram(GLuint program);
+ #endregion
+
+ #region Vertex2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2d", ExactSpelling = true)]
+ public extern static void Vertex2d(GLdouble x, GLdouble y);
+ #endregion
+
+ #region Vertex2dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2dv", ExactSpelling = true)]
+ public extern static void Vertex2dv(System.IntPtr v);
+ #endregion
+
+ #region Vertex2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2f", ExactSpelling = true)]
+ public extern static void Vertex2f(GLfloat x, GLfloat y);
+ #endregion
+
+ #region Vertex2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2fv", ExactSpelling = true)]
+ public extern static void Vertex2fv(System.IntPtr v);
+ #endregion
+
+ #region Vertex2i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2i", ExactSpelling = true)]
+ public extern static void Vertex2i(GLint x, GLint y);
+ #endregion
+
+ #region Vertex2iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2iv", ExactSpelling = true)]
+ public extern static void Vertex2iv(System.IntPtr v);
+ #endregion
+
+ #region Vertex2s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2s", ExactSpelling = true)]
+ public extern static void Vertex2s(GLshort x, GLshort y);
+ #endregion
+
+ #region Vertex2sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex2sv", ExactSpelling = true)]
+ public extern static void Vertex2sv(System.IntPtr v);
+ #endregion
+
+ #region Vertex3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3d", ExactSpelling = true)]
+ public extern static void Vertex3d(GLdouble x, GLdouble y, GLdouble z);
+ #endregion
+
+ #region Vertex3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3dv", ExactSpelling = true)]
+ public extern static void Vertex3dv(System.IntPtr v);
+ #endregion
+
+ #region Vertex3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3f", ExactSpelling = true)]
+ public extern static void Vertex3f(GLfloat x, GLfloat y, GLfloat z);
+ #endregion
+
+ #region Vertex3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3fv", ExactSpelling = true)]
+ public extern static void Vertex3fv(System.IntPtr v);
+ #endregion
+
+ #region Vertex3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3i", ExactSpelling = true)]
+ public extern static void Vertex3i(GLint x, GLint y, GLint z);
+ #endregion
+
+ #region Vertex3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3iv", ExactSpelling = true)]
+ public extern static void Vertex3iv(System.IntPtr v);
+ #endregion
+
+ #region Vertex3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3s", ExactSpelling = true)]
+ public extern static void Vertex3s(GLshort x, GLshort y, GLshort z);
+ #endregion
+
+ #region Vertex3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex3sv", ExactSpelling = true)]
+ public extern static void Vertex3sv(System.IntPtr v);
+ #endregion
+
+ #region Vertex4d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4d", ExactSpelling = true)]
+ public extern static void Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ #endregion
+
+ #region Vertex4dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4dv", ExactSpelling = true)]
+ public extern static void Vertex4dv(System.IntPtr v);
+ #endregion
+
+ #region Vertex4f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4f", ExactSpelling = true)]
+ public extern static void Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ #endregion
+
+ #region Vertex4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4fv", ExactSpelling = true)]
+ public extern static void Vertex4fv(System.IntPtr v);
+ #endregion
+
+ #region Vertex4i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4i", ExactSpelling = true)]
+ public extern static void Vertex4i(GLint x, GLint y, GLint z, GLint w);
+ #endregion
+
+ #region Vertex4iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4iv", ExactSpelling = true)]
+ public extern static void Vertex4iv(System.IntPtr v);
+ #endregion
+
+ #region Vertex4s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4s", ExactSpelling = true)]
+ public extern static void Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w);
+ #endregion
+
+ #region Vertex4sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertex4sv", ExactSpelling = true)]
+ public extern static void Vertex4sv(System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib1d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib1d", ExactSpelling = true)]
+ public extern static void VertexAttrib1d(GLuint index, GLdouble x);
+ #endregion
+
+ #region VertexAttrib1dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib1dv", ExactSpelling = true)]
+ public extern static void VertexAttrib1dv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib1f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib1f", ExactSpelling = true)]
+ public extern static void VertexAttrib1f(GLuint index, GLfloat x);
+ #endregion
+
+ #region VertexAttrib1fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib1fv", ExactSpelling = true)]
+ public extern static void VertexAttrib1fv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib1s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib1s", ExactSpelling = true)]
+ public extern static void VertexAttrib1s(GLuint index, GLshort x);
+ #endregion
+
+ #region VertexAttrib1sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib1sv", ExactSpelling = true)]
+ public extern static void VertexAttrib1sv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib2d", ExactSpelling = true)]
+ public extern static void VertexAttrib2d(GLuint index, GLdouble x, GLdouble y);
+ #endregion
+
+ #region VertexAttrib2dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib2dv", ExactSpelling = true)]
+ public extern static void VertexAttrib2dv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib2f", ExactSpelling = true)]
+ public extern static void VertexAttrib2f(GLuint index, GLfloat x, GLfloat y);
+ #endregion
+
+ #region VertexAttrib2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib2fv", ExactSpelling = true)]
+ public extern static void VertexAttrib2fv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib2s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib2s", ExactSpelling = true)]
+ public extern static void VertexAttrib2s(GLuint index, GLshort x, GLshort y);
+ #endregion
+
+ #region VertexAttrib2sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib2sv", ExactSpelling = true)]
+ public extern static void VertexAttrib2sv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib3d", ExactSpelling = true)]
+ public extern static void VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z);
+ #endregion
+
+ #region VertexAttrib3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib3dv", ExactSpelling = true)]
+ public extern static void VertexAttrib3dv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib3f", ExactSpelling = true)]
+ public extern static void VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z);
+ #endregion
+
+ #region VertexAttrib3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib3fv", ExactSpelling = true)]
+ public extern static void VertexAttrib3fv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib3s", ExactSpelling = true)]
+ public extern static void VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z);
+ #endregion
+
+ #region VertexAttrib3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib3sv", ExactSpelling = true)]
+ public extern static void VertexAttrib3sv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4bv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4bv", ExactSpelling = true)]
+ public extern static void VertexAttrib4bv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4d", ExactSpelling = true)]
+ public extern static void VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
+ #endregion
+
+ #region VertexAttrib4dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4dv", ExactSpelling = true)]
+ public extern static void VertexAttrib4dv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4f", ExactSpelling = true)]
+ public extern static void VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+ #endregion
+
+ #region VertexAttrib4fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4fv", ExactSpelling = true)]
+ public extern static void VertexAttrib4fv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4iv", ExactSpelling = true)]
+ public extern static void VertexAttrib4iv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4Nbv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4Nbv", ExactSpelling = true)]
+ public extern static void VertexAttrib4Nbv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4Niv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4Niv", ExactSpelling = true)]
+ public extern static void VertexAttrib4Niv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4Nsv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4Nsv", ExactSpelling = true)]
+ public extern static void VertexAttrib4Nsv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4Nub
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4Nub", ExactSpelling = true)]
+ public extern static void VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
+ #endregion
+
+ #region VertexAttrib4Nubv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4Nubv", ExactSpelling = true)]
+ public extern static void VertexAttrib4Nubv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4Nuiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4Nuiv", ExactSpelling = true)]
+ public extern static void VertexAttrib4Nuiv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4Nusv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4Nusv", ExactSpelling = true)]
+ public extern static void VertexAttrib4Nusv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4s", ExactSpelling = true)]
+ public extern static void VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
+ #endregion
+
+ #region VertexAttrib4sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4sv", ExactSpelling = true)]
+ public extern static void VertexAttrib4sv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4ubv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4ubv", ExactSpelling = true)]
+ public extern static void VertexAttrib4ubv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4uiv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4uiv", ExactSpelling = true)]
+ public extern static void VertexAttrib4uiv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttrib4usv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttrib4usv", ExactSpelling = true)]
+ public extern static void VertexAttrib4usv(GLuint index, System.IntPtr v);
+ #endregion
+
+ #region VertexAttribPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexAttribPointer", ExactSpelling = true)]
+ public extern static void VertexAttribPointer(GLuint index, GLint size, Enums.VERSION_2_0 type, System.Boolean normalized, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region VertexPointer
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glVertexPointer", ExactSpelling = true)]
+ public extern static void VertexPointer(GLint size, Enums.VertexPointerType type, GLsizei stride, System.IntPtr pointer);
+ #endregion
+
+ #region Viewport
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glViewport", ExactSpelling = true)]
+ public extern static void Viewport(GLint x, GLint y, GLsizei width, GLsizei height);
+ #endregion
+
+ #region WindowPos2d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2d", ExactSpelling = true)]
+ public extern static void WindowPos2d(GLdouble x, GLdouble y);
+ #endregion
+
+ #region WindowPos2dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2dv", ExactSpelling = true)]
+ public extern static void WindowPos2dv(System.IntPtr v);
+ #endregion
+
+ #region WindowPos2f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2f", ExactSpelling = true)]
+ public extern static void WindowPos2f(GLfloat x, GLfloat y);
+ #endregion
+
+ #region WindowPos2fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2fv", ExactSpelling = true)]
+ public extern static void WindowPos2fv(System.IntPtr v);
+ #endregion
+
+ #region WindowPos2i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2i", ExactSpelling = true)]
+ public extern static void WindowPos2i(GLint x, GLint y);
+ #endregion
+
+ #region WindowPos2iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2iv", ExactSpelling = true)]
+ public extern static void WindowPos2iv(System.IntPtr v);
+ #endregion
+
+ #region WindowPos2s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2s", ExactSpelling = true)]
+ public extern static void WindowPos2s(GLshort x, GLshort y);
+ #endregion
+
+ #region WindowPos2sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos2sv", ExactSpelling = true)]
+ public extern static void WindowPos2sv(System.IntPtr v);
+ #endregion
+
+ #region WindowPos3d
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3d", ExactSpelling = true)]
+ public extern static void WindowPos3d(GLdouble x, GLdouble y, GLdouble z);
+ #endregion
+
+ #region WindowPos3dv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3dv", ExactSpelling = true)]
+ public extern static void WindowPos3dv(System.IntPtr v);
+ #endregion
+
+ #region WindowPos3f
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3f", ExactSpelling = true)]
+ public extern static void WindowPos3f(GLfloat x, GLfloat y, GLfloat z);
+ #endregion
+
+ #region WindowPos3fv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3fv", ExactSpelling = true)]
+ public extern static void WindowPos3fv(System.IntPtr v);
+ #endregion
+
+ #region WindowPos3i
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3i", ExactSpelling = true)]
+ public extern static void WindowPos3i(GLint x, GLint y, GLint z);
+ #endregion
+
+ #region WindowPos3iv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3iv", ExactSpelling = true)]
+ public extern static void WindowPos3iv(System.IntPtr v);
+ #endregion
+
+ #region WindowPos3s
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3s", ExactSpelling = true)]
+ public extern static void WindowPos3s(GLshort x, GLshort y, GLshort z);
+ #endregion
+
+ #region WindowPos3sv
+ [System.Security.SuppressUnmanagedCodeSecurity()]
+ [DllImport(GL.GL_NATIVE_LIBRARY, EntryPoint = "glWindowPos3sv", ExactSpelling = true)]
+ public extern static void WindowPos3sv(System.IntPtr v);
+ #endregion
+
+ }
+ #endregion
+}
diff --git a/Source/OpenTK/OpenGL/Bindings/GLEnums.cs b/Source/OpenTK/OpenGL/Bindings/GLEnums.cs
new file mode 100644
index 00000000..1dcc7fe0
--- /dev/null
+++ b/Source/OpenTK/OpenGL/Bindings/GLEnums.cs
@@ -0,0 +1,8858 @@
+//------------------------------------------------------------------------------
+//
+// This code was generated by a tool.
+// Runtime Version:2.0.50727.312
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+//------------------------------------------------------------------------------
+
+namespace OpenTK.OpenGL.Enums
+{
+ using System;
+
+ public enum GLenum
+ {
+ CURRENT_BIT = 0x00000001,
+ POINT_BIT = 0x00000002,
+ LINE_BIT = 0x00000004,
+ POLYGON_BIT = 0x00000008,
+ POLYGON_STIPPLE_BIT = 0x00000010,
+ PIXEL_MODE_BIT = 0x00000020,
+ LIGHTING_BIT = 0x00000040,
+ FOG_BIT = 0x00000080,
+ DEPTH_BUFFER_BIT = 0x00000100,
+ ACCUM_BUFFER_BIT = 0x00000200,
+ STENCIL_BUFFER_BIT = 0x00000400,
+ VIEWPORT_BIT = 0x00000800,
+ TRANSFORM_BIT = 0x00001000,
+ ENABLE_BIT = 0x00002000,
+ COLOR_BUFFER_BIT = 0x00004000,
+ HINT_BIT = 0x00008000,
+ EVAL_BIT = 0x00010000,
+ LIST_BIT = 0x00020000,
+ TEXTURE_BIT = 0x00040000,
+ SCISSOR_BIT = 0x00080000,
+ ALL_ATTRIB_BITS = unchecked((Int32)0xFFFFFFFF),
+ CLIENT_PIXEL_STORE_BIT = 0x00000001,
+ CLIENT_VERTEX_ARRAY_BIT = 0x00000002,
+ CLIENT_ALL_ATTRIB_BITS = unchecked((Int32)0xFFFFFFFF),
+ FALSE = 0,
+ TRUE = 1,
+ POINTS = 0x0000,
+ LINES = 0x0001,
+ LINE_LOOP = 0x0002,
+ LINE_STRIP = 0x0003,
+ TRIANGLES = 0x0004,
+ TRIANGLE_STRIP = 0x0005,
+ TRIANGLE_FAN = 0x0006,
+ QUADS = 0x0007,
+ QUAD_STRIP = 0x0008,
+ POLYGON = 0x0009,
+ ACCUM = 0x0100,
+ LOAD = 0x0101,
+ RETURN = 0x0102,
+ MULT = 0x0103,
+ ADD = 0x0104,
+ NEVER = 0x0200,
+ LESS = 0x0201,
+ EQUAL = 0x0202,
+ LEQUAL = 0x0203,
+ GREATER = 0x0204,
+ NOTEQUAL = 0x0205,
+ GEQUAL = 0x0206,
+ ALWAYS = 0x0207,
+ ZERO = 0,
+ ONE = 1,
+ SRC_COLOR = 0x0300,
+ ONE_MINUS_SRC_COLOR = 0x0301,
+ SRC_ALPHA = 0x0302,
+ ONE_MINUS_SRC_ALPHA = 0x0303,
+ DST_ALPHA = 0x0304,
+ ONE_MINUS_DST_ALPHA = 0x0305,
+ CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT,
+ ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT,
+ CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT,
+ ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT,
+ DST_COLOR = 0x0306,
+ ONE_MINUS_DST_COLOR = 0x0307,
+ SRC_ALPHA_SATURATE = 0x0308,
+ LOGIC_OP = GetPName.LOGIC_OP,
+ FUNC_ADD_EXT = EXT_blend_minmax.FUNC_ADD_EXT,
+ MIN_EXT = EXT_blend_minmax.MIN_EXT,
+ MAX_EXT = EXT_blend_minmax.MAX_EXT,
+ FUNC_SUBTRACT_EXT = EXT_blend_subtract.FUNC_SUBTRACT_EXT,
+ FUNC_REVERSE_SUBTRACT_EXT = EXT_blend_subtract.FUNC_REVERSE_SUBTRACT_EXT,
+ ALPHA_MIN_SGIX = SGIX_blend_alpha_minmax.ALPHA_MIN_SGIX,
+ ALPHA_MAX_SGIX = SGIX_blend_alpha_minmax.ALPHA_MAX_SGIX,
+ FRONT = DrawBufferMode.FRONT,
+ BACK = DrawBufferMode.BACK,
+ FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
+ AMBIENT = LightParameter.AMBIENT,
+ DIFFUSE = LightParameter.DIFFUSE,
+ SPECULAR = LightParameter.SPECULAR,
+ EMISSION = MaterialParameter.EMISSION,
+ AMBIENT_AND_DIFFUSE = MaterialParameter.AMBIENT_AND_DIFFUSE,
+ BYTE = DataType.BYTE,
+ UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
+ SHORT = DataType.SHORT,
+ UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
+ INT = DataType.INT,
+ UNSIGNED_INT = DataType.UNSIGNED_INT,
+ FLOAT = DataType.FLOAT,
+ DOUBLE = DataType.DOUBLE,
+ COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI,
+ COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI,
+ COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
+ POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
+ POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.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,
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+ TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
+ PROXY_TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.PROXY_TEXTURE_COLOR_TABLE_SGI,
+ REDUCE_EXT = EXT_convolution.REDUCE_EXT,
+ CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT,
+ CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT,
+ CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT,
+ CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
+ CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
+ NONE = 0,
+ FRONT_LEFT = 0x0400,
+ FRONT_RIGHT = 0x0401,
+ BACK_LEFT = 0x0402,
+ BACK_RIGHT = 0x0403,
+ LEFT = 0x0406,
+ RIGHT = 0x0407,
+ AUX0 = 0x0409,
+ AUX1 = 0x040A,
+ AUX2 = 0x040B,
+ AUX3 = 0x040C,
+ FOG = GetPName.FOG,
+ LIGHTING = GetPName.LIGHTING,
+ TEXTURE_1D = GetPName.TEXTURE_1D,
+ TEXTURE_2D = GetPName.TEXTURE_2D,
+ LINE_STIPPLE = GetPName.LINE_STIPPLE,
+ POLYGON_STIPPLE = GetPName.POLYGON_STIPPLE,
+ CULL_FACE = GetPName.CULL_FACE,
+ ALPHA_TEST = GetPName.ALPHA_TEST,
+ BLEND = GetPName.BLEND,
+ INDEX_LOGIC_OP = GetPName.INDEX_LOGIC_OP,
+ COLOR_LOGIC_OP = GetPName.COLOR_LOGIC_OP,
+ DITHER = GetPName.DITHER,
+ STENCIL_TEST = GetPName.STENCIL_TEST,
+ DEPTH_TEST = GetPName.DEPTH_TEST,
+ CLIP_PLANE0 = GetPName.CLIP_PLANE0,
+ CLIP_PLANE1 = GetPName.CLIP_PLANE1,
+ CLIP_PLANE2 = GetPName.CLIP_PLANE2,
+ CLIP_PLANE3 = GetPName.CLIP_PLANE3,
+ CLIP_PLANE4 = GetPName.CLIP_PLANE4,
+ CLIP_PLANE5 = GetPName.CLIP_PLANE5,
+ LIGHT0 = GetPName.LIGHT0,
+ LIGHT1 = GetPName.LIGHT1,
+ LIGHT2 = GetPName.LIGHT2,
+ LIGHT3 = GetPName.LIGHT3,
+ LIGHT4 = GetPName.LIGHT4,
+ LIGHT5 = GetPName.LIGHT5,
+ LIGHT6 = GetPName.LIGHT6,
+ LIGHT7 = GetPName.LIGHT7,
+ TEXTURE_GEN_S = GetPName.TEXTURE_GEN_S,
+ TEXTURE_GEN_T = GetPName.TEXTURE_GEN_T,
+ TEXTURE_GEN_R = GetPName.TEXTURE_GEN_R,
+ TEXTURE_GEN_Q = GetPName.TEXTURE_GEN_Q,
+ MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3,
+ MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4,
+ MAP1_COLOR_4 = GetPName.MAP1_COLOR_4,
+ MAP1_INDEX = GetPName.MAP1_INDEX,
+ MAP1_NORMAL = GetPName.MAP1_NORMAL,
+ MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1,
+ MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2,
+ MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3,
+ MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4,
+ MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3,
+ MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4,
+ MAP2_COLOR_4 = GetPName.MAP2_COLOR_4,
+ MAP2_INDEX = GetPName.MAP2_INDEX,
+ MAP2_NORMAL = GetPName.MAP2_NORMAL,
+ MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1,
+ MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2,
+ MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3,
+ MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4,
+ POINT_SMOOTH = GetPName.POINT_SMOOTH,
+ LINE_SMOOTH = GetPName.LINE_SMOOTH,
+ POLYGON_SMOOTH = GetPName.POLYGON_SMOOTH,
+ SCISSOR_TEST = GetPName.SCISSOR_TEST,
+ COLOR_MATERIAL = GetPName.COLOR_MATERIAL,
+ NORMALIZE = GetPName.NORMALIZE,
+ AUTO_NORMAL = GetPName.AUTO_NORMAL,
+ POLYGON_OFFSET_POINT = GetPName.POLYGON_OFFSET_POINT,
+ POLYGON_OFFSET_LINE = GetPName.POLYGON_OFFSET_LINE,
+ POLYGON_OFFSET_FILL = GetPName.POLYGON_OFFSET_FILL,
+ VERTEX_ARRAY = GetPName.VERTEX_ARRAY,
+ NORMAL_ARRAY = GetPName.NORMAL_ARRAY,
+ COLOR_ARRAY = GetPName.COLOR_ARRAY,
+ INDEX_ARRAY = GetPName.INDEX_ARRAY,
+ TEXTURE_COORD_ARRAY = GetPName.TEXTURE_COORD_ARRAY,
+ EDGE_FLAG_ARRAY = GetPName.EDGE_FLAG_ARRAY,
+ SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
+ HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
+ MINMAX_EXT = EXT_histogram.MINMAX_EXT,
+ RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT,
+ SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT,
+ TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
+ MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS,
+ SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS,
+ SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS,
+ SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS,
+ TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
+ ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX,
+ ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX,
+ ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX,
+ ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX,
+ CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX,
+ FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX,
+ FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX,
+ FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX,
+ FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
+ FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX,
+ FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX,
+ FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX,
+ FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX,
+ FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX,
+ FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX,
+ FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX,
+ FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX,
+ INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX,
+ IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX,
+ PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX,
+ PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS,
+ REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX,
+ SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX,
+ NO_ERROR = 0,
+ INVALID_ENUM = 0x0500,
+ INVALID_VALUE = 0x0501,
+ INVALID_OPERATION = 0x0502,
+ STACK_OVERFLOW = 0x0503,
+ STACK_UNDERFLOW = 0x0504,
+ OUT_OF_MEMORY = 0x0505,
+ TABLE_TOO_LARGE_EXT = EXT_histogram.TABLE_TOO_LARGE_EXT,
+ TEXTURE_TOO_LARGE_EXT = EXT_texture.TEXTURE_TOO_LARGE_EXT,
+ _2D = 0x0600,
+ _3D = 0x0601,
+ _3D_COLOR = 0x0602,
+ _3D_COLOR_TEXTURE = 0x0603,
+ _4D_COLOR_TEXTURE = 0x0604,
+ PASS_THROUGH_TOKEN = 0x0700,
+ POINT_TOKEN = 0x0701,
+ LINE_TOKEN = 0x0702,
+ POLYGON_TOKEN = 0x0703,
+ BITMAP_TOKEN = 0x0704,
+ DRAW_PIXEL_TOKEN = 0x0705,
+ COPY_PIXEL_TOKEN = 0x0706,
+ LINE_RESET_TOKEN = 0x0707,
+ TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001,
+ GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002,
+ GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX,
+ TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX,
+ LINEAR = TextureMagFilter.LINEAR,
+ EXP = 0x0800,
+ EXP2 = 0x0801,
+ FOG_FUNC_SGIS = SGIS_fog_function.FOG_FUNC_SGIS,
+ FOG_COLOR = GetPName.FOG_COLOR,
+ FOG_DENSITY = GetPName.FOG_DENSITY,
+ FOG_END = GetPName.FOG_END,
+ FOG_INDEX = GetPName.FOG_INDEX,
+ FOG_MODE = GetPName.FOG_MODE,
+ FOG_START = GetPName.FOG_START,
+ FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX,
+ 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_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX,
+ FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX,
+ CW = 0x0900,
+ CCW = 0x0901,
+ COLOR_TABLE_FORMAT_SGI = SGI_color_table.COLOR_TABLE_FORMAT_SGI,
+ COLOR_TABLE_WIDTH_SGI = SGI_color_table.COLOR_TABLE_WIDTH_SGI,
+ COLOR_TABLE_RED_SIZE_SGI = SGI_color_table.COLOR_TABLE_RED_SIZE_SGI,
+ COLOR_TABLE_GREEN_SIZE_SGI = SGI_color_table.COLOR_TABLE_GREEN_SIZE_SGI,
+ COLOR_TABLE_BLUE_SIZE_SGI = SGI_color_table.COLOR_TABLE_BLUE_SIZE_SGI,
+ COLOR_TABLE_ALPHA_SIZE_SGI = SGI_color_table.COLOR_TABLE_ALPHA_SIZE_SGI,
+ COLOR_TABLE_LUMINANCE_SIZE_SGI = SGI_color_table.COLOR_TABLE_LUMINANCE_SIZE_SGI,
+ COLOR_TABLE_INTENSITY_SIZE_SGI = SGI_color_table.COLOR_TABLE_INTENSITY_SIZE_SGI,
+ CONVOLUTION_FORMAT_EXT = EXT_convolution.CONVOLUTION_FORMAT_EXT,
+ CONVOLUTION_WIDTH_EXT = EXT_convolution.CONVOLUTION_WIDTH_EXT,
+ CONVOLUTION_HEIGHT_EXT = EXT_convolution.CONVOLUTION_HEIGHT_EXT,
+ MAX_CONVOLUTION_WIDTH_EXT = EXT_convolution.MAX_CONVOLUTION_WIDTH_EXT,
+ MAX_CONVOLUTION_HEIGHT_EXT = EXT_convolution.MAX_CONVOLUTION_HEIGHT_EXT,
+ HISTOGRAM_WIDTH_EXT = EXT_histogram.HISTOGRAM_WIDTH_EXT,
+ HISTOGRAM_FORMAT_EXT = EXT_histogram.HISTOGRAM_FORMAT_EXT,
+ HISTOGRAM_RED_SIZE_EXT = EXT_histogram.HISTOGRAM_RED_SIZE_EXT,
+ HISTOGRAM_GREEN_SIZE_EXT = EXT_histogram.HISTOGRAM_GREEN_SIZE_EXT,
+ HISTOGRAM_BLUE_SIZE_EXT = EXT_histogram.HISTOGRAM_BLUE_SIZE_EXT,
+ HISTOGRAM_ALPHA_SIZE_EXT = EXT_histogram.HISTOGRAM_ALPHA_SIZE_EXT,
+ HISTOGRAM_LUMINANCE_SIZE_EXT = EXT_histogram.HISTOGRAM_LUMINANCE_SIZE_EXT,
+ HISTOGRAM_SINK_EXT = EXT_histogram.HISTOGRAM_SINK_EXT,
+ COEFF = 0x0A00,
+ ORDER = 0x0A01,
+ DOMAIN = 0x0A02,
+ MINMAX_FORMAT_EXT = EXT_histogram.MINMAX_FORMAT_EXT,
+ MINMAX_SINK_EXT = EXT_histogram.MINMAX_SINK_EXT,
+ PIXEL_MAP_I_TO_I = 0x0C70,
+ PIXEL_MAP_S_TO_S = 0x0C71,
+ PIXEL_MAP_I_TO_R = 0x0C72,
+ PIXEL_MAP_I_TO_G = 0x0C73,
+ PIXEL_MAP_I_TO_B = 0x0C74,
+ PIXEL_MAP_I_TO_A = 0x0C75,
+ PIXEL_MAP_R_TO_R = 0x0C76,
+ PIXEL_MAP_G_TO_G = 0x0C77,
+ PIXEL_MAP_B_TO_B = 0x0C78,
+ PIXEL_MAP_A_TO_A = 0x0C79,
+ VERTEX_ARRAY_POINTER = 0x808E,
+ NORMAL_ARRAY_POINTER = 0x808F,
+ COLOR_ARRAY_POINTER = 0x8090,
+ INDEX_ARRAY_POINTER = 0x8091,
+ TEXTURE_COORD_ARRAY_POINTER = 0x8092,
+ EDGE_FLAG_ARRAY_POINTER = 0x8093,
+ FEEDBACK_BUFFER_POINTER = 0x0DF0,
+ SELECTION_BUFFER_POINTER = 0x0DF3,
+ INSTRUMENT_BUFFER_POINTER_SGIX = SGIX_instruments.INSTRUMENT_BUFFER_POINTER_SGIX,
+ CURRENT_COLOR = 0x0B00,
+ CURRENT_INDEX = 0x0B01,
+ CURRENT_NORMAL = 0x0B02,
+ CURRENT_TEXTURE_COORDS = 0x0B03,
+ CURRENT_RASTER_COLOR = 0x0B04,
+ CURRENT_RASTER_INDEX = 0x0B05,
+ CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
+ CURRENT_RASTER_POSITION = 0x0B07,
+ CURRENT_RASTER_POSITION_VALID = 0x0B08,
+ CURRENT_RASTER_DISTANCE = 0x0B09,
+ POINT_SIZE = 0x0B11,
+ POINT_SIZE_RANGE = 0x0B12,
+ POINT_SIZE_GRANULARITY = 0x0B13,
+ LINE_WIDTH = 0x0B21,
+ LINE_WIDTH_RANGE = 0x0B22,
+ LINE_WIDTH_GRANULARITY = 0x0B23,
+ LINE_STIPPLE_PATTERN = 0x0B25,
+ LINE_STIPPLE_REPEAT = 0x0B26,
+ SMOOTH_POINT_SIZE_RANGE = VERSION_1_2.SMOOTH_POINT_SIZE_RANGE,
+ SMOOTH_POINT_SIZE_GRANULARITY = VERSION_1_2.SMOOTH_POINT_SIZE_GRANULARITY,
+ SMOOTH_LINE_WIDTH_RANGE = VERSION_1_2.SMOOTH_LINE_WIDTH_RANGE,
+ SMOOTH_LINE_WIDTH_GRANULARITY = VERSION_1_2.SMOOTH_LINE_WIDTH_GRANULARITY,
+ ALIASED_POINT_SIZE_RANGE = VERSION_1_2.ALIASED_POINT_SIZE_RANGE,
+ ALIASED_LINE_WIDTH_RANGE = VERSION_1_2.ALIASED_LINE_WIDTH_RANGE,
+ LIST_MODE = 0x0B30,
+ MAX_LIST_NESTING = 0x0B31,
+ LIST_BASE = 0x0B32,
+ LIST_INDEX = 0x0B33,
+ POLYGON_MODE = 0x0B40,
+ EDGE_FLAG = 0x0B43,
+ CULL_FACE_MODE = 0x0B45,
+ FRONT_FACE = 0x0B46,
+ LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
+ LIGHT_MODEL_TWO_SIDE = 0x0B52,
+ LIGHT_MODEL_AMBIENT = 0x0B53,
+ SHADE_MODEL = 0x0B54,
+ COLOR_MATERIAL_FACE = 0x0B55,
+ COLOR_MATERIAL_PARAMETER = 0x0B56,
+ DEPTH_RANGE = 0x0B70,
+ DEPTH_WRITEMASK = 0x0B72,
+ DEPTH_CLEAR_VALUE = 0x0B73,
+ DEPTH_FUNC = 0x0B74,
+ ACCUM_CLEAR_VALUE = 0x0B80,
+ STENCIL_CLEAR_VALUE = 0x0B91,
+ STENCIL_FUNC = 0x0B92,
+ STENCIL_VALUE_MASK = 0x0B93,
+ STENCIL_FAIL = 0x0B94,
+ STENCIL_PASS_DEPTH_FAIL = 0x0B95,
+ STENCIL_PASS_DEPTH_PASS = 0x0B96,
+ STENCIL_REF = 0x0B97,
+ STENCIL_WRITEMASK = 0x0B98,
+ MATRIX_MODE = 0x0BA0,
+ VIEWPORT = 0x0BA2,
+ MODELVIEW_STACK_DEPTH = 0x0BA3,
+ PROJECTION_STACK_DEPTH = 0x0BA4,
+ TEXTURE_STACK_DEPTH = 0x0BA5,
+ MODELVIEW_MATRIX = 0x0BA6,
+ PROJECTION_MATRIX = 0x0BA7,
+ TEXTURE_MATRIX = 0x0BA8,
+ ATTRIB_STACK_DEPTH = 0x0BB0,
+ CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1,
+ ALPHA_TEST_FUNC = 0x0BC1,
+ ALPHA_TEST_REF = 0x0BC2,
+ BLEND_DST = 0x0BE0,
+ BLEND_SRC = 0x0BE1,
+ LOGIC_OP_MODE = 0x0BF0,
+ AUX_BUFFERS = 0x0C00,
+ DRAW_BUFFER = 0x0C01,
+ READ_BUFFER = 0x0C02,
+ SCISSOR_BOX = 0x0C10,
+ INDEX_CLEAR_VALUE = 0x0C20,
+ INDEX_WRITEMASK = 0x0C21,
+ COLOR_CLEAR_VALUE = 0x0C22,
+ COLOR_WRITEMASK = 0x0C23,
+ INDEX_MODE = 0x0C30,
+ RGBA_MODE = 0x0C31,
+ DOUBLEBUFFER = 0x0C32,
+ STEREO = 0x0C33,
+ RENDER_MODE = 0x0C40,
+ PERSPECTIVE_CORRECTION_HINT = 0x0C50,
+ POINT_SMOOTH_HINT = 0x0C51,
+ LINE_SMOOTH_HINT = 0x0C52,
+ POLYGON_SMOOTH_HINT = 0x0C53,
+ FOG_HINT = 0x0C54,
+ PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
+ PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
+ PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
+ PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
+ PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
+ PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
+ PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
+ PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
+ PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
+ PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
+ UNPACK_SWAP_BYTES = 0x0CF0,
+ UNPACK_LSB_FIRST = 0x0CF1,
+ UNPACK_ROW_LENGTH = 0x0CF2,
+ UNPACK_SKIP_ROWS = 0x0CF3,
+ UNPACK_SKIP_PIXELS = 0x0CF4,
+ UNPACK_ALIGNMENT = 0x0CF5,
+ PACK_SWAP_BYTES = 0x0D00,
+ PACK_LSB_FIRST = 0x0D01,
+ PACK_ROW_LENGTH = 0x0D02,
+ PACK_SKIP_ROWS = 0x0D03,
+ PACK_SKIP_PIXELS = 0x0D04,
+ PACK_ALIGNMENT = 0x0D05,
+ MAP_COLOR = 0x0D10,
+ MAP_STENCIL = 0x0D11,
+ INDEX_SHIFT = 0x0D12,
+ INDEX_OFFSET = 0x0D13,
+ RED_SCALE = 0x0D14,
+ RED_BIAS = 0x0D15,
+ ZOOM_X = 0x0D16,
+ ZOOM_Y = 0x0D17,
+ GREEN_SCALE = 0x0D18,
+ GREEN_BIAS = 0x0D19,
+ BLUE_SCALE = 0x0D1A,
+ BLUE_BIAS = 0x0D1B,
+ ALPHA_SCALE = 0x0D1C,
+ ALPHA_BIAS = 0x0D1D,
+ DEPTH_SCALE = 0x0D1E,
+ DEPTH_BIAS = 0x0D1F,
+ MAX_EVAL_ORDER = 0x0D30,
+ MAX_LIGHTS = 0x0D31,
+ MAX_CLIP_PLANES = 0x0D32,
+ MAX_TEXTURE_SIZE = 0x0D33,
+ MAX_PIXEL_MAP_TABLE = 0x0D34,
+ MAX_ATTRIB_STACK_DEPTH = 0x0D35,
+ MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
+ MAX_NAME_STACK_DEPTH = 0x0D37,
+ MAX_PROJECTION_STACK_DEPTH = 0x0D38,
+ MAX_TEXTURE_STACK_DEPTH = 0x0D39,
+ MAX_VIEWPORT_DIMS = 0x0D3A,
+ MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
+ SUBPIXEL_BITS = 0x0D50,
+ INDEX_BITS = 0x0D51,
+ RED_BITS = 0x0D52,
+ GREEN_BITS = 0x0D53,
+ BLUE_BITS = 0x0D54,
+ ALPHA_BITS = 0x0D55,
+ DEPTH_BITS = 0x0D56,
+ STENCIL_BITS = 0x0D57,
+ ACCUM_RED_BITS = 0x0D58,
+ ACCUM_GREEN_BITS = 0x0D59,
+ ACCUM_BLUE_BITS = 0x0D5A,
+ ACCUM_ALPHA_BITS = 0x0D5B,
+ NAME_STACK_DEPTH = 0x0D70,
+ MAP1_GRID_DOMAIN = 0x0DD0,
+ MAP1_GRID_SEGMENTS = 0x0DD1,
+ MAP2_GRID_DOMAIN = 0x0DD2,
+ MAP2_GRID_SEGMENTS = 0x0DD3,
+ FEEDBACK_BUFFER_SIZE = 0x0DF1,
+ FEEDBACK_BUFFER_TYPE = 0x0DF2,
+ SELECTION_BUFFER_SIZE = 0x0DF4,
+ POLYGON_OFFSET_UNITS = 0x2A00,
+ POLYGON_OFFSET_FACTOR = 0x8038,
+ TEXTURE_BINDING_1D = 0x8068,
+ TEXTURE_BINDING_2D = 0x8069,
+ TEXTURE_BINDING_3D = 0x806A,
+ VERTEX_ARRAY_SIZE = 0x807A,
+ VERTEX_ARRAY_TYPE = 0x807B,
+ VERTEX_ARRAY_STRIDE = 0x807C,
+ NORMAL_ARRAY_TYPE = 0x807E,
+ NORMAL_ARRAY_STRIDE = 0x807F,
+ COLOR_ARRAY_SIZE = 0x8081,
+ COLOR_ARRAY_TYPE = 0x8082,
+ COLOR_ARRAY_STRIDE = 0x8083,
+ INDEX_ARRAY_TYPE = 0x8085,
+ INDEX_ARRAY_STRIDE = 0x8086,
+ TEXTURE_COORD_ARRAY_SIZE = 0x8088,
+ TEXTURE_COORD_ARRAY_TYPE = 0x8089,
+ TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
+ EDGE_FLAG_ARRAY_STRIDE = 0x808C,
+ LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL,
+ BLEND_COLOR_EXT = EXT_blend_color.BLEND_COLOR_EXT,
+ BLEND_EQUATION_EXT = EXT_blend_minmax.BLEND_EQUATION_EXT,
+ PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT,
+ UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT,
+ POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT,
+ POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT,
+ POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT,
+ POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT,
+ POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT,
+ POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT,
+ POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT,
+ POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT,
+ POLYGON_OFFSET_BIAS_EXT = EXT_polygon_offset.POLYGON_OFFSET_BIAS_EXT,
+ TEXTURE_3D_BINDING_EXT = EXT_texture_object.TEXTURE_3D_BINDING_EXT,
+ PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT,
+ PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT,
+ UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT,
+ UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT,
+ MAX_3D_TEXTURE_SIZE_EXT = EXT_texture3D.MAX_3D_TEXTURE_SIZE_EXT,
+ VERTEX_ARRAY_COUNT_EXT = EXT_vertex_array.VERTEX_ARRAY_COUNT_EXT,
+ NORMAL_ARRAY_COUNT_EXT = EXT_vertex_array.NORMAL_ARRAY_COUNT_EXT,
+ COLOR_ARRAY_COUNT_EXT = EXT_vertex_array.COLOR_ARRAY_COUNT_EXT,
+ INDEX_ARRAY_COUNT_EXT = EXT_vertex_array.INDEX_ARRAY_COUNT_EXT,
+ TEXTURE_COORD_ARRAY_COUNT_EXT = EXT_vertex_array.TEXTURE_COORD_ARRAY_COUNT_EXT,
+ EDGE_FLAG_ARRAY_COUNT_EXT = EXT_vertex_array.EDGE_FLAG_ARRAY_COUNT_EXT,
+ DETAIL_TEXTURE_2D_BINDING_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_BINDING_SGIS,
+ FOG_FUNC_POINTS_SGIS = SGIS_fog_function.FOG_FUNC_POINTS_SGIS,
+ MAX_FOG_FUNC_POINTS_SGIS = SGIS_fog_function.MAX_FOG_FUNC_POINTS_SGIS,
+ GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS,
+ SAMPLE_BUFFERS_SGIS = SGIS_multisample.SAMPLE_BUFFERS_SGIS,
+ SAMPLES_SGIS = SGIS_multisample.SAMPLES_SGIS,
+ SAMPLE_MASK_VALUE_SGIS = SGIS_multisample.SAMPLE_MASK_VALUE_SGIS,
+ SAMPLE_MASK_INVERT_SGIS = SGIS_multisample.SAMPLE_MASK_INVERT_SGIS,
+ SAMPLE_PATTERN_SGIS = SGIS_multisample.SAMPLE_PATTERN_SGIS,
+ POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_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,
+ DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS,
+ PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS,
+ PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS,
+ UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS,
+ UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS,
+ MAX_4D_TEXTURE_SIZE_SGIS = SGIS_texture4D.MAX_4D_TEXTURE_SIZE_SGIS,
+ TEXTURE_4D_BINDING_SGIS = SGIS_texture4D.TEXTURE_4D_BINDING_SGIS,
+ ASYNC_MARKER_SGIX = SGIX_async.ASYNC_MARKER_SGIX,
+ MAX_ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.MAX_ASYNC_HISTOGRAM_SGIX,
+ MAX_ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.MAX_ASYNC_TEX_IMAGE_SGIX,
+ MAX_ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_DRAW_PIXELS_SGIX,
+ MAX_ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_READ_PIXELS_SGIX,
+ MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+ MAX_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_DEPTH_SGIX,
+ CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX,
+ FRAGMENT_COLOR_MATERIAL_FACE_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_FACE_SGIX,
+ FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX,
+ MAX_FRAGMENT_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_FRAGMENT_LIGHTS_SGIX,
+ MAX_ACTIVE_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_ACTIVE_LIGHTS_SGIX,
+ LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX,
+ FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.FRAMEZOOM_FACTOR_SGIX,
+ MAX_FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.MAX_FRAMEZOOM_FACTOR_SGIX,
+ INSTRUMENT_MEASUREMENTS_SGIX = SGIX_instruments.INSTRUMENT_MEASUREMENTS_SGIX,
+ PIXEL_TEX_GEN_MODE_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_MODE_SGIX,
+ PIXEL_TILE_BEST_ALIGNMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_BEST_ALIGNMENT_SGIX,
+ PIXEL_TILE_CACHE_INCREMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_INCREMENT_SGIX,
+ PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX,
+ PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX,
+ PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX,
+ PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX,
+ PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX,
+ PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX,
+ DEFORMATIONS_MASK_SGIX = SGIX_polynomial_ffd.DEFORMATIONS_MASK_SGIX,
+ REFERENCE_PLANE_EQUATION_SGIX = SGIX_reference_plane.REFERENCE_PLANE_EQUATION_SGIX,
+ SPRITE_MODE_SGIX = SGIX_sprite.SPRITE_MODE_SGIX,
+ SPRITE_AXIS_SGIX = SGIX_sprite.SPRITE_AXIS_SGIX,
+ SPRITE_TRANSLATION_SGIX = SGIX_sprite.SPRITE_TRANSLATION_SGIX,
+ PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX,
+ UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX,
+ PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX,
+ UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX,
+ POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_RANGE_SGIX,
+ 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,
+ VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX,
+ COLOR_MATRIX_SGI = SGI_color_matrix.COLOR_MATRIX_SGI,
+ COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.COLOR_MATRIX_STACK_DEPTH_SGI,
+ MAX_COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.MAX_COLOR_MATRIX_STACK_DEPTH_SGI,
+ POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI,
+ POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI,
+ POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI,
+ POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI,
+ POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI,
+ POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI,
+ POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI,
+ POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI,
+ TEXTURE_MAG_FILTER = TextureParameterName.TEXTURE_MAG_FILTER,
+ TEXTURE_MIN_FILTER = TextureParameterName.TEXTURE_MIN_FILTER,
+ TEXTURE_WRAP_S = TextureParameterName.TEXTURE_WRAP_S,
+ TEXTURE_WRAP_T = TextureParameterName.TEXTURE_WRAP_T,
+ TEXTURE_WIDTH = 0x1000,
+ TEXTURE_HEIGHT = 0x1001,
+ TEXTURE_INTERNAL_FORMAT = 0x1003,
+ TEXTURE_COMPONENTS = 0x1003,
+ TEXTURE_BORDER_COLOR = 0x1004,
+ TEXTURE_BORDER = 0x1005,
+ TEXTURE_RED_SIZE = 0x805C,
+ TEXTURE_GREEN_SIZE = 0x805D,
+ TEXTURE_BLUE_SIZE = 0x805E,
+ TEXTURE_ALPHA_SIZE = 0x805F,
+ TEXTURE_LUMINANCE_SIZE = 0x8060,
+ TEXTURE_INTENSITY_SIZE = 0x8061,
+ TEXTURE_PRIORITY = 0x8066,
+ TEXTURE_RESIDENT = 0x8067,
+ TEXTURE_DEPTH_EXT = EXT_texture3D.TEXTURE_DEPTH_EXT,
+ TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT,
+ DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS,
+ DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS,
+ DETAIL_TEXTURE_FUNC_POINTS_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_FUNC_POINTS_SGIS,
+ GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS,
+ SHARPEN_TEXTURE_FUNC_POINTS_SGIS = SGIS_sharpen_texture.SHARPEN_TEXTURE_FUNC_POINTS_SGIS,
+ TEXTURE_FILTER4_SIZE_SGIS = SGIS_texture_filter4.TEXTURE_FILTER4_SIZE_SGIS,
+ TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS,
+ TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS,
+ TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS,
+ TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS,
+ DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS,
+ QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS,
+ TEXTURE_4DSIZE_SGIS = SGIS_texture4D.TEXTURE_4DSIZE_SGIS,
+ TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS,
+ TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX,
+ TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX,
+ TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX,
+ TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+ TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX,
+ TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX,
+ TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX,
+ 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,
+ SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX,
+ TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX,
+ TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX,
+ TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX,
+ TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX,
+ TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX,
+ TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX,
+ POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX,
+ POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX,
+ DONT_CARE = 0x1100,
+ FASTEST = 0x1101,
+ NICEST = 0x1102,
+ TEXTURE_MULTI_BUFFER_HINT_SGIX = SGIX_texture_multi_buffer.TEXTURE_MULTI_BUFFER_HINT_SGIX,
+ PROXY_HISTOGRAM_EXT = EXT_histogram.PROXY_HISTOGRAM_EXT,
+ REPLACE = StencilOp.REPLACE,
+ MODULATE = TextureEnvMode.MODULATE,
+ SINGLE_COLOR = VERSION_1_2.SINGLE_COLOR,
+ SEPARATE_SPECULAR_COLOR = VERSION_1_2.SEPARATE_SPECULAR_COLOR,
+ POSITION = 0x1203,
+ SPOT_DIRECTION = 0x1204,
+ SPOT_EXPONENT = 0x1205,
+ SPOT_CUTOFF = 0x1206,
+ CONSTANT_ATTENUATION = 0x1207,
+ LINEAR_ATTENUATION = 0x1208,
+ QUADRATIC_ATTENUATION = 0x1209,
+ COMPILE = 0x1300,
+ COMPILE_AND_EXECUTE = 0x1301,
+ _2_BYTES = 0x1407,
+ _3_BYTES = 0x1408,
+ _4_BYTES = 0x1409,
+ DOUBLE_EXT = 0x140A,
+ LIST_PRIORITY_SGIX = SGIX_list_priority.LIST_PRIORITY_SGIX,
+ CLEAR = 0x1500,
+ AND = 0x1501,
+ AND_REVERSE = 0x1502,
+ COPY = 0x1503,
+ AND_INVERTED = 0x1504,
+ NOOP = 0x1505,
+ XOR = 0x1506,
+ OR = 0x1507,
+ NOR = 0x1508,
+ EQUIV = 0x1509,
+ INVERT = 0x150A,
+ OR_REVERSE = 0x150B,
+ COPY_INVERTED = 0x150C,
+ OR_INVERTED = 0x150D,
+ NAND = 0x150E,
+ SET = 0x150F,
+ SHININESS = 0x1601,
+ COLOR_INDEXES = 0x1603,
+ MODELVIEW = 0x1700,
+ PROJECTION = 0x1701,
+ TEXTURE = 0x1702,
+ POINT = PolygonMode.POINT,
+ LINE = PolygonMode.LINE,
+ FILL = PolygonMode.FILL,
+ COLOR = 0x1800,
+ DEPTH = 0x1801,
+ STENCIL = 0x1802,
+ COLOR_INDEX = 0x1900,
+ STENCIL_INDEX = 0x1901,
+ DEPTH_COMPONENT = 0x1902,
+ RED = 0x1903,
+ GREEN = 0x1904,
+ BLUE = 0x1905,
+ ALPHA = 0x1906,
+ RGB = 0x1907,
+ RGBA = 0x1908,
+ LUMINANCE = 0x1909,
+ LUMINANCE_ALPHA = 0x190A,
+ ABGR_EXT = EXT_abgr.ABGR_EXT,
+ CMYK_EXT = EXT_cmyka.CMYK_EXT,
+ CMYKA_EXT = EXT_cmyka.CMYKA_EXT,
+ R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX,
+ R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX,
+ ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX,
+ LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX,
+ LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX,
+ YCRCB_422_SGIX = SGIX_ycrcb.YCRCB_422_SGIX,
+ YCRCB_444_SGIX = SGIX_ycrcb.YCRCB_444_SGIX,
+ RESAMPLE_REPLICATE_SGIX = SGIX_resample.RESAMPLE_REPLICATE_SGIX,
+ RESAMPLE_ZERO_FILL_SGIX = SGIX_resample.RESAMPLE_ZERO_FILL_SGIX,
+ RESAMPLE_DECIMATE_SGIX = SGIX_resample.RESAMPLE_DECIMATE_SGIX,
+ PIXEL_SUBSAMPLE_4444_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4444_SGIX,
+ PIXEL_SUBSAMPLE_2424_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_2424_SGIX,
+ PIXEL_SUBSAMPLE_4242_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4242_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,
+ PIXEL_TEX_GEN_ALPHA_MS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_MS_SGIX,
+ PIXEL_TEX_GEN_ALPHA_LS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_LS_SGIX,
+ 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,
+ BITMAP = 0x1A00,
+ UNSIGNED_BYTE_3_3_2_EXT = EXT_packed_pixels.UNSIGNED_BYTE_3_3_2_EXT,
+ UNSIGNED_SHORT_4_4_4_4_EXT = EXT_packed_pixels.UNSIGNED_SHORT_4_4_4_4_EXT,
+ UNSIGNED_SHORT_5_5_5_1_EXT = EXT_packed_pixels.UNSIGNED_SHORT_5_5_5_1_EXT,
+ UNSIGNED_INT_8_8_8_8_EXT = EXT_packed_pixels.UNSIGNED_INT_8_8_8_8_EXT,
+ UNSIGNED_INT_10_10_10_2_EXT = EXT_packed_pixels.UNSIGNED_INT_10_10_10_2_EXT,
+ RENDER = 0x1C00,
+ FEEDBACK = 0x1C01,
+ SELECT = 0x1C02,
+ _1PASS_SGIS = SGIS_multisample._1PASS_SGIS,
+ _2PASS_0_SGIS = SGIS_multisample._2PASS_0_SGIS,
+ _2PASS_1_SGIS = SGIS_multisample._2PASS_1_SGIS,
+ _4PASS_0_SGIS = SGIS_multisample._4PASS_0_SGIS,
+ _4PASS_1_SGIS = SGIS_multisample._4PASS_1_SGIS,
+ _4PASS_2_SGIS = SGIS_multisample._4PASS_2_SGIS,
+ _4PASS_3_SGIS = SGIS_multisample._4PASS_3_SGIS,
+ FLAT = 0x1D00,
+ SMOOTH = 0x1D01,
+ KEEP = 0x1E00,
+ INCR = 0x1E02,
+ DECR = 0x1E03,
+ VENDOR = 0x1F00,
+ RENDERER = 0x1F01,
+ VERSION = 0x1F02,
+ EXTENSIONS = 0x1F03,
+ S = 0x2000,
+ T = 0x2001,
+ R = 0x2002,
+ Q = 0x2003,
+ DECAL = 0x2101,
+ REPLACE_EXT = EXT_texture.REPLACE_EXT,
+ TEXTURE_ENV_BIAS_SGIX = SGIX_texture_add_env.TEXTURE_ENV_BIAS_SGIX,
+ TEXTURE_ENV_MODE = 0x2200,
+ TEXTURE_ENV_COLOR = 0x2201,
+ TEXTURE_ENV = 0x2300,
+ FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
+ EYE_LINEAR = 0x2400,
+ OBJECT_LINEAR = 0x2401,
+ SPHERE_MAP = 0x2402,
+ EYE_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_POINT_SGIS,
+ OBJECT_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_POINT_SGIS,
+ EYE_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_LINE_SGIS,
+ OBJECT_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_LINE_SGIS,
+ TEXTURE_GEN_MODE = 0x2500,
+ OBJECT_PLANE = 0x2501,
+ EYE_PLANE = 0x2502,
+ EYE_POINT_SGIS = SGIS_point_line_texgen.EYE_POINT_SGIS,
+ OBJECT_POINT_SGIS = SGIS_point_line_texgen.OBJECT_POINT_SGIS,
+ EYE_LINE_SGIS = SGIS_point_line_texgen.EYE_LINE_SGIS,
+ OBJECT_LINE_SGIS = SGIS_point_line_texgen.OBJECT_LINE_SGIS,
+ NEAREST = 0x2600,
+ LINEAR_DETAIL_SGIS = SGIS_detail_texture.LINEAR_DETAIL_SGIS,
+ LINEAR_DETAIL_ALPHA_SGIS = SGIS_detail_texture.LINEAR_DETAIL_ALPHA_SGIS,
+ LINEAR_DETAIL_COLOR_SGIS = SGIS_detail_texture.LINEAR_DETAIL_COLOR_SGIS,
+ LINEAR_SHARPEN_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_SGIS,
+ LINEAR_SHARPEN_ALPHA_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_ALPHA_SGIS,
+ LINEAR_SHARPEN_COLOR_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_COLOR_SGIS,
+ PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX,
+ PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX,
+ PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX,
+ NEAREST_MIPMAP_NEAREST = 0x2700,
+ LINEAR_MIPMAP_NEAREST = 0x2701,
+ NEAREST_MIPMAP_LINEAR = 0x2702,
+ LINEAR_MIPMAP_LINEAR = 0x2703,
+ LINEAR_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_LINEAR_SGIX,
+ NEAREST_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_NEAREST_SGIX,
+ NEAREST_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_LINEAR_SGIX,
+ LINEAR_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_NEAREST_SGIX,
+ PROXY_TEXTURE_1D = 0x8063,
+ PROXY_TEXTURE_2D = 0x8064,
+ PROXY_TEXTURE_3D_EXT = EXT_texture3D.PROXY_TEXTURE_3D_EXT,
+ DETAIL_TEXTURE_2D_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_SGIS,
+ PROXY_TEXTURE_4D_SGIS = SGIS_texture4D.PROXY_TEXTURE_4D_SGIS,
+ CLAMP = 0x2900,
+ REPEAT = 0x2901,
+ CLAMP_TO_BORDER_SGIS = SGIS_texture_border_clamp.CLAMP_TO_BORDER_SGIS,
+ CLAMP_TO_EDGE_SGIS = SGIS_texture_edge_clamp.CLAMP_TO_EDGE_SGIS,
+ R3_G3_B2 = 0x2A10,
+ ALPHA4 = 0x803B,
+ ALPHA8 = 0x803C,
+ ALPHA12 = 0x803D,
+ ALPHA16 = 0x803E,
+ LUMINANCE4 = 0x803F,
+ LUMINANCE8 = 0x8040,
+ LUMINANCE12 = 0x8041,
+ LUMINANCE16 = 0x8042,
+ LUMINANCE4_ALPHA4 = 0x8043,
+ LUMINANCE6_ALPHA2 = 0x8044,
+ LUMINANCE8_ALPHA8 = 0x8045,
+ LUMINANCE12_ALPHA4 = 0x8046,
+ LUMINANCE12_ALPHA12 = 0x8047,
+ LUMINANCE16_ALPHA16 = 0x8048,
+ INTENSITY = 0x8049,
+ INTENSITY4 = 0x804A,
+ INTENSITY8 = 0x804B,
+ INTENSITY12 = 0x804C,
+ INTENSITY16 = 0x804D,
+ RGB4 = 0x804F,
+ RGB5 = 0x8050,
+ RGB8 = 0x8051,
+ RGB10 = 0x8052,
+ RGB12 = 0x8053,
+ RGB16 = 0x8054,
+ RGBA2 = 0x8055,
+ RGBA4 = 0x8056,
+ RGB5_A1 = 0x8057,
+ RGBA8 = 0x8058,
+ RGB10_A2 = 0x8059,
+ RGBA12 = 0x805A,
+ RGBA16 = 0x805B,
+ RGB2_EXT = EXT_texture.RGB2_EXT,
+ DUAL_ALPHA4_SGIS = SGIS_texture_select.DUAL_ALPHA4_SGIS,
+ DUAL_ALPHA8_SGIS = SGIS_texture_select.DUAL_ALPHA8_SGIS,
+ DUAL_ALPHA12_SGIS = SGIS_texture_select.DUAL_ALPHA12_SGIS,
+ DUAL_ALPHA16_SGIS = SGIS_texture_select.DUAL_ALPHA16_SGIS,
+ DUAL_LUMINANCE4_SGIS = SGIS_texture_select.DUAL_LUMINANCE4_SGIS,
+ DUAL_LUMINANCE8_SGIS = SGIS_texture_select.DUAL_LUMINANCE8_SGIS,
+ DUAL_LUMINANCE12_SGIS = SGIS_texture_select.DUAL_LUMINANCE12_SGIS,
+ DUAL_LUMINANCE16_SGIS = SGIS_texture_select.DUAL_LUMINANCE16_SGIS,
+ DUAL_INTENSITY4_SGIS = SGIS_texture_select.DUAL_INTENSITY4_SGIS,
+ DUAL_INTENSITY8_SGIS = SGIS_texture_select.DUAL_INTENSITY8_SGIS,
+ DUAL_INTENSITY12_SGIS = SGIS_texture_select.DUAL_INTENSITY12_SGIS,
+ DUAL_INTENSITY16_SGIS = SGIS_texture_select.DUAL_INTENSITY16_SGIS,
+ DUAL_LUMINANCE_ALPHA4_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA4_SGIS,
+ DUAL_LUMINANCE_ALPHA8_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA8_SGIS,
+ QUAD_ALPHA4_SGIS = SGIS_texture_select.QUAD_ALPHA4_SGIS,
+ QUAD_ALPHA8_SGIS = SGIS_texture_select.QUAD_ALPHA8_SGIS,
+ QUAD_LUMINANCE4_SGIS = SGIS_texture_select.QUAD_LUMINANCE4_SGIS,
+ QUAD_LUMINANCE8_SGIS = SGIS_texture_select.QUAD_LUMINANCE8_SGIS,
+ QUAD_INTENSITY4_SGIS = SGIS_texture_select.QUAD_INTENSITY4_SGIS,
+ QUAD_INTENSITY8_SGIS = SGIS_texture_select.QUAD_INTENSITY8_SGIS,
+ DEPTH_COMPONENT16_SGIX = SGIX_depth_texture.DEPTH_COMPONENT16_SGIX,
+ DEPTH_COMPONENT24_SGIX = SGIX_depth_texture.DEPTH_COMPONENT24_SGIX,
+ DEPTH_COMPONENT32_SGIX = SGIX_depth_texture.DEPTH_COMPONENT32_SGIX,
+ RGB_ICC_SGIX = SGIX_icc_texture.RGB_ICC_SGIX,
+ RGBA_ICC_SGIX = SGIX_icc_texture.RGBA_ICC_SGIX,
+ ALPHA_ICC_SGIX = SGIX_icc_texture.ALPHA_ICC_SGIX,
+ LUMINANCE_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ICC_SGIX,
+ INTENSITY_ICC_SGIX = SGIX_icc_texture.INTENSITY_ICC_SGIX,
+ LUMINANCE_ALPHA_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ALPHA_ICC_SGIX,
+ INTENSITY16_ICC_SGIX = SGIX_icc_texture.INTENSITY16_ICC_SGIX,
+ V2F = 0x2A20,
+ V3F = 0x2A21,
+ C4UB_V2F = 0x2A22,
+ C4UB_V3F = 0x2A23,
+ C3F_V3F = 0x2A24,
+ N3F_V3F = 0x2A25,
+ C4F_N3F_V3F = 0x2A26,
+ T2F_V3F = 0x2A27,
+ T4F_V4F = 0x2A28,
+ T2F_C4UB_V3F = 0x2A29,
+ T2F_C3F_V3F = 0x2A2A,
+ T2F_N3F_V3F = 0x2A2B,
+ T2F_C4F_N3F_V3F = 0x2A2C,
+ T4F_C4F_N3F_V4F = 0x2A2D,
+ CONSTANT_COLOR = 0x8001,
+ ONE_MINUS_CONSTANT_COLOR = 0x8002,
+ CONSTANT_ALPHA = 0x8003,
+ ONE_MINUS_CONSTANT_ALPHA = 0x8004,
+ BLEND_COLOR = 0x8005,
+ FUNC_ADD = 0x8006,
+ MIN = 0x8007,
+ MAX = 0x8008,
+ BLEND_EQUATION = 0x8009,
+ FUNC_SUBTRACT = 0x800A,
+ FUNC_REVERSE_SUBTRACT = 0x800B,
+ CONVOLUTION_1D = 0x8010,
+ CONVOLUTION_2D = 0x8011,
+ SEPARABLE_2D = 0x8012,
+ CONVOLUTION_BORDER_MODE = 0x8013,
+ CONVOLUTION_FILTER_SCALE = 0x8014,
+ CONVOLUTION_FILTER_BIAS = 0x8015,
+ REDUCE = 0x8016,
+ CONVOLUTION_FORMAT = 0x8017,
+ CONVOLUTION_WIDTH = 0x8018,
+ CONVOLUTION_HEIGHT = 0x8019,
+ MAX_CONVOLUTION_WIDTH = 0x801A,
+ MAX_CONVOLUTION_HEIGHT = 0x801B,
+ POST_CONVOLUTION_RED_SCALE = 0x801C,
+ POST_CONVOLUTION_GREEN_SCALE = 0x801D,
+ POST_CONVOLUTION_BLUE_SCALE = 0x801E,
+ POST_CONVOLUTION_ALPHA_SCALE = 0x801F,
+ POST_CONVOLUTION_RED_BIAS = 0x8020,
+ POST_CONVOLUTION_GREEN_BIAS = 0x8021,
+ POST_CONVOLUTION_BLUE_BIAS = 0x8022,
+ POST_CONVOLUTION_ALPHA_BIAS = 0x8023,
+ HISTOGRAM = 0x8024,
+ PROXY_HISTOGRAM = 0x8025,
+ HISTOGRAM_WIDTH = 0x8026,
+ HISTOGRAM_FORMAT = 0x8027,
+ HISTOGRAM_RED_SIZE = 0x8028,
+ HISTOGRAM_GREEN_SIZE = 0x8029,
+ HISTOGRAM_BLUE_SIZE = 0x802A,
+ HISTOGRAM_ALPHA_SIZE = 0x802B,
+ HISTOGRAM_LUMINANCE_SIZE = 0x802C,
+ HISTOGRAM_SINK = 0x802D,
+ MINMAX = 0x802E,
+ MINMAX_FORMAT = 0x802F,
+ MINMAX_SINK = 0x8030,
+ TABLE_TOO_LARGE = 0x8031,
+ UNSIGNED_BYTE_3_3_2 = 0x8032,
+ UNSIGNED_SHORT_4_4_4_4 = 0x8033,
+ UNSIGNED_SHORT_5_5_5_1 = 0x8034,
+ UNSIGNED_INT_8_8_8_8 = 0x8035,
+ UNSIGNED_INT_10_10_10_2 = 0x8036,
+ UNSIGNED_BYTE_2_3_3_REV = 0x8362,
+ UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362,
+ UNSIGNED_SHORT_5_6_5 = 0x8363,
+ UNSIGNED_SHORT_5_6_5_EXT = 0x8363,
+ UNSIGNED_SHORT_5_6_5_REV = 0x8364,
+ UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364,
+ UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
+ UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365,
+ UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
+ UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366,
+ UNSIGNED_INT_8_8_8_8_REV = 0x8367,
+ UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367,
+ UNSIGNED_INT_2_10_10_10_REV = 0x8368,
+ UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368,
+ POLYGON_OFFSET_EXT = 0x8037,
+ POLYGON_OFFSET_FACTOR_EXT = 0x8038,
+ RESCALE_NORMAL = 0x803A,
+ ALPHA4_EXT = 0x803B,
+ ALPHA8_EXT = 0x803C,
+ ALPHA12_EXT = 0x803D,
+ ALPHA16_EXT = 0x803E,
+ LUMINANCE4_EXT = 0x803F,
+ LUMINANCE8_EXT = 0x8040,
+ LUMINANCE12_EXT = 0x8041,
+ LUMINANCE16_EXT = 0x8042,
+ LUMINANCE4_ALPHA4_EXT = 0x8043,
+ LUMINANCE6_ALPHA2_EXT = 0x8044,
+ LUMINANCE8_ALPHA8_EXT = 0x8045,
+ LUMINANCE12_ALPHA4_EXT = 0x8046,
+ LUMINANCE12_ALPHA12_EXT = 0x8047,
+ LUMINANCE16_ALPHA16_EXT = 0x8048,
+ INTENSITY_EXT = 0x8049,
+ INTENSITY4_EXT = 0x804A,
+ INTENSITY8_EXT = 0x804B,
+ INTENSITY12_EXT = 0x804C,
+ INTENSITY16_EXT = 0x804D,
+ RGB4_EXT = 0x804F,
+ RGB5_EXT = 0x8050,
+ RGB8_EXT = 0x8051,
+ RGB10_EXT = 0x8052,
+ RGB12_EXT = 0x8053,
+ RGB16_EXT = 0x8054,
+ RGBA2_EXT = 0x8055,
+ RGBA4_EXT = 0x8056,
+ RGB5_A1_EXT = 0x8057,
+ RGBA8_EXT = 0x8058,
+ RGB10_A2_EXT = 0x8059,
+ RGBA12_EXT = 0x805A,
+ RGBA16_EXT = 0x805B,
+ TEXTURE_RED_SIZE_EXT = 0x805C,
+ TEXTURE_GREEN_SIZE_EXT = 0x805D,
+ TEXTURE_BLUE_SIZE_EXT = 0x805E,
+ TEXTURE_ALPHA_SIZE_EXT = 0x805F,
+ TEXTURE_LUMINANCE_SIZE_EXT = 0x8060,
+ TEXTURE_INTENSITY_SIZE_EXT = 0x8061,
+ PROXY_TEXTURE_1D_EXT = 0x8063,
+ PROXY_TEXTURE_2D_EXT = 0x8064,
+ TEXTURE_PRIORITY_EXT = 0x8066,
+ TEXTURE_RESIDENT_EXT = 0x8067,
+ TEXTURE_1D_BINDING_EXT = 0x8068,
+ TEXTURE_2D_BINDING_EXT = 0x8069,
+ PACK_SKIP_IMAGES = 0x806B,
+ PACK_IMAGE_HEIGHT = 0x806C,
+ UNPACK_SKIP_IMAGES = 0x806D,
+ UNPACK_IMAGE_HEIGHT = 0x806E,
+ TEXTURE_3D = 0x806F,
+ PROXY_TEXTURE_3D = 0x8070,
+ TEXTURE_DEPTH = 0x8071,
+ TEXTURE_WRAP_R = 0x8072,
+ MAX_3D_TEXTURE_SIZE = 0x8073,
+ VERTEX_ARRAY_EXT = 0x8074,
+ NORMAL_ARRAY_EXT = 0x8075,
+ COLOR_ARRAY_EXT = 0x8076,
+ INDEX_ARRAY_EXT = 0x8077,
+ TEXTURE_COORD_ARRAY_EXT = 0x8078,
+ EDGE_FLAG_ARRAY_EXT = 0x8079,
+ VERTEX_ARRAY_SIZE_EXT = 0x807A,
+ VERTEX_ARRAY_TYPE_EXT = 0x807B,
+ VERTEX_ARRAY_STRIDE_EXT = 0x807C,
+ NORMAL_ARRAY_TYPE_EXT = 0x807E,
+ NORMAL_ARRAY_STRIDE_EXT = 0x807F,
+ COLOR_ARRAY_SIZE_EXT = 0x8081,
+ COLOR_ARRAY_TYPE_EXT = 0x8082,
+ COLOR_ARRAY_STRIDE_EXT = 0x8083,
+ INDEX_ARRAY_TYPE_EXT = 0x8085,
+ INDEX_ARRAY_STRIDE_EXT = 0x8086,
+ TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
+ TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
+ TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A,
+ EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C,
+ VERTEX_ARRAY_POINTER_EXT = 0x808E,
+ NORMAL_ARRAY_POINTER_EXT = 0x808F,
+ COLOR_ARRAY_POINTER_EXT = 0x8090,
+ INDEX_ARRAY_POINTER_EXT = 0x8091,
+ TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,
+ EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093,
+ MULTISAMPLE = 0x809D,
+ MULTISAMPLE_ARB = 0x809D,
+ SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
+ SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E,
+ SAMPLE_ALPHA_TO_ONE = 0x809F,
+ SAMPLE_ALPHA_TO_ONE_ARB = 0x809F,
+ SAMPLE_COVERAGE = 0x80A0,
+ SAMPLE_COVERAGE_ARB = 0x80A0,
+ SAMPLE_BUFFERS = 0x80A8,
+ SAMPLE_BUFFERS_ARB = 0x80A8,
+ SAMPLES = 0x80A9,
+ SAMPLES_ARB = 0x80A9,
+ SAMPLE_COVERAGE_VALUE = 0x80AA,
+ SAMPLE_COVERAGE_VALUE_ARB = 0x80AA,
+ SAMPLE_COVERAGE_INVERT = 0x80AB,
+ SAMPLE_COVERAGE_INVERT_ARB = 0x80AB,
+ COLOR_MATRIX = 0x80B1,
+ COLOR_MATRIX_STACK_DEPTH = 0x80B2,
+ MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3,
+ POST_COLOR_MATRIX_RED_SCALE = 0x80B4,
+ POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5,
+ POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6,
+ POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7,
+ POST_COLOR_MATRIX_RED_BIAS = 0x80B8,
+ POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9,
+ POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA,
+ POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB,
+ COLOR_TABLE = 0x80D0,
+ POST_CONVOLUTION_COLOR_TABLE = 0x80D1,
+ POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2,
+ PROXY_COLOR_TABLE = 0x80D3,
+ PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
+ COLOR_TABLE_SCALE = 0x80D6,
+ COLOR_TABLE_BIAS = 0x80D7,
+ COLOR_TABLE_FORMAT = 0x80D8,
+ COLOR_TABLE_WIDTH = 0x80D9,
+ COLOR_TABLE_RED_SIZE = 0x80DA,
+ COLOR_TABLE_GREEN_SIZE = 0x80DB,
+ COLOR_TABLE_BLUE_SIZE = 0x80DC,
+ COLOR_TABLE_ALPHA_SIZE = 0x80DD,
+ COLOR_TABLE_LUMINANCE_SIZE = 0x80DE,
+ COLOR_TABLE_INTENSITY_SIZE = 0x80DF,
+ BGR = 0x80E0,
+ BGR_EXT = 0x80E0,
+ BGRA = 0x80E1,
+ BGRA_EXT = 0x80E1,
+ MAX_ELEMENTS_VERTICES = 0x80E8,
+ MAX_ELEMENTS_INDICES = 0x80E9,
+ POINT_SIZE_MIN = 0x8126,
+ POINT_SIZE_MIN_ARB = 0x8126,
+ POINT_SIZE_MIN_EXT = 0x8126,
+ POINT_SIZE_MAX = 0x8127,
+ POINT_SIZE_MAX_ARB = 0x8127,
+ POINT_SIZE_MAX_EXT = 0x8127,
+ POINT_FADE_THRESHOLD_SIZE = 0x8128,
+ POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128,
+ POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128,
+ POINT_DISTANCE_ATTENUATION = 0x8129,
+ POINT_DISTANCE_ATTENUATION_ARB = 0x8129,
+ DISTANCE_ATTENUATION_EXT = 0x8129,
+ CLAMP_TO_BORDER = 0x812D,
+ CLAMP_TO_BORDER_ARB = 0x812D,
+ CLAMP_TO_EDGE = 0x812F,
+ TEXTURE_MIN_LOD = 0x813A,
+ TEXTURE_MAX_LOD = 0x813B,
+ TEXTURE_BASE_LEVEL = 0x813C,
+ TEXTURE_MAX_LEVEL = 0x813D,
+ SPRITE_AXIAL_SGIX = 0x814C,
+ SPRITE_OBJECT_ALIGNED_SGIX = 0x814D,
+ SPRITE_EYE_ALIGNED_SGIX = 0x814E,
+ IGNORE_BORDER_HP = 0x8150,
+ CONSTANT_BORDER = 0x8151,
+ CONSTANT_BORDER_HP = 0x8151,
+ REPLICATE_BORDER = 0x8153,
+ REPLICATE_BORDER_HP = 0x8153,
+ CONVOLUTION_BORDER_COLOR = 0x8154,
+ CONVOLUTION_BORDER_COLOR_HP = 0x8154,
+ GENERATE_MIPMAP = 0x8191,
+ GENERATE_MIPMAP_HINT = 0x8192,
+ MAX_DEFORMATION_ORDER_SGIX = 0x8197,
+ DEPTH_COMPONENT16 = 0x81A5,
+ DEPTH_COMPONENT24 = 0x81A6,
+ DEPTH_COMPONENT32 = 0x81A7,
+ TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF,
+ LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8,
+ SINGLE_COLOR_EXT = 0x81F9,
+ SEPARATE_SPECULAR_COLOR_EXT = 0x81FA,
+ PIXEL_TRANSFORM_2D_EXT = 0x8330,
+ PIXEL_MAG_FILTER_EXT = 0x8331,
+ PIXEL_MIN_FILTER_EXT = 0x8332,
+ PIXEL_CUBIC_WEIGHT_EXT = 0x8333,
+ CUBIC_EXT = 0x8334,
+ AVERAGE_EXT = 0x8335,
+ PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336,
+ MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337,
+ PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338,
+ PIXEL_GROUP_COLOR_SGIS = 0x8356,
+ FOG_FACTOR_TO_ALPHA_SGIX = 0x836F,
+ COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0,
+ COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1,
+ COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2,
+ COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3,
+ PARALLEL_ARRAYS_INTEL = 0x83F4,
+ VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5,
+ NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6,
+ COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7,
+ TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8,
+ CURRENT_RASTER_NORMAL_SGIX = 0x8406,
+ TEXTURE0 = 0x84C0,
+ TEXTURE1 = 0x84C1,
+ TEXTURE2 = 0x84C2,
+ TEXTURE3 = 0x84C3,
+ TEXTURE4 = 0x84C4,
+ TEXTURE5 = 0x84C5,
+ TEXTURE6 = 0x84C6,
+ TEXTURE7 = 0x84C7,
+ TEXTURE8 = 0x84C8,
+ TEXTURE9 = 0x84C9,
+ TEXTURE10 = 0x84CA,
+ TEXTURE11 = 0x84CB,
+ TEXTURE12 = 0x84CC,
+ TEXTURE13 = 0x84CD,
+ TEXTURE14 = 0x84CE,
+ TEXTURE15 = 0x84CF,
+ TEXTURE16 = 0x84D0,
+ TEXTURE17 = 0x84D1,
+ TEXTURE18 = 0x84D2,
+ TEXTURE19 = 0x84D3,
+ TEXTURE20 = 0x84D4,
+ TEXTURE21 = 0x84D5,
+ TEXTURE22 = 0x84D6,
+ TEXTURE23 = 0x84D7,
+ TEXTURE24 = 0x84D8,
+ TEXTURE25 = 0x84D9,
+ TEXTURE26 = 0x84DA,
+ TEXTURE27 = 0x84DB,
+ TEXTURE28 = 0x84DC,
+ TEXTURE29 = 0x84DD,
+ TEXTURE30 = 0x84DE,
+ TEXTURE31 = 0x84DF,
+ ACTIVE_TEXTURE = 0x84E0,
+ CLIENT_ACTIVE_TEXTURE = 0x84E1,
+ MAX_TEXTURE_UNITS = 0x84E2,
+ TRANSPOSE_MODELVIEW_MATRIX = 0x84E3,
+ TRANSPOSE_PROJECTION_MATRIX = 0x84E4,
+ TRANSPOSE_TEXTURE_MATRIX = 0x84E5,
+ TRANSPOSE_COLOR_MATRIX = 0x84E6,
+ MULTISAMPLE_BIT = 0x20000000,
+ NORMAL_MAP = 0x8511,
+ REFLECTION_MAP = 0x8512,
+ TEXTURE_CUBE_MAP = 0x8513,
+ TEXTURE_BINDING_CUBE_MAP = 0x8514,
+ TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515,
+ TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516,
+ TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517,
+ TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518,
+ TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519,
+ TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A,
+ PROXY_TEXTURE_CUBE_MAP = 0x851B,
+ MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C,
+ COMPRESSED_ALPHA = 0x84E9,
+ COMPRESSED_LUMINANCE = 0x84EA,
+ COMPRESSED_LUMINANCE_ALPHA = 0x84EB,
+ COMPRESSED_INTENSITY = 0x84EC,
+ COMPRESSED_RGB = 0x84ED,
+ COMPRESSED_RGBA = 0x84EE,
+ TEXTURE_COMPRESSION_HINT = 0x84EF,
+ TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0,
+ TEXTURE_COMPRESSED = 0x86A1,
+ NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2,
+ COMPRESSED_TEXTURE_FORMATS = 0x86A3,
+ COMBINE = 0x8570,
+ COMBINE_RGB = 0x8571,
+ COMBINE_ALPHA = 0x8572,
+ SOURCE0_RGB = 0x8580,
+ SOURCE1_RGB = 0x8581,
+ SOURCE2_RGB = 0x8582,
+ SOURCE0_ALPHA = 0x8588,
+ SOURCE1_ALPHA = 0x8589,
+ SOURCE2_ALPHA = 0x858A,
+ OPERAND0_RGB = 0x8590,
+ OPERAND1_RGB = 0x8591,
+ OPERAND2_RGB = 0x8592,
+ OPERAND0_ALPHA = 0x8598,
+ OPERAND1_ALPHA = 0x8599,
+ OPERAND2_ALPHA = 0x859A,
+ RGB_SCALE = 0x8573,
+ ADD_SIGNED = 0x8574,
+ INTERPOLATE = 0x8575,
+ SUBTRACT = 0x84E7,
+ CONSTANT = 0x8576,
+ PRIMARY_COLOR = 0x8577,
+ PREVIOUS = 0x8578,
+ DOT3_RGB = 0x86AE,
+ DOT3_RGBA = 0x86AF,
+ BLEND_DST_RGB = 0x80C8,
+ BLEND_SRC_RGB = 0x80C9,
+ BLEND_DST_ALPHA = 0x80CA,
+ BLEND_SRC_ALPHA = 0x80CB,
+ MIRRORED_REPEAT = 0x8370,
+ FOG_COORDINATE_SOURCE = 0x8450,
+ FOG_COORDINATE = 0x8451,
+ FRAGMENT_DEPTH = 0x8452,
+ CURRENT_FOG_COORDINATE = 0x8453,
+ FOG_COORDINATE_ARRAY_TYPE = 0x8454,
+ FOG_COORDINATE_ARRAY_STRIDE = 0x8455,
+ FOG_COORDINATE_ARRAY_POINTER = 0x8456,
+ FOG_COORDINATE_ARRAY = 0x8457,
+ COLOR_SUM = 0x8458,
+ CURRENT_SECONDARY_COLOR = 0x8459,
+ SECONDARY_COLOR_ARRAY_SIZE = 0x845A,
+ SECONDARY_COLOR_ARRAY_TYPE = 0x845B,
+ SECONDARY_COLOR_ARRAY_STRIDE = 0x845C,
+ SECONDARY_COLOR_ARRAY_POINTER = 0x845D,
+ SECONDARY_COLOR_ARRAY = 0x845E,
+ MAX_TEXTURE_LOD_BIAS = 0x84FD,
+ TEXTURE_FILTER_CONTROL = 0x8500,
+ TEXTURE_LOD_BIAS = 0x8501,
+ INCR_WRAP = 0x8507,
+ DECR_WRAP = 0x8508,
+ TEXTURE_DEPTH_SIZE = 0x884A,
+ DEPTH_TEXTURE_MODE = 0x884B,
+ TEXTURE_COMPARE_MODE = 0x884C,
+ TEXTURE_COMPARE_FUNC = 0x884D,
+ COMPARE_R_TO_TEXTURE = 0x884E,
+ BUFFER_SIZE = 0x8764,
+ BUFFER_USAGE = 0x8765,
+ QUERY_COUNTER_BITS = 0x8864,
+ CURRENT_QUERY = 0x8865,
+ QUERY_RESULT = 0x8866,
+ QUERY_RESULT_AVAILABLE = 0x8867,
+ ARRAY_BUFFER = 0x8892,
+ ELEMENT_ARRAY_BUFFER = 0x8893,
+ ARRAY_BUFFER_BINDING = 0x8894,
+ ELEMENT_ARRAY_BUFFER_BINDING = 0x8895,
+ VERTEX_ARRAY_BUFFER_BINDING = 0x8896,
+ NORMAL_ARRAY_BUFFER_BINDING = 0x8897,
+ COLOR_ARRAY_BUFFER_BINDING = 0x8898,
+ INDEX_ARRAY_BUFFER_BINDING = 0x8899,
+ TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A,
+ EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B,
+ SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C,
+ FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D,
+ WEIGHT_ARRAY_BUFFER_BINDING = 0x889E,
+ VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
+ READ_ONLY = 0x88B8,
+ WRITE_ONLY = 0x88B9,
+ READ_WRITE = 0x88BA,
+ BUFFER_ACCESS = 0x88BB,
+ BUFFER_MAPPED = 0x88BC,
+ BUFFER_MAP_POINTER = 0x88BD,
+ STREAM_DRAW = 0x88E0,
+ STREAM_READ = 0x88E1,
+ STREAM_COPY = 0x88E2,
+ STATIC_DRAW = 0x88E4,
+ STATIC_READ = 0x88E5,
+ STATIC_COPY = 0x88E6,
+ DYNAMIC_DRAW = 0x88E8,
+ DYNAMIC_READ = 0x88E9,
+ DYNAMIC_COPY = 0x88EA,
+ SAMPLES_PASSED = 0x8914,
+ FOG_COORD_SRC = VERSION_1_4.FOG_COORDINATE_SOURCE,
+ FOG_COORD = VERSION_1_4.FOG_COORDINATE,
+ CURRENT_FOG_COORD = VERSION_1_4.CURRENT_FOG_COORDINATE,
+ FOG_COORD_ARRAY_TYPE = VERSION_1_4.FOG_COORDINATE_ARRAY_TYPE,
+ FOG_COORD_ARRAY_STRIDE = VERSION_1_4.FOG_COORDINATE_ARRAY_STRIDE,
+ FOG_COORD_ARRAY_POINTER = VERSION_1_4.FOG_COORDINATE_ARRAY_POINTER,
+ FOG_COORD_ARRAY = VERSION_1_4.FOG_COORDINATE_ARRAY,
+ FOG_COORD_ARRAY_BUFFER_BINDING = VERSION_1_5.FOG_COORDINATE_ARRAY_BUFFER_BINDING,
+ SRC0_RGB = VERSION_1_3.SOURCE0_RGB,
+ SRC1_RGB = VERSION_1_3.SOURCE1_RGB,
+ SRC2_RGB = VERSION_1_3.SOURCE2_RGB,
+ SRC0_ALPHA = VERSION_1_3.SOURCE0_ALPHA,
+ SRC1_ALPHA = VERSION_1_3.SOURCE1_ALPHA,
+ SRC2_ALPHA = VERSION_1_3.SOURCE2_ALPHA,
+ BLEND_EQUATION_RGB = ARB_imaging.BLEND_EQUATION,
+ VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622,
+ VERTEX_ATTRIB_ARRAY_SIZE = 0x8623,
+ VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624,
+ VERTEX_ATTRIB_ARRAY_TYPE = 0x8625,
+ CURRENT_VERTEX_ATTRIB = 0x8626,
+ VERTEX_PROGRAM_POINT_SIZE = 0x8642,
+ VERTEX_PROGRAM_TWO_SIDE = 0x8643,
+ VERTEX_ATTRIB_ARRAY_POINTER = 0x8645,
+ STENCIL_BACK_FUNC = 0x8800,
+ STENCIL_BACK_FAIL = 0x8801,
+ STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802,
+ STENCIL_BACK_PASS_DEPTH_PASS = 0x8803,
+ MAX_DRAW_BUFFERS = 0x8824,
+ DRAW_BUFFER0 = 0x8825,
+ DRAW_BUFFER1 = 0x8826,
+ DRAW_BUFFER2 = 0x8827,
+ DRAW_BUFFER3 = 0x8828,
+ DRAW_BUFFER4 = 0x8829,
+ DRAW_BUFFER5 = 0x882A,
+ DRAW_BUFFER6 = 0x882B,
+ DRAW_BUFFER7 = 0x882C,
+ DRAW_BUFFER8 = 0x882D,
+ DRAW_BUFFER9 = 0x882E,
+ DRAW_BUFFER10 = 0x882F,
+ DRAW_BUFFER11 = 0x8830,
+ DRAW_BUFFER12 = 0x8831,
+ DRAW_BUFFER13 = 0x8832,
+ DRAW_BUFFER14 = 0x8833,
+ DRAW_BUFFER15 = 0x8834,
+ BLEND_EQUATION_ALPHA = 0x883D,
+ POINT_SPRITE = 0x8861,
+ COORD_REPLACE = 0x8862,
+ MAX_VERTEX_ATTRIBS = 0x8869,
+ VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A,
+ MAX_TEXTURE_COORDS = 0x8871,
+ MAX_TEXTURE_IMAGE_UNITS = 0x8872,
+ FRAGMENT_SHADER = 0x8B30,
+ VERTEX_SHADER = 0x8B31,
+ MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49,
+ MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A,
+ MAX_VARYING_FLOATS = 0x8B4B,
+ MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C,
+ MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
+ SHADER_TYPE = 0x8B4F,
+ FLOAT_VEC2 = 0x8B50,
+ FLOAT_VEC3 = 0x8B51,
+ FLOAT_VEC4 = 0x8B52,
+ INT_VEC2 = 0x8B53,
+ INT_VEC3 = 0x8B54,
+ INT_VEC4 = 0x8B55,
+ BOOL = 0x8B56,
+ BOOL_VEC2 = 0x8B57,
+ BOOL_VEC3 = 0x8B58,
+ BOOL_VEC4 = 0x8B59,
+ FLOAT_MAT2 = 0x8B5A,
+ FLOAT_MAT3 = 0x8B5B,
+ FLOAT_MAT4 = 0x8B5C,
+ SAMPLER_1D = 0x8B5D,
+ SAMPLER_2D = 0x8B5E,
+ SAMPLER_3D = 0x8B5F,
+ SAMPLER_CUBE = 0x8B60,
+ SAMPLER_1D_SHADOW = 0x8B61,
+ SAMPLER_2D_SHADOW = 0x8B62,
+ DELETE_STATUS = 0x8B80,
+ COMPILE_STATUS = 0x8B81,
+ LINK_STATUS = 0x8B82,
+ VALIDATE_STATUS = 0x8B83,
+ INFO_LOG_LENGTH = 0x8B84,
+ ATTACHED_SHADERS = 0x8B85,
+ ACTIVE_UNIFORMS = 0x8B86,
+ ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87,
+ SHADER_SOURCE_LENGTH = 0x8B88,
+ ACTIVE_ATTRIBUTES = 0x8B89,
+ ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A,
+ FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B,
+ SHADING_LANGUAGE_VERSION = 0x8B8C,
+ CURRENT_PROGRAM = 0x8B8D,
+ POINT_SPRITE_COORD_ORIGIN = 0x8CA0,
+ LOWER_LEFT = 0x8CA1,
+ UPPER_LEFT = 0x8CA2,
+ STENCIL_BACK_REF = 0x8CA3,
+ STENCIL_BACK_VALUE_MASK = 0x8CA4,
+ STENCIL_BACK_WRITEMASK = 0x8CA5,
+ CURRENT_RASTER_SECONDARY_COLOR = 0x845F,
+ PIXEL_PACK_BUFFER = 0x88EB,
+ PIXEL_UNPACK_BUFFER = 0x88EC,
+ PIXEL_PACK_BUFFER_BINDING = 0x88ED,
+ PIXEL_UNPACK_BUFFER_BINDING = 0x88EF,
+ FLOAT_MAT2x3 = 0x8B65,
+ FLOAT_MAT2x4 = 0x8B66,
+ FLOAT_MAT3x2 = 0x8B67,
+ FLOAT_MAT3x4 = 0x8B68,
+ FLOAT_MAT4x2 = 0x8B69,
+ FLOAT_MAT4x3 = 0x8B6A,
+ SRGB = 0x8C40,
+ SRGB8 = 0x8C41,
+ SRGB_ALPHA = 0x8C42,
+ SRGB8_ALPHA8 = 0x8C43,
+ SLUMINANCE_ALPHA = 0x8C44,
+ SLUMINANCE8_ALPHA8 = 0x8C45,
+ SLUMINANCE = 0x8C46,
+ SLUMINANCE8 = 0x8C47,
+ COMPRESSED_SRGB = 0x8C48,
+ COMPRESSED_SRGB_ALPHA = 0x8C49,
+ COMPRESSED_SLUMINANCE = 0x8C4A,
+ COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B,
+ TEXTURE0_ARB = 0x84C0,
+ TEXTURE1_ARB = 0x84C1,
+ TEXTURE2_ARB = 0x84C2,
+ TEXTURE3_ARB = 0x84C3,
+ TEXTURE4_ARB = 0x84C4,
+ TEXTURE5_ARB = 0x84C5,
+ TEXTURE6_ARB = 0x84C6,
+ TEXTURE7_ARB = 0x84C7,
+ TEXTURE8_ARB = 0x84C8,
+ TEXTURE9_ARB = 0x84C9,
+ TEXTURE10_ARB = 0x84CA,
+ TEXTURE11_ARB = 0x84CB,
+ TEXTURE12_ARB = 0x84CC,
+ TEXTURE13_ARB = 0x84CD,
+ TEXTURE14_ARB = 0x84CE,
+ TEXTURE15_ARB = 0x84CF,
+ TEXTURE16_ARB = 0x84D0,
+ TEXTURE17_ARB = 0x84D1,
+ TEXTURE18_ARB = 0x84D2,
+ TEXTURE19_ARB = 0x84D3,
+ TEXTURE20_ARB = 0x84D4,
+ TEXTURE21_ARB = 0x84D5,
+ TEXTURE22_ARB = 0x84D6,
+ TEXTURE23_ARB = 0x84D7,
+ TEXTURE24_ARB = 0x84D8,
+ TEXTURE25_ARB = 0x84D9,
+ TEXTURE26_ARB = 0x84DA,
+ TEXTURE27_ARB = 0x84DB,
+ TEXTURE28_ARB = 0x84DC,
+ TEXTURE29_ARB = 0x84DD,
+ TEXTURE30_ARB = 0x84DE,
+ TEXTURE31_ARB = 0x84DF,
+ ACTIVE_TEXTURE_ARB = 0x84E0,
+ CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1,
+ MAX_TEXTURE_UNITS_ARB = 0x84E2,
+ TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3,
+ TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4,
+ TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5,
+ TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6,
+ MULTISAMPLE_BIT_ARB = 0x20000000,
+ NORMAL_MAP_ARB = 0x8511,
+ REFLECTION_MAP_ARB = 0x8512,
+ TEXTURE_CUBE_MAP_ARB = 0x8513,
+ TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514,
+ TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515,
+ TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516,
+ TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517,
+ TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518,
+ TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519,
+ TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A,
+ PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B,
+ MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C,
+ COMPRESSED_ALPHA_ARB = 0x84E9,
+ COMPRESSED_LUMINANCE_ARB = 0x84EA,
+ COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB,
+ COMPRESSED_INTENSITY_ARB = 0x84EC,
+ COMPRESSED_RGB_ARB = 0x84ED,
+ COMPRESSED_RGBA_ARB = 0x84EE,
+ TEXTURE_COMPRESSION_HINT_ARB = 0x84EF,
+ TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0,
+ TEXTURE_COMPRESSED_ARB = 0x86A1,
+ NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2,
+ COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3,
+ MAX_VERTEX_UNITS_ARB = 0x86A4,
+ ACTIVE_VERTEX_UNITS_ARB = 0x86A5,
+ WEIGHT_SUM_UNITY_ARB = 0x86A6,
+ VERTEX_BLEND_ARB = 0x86A7,
+ CURRENT_WEIGHT_ARB = 0x86A8,
+ WEIGHT_ARRAY_TYPE_ARB = 0x86A9,
+ WEIGHT_ARRAY_STRIDE_ARB = 0x86AA,
+ WEIGHT_ARRAY_SIZE_ARB = 0x86AB,
+ WEIGHT_ARRAY_POINTER_ARB = 0x86AC,
+ WEIGHT_ARRAY_ARB = 0x86AD,
+ MODELVIEW0_ARB = 0x1700,
+ MODELVIEW1_ARB = 0x850A,
+ MODELVIEW2_ARB = 0x8722,
+ MODELVIEW3_ARB = 0x8723,
+ MODELVIEW4_ARB = 0x8724,
+ MODELVIEW5_ARB = 0x8725,
+ MODELVIEW6_ARB = 0x8726,
+ MODELVIEW7_ARB = 0x8727,
+ MODELVIEW8_ARB = 0x8728,
+ MODELVIEW9_ARB = 0x8729,
+ MODELVIEW10_ARB = 0x872A,
+ MODELVIEW11_ARB = 0x872B,
+ MODELVIEW12_ARB = 0x872C,
+ MODELVIEW13_ARB = 0x872D,
+ MODELVIEW14_ARB = 0x872E,
+ MODELVIEW15_ARB = 0x872F,
+ MODELVIEW16_ARB = 0x8730,
+ MODELVIEW17_ARB = 0x8731,
+ MODELVIEW18_ARB = 0x8732,
+ MODELVIEW19_ARB = 0x8733,
+ MODELVIEW20_ARB = 0x8734,
+ MODELVIEW21_ARB = 0x8735,
+ MODELVIEW22_ARB = 0x8736,
+ MODELVIEW23_ARB = 0x8737,
+ MODELVIEW24_ARB = 0x8738,
+ MODELVIEW25_ARB = 0x8739,
+ MODELVIEW26_ARB = 0x873A,
+ MODELVIEW27_ARB = 0x873B,
+ MODELVIEW28_ARB = 0x873C,
+ MODELVIEW29_ARB = 0x873D,
+ MODELVIEW30_ARB = 0x873E,
+ MODELVIEW31_ARB = 0x873F,
+ MATRIX_PALETTE_ARB = 0x8840,
+ MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841,
+ MAX_PALETTE_MATRICES_ARB = 0x8842,
+ CURRENT_PALETTE_MATRIX_ARB = 0x8843,
+ MATRIX_INDEX_ARRAY_ARB = 0x8844,
+ CURRENT_MATRIX_INDEX_ARB = 0x8845,
+ MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846,
+ MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847,
+ MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848,
+ MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849,
+ COMBINE_ARB = 0x8570,
+ COMBINE_RGB_ARB = 0x8571,
+ COMBINE_ALPHA_ARB = 0x8572,
+ SOURCE0_RGB_ARB = 0x8580,
+ SOURCE1_RGB_ARB = 0x8581,
+ SOURCE2_RGB_ARB = 0x8582,
+ SOURCE0_ALPHA_ARB = 0x8588,
+ SOURCE1_ALPHA_ARB = 0x8589,
+ SOURCE2_ALPHA_ARB = 0x858A,
+ OPERAND0_RGB_ARB = 0x8590,
+ OPERAND1_RGB_ARB = 0x8591,
+ OPERAND2_RGB_ARB = 0x8592,
+ OPERAND0_ALPHA_ARB = 0x8598,
+ OPERAND1_ALPHA_ARB = 0x8599,
+ OPERAND2_ALPHA_ARB = 0x859A,
+ RGB_SCALE_ARB = 0x8573,
+ ADD_SIGNED_ARB = 0x8574,
+ INTERPOLATE_ARB = 0x8575,
+ SUBTRACT_ARB = 0x84E7,
+ CONSTANT_ARB = 0x8576,
+ PRIMARY_COLOR_ARB = 0x8577,
+ PREVIOUS_ARB = 0x8578,
+ DOT3_RGB_ARB = 0x86AE,
+ DOT3_RGBA_ARB = 0x86AF,
+ MIRRORED_REPEAT_ARB = 0x8370,
+ DEPTH_COMPONENT16_ARB = 0x81A5,
+ DEPTH_COMPONENT24_ARB = 0x81A6,
+ DEPTH_COMPONENT32_ARB = 0x81A7,
+ TEXTURE_DEPTH_SIZE_ARB = 0x884A,
+ DEPTH_TEXTURE_MODE_ARB = 0x884B,
+ TEXTURE_COMPARE_MODE_ARB = 0x884C,
+ TEXTURE_COMPARE_FUNC_ARB = 0x884D,
+ COMPARE_R_TO_TEXTURE_ARB = 0x884E,
+ TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF,
+ COLOR_SUM_ARB = 0x8458,
+ VERTEX_PROGRAM_ARB = 0x8620,
+ VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622,
+ VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623,
+ VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624,
+ VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625,
+ CURRENT_VERTEX_ATTRIB_ARB = 0x8626,
+ PROGRAM_LENGTH_ARB = 0x8627,
+ PROGRAM_STRING_ARB = 0x8628,
+ MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E,
+ MAX_PROGRAM_MATRICES_ARB = 0x862F,
+ CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640,
+ CURRENT_MATRIX_ARB = 0x8641,
+ VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642,
+ VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643,
+ VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645,
+ PROGRAM_ERROR_POSITION_ARB = 0x864B,
+ PROGRAM_BINDING_ARB = 0x8677,
+ MAX_VERTEX_ATTRIBS_ARB = 0x8869,
+ VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A,
+ PROGRAM_ERROR_STRING_ARB = 0x8874,
+ PROGRAM_FORMAT_ASCII_ARB = 0x8875,
+ PROGRAM_FORMAT_ARB = 0x8876,
+ PROGRAM_INSTRUCTIONS_ARB = 0x88A0,
+ MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1,
+ PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2,
+ MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3,
+ PROGRAM_TEMPORARIES_ARB = 0x88A4,
+ MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5,
+ PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6,
+ MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7,
+ PROGRAM_PARAMETERS_ARB = 0x88A8,
+ MAX_PROGRAM_PARAMETERS_ARB = 0x88A9,
+ PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA,
+ MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB,
+ PROGRAM_ATTRIBS_ARB = 0x88AC,
+ MAX_PROGRAM_ATTRIBS_ARB = 0x88AD,
+ PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE,
+ MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF,
+ PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0,
+ MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1,
+ PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2,
+ MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3,
+ MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4,
+ MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5,
+ PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6,
+ TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7,
+ MATRIX0_ARB = 0x88C0,
+ MATRIX1_ARB = 0x88C1,
+ MATRIX2_ARB = 0x88C2,
+ MATRIX3_ARB = 0x88C3,
+ MATRIX4_ARB = 0x88C4,
+ MATRIX5_ARB = 0x88C5,
+ MATRIX6_ARB = 0x88C6,
+ MATRIX7_ARB = 0x88C7,
+ MATRIX8_ARB = 0x88C8,
+ MATRIX9_ARB = 0x88C9,
+ MATRIX10_ARB = 0x88CA,
+ MATRIX11_ARB = 0x88CB,
+ MATRIX12_ARB = 0x88CC,
+ MATRIX13_ARB = 0x88CD,
+ MATRIX14_ARB = 0x88CE,
+ MATRIX15_ARB = 0x88CF,
+ MATRIX16_ARB = 0x88D0,
+ MATRIX17_ARB = 0x88D1,
+ MATRIX18_ARB = 0x88D2,
+ MATRIX19_ARB = 0x88D3,
+ MATRIX20_ARB = 0x88D4,
+ MATRIX21_ARB = 0x88D5,
+ MATRIX22_ARB = 0x88D6,
+ MATRIX23_ARB = 0x88D7,
+ MATRIX24_ARB = 0x88D8,
+ MATRIX25_ARB = 0x88D9,
+ MATRIX26_ARB = 0x88DA,
+ MATRIX27_ARB = 0x88DB,
+ MATRIX28_ARB = 0x88DC,
+ MATRIX29_ARB = 0x88DD,
+ MATRIX30_ARB = 0x88DE,
+ MATRIX31_ARB = 0x88DF,
+ FRAGMENT_PROGRAM_ARB = 0x8804,
+ PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805,
+ PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806,
+ PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807,
+ PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808,
+ PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809,
+ PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A,
+ MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B,
+ MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C,
+ MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D,
+ MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E,
+ MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F,
+ MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810,
+ MAX_TEXTURE_COORDS_ARB = 0x8871,
+ MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872,
+ BUFFER_SIZE_ARB = 0x8764,
+ BUFFER_USAGE_ARB = 0x8765,
+ ARRAY_BUFFER_ARB = 0x8892,
+ ELEMENT_ARRAY_BUFFER_ARB = 0x8893,
+ ARRAY_BUFFER_BINDING_ARB = 0x8894,
+ ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895,
+ VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896,
+ NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897,
+ COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898,
+ INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899,
+ TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A,
+ EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B,
+ SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C,
+ FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D,
+ WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E,
+ VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F,
+ READ_ONLY_ARB = 0x88B8,
+ WRITE_ONLY_ARB = 0x88B9,
+ READ_WRITE_ARB = 0x88BA,
+ BUFFER_ACCESS_ARB = 0x88BB,
+ BUFFER_MAPPED_ARB = 0x88BC,
+ BUFFER_MAP_POINTER_ARB = 0x88BD,
+ STREAM_DRAW_ARB = 0x88E0,
+ STREAM_READ_ARB = 0x88E1,
+ STREAM_COPY_ARB = 0x88E2,
+ STATIC_DRAW_ARB = 0x88E4,
+ STATIC_READ_ARB = 0x88E5,
+ STATIC_COPY_ARB = 0x88E6,
+ DYNAMIC_DRAW_ARB = 0x88E8,
+ DYNAMIC_READ_ARB = 0x88E9,
+ DYNAMIC_COPY_ARB = 0x88EA,
+ QUERY_COUNTER_BITS_ARB = 0x8864,
+ CURRENT_QUERY_ARB = 0x8865,
+ QUERY_RESULT_ARB = 0x8866,
+ QUERY_RESULT_AVAILABLE_ARB = 0x8867,
+ SAMPLES_PASSED_ARB = 0x8914,
+ PROGRAM_OBJECT_ARB = 0x8B40,
+ SHADER_OBJECT_ARB = 0x8B48,
+ OBJECT_TYPE_ARB = 0x8B4E,
+ OBJECT_SUBTYPE_ARB = 0x8B4F,
+ FLOAT_VEC2_ARB = 0x8B50,
+ FLOAT_VEC3_ARB = 0x8B51,
+ FLOAT_VEC4_ARB = 0x8B52,
+ INT_VEC2_ARB = 0x8B53,
+ INT_VEC3_ARB = 0x8B54,
+ INT_VEC4_ARB = 0x8B55,
+ BOOL_ARB = 0x8B56,
+ BOOL_VEC2_ARB = 0x8B57,
+ BOOL_VEC3_ARB = 0x8B58,
+ BOOL_VEC4_ARB = 0x8B59,
+ FLOAT_MAT2_ARB = 0x8B5A,
+ FLOAT_MAT3_ARB = 0x8B5B,
+ FLOAT_MAT4_ARB = 0x8B5C,
+ SAMPLER_1D_ARB = 0x8B5D,
+ SAMPLER_2D_ARB = 0x8B5E,
+ SAMPLER_3D_ARB = 0x8B5F,
+ SAMPLER_CUBE_ARB = 0x8B60,
+ SAMPLER_1D_SHADOW_ARB = 0x8B61,
+ SAMPLER_2D_SHADOW_ARB = 0x8B62,
+ SAMPLER_2D_RECT_ARB = 0x8B63,
+ SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64,
+ OBJECT_DELETE_STATUS_ARB = 0x8B80,
+ OBJECT_COMPILE_STATUS_ARB = 0x8B81,
+ OBJECT_LINK_STATUS_ARB = 0x8B82,
+ OBJECT_VALIDATE_STATUS_ARB = 0x8B83,
+ OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84,
+ OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85,
+ OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86,
+ OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87,
+ OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88,
+ VERTEX_SHADER_ARB = 0x8B31,
+ MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A,
+ MAX_VARYING_FLOATS_ARB = 0x8B4B,
+ MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C,
+ MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D,
+ OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89,
+ OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A,
+ FRAGMENT_SHADER_ARB = 0x8B30,
+ MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49,
+ FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B,
+ SHADING_LANGUAGE_VERSION_ARB = 0x8B8C,
+ POINT_SPRITE_ARB = 0x8861,
+ COORD_REPLACE_ARB = 0x8862,
+ MAX_DRAW_BUFFERS_ARB = 0x8824,
+ DRAW_BUFFER0_ARB = 0x8825,
+ DRAW_BUFFER1_ARB = 0x8826,
+ DRAW_BUFFER2_ARB = 0x8827,
+ DRAW_BUFFER3_ARB = 0x8828,
+ DRAW_BUFFER4_ARB = 0x8829,
+ DRAW_BUFFER5_ARB = 0x882A,
+ DRAW_BUFFER6_ARB = 0x882B,
+ DRAW_BUFFER7_ARB = 0x882C,
+ DRAW_BUFFER8_ARB = 0x882D,
+ DRAW_BUFFER9_ARB = 0x882E,
+ DRAW_BUFFER10_ARB = 0x882F,
+ DRAW_BUFFER11_ARB = 0x8830,
+ DRAW_BUFFER12_ARB = 0x8831,
+ DRAW_BUFFER13_ARB = 0x8832,
+ DRAW_BUFFER14_ARB = 0x8833,
+ DRAW_BUFFER15_ARB = 0x8834,
+ TEXTURE_RECTANGLE_ARB = 0x84F5,
+ TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6,
+ PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7,
+ MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8,
+ RGBA_FLOAT_MODE_ARB = 0x8820,
+ CLAMP_VERTEX_COLOR_ARB = 0x891A,
+ CLAMP_FRAGMENT_COLOR_ARB = 0x891B,
+ CLAMP_READ_COLOR_ARB = 0x891C,
+ FIXED_ONLY_ARB = 0x891D,
+ HALF_FLOAT_ARB = 0x140B,
+ TEXTURE_RED_TYPE_ARB = 0x8C10,
+ TEXTURE_GREEN_TYPE_ARB = 0x8C11,
+ TEXTURE_BLUE_TYPE_ARB = 0x8C12,
+ TEXTURE_ALPHA_TYPE_ARB = 0x8C13,
+ TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14,
+ TEXTURE_INTENSITY_TYPE_ARB = 0x8C15,
+ TEXTURE_DEPTH_TYPE_ARB = 0x8C16,
+ UNSIGNED_NORMALIZED_ARB = 0x8C17,
+ RGBA32F_ARB = 0x8814,
+ RGB32F_ARB = 0x8815,
+ ALPHA32F_ARB = 0x8816,
+ INTENSITY32F_ARB = 0x8817,
+ LUMINANCE32F_ARB = 0x8818,
+ LUMINANCE_ALPHA32F_ARB = 0x8819,
+ RGBA16F_ARB = 0x881A,
+ RGB16F_ARB = 0x881B,
+ ALPHA16F_ARB = 0x881C,
+ INTENSITY16F_ARB = 0x881D,
+ LUMINANCE16F_ARB = 0x881E,
+ LUMINANCE_ALPHA16F_ARB = 0x881F,
+ PIXEL_PACK_BUFFER_ARB = 0x88EB,
+ PIXEL_UNPACK_BUFFER_ARB = 0x88EC,
+ PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED,
+ PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF,
+ IMAGE_SCALE_X_HP = 0x8155,
+ IMAGE_SCALE_Y_HP = 0x8156,
+ IMAGE_TRANSLATE_X_HP = 0x8157,
+ IMAGE_TRANSLATE_Y_HP = 0x8158,
+ IMAGE_ROTATE_ANGLE_HP = 0x8159,
+ IMAGE_ROTATE_ORIGIN_X_HP = 0x815A,
+ IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B,
+ IMAGE_MAG_FILTER_HP = 0x815C,
+ IMAGE_MIN_FILTER_HP = 0x815D,
+ IMAGE_CUBIC_WEIGHT_HP = 0x815E,
+ CUBIC_HP = 0x815F,
+ AVERAGE_HP = 0x8160,
+ IMAGE_TRANSFORM_2D_HP = 0x8161,
+ POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162,
+ PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163,
+ VERTEX_DATA_HINT_PGI = 0x1A22A,
+ VERTEX_CONSISTENT_HINT_PGI = 0x1A22B,
+ MATERIAL_SIDE_HINT_PGI = 0x1A22C,
+ MAX_VERTEX_HINT_PGI = 0x1A22D,
+ COLOR3_BIT_PGI = 0x00010000,
+ COLOR4_BIT_PGI = 0x00020000,
+ EDGEFLAG_BIT_PGI = 0x00040000,
+ INDEX_BIT_PGI = 0x00080000,
+ MAT_AMBIENT_BIT_PGI = 0x00100000,
+ MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000,
+ MAT_DIFFUSE_BIT_PGI = 0x00400000,
+ MAT_EMISSION_BIT_PGI = 0x00800000,
+ MAT_COLOR_INDEXES_BIT_PGI = 0x01000000,
+ MAT_SHININESS_BIT_PGI = 0x02000000,
+ MAT_SPECULAR_BIT_PGI = 0x04000000,
+ NORMAL_BIT_PGI = 0x08000000,
+ TEXCOORD1_BIT_PGI = 0x10000000,
+ TEXCOORD2_BIT_PGI = 0x20000000,
+ TEXCOORD3_BIT_PGI = 0x40000000,
+ TEXCOORD4_BIT_PGI = unchecked((Int32)0x80000000),
+ VERTEX23_BIT_PGI = 0x00000004,
+ VERTEX4_BIT_PGI = 0x00000008,
+ PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8,
+ CONSERVE_MEMORY_HINT_PGI = 0x1A1FD,
+ RECLAIM_MEMORY_HINT_PGI = 0x1A1FE,
+ NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202,
+ NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203,
+ NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204,
+ ALWAYS_FAST_HINT_PGI = 0x1A20C,
+ ALWAYS_SOFT_HINT_PGI = 0x1A20D,
+ ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E,
+ ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F,
+ ALLOW_DRAW_FRG_HINT_PGI = 0x1A210,
+ ALLOW_DRAW_MEM_HINT_PGI = 0x1A211,
+ STRICT_DEPTHFUNC_HINT_PGI = 0x1A216,
+ STRICT_LIGHTING_HINT_PGI = 0x1A217,
+ STRICT_SCISSOR_HINT_PGI = 0x1A218,
+ FULL_STIPPLE_HINT_PGI = 0x1A219,
+ CLIP_NEAR_HINT_PGI = 0x1A220,
+ CLIP_FAR_HINT_PGI = 0x1A221,
+ WIDE_LINE_HINT_PGI = 0x1A222,
+ BACK_NORMALS_HINT_PGI = 0x1A223,
+ COLOR_INDEX1_EXT = 0x80E2,
+ COLOR_INDEX2_EXT = 0x80E3,
+ COLOR_INDEX4_EXT = 0x80E4,
+ COLOR_INDEX8_EXT = 0x80E5,
+ COLOR_INDEX12_EXT = 0x80E6,
+ COLOR_INDEX16_EXT = 0x80E7,
+ TEXTURE_INDEX_SIZE_EXT = 0x80ED,
+ CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0,
+ INDEX_MATERIAL_EXT = 0x81B8,
+ INDEX_MATERIAL_PARAMETER_EXT = 0x81B9,
+ INDEX_MATERIAL_FACE_EXT = 0x81BA,
+ INDEX_TEST_EXT = 0x81B5,
+ INDEX_TEST_FUNC_EXT = 0x81B6,
+ INDEX_TEST_REF_EXT = 0x81B7,
+ IUI_V2F_EXT = 0x81AD,
+ IUI_V3F_EXT = 0x81AE,
+ IUI_N3F_V2F_EXT = 0x81AF,
+ IUI_N3F_V3F_EXT = 0x81B0,
+ T2F_IUI_V2F_EXT = 0x81B1,
+ T2F_IUI_V3F_EXT = 0x81B2,
+ T2F_IUI_N3F_V2F_EXT = 0x81B3,
+ T2F_IUI_N3F_V3F_EXT = 0x81B4,
+ ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8,
+ ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9,
+ CULL_VERTEX_EXT = 0x81AA,
+ CULL_VERTEX_EYE_POSITION_EXT = 0x81AB,
+ CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC,
+ RASTER_POSITION_UNCLIPPED_IBM = 0x19262,
+ TEXTURE_LIGHTING_MODE_HP = 0x8167,
+ TEXTURE_POST_SPECULAR_HP = 0x8168,
+ TEXTURE_PRE_SPECULAR_HP = 0x8169,
+ MAX_ELEMENTS_VERTICES_EXT = 0x80E8,
+ MAX_ELEMENTS_INDICES_EXT = 0x80E9,
+ PHONG_WIN = 0x80EA,
+ PHONG_HINT_WIN = 0x80EB,
+ FOG_SPECULAR_TEXTURE_WIN = 0x80EC,
+ FRAGMENT_MATERIAL_EXT = 0x8349,
+ FRAGMENT_NORMAL_EXT = 0x834A,
+ FRAGMENT_COLOR_EXT = 0x834C,
+ ATTENUATION_EXT = 0x834D,
+ SHADOW_ATTENUATION_EXT = 0x834E,
+ TEXTURE_APPLICATION_MODE_EXT = 0x834F,
+ TEXTURE_LIGHT_EXT = 0x8350,
+ TEXTURE_MATERIAL_FACE_EXT = 0x8351,
+ TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352,
+ FRAGMENT_DEPTH_EXT = EXT_fog_coord.FRAGMENT_DEPTH_EXT,
+ OCCLUSION_TEST_HP = 0x8165,
+ OCCLUSION_TEST_RESULT_HP = 0x8166,
+ COLOR_SUM_EXT = 0x8458,
+ CURRENT_SECONDARY_COLOR_EXT = 0x8459,
+ SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A,
+ SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B,
+ SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C,
+ SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D,
+ SECONDARY_COLOR_ARRAY_EXT = 0x845E,
+ PERTURB_EXT = 0x85AE,
+ TEXTURE_NORMAL_EXT = 0x85AF,
+ FOG_COORDINATE_SOURCE_EXT = 0x8450,
+ FOG_COORDINATE_EXT = 0x8451,
+ CURRENT_FOG_COORDINATE_EXT = 0x8453,
+ FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454,
+ FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455,
+ FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456,
+ FOG_COORDINATE_ARRAY_EXT = 0x8457,
+ SCREEN_COORDINATES_REND = 0x8490,
+ INVERTED_SCREEN_W_REND = 0x8491,
+ TANGENT_ARRAY_EXT = 0x8439,
+ BINORMAL_ARRAY_EXT = 0x843A,
+ CURRENT_TANGENT_EXT = 0x843B,
+ CURRENT_BINORMAL_EXT = 0x843C,
+ TANGENT_ARRAY_TYPE_EXT = 0x843E,
+ TANGENT_ARRAY_STRIDE_EXT = 0x843F,
+ BINORMAL_ARRAY_TYPE_EXT = 0x8440,
+ BINORMAL_ARRAY_STRIDE_EXT = 0x8441,
+ TANGENT_ARRAY_POINTER_EXT = 0x8442,
+ BINORMAL_ARRAY_POINTER_EXT = 0x8443,
+ MAP1_TANGENT_EXT = 0x8444,
+ MAP2_TANGENT_EXT = 0x8445,
+ MAP1_BINORMAL_EXT = 0x8446,
+ MAP2_BINORMAL_EXT = 0x8447,
+ COMBINE_EXT = 0x8570,
+ COMBINE_RGB_EXT = 0x8571,
+ COMBINE_ALPHA_EXT = 0x8572,
+ RGB_SCALE_EXT = 0x8573,
+ ADD_SIGNED_EXT = 0x8574,
+ INTERPOLATE_EXT = 0x8575,
+ CONSTANT_EXT = 0x8576,
+ PRIMARY_COLOR_EXT = 0x8577,
+ PREVIOUS_EXT = 0x8578,
+ SOURCE0_RGB_EXT = 0x8580,
+ SOURCE1_RGB_EXT = 0x8581,
+ SOURCE2_RGB_EXT = 0x8582,
+ SOURCE0_ALPHA_EXT = 0x8588,
+ SOURCE1_ALPHA_EXT = 0x8589,
+ SOURCE2_ALPHA_EXT = 0x858A,
+ OPERAND0_RGB_EXT = 0x8590,
+ OPERAND1_RGB_EXT = 0x8591,
+ OPERAND2_RGB_EXT = 0x8592,
+ OPERAND0_ALPHA_EXT = 0x8598,
+ OPERAND1_ALPHA_EXT = 0x8599,
+ OPERAND2_ALPHA_EXT = 0x859A,
+ LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0,
+ TRANSFORM_HINT_APPLE = 0x85B1,
+ FOG_SCALE_SGIX = 0x81FC,
+ FOG_SCALE_VALUE_SGIX = 0x81FD,
+ UNPACK_CONSTANT_DATA_SUNX = 0x81D5,
+ TEXTURE_CONSTANT_DATA_SUNX = 0x81D6,
+ GLOBAL_ALPHA_SUN = 0x81D9,
+ GLOBAL_ALPHA_FACTOR_SUN = 0x81DA,
+ RESTART_SUN = 0x0001,
+ REPLACE_MIDDLE_SUN = 0x0002,
+ REPLACE_OLDEST_SUN = 0x0003,
+ TRIANGLE_LIST_SUN = 0x81D7,
+ REPLACEMENT_CODE_SUN = 0x81D8,
+ REPLACEMENT_CODE_ARRAY_SUN = 0x85C0,
+ REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1,
+ REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2,
+ REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3,
+ R1UI_V3F_SUN = 0x85C4,
+ R1UI_C4UB_V3F_SUN = 0x85C5,
+ R1UI_C3F_V3F_SUN = 0x85C6,
+ R1UI_N3F_V3F_SUN = 0x85C7,
+ R1UI_C4F_N3F_V3F_SUN = 0x85C8,
+ R1UI_T2F_V3F_SUN = 0x85C9,
+ R1UI_T2F_N3F_V3F_SUN = 0x85CA,
+ R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB,
+ BLEND_DST_RGB_EXT = 0x80C8,
+ BLEND_SRC_RGB_EXT = 0x80C9,
+ BLEND_DST_ALPHA_EXT = 0x80CA,
+ BLEND_SRC_ALPHA_EXT = 0x80CB,
+ RED_MIN_CLAMP_INGR = 0x8560,
+ GREEN_MIN_CLAMP_INGR = 0x8561,
+ BLUE_MIN_CLAMP_INGR = 0x8562,
+ ALPHA_MIN_CLAMP_INGR = 0x8563,
+ RED_MAX_CLAMP_INGR = 0x8564,
+ GREEN_MAX_CLAMP_INGR = 0x8565,
+ BLUE_MAX_CLAMP_INGR = 0x8566,
+ ALPHA_MAX_CLAMP_INGR = 0x8567,
+ INTERLACE_READ_INGR = 0x8568,
+ INCR_WRAP_EXT = 0x8507,
+ DECR_WRAP_EXT = 0x8508,
+ _422_EXT = 0x80CC,
+ _422_REV_EXT = 0x80CD,
+ _422_AVERAGE_EXT = 0x80CE,
+ _422_REV_AVERAGE_EXT = 0x80CF,
+ NORMAL_MAP_NV = 0x8511,
+ REFLECTION_MAP_NV = 0x8512,
+ NORMAL_MAP_EXT = 0x8511,
+ REFLECTION_MAP_EXT = 0x8512,
+ TEXTURE_CUBE_MAP_EXT = 0x8513,
+ TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514,
+ TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515,
+ TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516,
+ TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517,
+ TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518,
+ TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519,
+ TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A,
+ PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B,
+ MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C,
+ WRAP_BORDER_SUN = 0x81D4,
+ MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD,
+ TEXTURE_FILTER_CONTROL_EXT = 0x8500,
+ TEXTURE_LOD_BIAS_EXT = 0x8501,
+ TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE,
+ MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF,
+ MODELVIEW0_STACK_DEPTH_EXT = GetPName.MODELVIEW_STACK_DEPTH,
+ MODELVIEW1_STACK_DEPTH_EXT = 0x8502,
+ MODELVIEW0_MATRIX_EXT = GetPName.MODELVIEW_MATRIX,
+ MODELVIEW1_MATRIX_EXT = 0x8506,
+ VERTEX_WEIGHTING_EXT = 0x8509,
+ MODELVIEW0_EXT = MatrixMode.MODELVIEW,
+ MODELVIEW1_EXT = 0x850A,
+ CURRENT_VERTEX_WEIGHT_EXT = 0x850B,
+ VERTEX_WEIGHT_ARRAY_EXT = 0x850C,
+ VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D,
+ VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E,
+ VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F,
+ VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510,
+ MAX_SHININESS_NV = 0x8504,
+ MAX_SPOT_EXPONENT_NV = 0x8505,
+ VERTEX_ARRAY_RANGE_NV = 0x851D,
+ VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E,
+ VERTEX_ARRAY_RANGE_VALID_NV = 0x851F,
+ MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520,
+ VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521,
+ REGISTER_COMBINERS_NV = 0x8522,
+ VARIABLE_A_NV = 0x8523,
+ VARIABLE_B_NV = 0x8524,
+ VARIABLE_C_NV = 0x8525,
+ VARIABLE_D_NV = 0x8526,
+ VARIABLE_E_NV = 0x8527,
+ VARIABLE_F_NV = 0x8528,
+ VARIABLE_G_NV = 0x8529,
+ CONSTANT_COLOR0_NV = 0x852A,
+ CONSTANT_COLOR1_NV = 0x852B,
+ PRIMARY_COLOR_NV = 0x852C,
+ SECONDARY_COLOR_NV = 0x852D,
+ SPARE0_NV = 0x852E,
+ SPARE1_NV = 0x852F,
+ DISCARD_NV = 0x8530,
+ E_TIMES_F_NV = 0x8531,
+ SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532,
+ UNSIGNED_IDENTITY_NV = 0x8536,
+ UNSIGNED_INVERT_NV = 0x8537,
+ EXPAND_NORMAL_NV = 0x8538,
+ EXPAND_NEGATE_NV = 0x8539,
+ HALF_BIAS_NORMAL_NV = 0x853A,
+ HALF_BIAS_NEGATE_NV = 0x853B,
+ SIGNED_IDENTITY_NV = 0x853C,
+ SIGNED_NEGATE_NV = 0x853D,
+ SCALE_BY_TWO_NV = 0x853E,
+ SCALE_BY_FOUR_NV = 0x853F,
+ SCALE_BY_ONE_HALF_NV = 0x8540,
+ BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541,
+ COMBINER_INPUT_NV = 0x8542,
+ COMBINER_MAPPING_NV = 0x8543,
+ COMBINER_COMPONENT_USAGE_NV = 0x8544,
+ COMBINER_AB_DOT_PRODUCT_NV = 0x8545,
+ COMBINER_CD_DOT_PRODUCT_NV = 0x8546,
+ COMBINER_MUX_SUM_NV = 0x8547,
+ COMBINER_SCALE_NV = 0x8548,
+ COMBINER_BIAS_NV = 0x8549,
+ COMBINER_AB_OUTPUT_NV = 0x854A,
+ COMBINER_CD_OUTPUT_NV = 0x854B,
+ COMBINER_SUM_OUTPUT_NV = 0x854C,
+ MAX_GENERAL_COMBINERS_NV = 0x854D,
+ NUM_GENERAL_COMBINERS_NV = 0x854E,
+ COLOR_SUM_CLAMP_NV = 0x854F,
+ COMBINER0_NV = 0x8550,
+ COMBINER1_NV = 0x8551,
+ COMBINER2_NV = 0x8552,
+ COMBINER3_NV = 0x8553,
+ COMBINER4_NV = 0x8554,
+ COMBINER5_NV = 0x8555,
+ COMBINER6_NV = 0x8556,
+ COMBINER7_NV = 0x8557,
+ FOG_DISTANCE_MODE_NV = 0x855A,
+ EYE_RADIAL_NV = 0x855B,
+ EYE_PLANE_ABSOLUTE_NV = 0x855C,
+ EMBOSS_LIGHT_NV = 0x855D,
+ EMBOSS_CONSTANT_NV = 0x855E,
+ EMBOSS_MAP_NV = 0x855F,
+ COMBINE4_NV = 0x8503,
+ SOURCE3_RGB_NV = 0x8583,
+ SOURCE3_ALPHA_NV = 0x858B,
+ OPERAND3_RGB_NV = 0x8593,
+ OPERAND3_ALPHA_NV = 0x859B,
+ CULL_VERTEX_IBM = 103050,
+ VERTEX_ARRAY_LIST_IBM = 103070,
+ NORMAL_ARRAY_LIST_IBM = 103071,
+ COLOR_ARRAY_LIST_IBM = 103072,
+ INDEX_ARRAY_LIST_IBM = 103073,
+ TEXTURE_COORD_ARRAY_LIST_IBM = 103074,
+ EDGE_FLAG_ARRAY_LIST_IBM = 103075,
+ FOG_COORDINATE_ARRAY_LIST_IBM = 103076,
+ SECONDARY_COLOR_ARRAY_LIST_IBM = 103077,
+ VERTEX_ARRAY_LIST_STRIDE_IBM = 103080,
+ NORMAL_ARRAY_LIST_STRIDE_IBM = 103081,
+ COLOR_ARRAY_LIST_STRIDE_IBM = 103082,
+ INDEX_ARRAY_LIST_STRIDE_IBM = 103083,
+ TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084,
+ EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085,
+ FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086,
+ SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087,
+ YCRCB_SGIX = 0x8318,
+ YCRCBA_SGIX = 0x8319,
+ DEPTH_PASS_INSTRUMENT_SGIX = 0x8310,
+ DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311,
+ DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312,
+ COMPRESSED_RGB_FXT1_3DFX = 0x86B0,
+ COMPRESSED_RGBA_FXT1_3DFX = 0x86B1,
+ MULTISAMPLE_3DFX = 0x86B2,
+ SAMPLE_BUFFERS_3DFX = 0x86B3,
+ SAMPLES_3DFX = 0x86B4,
+ MULTISAMPLE_BIT_3DFX = 0x20000000,
+ MULTISAMPLE_EXT = 0x809D,
+ SAMPLE_ALPHA_TO_MASK_EXT = 0x809E,
+ SAMPLE_ALPHA_TO_ONE_EXT = 0x809F,
+ SAMPLE_MASK_EXT = 0x80A0,
+ _1PASS_EXT = 0x80A1,
+ _2PASS_0_EXT = 0x80A2,
+ _2PASS_1_EXT = 0x80A3,
+ _4PASS_0_EXT = 0x80A4,
+ _4PASS_1_EXT = 0x80A5,
+ _4PASS_2_EXT = 0x80A6,
+ _4PASS_3_EXT = 0x80A7,
+ SAMPLE_BUFFERS_EXT = 0x80A8,
+ SAMPLES_EXT = 0x80A9,
+ SAMPLE_MASK_VALUE_EXT = 0x80AA,
+ SAMPLE_MASK_INVERT_EXT = 0x80AB,
+ SAMPLE_PATTERN_EXT = 0x80AC,
+ MULTISAMPLE_BIT_EXT = 0x20000000,
+ DOT3_RGB_EXT = 0x8740,
+ DOT3_RGBA_EXT = 0x8741,
+ MIRROR_CLAMP_ATI = 0x8742,
+ MIRROR_CLAMP_TO_EDGE_ATI = 0x8743,
+ ALL_COMPLETED_NV = 0x84F2,
+ FENCE_STATUS_NV = 0x84F3,
+ FENCE_CONDITION_NV = 0x84F4,
+ MIRRORED_REPEAT_IBM = 0x8370,
+ EVAL_2D_NV = 0x86C0,
+ EVAL_TRIANGULAR_2D_NV = 0x86C1,
+ MAP_TESSELLATION_NV = 0x86C2,
+ MAP_ATTRIB_U_ORDER_NV = 0x86C3,
+ MAP_ATTRIB_V_ORDER_NV = 0x86C4,
+ EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5,
+ EVAL_VERTEX_ATTRIB0_NV = 0x86C6,
+ EVAL_VERTEX_ATTRIB1_NV = 0x86C7,
+ EVAL_VERTEX_ATTRIB2_NV = 0x86C8,
+ EVAL_VERTEX_ATTRIB3_NV = 0x86C9,
+ EVAL_VERTEX_ATTRIB4_NV = 0x86CA,
+ EVAL_VERTEX_ATTRIB5_NV = 0x86CB,
+ EVAL_VERTEX_ATTRIB6_NV = 0x86CC,
+ EVAL_VERTEX_ATTRIB7_NV = 0x86CD,
+ EVAL_VERTEX_ATTRIB8_NV = 0x86CE,
+ EVAL_VERTEX_ATTRIB9_NV = 0x86CF,
+ EVAL_VERTEX_ATTRIB10_NV = 0x86D0,
+ EVAL_VERTEX_ATTRIB11_NV = 0x86D1,
+ EVAL_VERTEX_ATTRIB12_NV = 0x86D2,
+ EVAL_VERTEX_ATTRIB13_NV = 0x86D3,
+ EVAL_VERTEX_ATTRIB14_NV = 0x86D4,
+ EVAL_VERTEX_ATTRIB15_NV = 0x86D5,
+ MAX_MAP_TESSELLATION_NV = 0x86D6,
+ MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7,
+ DEPTH_STENCIL_NV = 0x84F9,
+ UNSIGNED_INT_24_8_NV = 0x84FA,
+ PER_STAGE_CONSTANTS_NV = 0x8535,
+ TEXTURE_RECTANGLE_NV = 0x84F5,
+ TEXTURE_BINDING_RECTANGLE_NV = 0x84F6,
+ PROXY_TEXTURE_RECTANGLE_NV = 0x84F7,
+ MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8,
+ OFFSET_TEXTURE_RECTANGLE_NV = 0x864C,
+ OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D,
+ DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E,
+ RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9,
+ UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA,
+ UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB,
+ DSDT_MAG_INTENSITY_NV = 0x86DC,
+ SHADER_CONSISTENT_NV = 0x86DD,
+ TEXTURE_SHADER_NV = 0x86DE,
+ SHADER_OPERATION_NV = 0x86DF,
+ CULL_MODES_NV = 0x86E0,
+ OFFSET_TEXTURE_MATRIX_NV = 0x86E1,
+ OFFSET_TEXTURE_SCALE_NV = 0x86E2,
+ OFFSET_TEXTURE_BIAS_NV = 0x86E3,
+ OFFSET_TEXTURE_2D_MATRIX_NV = NV_texture_shader.OFFSET_TEXTURE_MATRIX_NV,
+ OFFSET_TEXTURE_2D_SCALE_NV = NV_texture_shader.OFFSET_TEXTURE_SCALE_NV,
+ OFFSET_TEXTURE_2D_BIAS_NV = NV_texture_shader.OFFSET_TEXTURE_BIAS_NV,
+ PREVIOUS_TEXTURE_INPUT_NV = 0x86E4,
+ CONST_EYE_NV = 0x86E5,
+ PASS_THROUGH_NV = 0x86E6,
+ CULL_FRAGMENT_NV = 0x86E7,
+ OFFSET_TEXTURE_2D_NV = 0x86E8,
+ DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9,
+ DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA,
+ DOT_PRODUCT_NV = 0x86EC,
+ DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED,
+ DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE,
+ DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0,
+ DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1,
+ DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2,
+ DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3,
+ HILO_NV = 0x86F4,
+ DSDT_NV = 0x86F5,
+ DSDT_MAG_NV = 0x86F6,
+ DSDT_MAG_VIB_NV = 0x86F7,
+ HILO16_NV = 0x86F8,
+ SIGNED_HILO_NV = 0x86F9,
+ SIGNED_HILO16_NV = 0x86FA,
+ SIGNED_RGBA_NV = 0x86FB,
+ SIGNED_RGBA8_NV = 0x86FC,
+ SIGNED_RGB_NV = 0x86FE,
+ SIGNED_RGB8_NV = 0x86FF,
+ SIGNED_LUMINANCE_NV = 0x8701,
+ SIGNED_LUMINANCE8_NV = 0x8702,
+ SIGNED_LUMINANCE_ALPHA_NV = 0x8703,
+ SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704,
+ SIGNED_ALPHA_NV = 0x8705,
+ SIGNED_ALPHA8_NV = 0x8706,
+ SIGNED_INTENSITY_NV = 0x8707,
+ SIGNED_INTENSITY8_NV = 0x8708,
+ DSDT8_NV = 0x8709,
+ DSDT8_MAG8_NV = 0x870A,
+ DSDT8_MAG8_INTENSITY8_NV = 0x870B,
+ SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C,
+ SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D,
+ HI_SCALE_NV = 0x870E,
+ LO_SCALE_NV = 0x870F,
+ DS_SCALE_NV = 0x8710,
+ DT_SCALE_NV = 0x8711,
+ MAGNITUDE_SCALE_NV = 0x8712,
+ VIBRANCE_SCALE_NV = 0x8713,
+ HI_BIAS_NV = 0x8714,
+ LO_BIAS_NV = 0x8715,
+ DS_BIAS_NV = 0x8716,
+ DT_BIAS_NV = 0x8717,
+ MAGNITUDE_BIAS_NV = 0x8718,
+ VIBRANCE_BIAS_NV = 0x8719,
+ TEXTURE_BORDER_VALUES_NV = 0x871A,
+ TEXTURE_HI_SIZE_NV = 0x871B,
+ TEXTURE_LO_SIZE_NV = 0x871C,
+ TEXTURE_DS_SIZE_NV = 0x871D,
+ TEXTURE_DT_SIZE_NV = 0x871E,
+ TEXTURE_MAG_SIZE_NV = 0x871F,
+ DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF,
+ VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533,
+ VERTEX_PROGRAM_NV = 0x8620,
+ VERTEX_STATE_PROGRAM_NV = 0x8621,
+ ATTRIB_ARRAY_SIZE_NV = 0x8623,
+ ATTRIB_ARRAY_STRIDE_NV = 0x8624,
+ ATTRIB_ARRAY_TYPE_NV = 0x8625,
+ CURRENT_ATTRIB_NV = 0x8626,
+ PROGRAM_LENGTH_NV = 0x8627,
+ PROGRAM_STRING_NV = 0x8628,
+ MODELVIEW_PROJECTION_NV = 0x8629,
+ IDENTITY_NV = 0x862A,
+ INVERSE_NV = 0x862B,
+ TRANSPOSE_NV = 0x862C,
+ INVERSE_TRANSPOSE_NV = 0x862D,
+ MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E,
+ MAX_TRACK_MATRICES_NV = 0x862F,
+ MATRIX0_NV = 0x8630,
+ MATRIX1_NV = 0x8631,
+ MATRIX2_NV = 0x8632,
+ MATRIX3_NV = 0x8633,
+ MATRIX4_NV = 0x8634,
+ MATRIX5_NV = 0x8635,
+ MATRIX6_NV = 0x8636,
+ MATRIX7_NV = 0x8637,
+ CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640,
+ CURRENT_MATRIX_NV = 0x8641,
+ VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642,
+ VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643,
+ PROGRAM_PARAMETER_NV = 0x8644,
+ ATTRIB_ARRAY_POINTER_NV = 0x8645,
+ PROGRAM_TARGET_NV = 0x8646,
+ PROGRAM_RESIDENT_NV = 0x8647,
+ TRACK_MATRIX_NV = 0x8648,
+ TRACK_MATRIX_TRANSFORM_NV = 0x8649,
+ VERTEX_PROGRAM_BINDING_NV = 0x864A,
+ PROGRAM_ERROR_POSITION_NV = 0x864B,
+ VERTEX_ATTRIB_ARRAY0_NV = 0x8650,
+ VERTEX_ATTRIB_ARRAY1_NV = 0x8651,
+ VERTEX_ATTRIB_ARRAY2_NV = 0x8652,
+ VERTEX_ATTRIB_ARRAY3_NV = 0x8653,
+ VERTEX_ATTRIB_ARRAY4_NV = 0x8654,
+ VERTEX_ATTRIB_ARRAY5_NV = 0x8655,
+ VERTEX_ATTRIB_ARRAY6_NV = 0x8656,
+ VERTEX_ATTRIB_ARRAY7_NV = 0x8657,
+ VERTEX_ATTRIB_ARRAY8_NV = 0x8658,
+ VERTEX_ATTRIB_ARRAY9_NV = 0x8659,
+ VERTEX_ATTRIB_ARRAY10_NV = 0x865A,
+ VERTEX_ATTRIB_ARRAY11_NV = 0x865B,
+ VERTEX_ATTRIB_ARRAY12_NV = 0x865C,
+ VERTEX_ATTRIB_ARRAY13_NV = 0x865D,
+ VERTEX_ATTRIB_ARRAY14_NV = 0x865E,
+ VERTEX_ATTRIB_ARRAY15_NV = 0x865F,
+ MAP1_VERTEX_ATTRIB0_4_NV = 0x8660,
+ MAP1_VERTEX_ATTRIB1_4_NV = 0x8661,
+ MAP1_VERTEX_ATTRIB2_4_NV = 0x8662,
+ MAP1_VERTEX_ATTRIB3_4_NV = 0x8663,
+ MAP1_VERTEX_ATTRIB4_4_NV = 0x8664,
+ MAP1_VERTEX_ATTRIB5_4_NV = 0x8665,
+ MAP1_VERTEX_ATTRIB6_4_NV = 0x8666,
+ MAP1_VERTEX_ATTRIB7_4_NV = 0x8667,
+ MAP1_VERTEX_ATTRIB8_4_NV = 0x8668,
+ MAP1_VERTEX_ATTRIB9_4_NV = 0x8669,
+ MAP1_VERTEX_ATTRIB10_4_NV = 0x866A,
+ MAP1_VERTEX_ATTRIB11_4_NV = 0x866B,
+ MAP1_VERTEX_ATTRIB12_4_NV = 0x866C,
+ MAP1_VERTEX_ATTRIB13_4_NV = 0x866D,
+ MAP1_VERTEX_ATTRIB14_4_NV = 0x866E,
+ MAP1_VERTEX_ATTRIB15_4_NV = 0x866F,
+ MAP2_VERTEX_ATTRIB0_4_NV = 0x8670,
+ MAP2_VERTEX_ATTRIB1_4_NV = 0x8671,
+ MAP2_VERTEX_ATTRIB2_4_NV = 0x8672,
+ MAP2_VERTEX_ATTRIB3_4_NV = 0x8673,
+ MAP2_VERTEX_ATTRIB4_4_NV = 0x8674,
+ MAP2_VERTEX_ATTRIB5_4_NV = 0x8675,
+ MAP2_VERTEX_ATTRIB6_4_NV = 0x8676,
+ MAP2_VERTEX_ATTRIB7_4_NV = 0x8677,
+ MAP2_VERTEX_ATTRIB8_4_NV = 0x8678,
+ MAP2_VERTEX_ATTRIB9_4_NV = 0x8679,
+ MAP2_VERTEX_ATTRIB10_4_NV = 0x867A,
+ MAP2_VERTEX_ATTRIB11_4_NV = 0x867B,
+ MAP2_VERTEX_ATTRIB12_4_NV = 0x867C,
+ MAP2_VERTEX_ATTRIB13_4_NV = 0x867D,
+ MAP2_VERTEX_ATTRIB14_4_NV = 0x867E,
+ MAP2_VERTEX_ATTRIB15_4_NV = 0x867F,
+ SCALEBIAS_HINT_SGIX = 0x8322,
+ INTERLACE_OML = 0x8980,
+ INTERLACE_READ_OML = 0x8981,
+ FORMAT_SUBSAMPLE_24_24_OML = 0x8982,
+ FORMAT_SUBSAMPLE_244_244_OML = 0x8983,
+ PACK_RESAMPLE_OML = 0x8984,
+ UNPACK_RESAMPLE_OML = 0x8985,
+ RESAMPLE_REPLICATE_OML = 0x8986,
+ RESAMPLE_ZERO_FILL_OML = 0x8987,
+ RESAMPLE_AVERAGE_OML = 0x8988,
+ RESAMPLE_DECIMATE_OML = 0x8989,
+ DEPTH_STENCIL_TO_RGBA_NV = 0x886E,
+ DEPTH_STENCIL_TO_BGRA_NV = 0x886F,
+ BUMP_ROT_MATRIX_ATI = 0x8775,
+ BUMP_ROT_MATRIX_SIZE_ATI = 0x8776,
+ BUMP_NUM_TEX_UNITS_ATI = 0x8777,
+ BUMP_TEX_UNITS_ATI = 0x8778,
+ DUDV_ATI = 0x8779,
+ DU8DV8_ATI = 0x877A,
+ BUMP_ENVMAP_ATI = 0x877B,
+ BUMP_TARGET_ATI = 0x877C,
+ FRAGMENT_SHADER_ATI = 0x8920,
+ REG_0_ATI = 0x8921,
+ REG_1_ATI = 0x8922,
+ REG_2_ATI = 0x8923,
+ REG_3_ATI = 0x8924,
+ REG_4_ATI = 0x8925,
+ REG_5_ATI = 0x8926,
+ REG_6_ATI = 0x8927,
+ REG_7_ATI = 0x8928,
+ REG_8_ATI = 0x8929,
+ REG_9_ATI = 0x892A,
+ REG_10_ATI = 0x892B,
+ REG_11_ATI = 0x892C,
+ REG_12_ATI = 0x892D,
+ REG_13_ATI = 0x892E,
+ REG_14_ATI = 0x892F,
+ REG_15_ATI = 0x8930,
+ REG_16_ATI = 0x8931,
+ REG_17_ATI = 0x8932,
+ REG_18_ATI = 0x8933,
+ REG_19_ATI = 0x8934,
+ REG_20_ATI = 0x8935,
+ REG_21_ATI = 0x8936,
+ REG_22_ATI = 0x8937,
+ REG_23_ATI = 0x8938,
+ REG_24_ATI = 0x8939,
+ REG_25_ATI = 0x893A,
+ REG_26_ATI = 0x893B,
+ REG_27_ATI = 0x893C,
+ REG_28_ATI = 0x893D,
+ REG_29_ATI = 0x893E,
+ REG_30_ATI = 0x893F,
+ REG_31_ATI = 0x8940,
+ CON_0_ATI = 0x8941,
+ CON_1_ATI = 0x8942,
+ CON_2_ATI = 0x8943,
+ CON_3_ATI = 0x8944,
+ CON_4_ATI = 0x8945,
+ CON_5_ATI = 0x8946,
+ CON_6_ATI = 0x8947,
+ CON_7_ATI = 0x8948,
+ CON_8_ATI = 0x8949,
+ CON_9_ATI = 0x894A,
+ CON_10_ATI = 0x894B,
+ CON_11_ATI = 0x894C,
+ CON_12_ATI = 0x894D,
+ CON_13_ATI = 0x894E,
+ CON_14_ATI = 0x894F,
+ CON_15_ATI = 0x8950,
+ CON_16_ATI = 0x8951,
+ CON_17_ATI = 0x8952,
+ CON_18_ATI = 0x8953,
+ CON_19_ATI = 0x8954,
+ CON_20_ATI = 0x8955,
+ CON_21_ATI = 0x8956,
+ CON_22_ATI = 0x8957,
+ CON_23_ATI = 0x8958,
+ CON_24_ATI = 0x8959,
+ CON_25_ATI = 0x895A,
+ CON_26_ATI = 0x895B,
+ CON_27_ATI = 0x895C,
+ CON_28_ATI = 0x895D,
+ CON_29_ATI = 0x895E,
+ CON_30_ATI = 0x895F,
+ CON_31_ATI = 0x8960,
+ MOV_ATI = 0x8961,
+ ADD_ATI = 0x8963,
+ MUL_ATI = 0x8964,
+ SUB_ATI = 0x8965,
+ DOT3_ATI = 0x8966,
+ DOT4_ATI = 0x8967,
+ MAD_ATI = 0x8968,
+ LERP_ATI = 0x8969,
+ CND_ATI = 0x896A,
+ CND0_ATI = 0x896B,
+ DOT2_ADD_ATI = 0x896C,
+ SECONDARY_INTERPOLATOR_ATI = 0x896D,
+ NUM_FRAGMENT_REGISTERS_ATI = 0x896E,
+ NUM_FRAGMENT_CONSTANTS_ATI = 0x896F,
+ NUM_PASSES_ATI = 0x8970,
+ NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971,
+ NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972,
+ NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973,
+ NUM_LOOPBACK_COMPONENTS_ATI = 0x8974,
+ COLOR_ALPHA_PAIRING_ATI = 0x8975,
+ SWIZZLE_STR_ATI = 0x8976,
+ SWIZZLE_STQ_ATI = 0x8977,
+ SWIZZLE_STR_DR_ATI = 0x8978,
+ SWIZZLE_STQ_DQ_ATI = 0x8979,
+ SWIZZLE_STRQ_ATI = 0x897A,
+ SWIZZLE_STRQ_DQ_ATI = 0x897B,
+ RED_BIT_ATI = 0x00000001,
+ GREEN_BIT_ATI = 0x00000002,
+ BLUE_BIT_ATI = 0x00000004,
+ _2X_BIT_ATI = 0x00000001,
+ _4X_BIT_ATI = 0x00000002,
+ _8X_BIT_ATI = 0x00000004,
+ HALF_BIT_ATI = 0x00000008,
+ QUARTER_BIT_ATI = 0x00000010,
+ EIGHTH_BIT_ATI = 0x00000020,
+ SATURATE_BIT_ATI = 0x00000040,
+ COMP_BIT_ATI = 0x00000002,
+ NEGATE_BIT_ATI = 0x00000004,
+ BIAS_BIT_ATI = 0x00000008,
+ PN_TRIANGLES_ATI = 0x87F0,
+ MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1,
+ PN_TRIANGLES_POINT_MODE_ATI = 0x87F2,
+ PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3,
+ PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4,
+ PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5,
+ PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6,
+ PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7,
+ PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8,
+ STATIC_ATI = 0x8760,
+ DYNAMIC_ATI = 0x8761,
+ PRESERVE_ATI = 0x8762,
+ DISCARD_ATI = 0x8763,
+ OBJECT_BUFFER_SIZE_ATI = 0x8764,
+ OBJECT_BUFFER_USAGE_ATI = 0x8765,
+ ARRAY_OBJECT_BUFFER_ATI = 0x8766,
+ ARRAY_OBJECT_OFFSET_ATI = 0x8767,
+ VERTEX_SHADER_EXT = 0x8780,
+ VERTEX_SHADER_BINDING_EXT = 0x8781,
+ OP_INDEX_EXT = 0x8782,
+ OP_NEGATE_EXT = 0x8783,
+ OP_DOT3_EXT = 0x8784,
+ OP_DOT4_EXT = 0x8785,
+ OP_MUL_EXT = 0x8786,
+ OP_ADD_EXT = 0x8787,
+ OP_MADD_EXT = 0x8788,
+ OP_FRAC_EXT = 0x8789,
+ OP_MAX_EXT = 0x878A,
+ OP_MIN_EXT = 0x878B,
+ OP_SET_GE_EXT = 0x878C,
+ OP_SET_LT_EXT = 0x878D,
+ OP_CLAMP_EXT = 0x878E,
+ OP_FLOOR_EXT = 0x878F,
+ OP_ROUND_EXT = 0x8790,
+ OP_EXP_BASE_2_EXT = 0x8791,
+ OP_LOG_BASE_2_EXT = 0x8792,
+ OP_POWER_EXT = 0x8793,
+ OP_RECIP_EXT = 0x8794,
+ OP_RECIP_SQRT_EXT = 0x8795,
+ OP_SUB_EXT = 0x8796,
+ OP_CROSS_PRODUCT_EXT = 0x8797,
+ OP_MULTIPLY_MATRIX_EXT = 0x8798,
+ OP_MOV_EXT = 0x8799,
+ OUTPUT_VERTEX_EXT = 0x879A,
+ OUTPUT_COLOR0_EXT = 0x879B,
+ OUTPUT_COLOR1_EXT = 0x879C,
+ OUTPUT_TEXTURE_COORD0_EXT = 0x879D,
+ OUTPUT_TEXTURE_COORD1_EXT = 0x879E,
+ OUTPUT_TEXTURE_COORD2_EXT = 0x879F,
+ OUTPUT_TEXTURE_COORD3_EXT = 0x87A0,
+ OUTPUT_TEXTURE_COORD4_EXT = 0x87A1,
+ OUTPUT_TEXTURE_COORD5_EXT = 0x87A2,
+ OUTPUT_TEXTURE_COORD6_EXT = 0x87A3,
+ OUTPUT_TEXTURE_COORD7_EXT = 0x87A4,
+ OUTPUT_TEXTURE_COORD8_EXT = 0x87A5,
+ OUTPUT_TEXTURE_COORD9_EXT = 0x87A6,
+ OUTPUT_TEXTURE_COORD10_EXT = 0x87A7,
+ OUTPUT_TEXTURE_COORD11_EXT = 0x87A8,
+ OUTPUT_TEXTURE_COORD12_EXT = 0x87A9,
+ OUTPUT_TEXTURE_COORD13_EXT = 0x87AA,
+ OUTPUT_TEXTURE_COORD14_EXT = 0x87AB,
+ OUTPUT_TEXTURE_COORD15_EXT = 0x87AC,
+ OUTPUT_TEXTURE_COORD16_EXT = 0x87AD,
+ OUTPUT_TEXTURE_COORD17_EXT = 0x87AE,
+ OUTPUT_TEXTURE_COORD18_EXT = 0x87AF,
+ OUTPUT_TEXTURE_COORD19_EXT = 0x87B0,
+ OUTPUT_TEXTURE_COORD20_EXT = 0x87B1,
+ OUTPUT_TEXTURE_COORD21_EXT = 0x87B2,
+ OUTPUT_TEXTURE_COORD22_EXT = 0x87B3,
+ OUTPUT_TEXTURE_COORD23_EXT = 0x87B4,
+ OUTPUT_TEXTURE_COORD24_EXT = 0x87B5,
+ OUTPUT_TEXTURE_COORD25_EXT = 0x87B6,
+ OUTPUT_TEXTURE_COORD26_EXT = 0x87B7,
+ OUTPUT_TEXTURE_COORD27_EXT = 0x87B8,
+ OUTPUT_TEXTURE_COORD28_EXT = 0x87B9,
+ OUTPUT_TEXTURE_COORD29_EXT = 0x87BA,
+ OUTPUT_TEXTURE_COORD30_EXT = 0x87BB,
+ OUTPUT_TEXTURE_COORD31_EXT = 0x87BC,
+ OUTPUT_FOG_EXT = 0x87BD,
+ SCALAR_EXT = 0x87BE,
+ VECTOR_EXT = 0x87BF,
+ MATRIX_EXT = 0x87C0,
+ VARIANT_EXT = 0x87C1,
+ INVARIANT_EXT = 0x87C2,
+ LOCAL_CONSTANT_EXT = 0x87C3,
+ LOCAL_EXT = 0x87C4,
+ MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5,
+ MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6,
+ MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7,
+ MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8,
+ MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9,
+ MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA,
+ MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB,
+ MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC,
+ MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD,
+ MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE,
+ VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF,
+ VERTEX_SHADER_VARIANTS_EXT = 0x87D0,
+ VERTEX_SHADER_INVARIANTS_EXT = 0x87D1,
+ VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2,
+ VERTEX_SHADER_LOCALS_EXT = 0x87D3,
+ VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4,
+ X_EXT = 0x87D5,
+ Y_EXT = 0x87D6,
+ Z_EXT = 0x87D7,
+ W_EXT = 0x87D8,
+ NEGATIVE_X_EXT = 0x87D9,
+ NEGATIVE_Y_EXT = 0x87DA,
+ NEGATIVE_Z_EXT = 0x87DB,
+ NEGATIVE_W_EXT = 0x87DC,
+ ZERO_EXT = 0x87DD,
+ ONE_EXT = 0x87DE,
+ NEGATIVE_ONE_EXT = 0x87DF,
+ NORMALIZED_RANGE_EXT = 0x87E0,
+ FULL_RANGE_EXT = 0x87E1,
+ CURRENT_VERTEX_EXT = 0x87E2,
+ MVP_MATRIX_EXT = 0x87E3,
+ VARIANT_VALUE_EXT = 0x87E4,
+ VARIANT_DATATYPE_EXT = 0x87E5,
+ VARIANT_ARRAY_STRIDE_EXT = 0x87E6,
+ VARIANT_ARRAY_TYPE_EXT = 0x87E7,
+ VARIANT_ARRAY_EXT = 0x87E8,
+ VARIANT_ARRAY_POINTER_EXT = 0x87E9,
+ INVARIANT_VALUE_EXT = 0x87EA,
+ INVARIANT_DATATYPE_EXT = 0x87EB,
+ LOCAL_CONSTANT_VALUE_EXT = 0x87EC,
+ LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED,
+ MAX_VERTEX_STREAMS_ATI = 0x876B,
+ VERTEX_STREAM0_ATI = 0x876C,
+ VERTEX_STREAM1_ATI = 0x876D,
+ VERTEX_STREAM2_ATI = 0x876E,
+ VERTEX_STREAM3_ATI = 0x876F,
+ VERTEX_STREAM4_ATI = 0x8770,
+ VERTEX_STREAM5_ATI = 0x8771,
+ VERTEX_STREAM6_ATI = 0x8772,
+ VERTEX_STREAM7_ATI = 0x8773,
+ VERTEX_SOURCE_ATI = 0x8774,
+ ELEMENT_ARRAY_ATI = 0x8768,
+ ELEMENT_ARRAY_TYPE_ATI = 0x8769,
+ ELEMENT_ARRAY_POINTER_ATI = 0x876A,
+ QUAD_MESH_SUN = 0x8614,
+ TRIANGLE_MESH_SUN = 0x8615,
+ SLICE_ACCUM_SUN = 0x85CC,
+ MULTISAMPLE_FILTER_HINT_NV = 0x8534,
+ DEPTH_CLAMP_NV = 0x864F,
+ PIXEL_COUNTER_BITS_NV = 0x8864,
+ CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865,
+ PIXEL_COUNT_NV = 0x8866,
+ PIXEL_COUNT_AVAILABLE_NV = 0x8867,
+ POINT_SPRITE_NV = 0x8861,
+ COORD_REPLACE_NV = 0x8862,
+ POINT_SPRITE_R_MODE_NV = 0x8863,
+ OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850,
+ OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851,
+ OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852,
+ OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853,
+ OFFSET_HILO_TEXTURE_2D_NV = 0x8854,
+ OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855,
+ OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856,
+ OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857,
+ DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858,
+ DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859,
+ DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A,
+ DOT_PRODUCT_PASS_THROUGH_NV = 0x885B,
+ DOT_PRODUCT_TEXTURE_1D_NV = 0x885C,
+ DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D,
+ HILO8_NV = 0x885E,
+ SIGNED_HILO8_NV = 0x885F,
+ FORCE_BLUE_TO_ONE_NV = 0x8860,
+ STENCIL_TEST_TWO_SIDE_EXT = 0x8910,
+ ACTIVE_STENCIL_FACE_EXT = 0x8911,
+ TEXT_FRAGMENT_SHADER_ATI = 0x8200,
+ UNPACK_CLIENT_STORAGE_APPLE = 0x85B2,
+ ELEMENT_ARRAY_APPLE = 0x8768,
+ ELEMENT_ARRAY_TYPE_APPLE = 0x8769,
+ ELEMENT_ARRAY_POINTER_APPLE = 0x876A,
+ DRAW_PIXELS_APPLE = 0x8A0A,
+ FENCE_APPLE = 0x8A0B,
+ VERTEX_ARRAY_BINDING_APPLE = 0x85B5,
+ VERTEX_ARRAY_RANGE_APPLE = 0x851D,
+ VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E,
+ VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F,
+ VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521,
+ STORAGE_CACHED_APPLE = 0x85BE,
+ STORAGE_SHARED_APPLE = 0x85BF,
+ YCBCR_422_APPLE = 0x85B9,
+ UNSIGNED_SHORT_8_8_APPLE = 0x85BA,
+ UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB,
+ RGB_S3TC = 0x83A0,
+ RGB4_S3TC = 0x83A1,
+ RGBA_S3TC = 0x83A2,
+ RGBA4_S3TC = 0x83A3,
+ MAX_DRAW_BUFFERS_ATI = 0x8824,
+ DRAW_BUFFER0_ATI = 0x8825,
+ DRAW_BUFFER1_ATI = 0x8826,
+ DRAW_BUFFER2_ATI = 0x8827,
+ DRAW_BUFFER3_ATI = 0x8828,
+ DRAW_BUFFER4_ATI = 0x8829,
+ DRAW_BUFFER5_ATI = 0x882A,
+ DRAW_BUFFER6_ATI = 0x882B,
+ DRAW_BUFFER7_ATI = 0x882C,
+ DRAW_BUFFER8_ATI = 0x882D,
+ DRAW_BUFFER9_ATI = 0x882E,
+ DRAW_BUFFER10_ATI = 0x882F,
+ DRAW_BUFFER11_ATI = 0x8830,
+ DRAW_BUFFER12_ATI = 0x8831,
+ DRAW_BUFFER13_ATI = 0x8832,
+ DRAW_BUFFER14_ATI = 0x8833,
+ DRAW_BUFFER15_ATI = 0x8834,
+ TYPE_RGBA_FLOAT_ATI = 0x8820,
+ COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835,
+ MODULATE_ADD_ATI = 0x8744,
+ MODULATE_SIGNED_ADD_ATI = 0x8745,
+ MODULATE_SUBTRACT_ATI = 0x8746,
+ RGBA_FLOAT32_ATI = 0x8814,
+ RGB_FLOAT32_ATI = 0x8815,
+ ALPHA_FLOAT32_ATI = 0x8816,
+ INTENSITY_FLOAT32_ATI = 0x8817,
+ LUMINANCE_FLOAT32_ATI = 0x8818,
+ LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819,
+ RGBA_FLOAT16_ATI = 0x881A,
+ RGB_FLOAT16_ATI = 0x881B,
+ ALPHA_FLOAT16_ATI = 0x881C,
+ INTENSITY_FLOAT16_ATI = 0x881D,
+ LUMINANCE_FLOAT16_ATI = 0x881E,
+ LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F,
+ FLOAT_R_NV = 0x8880,
+ FLOAT_RG_NV = 0x8881,
+ FLOAT_RGB_NV = 0x8882,
+ FLOAT_RGBA_NV = 0x8883,
+ FLOAT_R16_NV = 0x8884,
+ FLOAT_R32_NV = 0x8885,
+ FLOAT_RG16_NV = 0x8886,
+ FLOAT_RG32_NV = 0x8887,
+ FLOAT_RGB16_NV = 0x8888,
+ FLOAT_RGB32_NV = 0x8889,
+ FLOAT_RGBA16_NV = 0x888A,
+ FLOAT_RGBA32_NV = 0x888B,
+ TEXTURE_FLOAT_COMPONENTS_NV = 0x888C,
+ FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D,
+ FLOAT_RGBA_MODE_NV = 0x888E,
+ MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868,
+ FRAGMENT_PROGRAM_NV = 0x8870,
+ MAX_TEXTURE_COORDS_NV = 0x8871,
+ MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872,
+ FRAGMENT_PROGRAM_BINDING_NV = 0x8873,
+ PROGRAM_ERROR_STRING_NV = 0x8874,
+ HALF_FLOAT_NV = 0x140B,
+ WRITE_PIXEL_DATA_RANGE_NV = 0x8878,
+ READ_PIXEL_DATA_RANGE_NV = 0x8879,
+ WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A,
+ READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B,
+ WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C,
+ READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D,
+ PRIMITIVE_RESTART_NV = 0x8558,
+ PRIMITIVE_RESTART_INDEX_NV = 0x8559,
+ TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F,
+ STENCIL_BACK_FUNC_ATI = 0x8800,
+ STENCIL_BACK_FAIL_ATI = 0x8801,
+ STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802,
+ STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803,
+ IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A,
+ IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B,
+ DEPTH_BOUNDS_TEST_EXT = 0x8890,
+ DEPTH_BOUNDS_EXT = 0x8891,
+ MIRROR_CLAMP_EXT = 0x8742,
+ MIRROR_CLAMP_TO_EDGE_EXT = 0x8743,
+ MIRROR_CLAMP_TO_BORDER_EXT = 0x8912,
+ BLEND_EQUATION_RGB_EXT = ARB_imaging.BLEND_EQUATION,
+ BLEND_EQUATION_ALPHA_EXT = 0x883D,
+ PACK_INVERT_MESA = 0x8758,
+ UNSIGNED_SHORT_8_8_MESA = 0x85BA,
+ UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB,
+ YCBCR_MESA = 0x8757,
+ PIXEL_PACK_BUFFER_EXT = 0x88EB,
+ PIXEL_UNPACK_BUFFER_EXT = 0x88EC,
+ PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED,
+ PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF,
+ MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4,
+ MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5,
+ MAX_PROGRAM_IF_DEPTH_NV = 0x88F6,
+ MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7,
+ MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8,
+ INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506,
+ MAX_RENDERBUFFER_SIZE_EXT = 0x84E8,
+ FRAMEBUFFER_BINDING_EXT = 0x8CA6,
+ RENDERBUFFER_BINDING_EXT = 0x8CA7,
+ FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0,
+ FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4,
+ FRAMEBUFFER_COMPLETE_EXT = 0x8CD5,
+ FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6,
+ FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7,
+ FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9,
+ FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA,
+ FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB,
+ FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC,
+ FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD,
+ MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF,
+ COLOR_ATTACHMENT0_EXT = 0x8CE0,
+ COLOR_ATTACHMENT1_EXT = 0x8CE1,
+ COLOR_ATTACHMENT2_EXT = 0x8CE2,
+ COLOR_ATTACHMENT3_EXT = 0x8CE3,
+ COLOR_ATTACHMENT4_EXT = 0x8CE4,
+ COLOR_ATTACHMENT5_EXT = 0x8CE5,
+ COLOR_ATTACHMENT6_EXT = 0x8CE6,
+ COLOR_ATTACHMENT7_EXT = 0x8CE7,
+ COLOR_ATTACHMENT8_EXT = 0x8CE8,
+ COLOR_ATTACHMENT9_EXT = 0x8CE9,
+ COLOR_ATTACHMENT10_EXT = 0x8CEA,
+ COLOR_ATTACHMENT11_EXT = 0x8CEB,
+ COLOR_ATTACHMENT12_EXT = 0x8CEC,
+ COLOR_ATTACHMENT13_EXT = 0x8CED,
+ COLOR_ATTACHMENT14_EXT = 0x8CEE,
+ COLOR_ATTACHMENT15_EXT = 0x8CEF,
+ DEPTH_ATTACHMENT_EXT = 0x8D00,
+ STENCIL_ATTACHMENT_EXT = 0x8D20,
+ FRAMEBUFFER_EXT = 0x8D40,
+ RENDERBUFFER_EXT = 0x8D41,
+ RENDERBUFFER_WIDTH_EXT = 0x8D42,
+ RENDERBUFFER_HEIGHT_EXT = 0x8D43,
+ RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44,
+ STENCIL_INDEX1_EXT = 0x8D46,
+ STENCIL_INDEX4_EXT = 0x8D47,
+ STENCIL_INDEX8_EXT = 0x8D48,
+ STENCIL_INDEX16_EXT = 0x8D49,
+ RENDERBUFFER_RED_SIZE_EXT = 0x8D50,
+ RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51,
+ RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52,
+ RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53,
+ RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54,
+ RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55,
+ DEPTH_STENCIL_EXT = 0x84F9,
+ UNSIGNED_INT_24_8_EXT = 0x84FA,
+ DEPTH24_STENCIL8_EXT = 0x88F0,
+ TEXTURE_STENCIL_SIZE_EXT = 0x88F1,
+ STENCIL_TAG_BITS_EXT = 0x88F2,
+ STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3,
+ SRGB_EXT = 0x8C40,
+ SRGB8_EXT = 0x8C41,
+ SRGB_ALPHA_EXT = 0x8C42,
+ SRGB8_ALPHA8_EXT = 0x8C43,
+ SLUMINANCE_ALPHA_EXT = 0x8C44,
+ SLUMINANCE8_ALPHA8_EXT = 0x8C45,
+ SLUMINANCE_EXT = 0x8C46,
+ SLUMINANCE8_EXT = 0x8C47,
+ COMPRESSED_SRGB_EXT = 0x8C48,
+ COMPRESSED_SRGB_ALPHA_EXT = 0x8C49,
+ COMPRESSED_SLUMINANCE_EXT = 0x8C4A,
+ COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B,
+ COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C,
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D,
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E,
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F,
+ READ_FRAMEBUFFER_EXT = 0x8CA8,
+ DRAW_FRAMEBUFFER_EXT = 0x8CA9,
+ READ_FRAMEBUFFER_BINDING_EXT = EXT_framebuffer_object.FRAMEBUFFER_BINDING_EXT,
+ DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CAA,
+ RENDERBUFFER_SAMPLES_EXT = 0x8CAB,
+ FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56,
+ MAX_SAMPLES_EXT = 0x8D57,
+ TEXTURE_1D_STACK_MESAX = 0x8759,
+ TEXTURE_2D_STACK_MESAX = 0x875A,
+ PROXY_TEXTURE_1D_STACK_MESAX = 0x875B,
+ PROXY_TEXTURE_2D_STACK_MESAX = 0x875C,
+ TEXTURE_1D_STACK_BINDING_MESAX = 0x875D,
+ TEXTURE_2D_STACK_BINDING_MESAX = 0x875E,
+ TIME_ELAPSED_EXT = 0x88BF,
+ BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12,
+ BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13,
+ MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904,
+ MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905,
+ PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906,
+ PROGRAM_RESULT_COMPONENTS_NV = 0x8907,
+ MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908,
+ MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909,
+ MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5,
+ MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6,
+ LINES_ADJACENCY_EXT = 0x000A,
+ LINE_STRIP_ADJACENCY_EXT = 0x000B,
+ TRIANGLES_ADJACENCY_EXT = 0x000C,
+ TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D,
+ GEOMETRY_PROGRAM_NV = 0x8C26,
+ MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27,
+ MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28,
+ GEOMETRY_VERTICES_OUT_EXT = 0x8DDA,
+ GEOMETRY_INPUT_TYPE_EXT = 0x8DDB,
+ GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC,
+ MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29,
+ FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7,
+ FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8,
+ FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4,
+ PROGRAM_POINT_SIZE_EXT = 0x8642,
+ GEOMETRY_SHADER_EXT = 0x8DD9,
+ MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD,
+ MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE,
+ MAX_VARYING_COMPONENTS_EXT = 0x8B4B,
+ MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF,
+ MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0,
+ MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1,
+ VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD,
+ SAMPLER_1D_ARRAY_EXT = 0x8DC0,
+ SAMPLER_2D_ARRAY_EXT = 0x8DC1,
+ SAMPLER_BUFFER_EXT = 0x8DC2,
+ SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3,
+ SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4,
+ SAMPLER_CUBE_SHADOW_EXT = 0x8DC5,
+ UNSIGNED_INT_VEC2_EXT = 0x8DC6,
+ UNSIGNED_INT_VEC3_EXT = 0x8DC7,
+ UNSIGNED_INT_VEC4_EXT = 0x8DC8,
+ INT_SAMPLER_1D_EXT = 0x8DC9,
+ INT_SAMPLER_2D_EXT = 0x8DCA,
+ INT_SAMPLER_3D_EXT = 0x8DCB,
+ INT_SAMPLER_CUBE_EXT = 0x8DCC,
+ INT_SAMPLER_2D_RECT_EXT = 0x8DCD,
+ INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE,
+ INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF,
+ INT_SAMPLER_BUFFER_EXT = 0x8DD0,
+ UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1,
+ UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2,
+ UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3,
+ UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4,
+ UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5,
+ UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6,
+ UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7,
+ UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8,
+ R11F_G11F_B10F_EXT = 0x8C3A,
+ UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B,
+ RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C,
+ TEXTURE_1D_ARRAY_EXT = 0x8C18,
+ PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19,
+ TEXTURE_2D_ARRAY_EXT = 0x8C1A,
+ PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B,
+ TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C,
+ TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D,
+ MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF,
+ COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E,
+ TEXTURE_BUFFER_EXT = 0x8C2A,
+ MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B,
+ TEXTURE_BINDING_BUFFER_EXT = 0x8C2C,
+ TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D,
+ TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E,
+ COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70,
+ COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71,
+ COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72,
+ COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73,
+ COMPRESSED_RED_RGTC1_EXT = 0x8DBB,
+ COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC,
+ COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD,
+ COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE,
+ RGB9_E5_EXT = 0x8C3D,
+ UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E,
+ TEXTURE_SHARED_SIZE_EXT = 0x8C3F,
+ DEPTH_COMPONENT32F_NV = 0x8DAB,
+ DEPTH32F_STENCIL8_NV = 0x8DAC,
+ FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD,
+ DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF,
+ RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB,
+ RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10,
+ MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11,
+ MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12,
+ FRAMEBUFFER_SRGB_EXT = 0x8DB9,
+ FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA,
+ MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0,
+ MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1,
+ VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2,
+ GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3,
+ FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4,
+ BACK_PRIMARY_COLOR_NV = 0x8C77,
+ BACK_SECONDARY_COLOR_NV = 0x8C78,
+ TEXTURE_COORD_NV = 0x8C79,
+ CLIP_DISTANCE_NV = 0x8C7A,
+ VERTEX_ID_NV = 0x8C7B,
+ PRIMITIVE_ID_NV = 0x8C7C,
+ GENERIC_ATTRIB_NV = 0x8C7D,
+ TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E,
+ TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F,
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80,
+ ACTIVE_VARYINGS_NV = 0x8C81,
+ ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82,
+ TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83,
+ TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84,
+ TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85,
+ TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86,
+ PRIMITIVES_GENERATED_NV = 0x8C87,
+ TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88,
+ RASTERIZER_DISCARD_NV = 0x8C89,
+ MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV = 0x8C8A,
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B,
+ INTERLEAVED_ATTRIBS_NV = 0x8C8C,
+ SEPARATE_ATTRIBS_NV = 0x8C8D,
+ TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E,
+ TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F,
+ MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2,
+ MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3,
+ MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4,
+ MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED,
+ UNIFORM_BUFFER_EXT = 0x8DEE,
+ UNIFORM_BUFFER_BINDING_EXT = 0x8DEF,
+ RGBA32UI_EXT = 0x8D70,
+ RGB32UI_EXT = 0x8D71,
+ ALPHA32UI_EXT = 0x8D72,
+ INTENSITY32UI_EXT = 0x8D73,
+ LUMINANCE32UI_EXT = 0x8D74,
+ LUMINANCE_ALPHA32UI_EXT = 0x8D75,
+ RGBA16UI_EXT = 0x8D76,
+ RGB16UI_EXT = 0x8D77,
+ ALPHA16UI_EXT = 0x8D78,
+ INTENSITY16UI_EXT = 0x8D79,
+ LUMINANCE16UI_EXT = 0x8D7A,
+ LUMINANCE_ALPHA16UI_EXT = 0x8D7B,
+ RGBA8UI_EXT = 0x8D7C,
+ RGB8UI_EXT = 0x8D7D,
+ ALPHA8UI_EXT = 0x8D7E,
+ INTENSITY8UI_EXT = 0x8D7F,
+ LUMINANCE8UI_EXT = 0x8D80,
+ LUMINANCE_ALPHA8UI_EXT = 0x8D81,
+ RGBA32I_EXT = 0x8D82,
+ RGB32I_EXT = 0x8D83,
+ ALPHA32I_EXT = 0x8D84,
+ INTENSITY32I_EXT = 0x8D85,
+ LUMINANCE32I_EXT = 0x8D86,
+ LUMINANCE_ALPHA32I_EXT = 0x8D87,
+ RGBA16I_EXT = 0x8D88,
+ RGB16I_EXT = 0x8D89,
+ ALPHA16I_EXT = 0x8D8A,
+ INTENSITY16I_EXT = 0x8D8B,
+ LUMINANCE16I_EXT = 0x8D8C,
+ LUMINANCE_ALPHA16I_EXT = 0x8D8D,
+ RGBA8I_EXT = 0x8D8E,
+ RGB8I_EXT = 0x8D8F,
+ ALPHA8I_EXT = 0x8D90,
+ INTENSITY8I_EXT = 0x8D91,
+ LUMINANCE8I_EXT = 0x8D92,
+ LUMINANCE_ALPHA8I_EXT = 0x8D93,
+ RED_INTEGER_EXT = 0x8D94,
+ GREEN_INTEGER_EXT = 0x8D95,
+ BLUE_INTEGER_EXT = 0x8D96,
+ ALPHA_INTEGER_EXT = 0x8D97,
+ RGB_INTEGER_EXT = 0x8D98,
+ RGBA_INTEGER_EXT = 0x8D99,
+ BGR_INTEGER_EXT = 0x8D9A,
+ BGRA_INTEGER_EXT = 0x8D9B,
+ LUMINANCE_INTEGER_EXT = 0x8D9C,
+ LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D,
+ RGBA_INTEGER_MODE_EXT = 0x8D9E,
+ }
+ #region public enum AttribMask
+ public enum AttribMask
+ {
+ CURRENT_BIT = 0x00000001,
+ POINT_BIT = 0x00000002,
+ LINE_BIT = 0x00000004,
+ POLYGON_BIT = 0x00000008,
+ POLYGON_STIPPLE_BIT = 0x00000010,
+ PIXEL_MODE_BIT = 0x00000020,
+ LIGHTING_BIT = 0x00000040,
+ FOG_BIT = 0x00000080,
+ DEPTH_BUFFER_BIT = 0x00000100,
+ ACCUM_BUFFER_BIT = 0x00000200,
+ STENCIL_BUFFER_BIT = 0x00000400,
+ VIEWPORT_BIT = 0x00000800,
+ TRANSFORM_BIT = 0x00001000,
+ ENABLE_BIT = 0x00002000,
+ COLOR_BUFFER_BIT = 0x00004000,
+ HINT_BIT = 0x00008000,
+ EVAL_BIT = 0x00010000,
+ LIST_BIT = 0x00020000,
+ TEXTURE_BIT = 0x00040000,
+ SCISSOR_BIT = 0x00080000,
+ ALL_ATTRIB_BITS = unchecked((Int32)0xFFFFFFFF),
+ }
+ #endregion
+ #region public enum ClearBufferMask
+ public enum ClearBufferMask
+ {
+ COLOR_BUFFER_BIT = AttribMask.COLOR_BUFFER_BIT,
+ ACCUM_BUFFER_BIT = AttribMask.ACCUM_BUFFER_BIT,
+ STENCIL_BUFFER_BIT = AttribMask.STENCIL_BUFFER_BIT,
+ DEPTH_BUFFER_BIT = AttribMask.DEPTH_BUFFER_BIT,
+ }
+ #endregion
+ #region public enum ClientAttribMask
+ public enum ClientAttribMask
+ {
+ CLIENT_PIXEL_STORE_BIT = 0x00000001,
+ CLIENT_VERTEX_ARRAY_BIT = 0x00000002,
+ CLIENT_ALL_ATTRIB_BITS = unchecked((Int32)0xFFFFFFFF),
+ }
+ #endregion
+ #region public enum Boolean
+ public enum Boolean
+ {
+ FALSE = 0,
+ TRUE = 1,
+ }
+ #endregion
+ #region public enum BeginMode
+ public enum BeginMode
+ {
+ POINTS = 0x0000,
+ LINES = 0x0001,
+ LINE_LOOP = 0x0002,
+ LINE_STRIP = 0x0003,
+ TRIANGLES = 0x0004,
+ TRIANGLE_STRIP = 0x0005,
+ TRIANGLE_FAN = 0x0006,
+ QUADS = 0x0007,
+ QUAD_STRIP = 0x0008,
+ POLYGON = 0x0009,
+ }
+ #endregion
+ #region public enum AccumOp
+ public enum AccumOp
+ {
+ ACCUM = 0x0100,
+ LOAD = 0x0101,
+ RETURN = 0x0102,
+ MULT = 0x0103,
+ ADD = 0x0104,
+ }
+ #endregion
+ #region public enum AlphaFunction
+ public enum AlphaFunction
+ {
+ NEVER = 0x0200,
+ LESS = 0x0201,
+ EQUAL = 0x0202,
+ LEQUAL = 0x0203,
+ GREATER = 0x0204,
+ NOTEQUAL = 0x0205,
+ GEQUAL = 0x0206,
+ ALWAYS = 0x0207,
+ }
+ #endregion
+ #region public enum BlendingFactorDest
+ public enum BlendingFactorDest
+ {
+ ZERO = 0,
+ ONE = 1,
+ SRC_COLOR = 0x0300,
+ ONE_MINUS_SRC_COLOR = 0x0301,
+ SRC_ALPHA = 0x0302,
+ ONE_MINUS_SRC_ALPHA = 0x0303,
+ DST_ALPHA = 0x0304,
+ ONE_MINUS_DST_ALPHA = 0x0305,
+ CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT,
+ ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT,
+ CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT,
+ ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT,
+ }
+ #endregion
+ #region public enum BlendingFactorSrc
+ public enum BlendingFactorSrc
+ {
+ ZERO = BlendingFactorDest.ZERO,
+ ONE = BlendingFactorDest.ONE,
+ DST_COLOR = 0x0306,
+ ONE_MINUS_DST_COLOR = 0x0307,
+ SRC_ALPHA_SATURATE = 0x0308,
+ SRC_ALPHA = BlendingFactorDest.SRC_ALPHA,
+ ONE_MINUS_SRC_ALPHA = BlendingFactorDest.ONE_MINUS_SRC_ALPHA,
+ DST_ALPHA = BlendingFactorDest.DST_ALPHA,
+ ONE_MINUS_DST_ALPHA = BlendingFactorDest.ONE_MINUS_DST_ALPHA,
+ CONSTANT_COLOR_EXT = EXT_blend_color.CONSTANT_COLOR_EXT,
+ ONE_MINUS_CONSTANT_COLOR_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_COLOR_EXT,
+ CONSTANT_ALPHA_EXT = EXT_blend_color.CONSTANT_ALPHA_EXT,
+ ONE_MINUS_CONSTANT_ALPHA_EXT = EXT_blend_color.ONE_MINUS_CONSTANT_ALPHA_EXT,
+ }
+ #endregion
+ #region public enum BlendEquationModeEXT
+ public enum BlendEquationModeEXT
+ {
+ LOGIC_OP = GetPName.LOGIC_OP,
+ FUNC_ADD_EXT = EXT_blend_minmax.FUNC_ADD_EXT,
+ MIN_EXT = EXT_blend_minmax.MIN_EXT,
+ MAX_EXT = EXT_blend_minmax.MAX_EXT,
+ FUNC_SUBTRACT_EXT = EXT_blend_subtract.FUNC_SUBTRACT_EXT,
+ FUNC_REVERSE_SUBTRACT_EXT = EXT_blend_subtract.FUNC_REVERSE_SUBTRACT_EXT,
+ ALPHA_MIN_SGIX = SGIX_blend_alpha_minmax.ALPHA_MIN_SGIX,
+ ALPHA_MAX_SGIX = SGIX_blend_alpha_minmax.ALPHA_MAX_SGIX,
+ }
+ #endregion
+ #region public enum ColorMaterialFace
+ public enum ColorMaterialFace
+ {
+ FRONT = DrawBufferMode.FRONT,
+ BACK = DrawBufferMode.BACK,
+ FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
+ }
+ #endregion
+ #region public enum ColorMaterialParameter
+ public enum ColorMaterialParameter
+ {
+ AMBIENT = LightParameter.AMBIENT,
+ DIFFUSE = LightParameter.DIFFUSE,
+ SPECULAR = LightParameter.SPECULAR,
+ EMISSION = MaterialParameter.EMISSION,
+ AMBIENT_AND_DIFFUSE = MaterialParameter.AMBIENT_AND_DIFFUSE,
+ }
+ #endregion
+ #region public enum ColorPointerType
+ public enum ColorPointerType
+ {
+ BYTE = DataType.BYTE,
+ UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
+ SHORT = DataType.SHORT,
+ UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
+ INT = DataType.INT,
+ UNSIGNED_INT = DataType.UNSIGNED_INT,
+ FLOAT = DataType.FLOAT,
+ DOUBLE = DataType.DOUBLE,
+ }
+ #endregion
+ #region public enum ColorTableParameterPNameSGI
+ public enum ColorTableParameterPNameSGI
+ {
+ COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI,
+ COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI,
+ }
+ #endregion
+ #region public enum ColorTableTargetSGI
+ public enum ColorTableTargetSGI
+ {
+ COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
+ POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
+ POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.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,
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+ TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
+ PROXY_TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.PROXY_TEXTURE_COLOR_TABLE_SGI,
+ }
+ #endregion
+ #region public enum ConvolutionBorderModeEXT
+ public enum ConvolutionBorderModeEXT
+ {
+ REDUCE_EXT = EXT_convolution.REDUCE_EXT,
+ }
+ #endregion
+ #region public enum ConvolutionParameterEXT
+ public enum ConvolutionParameterEXT
+ {
+ CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT,
+ CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT,
+ CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT,
+ }
+ #endregion
+ #region public enum ConvolutionTargetEXT
+ public enum ConvolutionTargetEXT
+ {
+ CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
+ CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
+ }
+ #endregion
+ #region public enum CullFaceMode
+ public enum CullFaceMode
+ {
+ FRONT = DrawBufferMode.FRONT,
+ BACK = DrawBufferMode.BACK,
+ FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
+ }
+ #endregion
+ #region public enum DepthFunction
+ public enum DepthFunction
+ {
+ NEVER = AlphaFunction.NEVER,
+ LESS = AlphaFunction.LESS,
+ EQUAL = AlphaFunction.EQUAL,
+ LEQUAL = AlphaFunction.LEQUAL,
+ GREATER = AlphaFunction.GREATER,
+ NOTEQUAL = AlphaFunction.NOTEQUAL,
+ GEQUAL = AlphaFunction.GEQUAL,
+ ALWAYS = AlphaFunction.ALWAYS,
+ }
+ #endregion
+ #region public enum DrawBufferMode
+ public enum DrawBufferMode
+ {
+ NONE = 0,
+ FRONT_LEFT = 0x0400,
+ FRONT_RIGHT = 0x0401,
+ BACK_LEFT = 0x0402,
+ BACK_RIGHT = 0x0403,
+ FRONT = 0x0404,
+ BACK = 0x0405,
+ LEFT = 0x0406,
+ RIGHT = 0x0407,
+ FRONT_AND_BACK = 0x0408,
+ AUX0 = 0x0409,
+ AUX1 = 0x040A,
+ AUX2 = 0x040B,
+ AUX3 = 0x040C,
+ }
+ #endregion
+ #region public enum EnableCap
+ public enum EnableCap
+ {
+ FOG = GetPName.FOG,
+ LIGHTING = GetPName.LIGHTING,
+ TEXTURE_1D = GetPName.TEXTURE_1D,
+ TEXTURE_2D = GetPName.TEXTURE_2D,
+ LINE_STIPPLE = GetPName.LINE_STIPPLE,
+ POLYGON_STIPPLE = GetPName.POLYGON_STIPPLE,
+ CULL_FACE = GetPName.CULL_FACE,
+ ALPHA_TEST = GetPName.ALPHA_TEST,
+ BLEND = GetPName.BLEND,
+ INDEX_LOGIC_OP = GetPName.INDEX_LOGIC_OP,
+ COLOR_LOGIC_OP = GetPName.COLOR_LOGIC_OP,
+ DITHER = GetPName.DITHER,
+ STENCIL_TEST = GetPName.STENCIL_TEST,
+ DEPTH_TEST = GetPName.DEPTH_TEST,
+ CLIP_PLANE0 = GetPName.CLIP_PLANE0,
+ CLIP_PLANE1 = GetPName.CLIP_PLANE1,
+ CLIP_PLANE2 = GetPName.CLIP_PLANE2,
+ CLIP_PLANE3 = GetPName.CLIP_PLANE3,
+ CLIP_PLANE4 = GetPName.CLIP_PLANE4,
+ CLIP_PLANE5 = GetPName.CLIP_PLANE5,
+ LIGHT0 = GetPName.LIGHT0,
+ LIGHT1 = GetPName.LIGHT1,
+ LIGHT2 = GetPName.LIGHT2,
+ LIGHT3 = GetPName.LIGHT3,
+ LIGHT4 = GetPName.LIGHT4,
+ LIGHT5 = GetPName.LIGHT5,
+ LIGHT6 = GetPName.LIGHT6,
+ LIGHT7 = GetPName.LIGHT7,
+ TEXTURE_GEN_S = GetPName.TEXTURE_GEN_S,
+ TEXTURE_GEN_T = GetPName.TEXTURE_GEN_T,
+ TEXTURE_GEN_R = GetPName.TEXTURE_GEN_R,
+ TEXTURE_GEN_Q = GetPName.TEXTURE_GEN_Q,
+ MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3,
+ MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4,
+ MAP1_COLOR_4 = GetPName.MAP1_COLOR_4,
+ MAP1_INDEX = GetPName.MAP1_INDEX,
+ MAP1_NORMAL = GetPName.MAP1_NORMAL,
+ MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1,
+ MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2,
+ MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3,
+ MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4,
+ MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3,
+ MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4,
+ MAP2_COLOR_4 = GetPName.MAP2_COLOR_4,
+ MAP2_INDEX = GetPName.MAP2_INDEX,
+ MAP2_NORMAL = GetPName.MAP2_NORMAL,
+ MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1,
+ MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2,
+ MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3,
+ MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4,
+ POINT_SMOOTH = GetPName.POINT_SMOOTH,
+ LINE_SMOOTH = GetPName.LINE_SMOOTH,
+ POLYGON_SMOOTH = GetPName.POLYGON_SMOOTH,
+ SCISSOR_TEST = GetPName.SCISSOR_TEST,
+ COLOR_MATERIAL = GetPName.COLOR_MATERIAL,
+ NORMALIZE = GetPName.NORMALIZE,
+ AUTO_NORMAL = GetPName.AUTO_NORMAL,
+ POLYGON_OFFSET_POINT = GetPName.POLYGON_OFFSET_POINT,
+ POLYGON_OFFSET_LINE = GetPName.POLYGON_OFFSET_LINE,
+ POLYGON_OFFSET_FILL = GetPName.POLYGON_OFFSET_FILL,
+ VERTEX_ARRAY = GetPName.VERTEX_ARRAY,
+ NORMAL_ARRAY = GetPName.NORMAL_ARRAY,
+ COLOR_ARRAY = GetPName.COLOR_ARRAY,
+ INDEX_ARRAY = GetPName.INDEX_ARRAY,
+ TEXTURE_COORD_ARRAY = GetPName.TEXTURE_COORD_ARRAY,
+ EDGE_FLAG_ARRAY = GetPName.EDGE_FLAG_ARRAY,
+ CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
+ CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
+ SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
+ HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
+ MINMAX_EXT = EXT_histogram.MINMAX_EXT,
+ RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT,
+ SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT,
+ TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
+ MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS,
+ SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS,
+ SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS,
+ SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS,
+ TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
+ ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX,
+ ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX,
+ ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX,
+ ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX,
+ CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX,
+ FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX,
+ FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX,
+ FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX,
+ FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
+ FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX,
+ FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX,
+ FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX,
+ FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX,
+ FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX,
+ FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX,
+ FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX,
+ FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX,
+ INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX,
+ IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX,
+ PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX,
+ PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS,
+ REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX,
+ SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX,
+ COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
+ POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
+ POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+ TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
+ }
+ #endregion
+ #region public enum ErrorCode
+ public enum ErrorCode
+ {
+ NO_ERROR = 0,
+ INVALID_ENUM = 0x0500,
+ INVALID_VALUE = 0x0501,
+ INVALID_OPERATION = 0x0502,
+ STACK_OVERFLOW = 0x0503,
+ STACK_UNDERFLOW = 0x0504,
+ OUT_OF_MEMORY = 0x0505,
+ TABLE_TOO_LARGE_EXT = EXT_histogram.TABLE_TOO_LARGE_EXT,
+ TEXTURE_TOO_LARGE_EXT = EXT_texture.TEXTURE_TOO_LARGE_EXT,
+ }
+ #endregion
+ #region public enum FeedbackType
+ public enum FeedbackType
+ {
+ _2D = 0x0600,
+ _3D = 0x0601,
+ _3D_COLOR = 0x0602,
+ _3D_COLOR_TEXTURE = 0x0603,
+ _4D_COLOR_TEXTURE = 0x0604,
+ }
+ #endregion
+ #region public enum FeedBackToken
+ public enum FeedBackToken
+ {
+ PASS_THROUGH_TOKEN = 0x0700,
+ POINT_TOKEN = 0x0701,
+ LINE_TOKEN = 0x0702,
+ POLYGON_TOKEN = 0x0703,
+ BITMAP_TOKEN = 0x0704,
+ DRAW_PIXEL_TOKEN = 0x0705,
+ COPY_PIXEL_TOKEN = 0x0706,
+ LINE_RESET_TOKEN = 0x0707,
+ }
+ #endregion
+ #region public enum FfdMaskSGIX
+ public enum FfdMaskSGIX
+ {
+ TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001,
+ GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002,
+ }
+ #endregion
+ #region public enum FfdTargetSGIX
+ public enum FfdTargetSGIX
+ {
+ GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX,
+ TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX,
+ }
+ #endregion
+ #region public enum FogMode
+ public enum FogMode
+ {
+ LINEAR = TextureMagFilter.LINEAR,
+ EXP = 0x0800,
+ EXP2 = 0x0801,
+ FOG_FUNC_SGIS = SGIS_fog_function.FOG_FUNC_SGIS,
+ }
+ #endregion
+ #region public enum FogParameter
+ public enum FogParameter
+ {
+ FOG_COLOR = GetPName.FOG_COLOR,
+ FOG_DENSITY = GetPName.FOG_DENSITY,
+ FOG_END = GetPName.FOG_END,
+ FOG_INDEX = GetPName.FOG_INDEX,
+ FOG_MODE = GetPName.FOG_MODE,
+ FOG_START = GetPName.FOG_START,
+ FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX,
+ }
+ #endregion
+ #region public enum FragmentLightModelParameterSGIX
+ public enum FragmentLightModelParameterSGIX
+ {
+ 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_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX,
+ FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX,
+ }
+ #endregion
+ #region public enum FrontFaceDirection
+ public enum FrontFaceDirection
+ {
+ CW = 0x0900,
+ CCW = 0x0901,
+ }
+ #endregion
+ #region public enum GetColorTableParameterPNameSGI
+ public enum GetColorTableParameterPNameSGI
+ {
+ COLOR_TABLE_SCALE_SGI = SGI_color_table.COLOR_TABLE_SCALE_SGI,
+ COLOR_TABLE_BIAS_SGI = SGI_color_table.COLOR_TABLE_BIAS_SGI,
+ COLOR_TABLE_FORMAT_SGI = SGI_color_table.COLOR_TABLE_FORMAT_SGI,
+ COLOR_TABLE_WIDTH_SGI = SGI_color_table.COLOR_TABLE_WIDTH_SGI,
+ COLOR_TABLE_RED_SIZE_SGI = SGI_color_table.COLOR_TABLE_RED_SIZE_SGI,
+ COLOR_TABLE_GREEN_SIZE_SGI = SGI_color_table.COLOR_TABLE_GREEN_SIZE_SGI,
+ COLOR_TABLE_BLUE_SIZE_SGI = SGI_color_table.COLOR_TABLE_BLUE_SIZE_SGI,
+ COLOR_TABLE_ALPHA_SIZE_SGI = SGI_color_table.COLOR_TABLE_ALPHA_SIZE_SGI,
+ COLOR_TABLE_LUMINANCE_SIZE_SGI = SGI_color_table.COLOR_TABLE_LUMINANCE_SIZE_SGI,
+ COLOR_TABLE_INTENSITY_SIZE_SGI = SGI_color_table.COLOR_TABLE_INTENSITY_SIZE_SGI,
+ }
+ #endregion
+ #region public enum GetConvolutionParameter
+ public enum GetConvolutionParameter
+ {
+ CONVOLUTION_BORDER_MODE_EXT = EXT_convolution.CONVOLUTION_BORDER_MODE_EXT,
+ CONVOLUTION_FILTER_SCALE_EXT = EXT_convolution.CONVOLUTION_FILTER_SCALE_EXT,
+ CONVOLUTION_FILTER_BIAS_EXT = EXT_convolution.CONVOLUTION_FILTER_BIAS_EXT,
+ CONVOLUTION_FORMAT_EXT = EXT_convolution.CONVOLUTION_FORMAT_EXT,
+ CONVOLUTION_WIDTH_EXT = EXT_convolution.CONVOLUTION_WIDTH_EXT,
+ CONVOLUTION_HEIGHT_EXT = EXT_convolution.CONVOLUTION_HEIGHT_EXT,
+ MAX_CONVOLUTION_WIDTH_EXT = EXT_convolution.MAX_CONVOLUTION_WIDTH_EXT,
+ MAX_CONVOLUTION_HEIGHT_EXT = EXT_convolution.MAX_CONVOLUTION_HEIGHT_EXT,
+ }
+ #endregion
+ #region public enum GetHistogramParameterPNameEXT
+ public enum GetHistogramParameterPNameEXT
+ {
+ HISTOGRAM_WIDTH_EXT = EXT_histogram.HISTOGRAM_WIDTH_EXT,
+ HISTOGRAM_FORMAT_EXT = EXT_histogram.HISTOGRAM_FORMAT_EXT,
+ HISTOGRAM_RED_SIZE_EXT = EXT_histogram.HISTOGRAM_RED_SIZE_EXT,
+ HISTOGRAM_GREEN_SIZE_EXT = EXT_histogram.HISTOGRAM_GREEN_SIZE_EXT,
+ HISTOGRAM_BLUE_SIZE_EXT = EXT_histogram.HISTOGRAM_BLUE_SIZE_EXT,
+ HISTOGRAM_ALPHA_SIZE_EXT = EXT_histogram.HISTOGRAM_ALPHA_SIZE_EXT,
+ HISTOGRAM_LUMINANCE_SIZE_EXT = EXT_histogram.HISTOGRAM_LUMINANCE_SIZE_EXT,
+ HISTOGRAM_SINK_EXT = EXT_histogram.HISTOGRAM_SINK_EXT,
+ }
+ #endregion
+ #region public enum GetMapQuery
+ public enum GetMapQuery
+ {
+ COEFF = 0x0A00,
+ ORDER = 0x0A01,
+ DOMAIN = 0x0A02,
+ }
+ #endregion
+ #region public enum GetMinmaxParameterPNameEXT
+ public enum GetMinmaxParameterPNameEXT
+ {
+ MINMAX_FORMAT_EXT = EXT_histogram.MINMAX_FORMAT_EXT,
+ MINMAX_SINK_EXT = EXT_histogram.MINMAX_SINK_EXT,
+ }
+ #endregion
+ #region public enum GetPixelMap
+ public enum GetPixelMap
+ {
+ PIXEL_MAP_I_TO_I = 0x0C70,
+ PIXEL_MAP_S_TO_S = 0x0C71,
+ PIXEL_MAP_I_TO_R = 0x0C72,
+ PIXEL_MAP_I_TO_G = 0x0C73,
+ PIXEL_MAP_I_TO_B = 0x0C74,
+ PIXEL_MAP_I_TO_A = 0x0C75,
+ PIXEL_MAP_R_TO_R = 0x0C76,
+ PIXEL_MAP_G_TO_G = 0x0C77,
+ PIXEL_MAP_B_TO_B = 0x0C78,
+ PIXEL_MAP_A_TO_A = 0x0C79,
+ }
+ #endregion
+ #region public enum GetPointervPName
+ public enum GetPointervPName
+ {
+ VERTEX_ARRAY_POINTER = 0x808E,
+ NORMAL_ARRAY_POINTER = 0x808F,
+ COLOR_ARRAY_POINTER = 0x8090,
+ INDEX_ARRAY_POINTER = 0x8091,
+ TEXTURE_COORD_ARRAY_POINTER = 0x8092,
+ EDGE_FLAG_ARRAY_POINTER = 0x8093,
+ FEEDBACK_BUFFER_POINTER = 0x0DF0,
+ SELECTION_BUFFER_POINTER = 0x0DF3,
+ INSTRUMENT_BUFFER_POINTER_SGIX = SGIX_instruments.INSTRUMENT_BUFFER_POINTER_SGIX,
+ }
+ #endregion
+ #region public enum GetPName
+ public enum GetPName
+ {
+ CURRENT_COLOR = 0x0B00,
+ CURRENT_INDEX = 0x0B01,
+ CURRENT_NORMAL = 0x0B02,
+ CURRENT_TEXTURE_COORDS = 0x0B03,
+ CURRENT_RASTER_COLOR = 0x0B04,
+ CURRENT_RASTER_INDEX = 0x0B05,
+ CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
+ CURRENT_RASTER_POSITION = 0x0B07,
+ CURRENT_RASTER_POSITION_VALID = 0x0B08,
+ CURRENT_RASTER_DISTANCE = 0x0B09,
+ POINT_SMOOTH = 0x0B10,
+ POINT_SIZE = 0x0B11,
+ POINT_SIZE_RANGE = 0x0B12,
+ POINT_SIZE_GRANULARITY = 0x0B13,
+ LINE_SMOOTH = 0x0B20,
+ LINE_WIDTH = 0x0B21,
+ LINE_WIDTH_RANGE = 0x0B22,
+ LINE_WIDTH_GRANULARITY = 0x0B23,
+ LINE_STIPPLE = 0x0B24,
+ LINE_STIPPLE_PATTERN = 0x0B25,
+ LINE_STIPPLE_REPEAT = 0x0B26,
+ SMOOTH_POINT_SIZE_RANGE = VERSION_1_2.SMOOTH_POINT_SIZE_RANGE,
+ SMOOTH_POINT_SIZE_GRANULARITY = VERSION_1_2.SMOOTH_POINT_SIZE_GRANULARITY,
+ SMOOTH_LINE_WIDTH_RANGE = VERSION_1_2.SMOOTH_LINE_WIDTH_RANGE,
+ SMOOTH_LINE_WIDTH_GRANULARITY = VERSION_1_2.SMOOTH_LINE_WIDTH_GRANULARITY,
+ ALIASED_POINT_SIZE_RANGE = VERSION_1_2.ALIASED_POINT_SIZE_RANGE,
+ ALIASED_LINE_WIDTH_RANGE = VERSION_1_2.ALIASED_LINE_WIDTH_RANGE,
+ LIST_MODE = 0x0B30,
+ MAX_LIST_NESTING = 0x0B31,
+ LIST_BASE = 0x0B32,
+ LIST_INDEX = 0x0B33,
+ POLYGON_MODE = 0x0B40,
+ POLYGON_SMOOTH = 0x0B41,
+ POLYGON_STIPPLE = 0x0B42,
+ EDGE_FLAG = 0x0B43,
+ CULL_FACE = 0x0B44,
+ CULL_FACE_MODE = 0x0B45,
+ FRONT_FACE = 0x0B46,
+ LIGHTING = 0x0B50,
+ LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
+ LIGHT_MODEL_TWO_SIDE = 0x0B52,
+ LIGHT_MODEL_AMBIENT = 0x0B53,
+ SHADE_MODEL = 0x0B54,
+ COLOR_MATERIAL_FACE = 0x0B55,
+ COLOR_MATERIAL_PARAMETER = 0x0B56,
+ COLOR_MATERIAL = 0x0B57,
+ FOG = 0x0B60,
+ FOG_INDEX = 0x0B61,
+ FOG_DENSITY = 0x0B62,
+ FOG_START = 0x0B63,
+ FOG_END = 0x0B64,
+ FOG_MODE = 0x0B65,
+ FOG_COLOR = 0x0B66,
+ DEPTH_RANGE = 0x0B70,
+ DEPTH_TEST = 0x0B71,
+ DEPTH_WRITEMASK = 0x0B72,
+ DEPTH_CLEAR_VALUE = 0x0B73,
+ DEPTH_FUNC = 0x0B74,
+ ACCUM_CLEAR_VALUE = 0x0B80,
+ STENCIL_TEST = 0x0B90,
+ STENCIL_CLEAR_VALUE = 0x0B91,
+ STENCIL_FUNC = 0x0B92,
+ STENCIL_VALUE_MASK = 0x0B93,
+ STENCIL_FAIL = 0x0B94,
+ STENCIL_PASS_DEPTH_FAIL = 0x0B95,
+ STENCIL_PASS_DEPTH_PASS = 0x0B96,
+ STENCIL_REF = 0x0B97,
+ STENCIL_WRITEMASK = 0x0B98,
+ MATRIX_MODE = 0x0BA0,
+ NORMALIZE = 0x0BA1,
+ VIEWPORT = 0x0BA2,
+ MODELVIEW_STACK_DEPTH = 0x0BA3,
+ PROJECTION_STACK_DEPTH = 0x0BA4,
+ TEXTURE_STACK_DEPTH = 0x0BA5,
+ MODELVIEW_MATRIX = 0x0BA6,
+ PROJECTION_MATRIX = 0x0BA7,
+ TEXTURE_MATRIX = 0x0BA8,
+ ATTRIB_STACK_DEPTH = 0x0BB0,
+ CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1,
+ ALPHA_TEST = 0x0BC0,
+ ALPHA_TEST_FUNC = 0x0BC1,
+ ALPHA_TEST_REF = 0x0BC2,
+ DITHER = 0x0BD0,
+ BLEND_DST = 0x0BE0,
+ BLEND_SRC = 0x0BE1,
+ BLEND = 0x0BE2,
+ LOGIC_OP_MODE = 0x0BF0,
+ INDEX_LOGIC_OP = 0x0BF1,
+ LOGIC_OP = 0x0BF1,
+ COLOR_LOGIC_OP = 0x0BF2,
+ AUX_BUFFERS = 0x0C00,
+ DRAW_BUFFER = 0x0C01,
+ READ_BUFFER = 0x0C02,
+ SCISSOR_BOX = 0x0C10,
+ SCISSOR_TEST = 0x0C11,
+ INDEX_CLEAR_VALUE = 0x0C20,
+ INDEX_WRITEMASK = 0x0C21,
+ COLOR_CLEAR_VALUE = 0x0C22,
+ COLOR_WRITEMASK = 0x0C23,
+ INDEX_MODE = 0x0C30,
+ RGBA_MODE = 0x0C31,
+ DOUBLEBUFFER = 0x0C32,
+ STEREO = 0x0C33,
+ RENDER_MODE = 0x0C40,
+ PERSPECTIVE_CORRECTION_HINT = 0x0C50,
+ POINT_SMOOTH_HINT = 0x0C51,
+ LINE_SMOOTH_HINT = 0x0C52,
+ POLYGON_SMOOTH_HINT = 0x0C53,
+ FOG_HINT = 0x0C54,
+ TEXTURE_GEN_S = 0x0C60,
+ TEXTURE_GEN_T = 0x0C61,
+ TEXTURE_GEN_R = 0x0C62,
+ TEXTURE_GEN_Q = 0x0C63,
+ PIXEL_MAP_I_TO_I_SIZE = 0x0CB0,
+ PIXEL_MAP_S_TO_S_SIZE = 0x0CB1,
+ PIXEL_MAP_I_TO_R_SIZE = 0x0CB2,
+ PIXEL_MAP_I_TO_G_SIZE = 0x0CB3,
+ PIXEL_MAP_I_TO_B_SIZE = 0x0CB4,
+ PIXEL_MAP_I_TO_A_SIZE = 0x0CB5,
+ PIXEL_MAP_R_TO_R_SIZE = 0x0CB6,
+ PIXEL_MAP_G_TO_G_SIZE = 0x0CB7,
+ PIXEL_MAP_B_TO_B_SIZE = 0x0CB8,
+ PIXEL_MAP_A_TO_A_SIZE = 0x0CB9,
+ UNPACK_SWAP_BYTES = 0x0CF0,
+ UNPACK_LSB_FIRST = 0x0CF1,
+ UNPACK_ROW_LENGTH = 0x0CF2,
+ UNPACK_SKIP_ROWS = 0x0CF3,
+ UNPACK_SKIP_PIXELS = 0x0CF4,
+ UNPACK_ALIGNMENT = 0x0CF5,
+ PACK_SWAP_BYTES = 0x0D00,
+ PACK_LSB_FIRST = 0x0D01,
+ PACK_ROW_LENGTH = 0x0D02,
+ PACK_SKIP_ROWS = 0x0D03,
+ PACK_SKIP_PIXELS = 0x0D04,
+ PACK_ALIGNMENT = 0x0D05,
+ MAP_COLOR = 0x0D10,
+ MAP_STENCIL = 0x0D11,
+ INDEX_SHIFT = 0x0D12,
+ INDEX_OFFSET = 0x0D13,
+ RED_SCALE = 0x0D14,
+ RED_BIAS = 0x0D15,
+ ZOOM_X = 0x0D16,
+ ZOOM_Y = 0x0D17,
+ GREEN_SCALE = 0x0D18,
+ GREEN_BIAS = 0x0D19,
+ BLUE_SCALE = 0x0D1A,
+ BLUE_BIAS = 0x0D1B,
+ ALPHA_SCALE = 0x0D1C,
+ ALPHA_BIAS = 0x0D1D,
+ DEPTH_SCALE = 0x0D1E,
+ DEPTH_BIAS = 0x0D1F,
+ MAX_EVAL_ORDER = 0x0D30,
+ MAX_LIGHTS = 0x0D31,
+ MAX_CLIP_PLANES = 0x0D32,
+ MAX_TEXTURE_SIZE = 0x0D33,
+ MAX_PIXEL_MAP_TABLE = 0x0D34,
+ MAX_ATTRIB_STACK_DEPTH = 0x0D35,
+ MAX_MODELVIEW_STACK_DEPTH = 0x0D36,
+ MAX_NAME_STACK_DEPTH = 0x0D37,
+ MAX_PROJECTION_STACK_DEPTH = 0x0D38,
+ MAX_TEXTURE_STACK_DEPTH = 0x0D39,
+ MAX_VIEWPORT_DIMS = 0x0D3A,
+ MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B,
+ SUBPIXEL_BITS = 0x0D50,
+ INDEX_BITS = 0x0D51,
+ RED_BITS = 0x0D52,
+ GREEN_BITS = 0x0D53,
+ BLUE_BITS = 0x0D54,
+ ALPHA_BITS = 0x0D55,
+ DEPTH_BITS = 0x0D56,
+ STENCIL_BITS = 0x0D57,
+ ACCUM_RED_BITS = 0x0D58,
+ ACCUM_GREEN_BITS = 0x0D59,
+ ACCUM_BLUE_BITS = 0x0D5A,
+ ACCUM_ALPHA_BITS = 0x0D5B,
+ NAME_STACK_DEPTH = 0x0D70,
+ AUTO_NORMAL = 0x0D80,
+ MAP1_COLOR_4 = 0x0D90,
+ MAP1_INDEX = 0x0D91,
+ MAP1_NORMAL = 0x0D92,
+ MAP1_TEXTURE_COORD_1 = 0x0D93,
+ MAP1_TEXTURE_COORD_2 = 0x0D94,
+ MAP1_TEXTURE_COORD_3 = 0x0D95,
+ MAP1_TEXTURE_COORD_4 = 0x0D96,
+ MAP1_VERTEX_3 = 0x0D97,
+ MAP1_VERTEX_4 = 0x0D98,
+ MAP2_COLOR_4 = 0x0DB0,
+ MAP2_INDEX = 0x0DB1,
+ MAP2_NORMAL = 0x0DB2,
+ MAP2_TEXTURE_COORD_1 = 0x0DB3,
+ MAP2_TEXTURE_COORD_2 = 0x0DB4,
+ MAP2_TEXTURE_COORD_3 = 0x0DB5,
+ MAP2_TEXTURE_COORD_4 = 0x0DB6,
+ MAP2_VERTEX_3 = 0x0DB7,
+ MAP2_VERTEX_4 = 0x0DB8,
+ MAP1_GRID_DOMAIN = 0x0DD0,
+ MAP1_GRID_SEGMENTS = 0x0DD1,
+ MAP2_GRID_DOMAIN = 0x0DD2,
+ MAP2_GRID_SEGMENTS = 0x0DD3,
+ TEXTURE_1D = 0x0DE0,
+ TEXTURE_2D = 0x0DE1,
+ FEEDBACK_BUFFER_SIZE = 0x0DF1,
+ FEEDBACK_BUFFER_TYPE = 0x0DF2,
+ SELECTION_BUFFER_SIZE = 0x0DF4,
+ POLYGON_OFFSET_UNITS = 0x2A00,
+ POLYGON_OFFSET_POINT = 0x2A01,
+ POLYGON_OFFSET_LINE = 0x2A02,
+ POLYGON_OFFSET_FILL = 0x8037,
+ POLYGON_OFFSET_FACTOR = 0x8038,
+ TEXTURE_BINDING_1D = 0x8068,
+ TEXTURE_BINDING_2D = 0x8069,
+ TEXTURE_BINDING_3D = 0x806A,
+ VERTEX_ARRAY = 0x8074,
+ NORMAL_ARRAY = 0x8075,
+ COLOR_ARRAY = 0x8076,
+ INDEX_ARRAY = 0x8077,
+ TEXTURE_COORD_ARRAY = 0x8078,
+ EDGE_FLAG_ARRAY = 0x8079,
+ VERTEX_ARRAY_SIZE = 0x807A,
+ VERTEX_ARRAY_TYPE = 0x807B,
+ VERTEX_ARRAY_STRIDE = 0x807C,
+ NORMAL_ARRAY_TYPE = 0x807E,
+ NORMAL_ARRAY_STRIDE = 0x807F,
+ COLOR_ARRAY_SIZE = 0x8081,
+ COLOR_ARRAY_TYPE = 0x8082,
+ COLOR_ARRAY_STRIDE = 0x8083,
+ INDEX_ARRAY_TYPE = 0x8085,
+ INDEX_ARRAY_STRIDE = 0x8086,
+ TEXTURE_COORD_ARRAY_SIZE = 0x8088,
+ TEXTURE_COORD_ARRAY_TYPE = 0x8089,
+ TEXTURE_COORD_ARRAY_STRIDE = 0x808A,
+ EDGE_FLAG_ARRAY_STRIDE = 0x808C,
+ CLIP_PLANE0 = ClipPlaneName.CLIP_PLANE0,
+ CLIP_PLANE1 = ClipPlaneName.CLIP_PLANE1,
+ CLIP_PLANE2 = ClipPlaneName.CLIP_PLANE2,
+ CLIP_PLANE3 = ClipPlaneName.CLIP_PLANE3,
+ CLIP_PLANE4 = ClipPlaneName.CLIP_PLANE4,
+ CLIP_PLANE5 = ClipPlaneName.CLIP_PLANE5,
+ LIGHT0 = LightName.LIGHT0,
+ LIGHT1 = LightName.LIGHT1,
+ LIGHT2 = LightName.LIGHT2,
+ LIGHT3 = LightName.LIGHT3,
+ LIGHT4 = LightName.LIGHT4,
+ LIGHT5 = LightName.LIGHT5,
+ LIGHT6 = LightName.LIGHT6,
+ LIGHT7 = LightName.LIGHT7,
+ LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL,
+ BLEND_COLOR_EXT = EXT_blend_color.BLEND_COLOR_EXT,
+ BLEND_EQUATION_EXT = EXT_blend_minmax.BLEND_EQUATION_EXT,
+ PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT,
+ UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT,
+ CONVOLUTION_1D_EXT = EXT_convolution.CONVOLUTION_1D_EXT,
+ CONVOLUTION_2D_EXT = EXT_convolution.CONVOLUTION_2D_EXT,
+ SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
+ POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT,
+ POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT,
+ POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT,
+ POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT,
+ POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT,
+ POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT,
+ POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT,
+ POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT,
+ HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
+ MINMAX_EXT = EXT_histogram.MINMAX_EXT,
+ POLYGON_OFFSET_BIAS_EXT = EXT_polygon_offset.POLYGON_OFFSET_BIAS_EXT,
+ RESCALE_NORMAL_EXT = EXT_rescale_normal.RESCALE_NORMAL_EXT,
+ SHARED_TEXTURE_PALETTE_EXT = EXT_shared_texture_palette.SHARED_TEXTURE_PALETTE_EXT,
+ TEXTURE_3D_BINDING_EXT = EXT_texture_object.TEXTURE_3D_BINDING_EXT,
+ PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT,
+ PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT,
+ UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT,
+ UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT,
+ TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
+ MAX_3D_TEXTURE_SIZE_EXT = EXT_texture3D.MAX_3D_TEXTURE_SIZE_EXT,
+ VERTEX_ARRAY_COUNT_EXT = EXT_vertex_array.VERTEX_ARRAY_COUNT_EXT,
+ NORMAL_ARRAY_COUNT_EXT = EXT_vertex_array.NORMAL_ARRAY_COUNT_EXT,
+ COLOR_ARRAY_COUNT_EXT = EXT_vertex_array.COLOR_ARRAY_COUNT_EXT,
+ INDEX_ARRAY_COUNT_EXT = EXT_vertex_array.INDEX_ARRAY_COUNT_EXT,
+ TEXTURE_COORD_ARRAY_COUNT_EXT = EXT_vertex_array.TEXTURE_COORD_ARRAY_COUNT_EXT,
+ EDGE_FLAG_ARRAY_COUNT_EXT = EXT_vertex_array.EDGE_FLAG_ARRAY_COUNT_EXT,
+ DETAIL_TEXTURE_2D_BINDING_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_BINDING_SGIS,
+ FOG_FUNC_POINTS_SGIS = SGIS_fog_function.FOG_FUNC_POINTS_SGIS,
+ MAX_FOG_FUNC_POINTS_SGIS = SGIS_fog_function.MAX_FOG_FUNC_POINTS_SGIS,
+ GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS,
+ MULTISAMPLE_SGIS = SGIS_multisample.MULTISAMPLE_SGIS,
+ SAMPLE_ALPHA_TO_MASK_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_MASK_SGIS,
+ SAMPLE_ALPHA_TO_ONE_SGIS = SGIS_multisample.SAMPLE_ALPHA_TO_ONE_SGIS,
+ SAMPLE_MASK_SGIS = SGIS_multisample.SAMPLE_MASK_SGIS,
+ SAMPLE_BUFFERS_SGIS = SGIS_multisample.SAMPLE_BUFFERS_SGIS,
+ SAMPLES_SGIS = SGIS_multisample.SAMPLES_SGIS,
+ SAMPLE_MASK_VALUE_SGIS = SGIS_multisample.SAMPLE_MASK_VALUE_SGIS,
+ SAMPLE_MASK_INVERT_SGIS = SGIS_multisample.SAMPLE_MASK_INVERT_SGIS,
+ SAMPLE_PATTERN_SGIS = SGIS_multisample.SAMPLE_PATTERN_SGIS,
+ PIXEL_TEXTURE_SGIS = SGIS_pixel_texture.PIXEL_TEXTURE_SGIS,
+ POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_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,
+ DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS,
+ PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS,
+ PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS,
+ UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS,
+ UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS,
+ TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
+ MAX_4D_TEXTURE_SIZE_SGIS = SGIS_texture4D.MAX_4D_TEXTURE_SIZE_SGIS,
+ TEXTURE_4D_BINDING_SGIS = SGIS_texture4D.TEXTURE_4D_BINDING_SGIS,
+ ASYNC_MARKER_SGIX = SGIX_async.ASYNC_MARKER_SGIX,
+ ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.ASYNC_HISTOGRAM_SGIX,
+ MAX_ASYNC_HISTOGRAM_SGIX = SGIX_async_histogram.MAX_ASYNC_HISTOGRAM_SGIX,
+ ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.ASYNC_TEX_IMAGE_SGIX,
+ ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.ASYNC_DRAW_PIXELS_SGIX,
+ ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.ASYNC_READ_PIXELS_SGIX,
+ MAX_ASYNC_TEX_IMAGE_SGIX = SGIX_async_pixel.MAX_ASYNC_TEX_IMAGE_SGIX,
+ MAX_ASYNC_DRAW_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_DRAW_PIXELS_SGIX,
+ MAX_ASYNC_READ_PIXELS_SGIX = SGIX_async_pixel.MAX_ASYNC_READ_PIXELS_SGIX,
+ CALLIGRAPHIC_FRAGMENT_SGIX = SGIX_calligraphic_fragment.CALLIGRAPHIC_FRAGMENT_SGIX,
+ MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+ MAX_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.MAX_CLIPMAP_DEPTH_SGIX,
+ CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX,
+ FOG_OFFSET_SGIX = SGIX_fog_offset.FOG_OFFSET_SGIX,
+ FOG_OFFSET_VALUE_SGIX = SGIX_fog_offset.FOG_OFFSET_VALUE_SGIX,
+ FRAGMENT_LIGHTING_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHTING_SGIX,
+ FRAGMENT_COLOR_MATERIAL_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_SGIX,
+ FRAGMENT_COLOR_MATERIAL_FACE_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_FACE_SGIX,
+ FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = SGIX_fragment_lighting.FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX,
+ MAX_FRAGMENT_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_FRAGMENT_LIGHTS_SGIX,
+ MAX_ACTIVE_LIGHTS_SGIX = SGIX_fragment_lighting.MAX_ACTIVE_LIGHTS_SGIX,
+ LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX,
+ 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_AMBIENT_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX,
+ FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX,
+ FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
+ FRAMEZOOM_SGIX = SGIX_framezoom.FRAMEZOOM_SGIX,
+ FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.FRAMEZOOM_FACTOR_SGIX,
+ MAX_FRAMEZOOM_FACTOR_SGIX = SGIX_framezoom.MAX_FRAMEZOOM_FACTOR_SGIX,
+ INSTRUMENT_MEASUREMENTS_SGIX = SGIX_instruments.INSTRUMENT_MEASUREMENTS_SGIX,
+ INTERLACE_SGIX = SGIX_interlace.INTERLACE_SGIX,
+ IR_INSTRUMENT1_SGIX = SGIX_ir_instrument1.IR_INSTRUMENT1_SGIX,
+ PIXEL_TEX_GEN_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_SGIX,
+ PIXEL_TEX_GEN_MODE_SGIX = SGIX_pixel_texture.PIXEL_TEX_GEN_MODE_SGIX,
+ PIXEL_TILE_BEST_ALIGNMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_BEST_ALIGNMENT_SGIX,
+ PIXEL_TILE_CACHE_INCREMENT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_INCREMENT_SGIX,
+ PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX,
+ PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX,
+ PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX,
+ PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX,
+ PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX,
+ PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX,
+ DEFORMATIONS_MASK_SGIX = SGIX_polynomial_ffd.DEFORMATIONS_MASK_SGIX,
+ REFERENCE_PLANE_EQUATION_SGIX = SGIX_reference_plane.REFERENCE_PLANE_EQUATION_SGIX,
+ REFERENCE_PLANE_SGIX = SGIX_reference_plane.REFERENCE_PLANE_SGIX,
+ SPRITE_SGIX = SGIX_sprite.SPRITE_SGIX,
+ SPRITE_MODE_SGIX = SGIX_sprite.SPRITE_MODE_SGIX,
+ SPRITE_AXIS_SGIX = SGIX_sprite.SPRITE_AXIS_SGIX,
+ SPRITE_TRANSLATION_SGIX = SGIX_sprite.SPRITE_TRANSLATION_SGIX,
+ PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX,
+ UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX,
+ PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX,
+ UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX,
+ POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_RANGE_SGIX,
+ 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,
+ VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX,
+ COLOR_MATRIX_SGI = SGI_color_matrix.COLOR_MATRIX_SGI,
+ COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.COLOR_MATRIX_STACK_DEPTH_SGI,
+ MAX_COLOR_MATRIX_STACK_DEPTH_SGI = SGI_color_matrix.MAX_COLOR_MATRIX_STACK_DEPTH_SGI,
+ POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI,
+ POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI,
+ POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI,
+ POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI,
+ POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI,
+ POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI,
+ POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI,
+ POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI,
+ COLOR_TABLE_SGI = SGI_color_table.COLOR_TABLE_SGI,
+ POST_CONVOLUTION_COLOR_TABLE_SGI = SGI_color_table.POST_CONVOLUTION_COLOR_TABLE_SGI,
+ POST_COLOR_MATRIX_COLOR_TABLE_SGI = SGI_color_table.POST_COLOR_MATRIX_COLOR_TABLE_SGI,
+ TEXTURE_COLOR_TABLE_SGI = SGI_texture_color_table.TEXTURE_COLOR_TABLE_SGI,
+ }
+ #endregion
+ #region public enum GetTextureParameter
+ public enum GetTextureParameter
+ {
+ TEXTURE_MAG_FILTER = TextureParameterName.TEXTURE_MAG_FILTER,
+ TEXTURE_MIN_FILTER = TextureParameterName.TEXTURE_MIN_FILTER,
+ TEXTURE_WRAP_S = TextureParameterName.TEXTURE_WRAP_S,
+ TEXTURE_WRAP_T = TextureParameterName.TEXTURE_WRAP_T,
+ TEXTURE_WIDTH = 0x1000,
+ TEXTURE_HEIGHT = 0x1001,
+ TEXTURE_INTERNAL_FORMAT = 0x1003,
+ TEXTURE_COMPONENTS = 0x1003,
+ TEXTURE_BORDER_COLOR = 0x1004,
+ TEXTURE_BORDER = 0x1005,
+ TEXTURE_RED_SIZE = 0x805C,
+ TEXTURE_GREEN_SIZE = 0x805D,
+ TEXTURE_BLUE_SIZE = 0x805E,
+ TEXTURE_ALPHA_SIZE = 0x805F,
+ TEXTURE_LUMINANCE_SIZE = 0x8060,
+ TEXTURE_INTENSITY_SIZE = 0x8061,
+ TEXTURE_PRIORITY = 0x8066,
+ TEXTURE_RESIDENT = 0x8067,
+ TEXTURE_DEPTH_EXT = EXT_texture3D.TEXTURE_DEPTH_EXT,
+ TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT,
+ DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS,
+ DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS,
+ DETAIL_TEXTURE_FUNC_POINTS_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_FUNC_POINTS_SGIS,
+ GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS,
+ SHARPEN_TEXTURE_FUNC_POINTS_SGIS = SGIS_sharpen_texture.SHARPEN_TEXTURE_FUNC_POINTS_SGIS,
+ TEXTURE_FILTER4_SIZE_SGIS = SGIS_texture_filter4.TEXTURE_FILTER4_SIZE_SGIS,
+ TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS,
+ TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS,
+ TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS,
+ TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS,
+ DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS,
+ QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS,
+ TEXTURE_4DSIZE_SGIS = SGIS_texture4D.TEXTURE_4DSIZE_SGIS,
+ TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS,
+ TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX,
+ TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX,
+ TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX,
+ TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+ TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX,
+ TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX,
+ TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX,
+ 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,
+ SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX,
+ TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX,
+ TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX,
+ TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX,
+ TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX,
+ TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX,
+ TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX,
+ POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX,
+ POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX,
+ }
+ #endregion
+ #region public enum HintMode
+ public enum HintMode
+ {
+ DONT_CARE = 0x1100,
+ FASTEST = 0x1101,
+ NICEST = 0x1102,
+ }
+ #endregion
+ #region public enum HintTarget
+ public enum HintTarget
+ {
+ PERSPECTIVE_CORRECTION_HINT = GetPName.PERSPECTIVE_CORRECTION_HINT,
+ POINT_SMOOTH_HINT = GetPName.POINT_SMOOTH_HINT,
+ LINE_SMOOTH_HINT = GetPName.LINE_SMOOTH_HINT,
+ POLYGON_SMOOTH_HINT = GetPName.POLYGON_SMOOTH_HINT,
+ FOG_HINT = GetPName.FOG_HINT,
+ PACK_CMYK_HINT_EXT = EXT_cmyka.PACK_CMYK_HINT_EXT,
+ UNPACK_CMYK_HINT_EXT = EXT_cmyka.UNPACK_CMYK_HINT_EXT,
+ GENERATE_MIPMAP_HINT_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_HINT_SGIS,
+ CONVOLUTION_HINT_SGIX = SGIX_convolution_accuracy.CONVOLUTION_HINT_SGIX,
+ TEXTURE_MULTI_BUFFER_HINT_SGIX = SGIX_texture_multi_buffer.TEXTURE_MULTI_BUFFER_HINT_SGIX,
+ VERTEX_PRECLIP_HINT_SGIX = SGIX_vertex_preclip.VERTEX_PRECLIP_HINT_SGIX,
+ }
+ #endregion
+ #region public enum HistogramTargetEXT
+ public enum HistogramTargetEXT
+ {
+ HISTOGRAM_EXT = EXT_histogram.HISTOGRAM_EXT,
+ PROXY_HISTOGRAM_EXT = EXT_histogram.PROXY_HISTOGRAM_EXT,
+ }
+ #endregion
+ #region public enum IndexPointerType
+ public enum IndexPointerType
+ {
+ SHORT = DataType.SHORT,
+ INT = DataType.INT,
+ FLOAT = DataType.FLOAT,
+ DOUBLE = DataType.DOUBLE,
+ }
+ #endregion
+ #region public enum LightEnvModeSGIX
+ public enum LightEnvModeSGIX
+ {
+ REPLACE = StencilOp.REPLACE,
+ MODULATE = TextureEnvMode.MODULATE,
+ ADD = AccumOp.ADD,
+ }
+ #endregion
+ #region public enum LightEnvParameterSGIX
+ public enum LightEnvParameterSGIX
+ {
+ LIGHT_ENV_MODE_SGIX = SGIX_fragment_lighting.LIGHT_ENV_MODE_SGIX,
+ }
+ #endregion
+ #region public enum LightModelColorControl
+ public enum LightModelColorControl
+ {
+ SINGLE_COLOR = VERSION_1_2.SINGLE_COLOR,
+ SEPARATE_SPECULAR_COLOR = VERSION_1_2.SEPARATE_SPECULAR_COLOR,
+ }
+ #endregion
+ #region public enum LightModelParameter
+ public enum LightModelParameter
+ {
+ LIGHT_MODEL_AMBIENT = GetPName.LIGHT_MODEL_AMBIENT,
+ LIGHT_MODEL_LOCAL_VIEWER = GetPName.LIGHT_MODEL_LOCAL_VIEWER,
+ LIGHT_MODEL_TWO_SIDE = GetPName.LIGHT_MODEL_TWO_SIDE,
+ LIGHT_MODEL_COLOR_CONTROL = VERSION_1_2.LIGHT_MODEL_COLOR_CONTROL,
+ }
+ #endregion
+ #region public enum LightParameter
+ public enum LightParameter
+ {
+ AMBIENT = 0x1200,
+ DIFFUSE = 0x1201,
+ SPECULAR = 0x1202,
+ POSITION = 0x1203,
+ SPOT_DIRECTION = 0x1204,
+ SPOT_EXPONENT = 0x1205,
+ SPOT_CUTOFF = 0x1206,
+ CONSTANT_ATTENUATION = 0x1207,
+ LINEAR_ATTENUATION = 0x1208,
+ QUADRATIC_ATTENUATION = 0x1209,
+ }
+ #endregion
+ #region public enum ListMode
+ public enum ListMode
+ {
+ COMPILE = 0x1300,
+ COMPILE_AND_EXECUTE = 0x1301,
+ }
+ #endregion
+ #region public enum DataType
+ public enum DataType
+ {
+ BYTE = 0x1400,
+ UNSIGNED_BYTE = 0x1401,
+ SHORT = 0x1402,
+ UNSIGNED_SHORT = 0x1403,
+ INT = 0x1404,
+ UNSIGNED_INT = 0x1405,
+ FLOAT = 0x1406,
+ _2_BYTES = 0x1407,
+ _3_BYTES = 0x1408,
+ _4_BYTES = 0x1409,
+ DOUBLE = 0x140A,
+ DOUBLE_EXT = 0x140A,
+ }
+ #endregion
+ #region public enum ListNameType
+ public enum ListNameType
+ {
+ BYTE = DataType.BYTE,
+ UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
+ SHORT = DataType.SHORT,
+ UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
+ INT = DataType.INT,
+ UNSIGNED_INT = DataType.UNSIGNED_INT,
+ FLOAT = DataType.FLOAT,
+ _2_BYTES = DataType._2_BYTES,
+ _3_BYTES = DataType._3_BYTES,
+ _4_BYTES = DataType._4_BYTES,
+ }
+ #endregion
+ #region public enum ListParameterName
+ public enum ListParameterName
+ {
+ LIST_PRIORITY_SGIX = SGIX_list_priority.LIST_PRIORITY_SGIX,
+ }
+ #endregion
+ #region public enum LogicOp
+ public enum LogicOp
+ {
+ CLEAR = 0x1500,
+ AND = 0x1501,
+ AND_REVERSE = 0x1502,
+ COPY = 0x1503,
+ AND_INVERTED = 0x1504,
+ NOOP = 0x1505,
+ XOR = 0x1506,
+ OR = 0x1507,
+ NOR = 0x1508,
+ EQUIV = 0x1509,
+ INVERT = 0x150A,
+ OR_REVERSE = 0x150B,
+ COPY_INVERTED = 0x150C,
+ OR_INVERTED = 0x150D,
+ NAND = 0x150E,
+ SET = 0x150F,
+ }
+ #endregion
+ #region public enum MapTarget
+ public enum MapTarget
+ {
+ MAP1_COLOR_4 = GetPName.MAP1_COLOR_4,
+ MAP1_INDEX = GetPName.MAP1_INDEX,
+ MAP1_NORMAL = GetPName.MAP1_NORMAL,
+ MAP1_TEXTURE_COORD_1 = GetPName.MAP1_TEXTURE_COORD_1,
+ MAP1_TEXTURE_COORD_2 = GetPName.MAP1_TEXTURE_COORD_2,
+ MAP1_TEXTURE_COORD_3 = GetPName.MAP1_TEXTURE_COORD_3,
+ MAP1_TEXTURE_COORD_4 = GetPName.MAP1_TEXTURE_COORD_4,
+ MAP1_VERTEX_3 = GetPName.MAP1_VERTEX_3,
+ MAP1_VERTEX_4 = GetPName.MAP1_VERTEX_4,
+ MAP2_COLOR_4 = GetPName.MAP2_COLOR_4,
+ MAP2_INDEX = GetPName.MAP2_INDEX,
+ MAP2_NORMAL = GetPName.MAP2_NORMAL,
+ MAP2_TEXTURE_COORD_1 = GetPName.MAP2_TEXTURE_COORD_1,
+ MAP2_TEXTURE_COORD_2 = GetPName.MAP2_TEXTURE_COORD_2,
+ MAP2_TEXTURE_COORD_3 = GetPName.MAP2_TEXTURE_COORD_3,
+ MAP2_TEXTURE_COORD_4 = GetPName.MAP2_TEXTURE_COORD_4,
+ MAP2_VERTEX_3 = GetPName.MAP2_VERTEX_3,
+ MAP2_VERTEX_4 = GetPName.MAP2_VERTEX_4,
+ GEOMETRY_DEFORMATION_SGIX = SGIX_polynomial_ffd.GEOMETRY_DEFORMATION_SGIX,
+ TEXTURE_DEFORMATION_SGIX = SGIX_polynomial_ffd.TEXTURE_DEFORMATION_SGIX,
+ }
+ #endregion
+ #region public enum MaterialFace
+ public enum MaterialFace
+ {
+ FRONT = DrawBufferMode.FRONT,
+ BACK = DrawBufferMode.BACK,
+ FRONT_AND_BACK = DrawBufferMode.FRONT_AND_BACK,
+ }
+ #endregion
+ #region public enum MaterialParameter
+ public enum MaterialParameter
+ {
+ EMISSION = 0x1600,
+ SHININESS = 0x1601,
+ AMBIENT_AND_DIFFUSE = 0x1602,
+ COLOR_INDEXES = 0x1603,
+ AMBIENT = LightParameter.AMBIENT,
+ DIFFUSE = LightParameter.DIFFUSE,
+ SPECULAR = LightParameter.SPECULAR,
+ }
+ #endregion
+ #region public enum MatrixMode
+ public enum MatrixMode
+ {
+ MODELVIEW = 0x1700,
+ PROJECTION = 0x1701,
+ TEXTURE = 0x1702,
+ }
+ #endregion
+ #region public enum MeshMode1
+ public enum MeshMode1
+ {
+ POINT = PolygonMode.POINT,
+ LINE = PolygonMode.LINE,
+ }
+ #endregion
+ #region public enum MeshMode2
+ public enum MeshMode2
+ {
+ POINT = PolygonMode.POINT,
+ LINE = PolygonMode.LINE,
+ FILL = PolygonMode.FILL,
+ }
+ #endregion
+ #region public enum MinmaxTargetEXT
+ public enum MinmaxTargetEXT
+ {
+ MINMAX_EXT = EXT_histogram.MINMAX_EXT,
+ }
+ #endregion
+ #region public enum NormalPointerType
+ public enum NormalPointerType
+ {
+ BYTE = DataType.BYTE,
+ SHORT = DataType.SHORT,
+ INT = DataType.INT,
+ FLOAT = DataType.FLOAT,
+ DOUBLE = DataType.DOUBLE,
+ }
+ #endregion
+ #region public enum PixelCopyType
+ public enum PixelCopyType
+ {
+ COLOR = 0x1800,
+ DEPTH = 0x1801,
+ STENCIL = 0x1802,
+ }
+ #endregion
+ #region public enum PixelFormat
+ public enum PixelFormat
+ {
+ COLOR_INDEX = 0x1900,
+ STENCIL_INDEX = 0x1901,
+ DEPTH_COMPONENT = 0x1902,
+ RED = 0x1903,
+ GREEN = 0x1904,
+ BLUE = 0x1905,
+ ALPHA = 0x1906,
+ RGB = 0x1907,
+ RGBA = 0x1908,
+ LUMINANCE = 0x1909,
+ LUMINANCE_ALPHA = 0x190A,
+ ABGR_EXT = EXT_abgr.ABGR_EXT,
+ CMYK_EXT = EXT_cmyka.CMYK_EXT,
+ CMYKA_EXT = EXT_cmyka.CMYKA_EXT,
+ R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX,
+ R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX,
+ ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX,
+ LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX,
+ LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX,
+ YCRCB_422_SGIX = SGIX_ycrcb.YCRCB_422_SGIX,
+ YCRCB_444_SGIX = SGIX_ycrcb.YCRCB_444_SGIX,
+ }
+ #endregion
+ #region public enum PixelMap
+ public enum PixelMap
+ {
+ PIXEL_MAP_I_TO_I = GetPixelMap.PIXEL_MAP_I_TO_I,
+ PIXEL_MAP_S_TO_S = GetPixelMap.PIXEL_MAP_S_TO_S,
+ PIXEL_MAP_I_TO_R = GetPixelMap.PIXEL_MAP_I_TO_R,
+ PIXEL_MAP_I_TO_G = GetPixelMap.PIXEL_MAP_I_TO_G,
+ PIXEL_MAP_I_TO_B = GetPixelMap.PIXEL_MAP_I_TO_B,
+ PIXEL_MAP_I_TO_A = GetPixelMap.PIXEL_MAP_I_TO_A,
+ PIXEL_MAP_R_TO_R = GetPixelMap.PIXEL_MAP_R_TO_R,
+ PIXEL_MAP_G_TO_G = GetPixelMap.PIXEL_MAP_G_TO_G,
+ PIXEL_MAP_B_TO_B = GetPixelMap.PIXEL_MAP_B_TO_B,
+ PIXEL_MAP_A_TO_A = GetPixelMap.PIXEL_MAP_A_TO_A,
+ }
+ #endregion
+ #region public enum PixelStoreParameter
+ public enum PixelStoreParameter
+ {
+ UNPACK_SWAP_BYTES = GetPName.UNPACK_SWAP_BYTES,
+ UNPACK_LSB_FIRST = GetPName.UNPACK_LSB_FIRST,
+ UNPACK_ROW_LENGTH = GetPName.UNPACK_ROW_LENGTH,
+ UNPACK_SKIP_ROWS = GetPName.UNPACK_SKIP_ROWS,
+ UNPACK_SKIP_PIXELS = GetPName.UNPACK_SKIP_PIXELS,
+ UNPACK_ALIGNMENT = GetPName.UNPACK_ALIGNMENT,
+ PACK_SWAP_BYTES = GetPName.PACK_SWAP_BYTES,
+ PACK_LSB_FIRST = GetPName.PACK_LSB_FIRST,
+ PACK_ROW_LENGTH = GetPName.PACK_ROW_LENGTH,
+ PACK_SKIP_ROWS = GetPName.PACK_SKIP_ROWS,
+ PACK_SKIP_PIXELS = GetPName.PACK_SKIP_PIXELS,
+ PACK_ALIGNMENT = GetPName.PACK_ALIGNMENT,
+ PACK_SKIP_IMAGES_EXT = EXT_texture3D.PACK_SKIP_IMAGES_EXT,
+ PACK_IMAGE_HEIGHT_EXT = EXT_texture3D.PACK_IMAGE_HEIGHT_EXT,
+ UNPACK_SKIP_IMAGES_EXT = EXT_texture3D.UNPACK_SKIP_IMAGES_EXT,
+ UNPACK_IMAGE_HEIGHT_EXT = EXT_texture3D.UNPACK_IMAGE_HEIGHT_EXT,
+ PACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.PACK_SKIP_VOLUMES_SGIS,
+ PACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.PACK_IMAGE_DEPTH_SGIS,
+ UNPACK_SKIP_VOLUMES_SGIS = SGIS_texture4D.UNPACK_SKIP_VOLUMES_SGIS,
+ UNPACK_IMAGE_DEPTH_SGIS = SGIS_texture4D.UNPACK_IMAGE_DEPTH_SGIS,
+ PIXEL_TILE_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_WIDTH_SGIX,
+ PIXEL_TILE_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_HEIGHT_SGIX,
+ PIXEL_TILE_GRID_WIDTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_WIDTH_SGIX,
+ PIXEL_TILE_GRID_HEIGHT_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_HEIGHT_SGIX,
+ PIXEL_TILE_GRID_DEPTH_SGIX = SGIX_pixel_tiles.PIXEL_TILE_GRID_DEPTH_SGIX,
+ PIXEL_TILE_CACHE_SIZE_SGIX = SGIX_pixel_tiles.PIXEL_TILE_CACHE_SIZE_SGIX,
+ PACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.PACK_SUBSAMPLE_RATE_SGIX,
+ UNPACK_SUBSAMPLE_RATE_SGIX = SGIX_subsample.UNPACK_SUBSAMPLE_RATE_SGIX,
+ PACK_RESAMPLE_SGIX = SGIX_resample.PACK_RESAMPLE_SGIX,
+ UNPACK_RESAMPLE_SGIX = SGIX_resample.UNPACK_RESAMPLE_SGIX,
+ }
+ #endregion
+ #region public enum PixelStoreResampleMode
+ public enum PixelStoreResampleMode
+ {
+ RESAMPLE_REPLICATE_SGIX = SGIX_resample.RESAMPLE_REPLICATE_SGIX,
+ RESAMPLE_ZERO_FILL_SGIX = SGIX_resample.RESAMPLE_ZERO_FILL_SGIX,
+ RESAMPLE_DECIMATE_SGIX = SGIX_resample.RESAMPLE_DECIMATE_SGIX,
+ }
+ #endregion
+ #region public enum PixelStoreSubsampleRate
+ public enum PixelStoreSubsampleRate
+ {
+ PIXEL_SUBSAMPLE_4444_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4444_SGIX,
+ PIXEL_SUBSAMPLE_2424_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_2424_SGIX,
+ PIXEL_SUBSAMPLE_4242_SGIX = SGIX_subsample.PIXEL_SUBSAMPLE_4242_SGIX,
+ }
+ #endregion
+ #region public enum PixelTexGenMode
+ public enum PixelTexGenMode
+ {
+ NONE = DrawBufferMode.NONE,
+ RGB = PixelFormat.RGB,
+ RGBA = PixelFormat.RGBA,
+ LUMINANCE = PixelFormat.LUMINANCE,
+ LUMINANCE_ALPHA = PixelFormat.LUMINANCE_ALPHA,
+ 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,
+ PIXEL_TEX_GEN_ALPHA_MS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_MS_SGIX,
+ PIXEL_TEX_GEN_ALPHA_LS_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_ALPHA_LS_SGIX,
+ }
+ #endregion
+ #region public enum PixelTexGenParameterNameSGIS
+ public enum PixelTexGenParameterNameSGIS
+ {
+ 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,
+ }
+ #endregion
+ #region public enum PixelTransferParameter
+ public enum PixelTransferParameter
+ {
+ MAP_COLOR = GetPName.MAP_COLOR,
+ MAP_STENCIL = GetPName.MAP_STENCIL,
+ INDEX_SHIFT = GetPName.INDEX_SHIFT,
+ INDEX_OFFSET = GetPName.INDEX_OFFSET,
+ RED_SCALE = GetPName.RED_SCALE,
+ RED_BIAS = GetPName.RED_BIAS,
+ GREEN_SCALE = GetPName.GREEN_SCALE,
+ GREEN_BIAS = GetPName.GREEN_BIAS,
+ BLUE_SCALE = GetPName.BLUE_SCALE,
+ BLUE_BIAS = GetPName.BLUE_BIAS,
+ ALPHA_SCALE = GetPName.ALPHA_SCALE,
+ ALPHA_BIAS = GetPName.ALPHA_BIAS,
+ DEPTH_SCALE = GetPName.DEPTH_SCALE,
+ DEPTH_BIAS = GetPName.DEPTH_BIAS,
+ POST_CONVOLUTION_RED_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_RED_SCALE_EXT,
+ POST_CONVOLUTION_GREEN_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_SCALE_EXT,
+ POST_CONVOLUTION_BLUE_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_SCALE_EXT,
+ POST_CONVOLUTION_ALPHA_SCALE_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_SCALE_EXT,
+ POST_CONVOLUTION_RED_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_RED_BIAS_EXT,
+ POST_CONVOLUTION_GREEN_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_GREEN_BIAS_EXT,
+ POST_CONVOLUTION_BLUE_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_BLUE_BIAS_EXT,
+ POST_CONVOLUTION_ALPHA_BIAS_EXT = EXT_convolution.POST_CONVOLUTION_ALPHA_BIAS_EXT,
+ POST_COLOR_MATRIX_RED_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_SCALE_SGI,
+ POST_COLOR_MATRIX_GREEN_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_SCALE_SGI,
+ POST_COLOR_MATRIX_BLUE_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_SCALE_SGI,
+ POST_COLOR_MATRIX_ALPHA_SCALE_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_SCALE_SGI,
+ POST_COLOR_MATRIX_RED_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_RED_BIAS_SGI,
+ POST_COLOR_MATRIX_GREEN_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_GREEN_BIAS_SGI,
+ POST_COLOR_MATRIX_BLUE_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_BLUE_BIAS_SGI,
+ POST_COLOR_MATRIX_ALPHA_BIAS_SGI = SGI_color_matrix.POST_COLOR_MATRIX_ALPHA_BIAS_SGI,
+ }
+ #endregion
+ #region public enum PixelType
+ public enum PixelType
+ {
+ BITMAP = 0x1A00,
+ BYTE = DataType.BYTE,
+ UNSIGNED_BYTE = DataType.UNSIGNED_BYTE,
+ SHORT = DataType.SHORT,
+ UNSIGNED_SHORT = DataType.UNSIGNED_SHORT,
+ INT = DataType.INT,
+ UNSIGNED_INT = DataType.UNSIGNED_INT,
+ FLOAT = DataType.FLOAT,
+ UNSIGNED_BYTE_3_3_2_EXT = EXT_packed_pixels.UNSIGNED_BYTE_3_3_2_EXT,
+ UNSIGNED_SHORT_4_4_4_4_EXT = EXT_packed_pixels.UNSIGNED_SHORT_4_4_4_4_EXT,
+ UNSIGNED_SHORT_5_5_5_1_EXT = EXT_packed_pixels.UNSIGNED_SHORT_5_5_5_1_EXT,
+ UNSIGNED_INT_8_8_8_8_EXT = EXT_packed_pixels.UNSIGNED_INT_8_8_8_8_EXT,
+ UNSIGNED_INT_10_10_10_2_EXT = EXT_packed_pixels.UNSIGNED_INT_10_10_10_2_EXT,
+ }
+ #endregion
+ #region public enum PointParameterNameSGIS
+ public enum PointParameterNameSGIS
+ {
+ POINT_SIZE_MIN_SGIS = SGIS_point_parameters.POINT_SIZE_MIN_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,
+ DISTANCE_ATTENUATION_SGIS = SGIS_point_parameters.DISTANCE_ATTENUATION_SGIS,
+ }
+ #endregion
+ #region public enum PolygonMode
+ public enum PolygonMode
+ {
+ POINT = 0x1B00,
+ LINE = 0x1B01,
+ FILL = 0x1B02,
+ }
+ #endregion
+ #region public enum ReadBufferMode
+ public enum ReadBufferMode
+ {
+ FRONT_LEFT = DrawBufferMode.FRONT_LEFT,
+ FRONT_RIGHT = DrawBufferMode.FRONT_RIGHT,
+ BACK_LEFT = DrawBufferMode.BACK_LEFT,
+ BACK_RIGHT = DrawBufferMode.BACK_RIGHT,
+ FRONT = DrawBufferMode.FRONT,
+ BACK = DrawBufferMode.BACK,
+ LEFT = DrawBufferMode.LEFT,
+ RIGHT = DrawBufferMode.RIGHT,
+ AUX0 = DrawBufferMode.AUX0,
+ AUX1 = DrawBufferMode.AUX1,
+ AUX2 = DrawBufferMode.AUX2,
+ AUX3 = DrawBufferMode.AUX3,
+ }
+ #endregion
+ #region public enum RenderingMode
+ public enum RenderingMode
+ {
+ RENDER = 0x1C00,
+ FEEDBACK = 0x1C01,
+ SELECT = 0x1C02,
+ }
+ #endregion
+ #region public enum SamplePatternSGIS
+ public enum SamplePatternSGIS
+ {
+ _1PASS_SGIS = SGIS_multisample._1PASS_SGIS,
+ _2PASS_0_SGIS = SGIS_multisample._2PASS_0_SGIS,
+ _2PASS_1_SGIS = SGIS_multisample._2PASS_1_SGIS,
+ _4PASS_0_SGIS = SGIS_multisample._4PASS_0_SGIS,
+ _4PASS_1_SGIS = SGIS_multisample._4PASS_1_SGIS,
+ _4PASS_2_SGIS = SGIS_multisample._4PASS_2_SGIS,
+ _4PASS_3_SGIS = SGIS_multisample._4PASS_3_SGIS,
+ }
+ #endregion
+ #region public enum SeparableTargetEXT
+ public enum SeparableTargetEXT
+ {
+ SEPARABLE_2D_EXT = EXT_convolution.SEPARABLE_2D_EXT,
+ }
+ #endregion
+ #region public enum ShadingModel
+ public enum ShadingModel
+ {
+ FLAT = 0x1D00,
+ SMOOTH = 0x1D01,
+ }
+ #endregion
+ #region public enum StencilFunction
+ public enum StencilFunction
+ {
+ NEVER = AlphaFunction.NEVER,
+ LESS = AlphaFunction.LESS,
+ EQUAL = AlphaFunction.EQUAL,
+ LEQUAL = AlphaFunction.LEQUAL,
+ GREATER = AlphaFunction.GREATER,
+ NOTEQUAL = AlphaFunction.NOTEQUAL,
+ GEQUAL = AlphaFunction.GEQUAL,
+ ALWAYS = AlphaFunction.ALWAYS,
+ }
+ #endregion
+ #region public enum StencilOp
+ public enum StencilOp
+ {
+ ZERO = BlendingFactorDest.ZERO,
+ KEEP = 0x1E00,
+ REPLACE = 0x1E01,
+ INCR = 0x1E02,
+ DECR = 0x1E03,
+ INVERT = LogicOp.INVERT,
+ }
+ #endregion
+ #region public enum StringName
+ public enum StringName
+ {
+ VENDOR = 0x1F00,
+ RENDERER = 0x1F01,
+ VERSION = 0x1F02,
+ EXTENSIONS = 0x1F03,
+ }
+ #endregion
+ #region public enum TexCoordPointerType
+ public enum TexCoordPointerType
+ {
+ SHORT = DataType.SHORT,
+ INT = DataType.INT,
+ FLOAT = DataType.FLOAT,
+ DOUBLE = DataType.DOUBLE,
+ }
+ #endregion
+ #region public enum TextureCoordName
+ public enum TextureCoordName
+ {
+ S = 0x2000,
+ T = 0x2001,
+ R = 0x2002,
+ Q = 0x2003,
+ }
+ #endregion
+ #region public enum TextureEnvMode
+ public enum TextureEnvMode
+ {
+ MODULATE = 0x2100,
+ DECAL = 0x2101,
+ BLEND = GetPName.BLEND,
+ REPLACE_EXT = EXT_texture.REPLACE_EXT,
+ ADD = AccumOp.ADD,
+ TEXTURE_ENV_BIAS_SGIX = SGIX_texture_add_env.TEXTURE_ENV_BIAS_SGIX,
+ }
+ #endregion
+ #region public enum TextureEnvParameter
+ public enum TextureEnvParameter
+ {
+ TEXTURE_ENV_MODE = 0x2200,
+ TEXTURE_ENV_COLOR = 0x2201,
+ }
+ #endregion
+ #region public enum TextureEnvTarget
+ public enum TextureEnvTarget
+ {
+ TEXTURE_ENV = 0x2300,
+ }
+ #endregion
+ #region public enum TextureFilterFuncSGIS
+ public enum TextureFilterFuncSGIS
+ {
+ FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
+ }
+ #endregion
+ #region public enum TextureGenMode
+ public enum TextureGenMode
+ {
+ EYE_LINEAR = 0x2400,
+ OBJECT_LINEAR = 0x2401,
+ SPHERE_MAP = 0x2402,
+ EYE_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_POINT_SGIS,
+ OBJECT_DISTANCE_TO_POINT_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_POINT_SGIS,
+ EYE_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.EYE_DISTANCE_TO_LINE_SGIS,
+ OBJECT_DISTANCE_TO_LINE_SGIS = SGIS_point_line_texgen.OBJECT_DISTANCE_TO_LINE_SGIS,
+ }
+ #endregion
+ #region public enum TextureGenParameter
+ public enum TextureGenParameter
+ {
+ TEXTURE_GEN_MODE = 0x2500,
+ OBJECT_PLANE = 0x2501,
+ EYE_PLANE = 0x2502,
+ EYE_POINT_SGIS = SGIS_point_line_texgen.EYE_POINT_SGIS,
+ OBJECT_POINT_SGIS = SGIS_point_line_texgen.OBJECT_POINT_SGIS,
+ EYE_LINE_SGIS = SGIS_point_line_texgen.EYE_LINE_SGIS,
+ OBJECT_LINE_SGIS = SGIS_point_line_texgen.OBJECT_LINE_SGIS,
+ }
+ #endregion
+ #region public enum TextureMagFilter
+ public enum TextureMagFilter
+ {
+ NEAREST = 0x2600,
+ LINEAR = 0x2601,
+ LINEAR_DETAIL_SGIS = SGIS_detail_texture.LINEAR_DETAIL_SGIS,
+ LINEAR_DETAIL_ALPHA_SGIS = SGIS_detail_texture.LINEAR_DETAIL_ALPHA_SGIS,
+ LINEAR_DETAIL_COLOR_SGIS = SGIS_detail_texture.LINEAR_DETAIL_COLOR_SGIS,
+ LINEAR_SHARPEN_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_SGIS,
+ LINEAR_SHARPEN_ALPHA_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_ALPHA_SGIS,
+ LINEAR_SHARPEN_COLOR_SGIS = SGIS_sharpen_texture.LINEAR_SHARPEN_COLOR_SGIS,
+ FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
+ PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX,
+ PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX,
+ PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX,
+ }
+ #endregion
+ #region public enum TextureMinFilter
+ public enum TextureMinFilter
+ {
+ NEAREST = TextureMagFilter.NEAREST,
+ LINEAR = TextureMagFilter.LINEAR,
+ NEAREST_MIPMAP_NEAREST = 0x2700,
+ LINEAR_MIPMAP_NEAREST = 0x2701,
+ NEAREST_MIPMAP_LINEAR = 0x2702,
+ LINEAR_MIPMAP_LINEAR = 0x2703,
+ FILTER4_SGIS = SGIS_texture_filter4.FILTER4_SGIS,
+ LINEAR_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_LINEAR_SGIX,
+ NEAREST_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_NEAREST_SGIX,
+ NEAREST_CLIPMAP_LINEAR_SGIX = SGIX_clipmap.NEAREST_CLIPMAP_LINEAR_SGIX,
+ LINEAR_CLIPMAP_NEAREST_SGIX = SGIX_clipmap.LINEAR_CLIPMAP_NEAREST_SGIX,
+ PIXEL_TEX_GEN_Q_CEILING_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_CEILING_SGIX,
+ PIXEL_TEX_GEN_Q_ROUND_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_ROUND_SGIX,
+ PIXEL_TEX_GEN_Q_FLOOR_SGIX = SGIX_impact_pixel_texture.PIXEL_TEX_GEN_Q_FLOOR_SGIX,
+ }
+ #endregion
+ #region public enum TextureParameterName
+ public enum TextureParameterName
+ {
+ TEXTURE_MAG_FILTER = 0x2800,
+ TEXTURE_MIN_FILTER = 0x2801,
+ TEXTURE_WRAP_S = 0x2802,
+ TEXTURE_WRAP_T = 0x2803,
+ TEXTURE_BORDER_COLOR = GetTextureParameter.TEXTURE_BORDER_COLOR,
+ TEXTURE_PRIORITY = GetTextureParameter.TEXTURE_PRIORITY,
+ TEXTURE_WRAP_R_EXT = EXT_texture3D.TEXTURE_WRAP_R_EXT,
+ DETAIL_TEXTURE_LEVEL_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_LEVEL_SGIS,
+ DETAIL_TEXTURE_MODE_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_MODE_SGIS,
+ GENERATE_MIPMAP_SGIS = SGIS_generate_mipmap.GENERATE_MIPMAP_SGIS,
+ DUAL_TEXTURE_SELECT_SGIS = SGIS_texture_select.DUAL_TEXTURE_SELECT_SGIS,
+ QUAD_TEXTURE_SELECT_SGIS = SGIS_texture_select.QUAD_TEXTURE_SELECT_SGIS,
+ TEXTURE_WRAP_Q_SGIS = SGIS_texture4D.TEXTURE_WRAP_Q_SGIS,
+ TEXTURE_CLIPMAP_CENTER_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_CENTER_SGIX,
+ TEXTURE_CLIPMAP_FRAME_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_FRAME_SGIX,
+ TEXTURE_CLIPMAP_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_OFFSET_SGIX,
+ TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX,
+ TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_LOD_OFFSET_SGIX,
+ TEXTURE_CLIPMAP_DEPTH_SGIX = SGIX_clipmap.TEXTURE_CLIPMAP_DEPTH_SGIX,
+ TEXTURE_COMPARE_SGIX = SGIX_shadow.TEXTURE_COMPARE_SGIX,
+ TEXTURE_COMPARE_OPERATOR_SGIX = SGIX_shadow.TEXTURE_COMPARE_OPERATOR_SGIX,
+ SHADOW_AMBIENT_SGIX = SGIX_shadow_ambient.SHADOW_AMBIENT_SGIX,
+ TEXTURE_MAX_CLAMP_S_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_S_SGIX,
+ TEXTURE_MAX_CLAMP_T_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_T_SGIX,
+ TEXTURE_MAX_CLAMP_R_SGIX = SGIX_texture_coordinate_clamp.TEXTURE_MAX_CLAMP_R_SGIX,
+ TEXTURE_LOD_BIAS_S_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_S_SGIX,
+ TEXTURE_LOD_BIAS_T_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_T_SGIX,
+ TEXTURE_LOD_BIAS_R_SGIX = SGIX_texture_lod_bias.TEXTURE_LOD_BIAS_R_SGIX,
+ POST_TEXTURE_FILTER_BIAS_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_BIAS_SGIX,
+ POST_TEXTURE_FILTER_SCALE_SGIX = SGIX_texture_scale_bias.POST_TEXTURE_FILTER_SCALE_SGIX,
+ }
+ #endregion
+ #region public enum TextureTarget
+ public enum TextureTarget
+ {
+ TEXTURE_1D = GetPName.TEXTURE_1D,
+ TEXTURE_2D = GetPName.TEXTURE_2D,
+ PROXY_TEXTURE_1D = 0x8063,
+ PROXY_TEXTURE_2D = 0x8064,
+ TEXTURE_3D_EXT = EXT_texture3D.TEXTURE_3D_EXT,
+ PROXY_TEXTURE_3D_EXT = EXT_texture3D.PROXY_TEXTURE_3D_EXT,
+ DETAIL_TEXTURE_2D_SGIS = SGIS_detail_texture.DETAIL_TEXTURE_2D_SGIS,
+ TEXTURE_4D_SGIS = SGIS_texture4D.TEXTURE_4D_SGIS,
+ PROXY_TEXTURE_4D_SGIS = SGIS_texture4D.PROXY_TEXTURE_4D_SGIS,
+ TEXTURE_MIN_LOD_SGIS = SGIS_texture_lod.TEXTURE_MIN_LOD_SGIS,
+ TEXTURE_MAX_LOD_SGIS = SGIS_texture_lod.TEXTURE_MAX_LOD_SGIS,
+ TEXTURE_BASE_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_BASE_LEVEL_SGIS,
+ TEXTURE_MAX_LEVEL_SGIS = SGIS_texture_lod.TEXTURE_MAX_LEVEL_SGIS,
+ }
+ #endregion
+ #region public enum TextureWrapMode
+ public enum TextureWrapMode
+ {
+ CLAMP = 0x2900,
+ REPEAT = 0x2901,
+ CLAMP_TO_BORDER_SGIS = SGIS_texture_border_clamp.CLAMP_TO_BORDER_SGIS,
+ CLAMP_TO_EDGE_SGIS = SGIS_texture_edge_clamp.CLAMP_TO_EDGE_SGIS,
+ }
+ #endregion
+ #region public enum PixelInternalFormat
+ public enum PixelInternalFormat
+ {
+ R3_G3_B2 = 0x2A10,
+ ALPHA4 = 0x803B,
+ ALPHA8 = 0x803C,
+ ALPHA12 = 0x803D,
+ ALPHA16 = 0x803E,
+ LUMINANCE4 = 0x803F,
+ LUMINANCE8 = 0x8040,
+ LUMINANCE12 = 0x8041,
+ LUMINANCE16 = 0x8042,
+ LUMINANCE4_ALPHA4 = 0x8043,
+ LUMINANCE6_ALPHA2 = 0x8044,
+ LUMINANCE8_ALPHA8 = 0x8045,
+ LUMINANCE12_ALPHA4 = 0x8046,
+ LUMINANCE12_ALPHA12 = 0x8047,
+ LUMINANCE16_ALPHA16 = 0x8048,
+ INTENSITY = 0x8049,
+ INTENSITY4 = 0x804A,
+ INTENSITY8 = 0x804B,
+ INTENSITY12 = 0x804C,
+ INTENSITY16 = 0x804D,
+ RGB4 = 0x804F,
+ RGB5 = 0x8050,
+ RGB8 = 0x8051,
+ RGB10 = 0x8052,
+ RGB12 = 0x8053,
+ RGB16 = 0x8054,
+ RGBA2 = 0x8055,
+ RGBA4 = 0x8056,
+ RGB5_A1 = 0x8057,
+ RGBA8 = 0x8058,
+ RGB10_A2 = 0x8059,
+ RGBA12 = 0x805A,
+ RGBA16 = 0x805B,
+ RGB2_EXT = EXT_texture.RGB2_EXT,
+ DUAL_ALPHA4_SGIS = SGIS_texture_select.DUAL_ALPHA4_SGIS,
+ DUAL_ALPHA8_SGIS = SGIS_texture_select.DUAL_ALPHA8_SGIS,
+ DUAL_ALPHA12_SGIS = SGIS_texture_select.DUAL_ALPHA12_SGIS,
+ DUAL_ALPHA16_SGIS = SGIS_texture_select.DUAL_ALPHA16_SGIS,
+ DUAL_LUMINANCE4_SGIS = SGIS_texture_select.DUAL_LUMINANCE4_SGIS,
+ DUAL_LUMINANCE8_SGIS = SGIS_texture_select.DUAL_LUMINANCE8_SGIS,
+ DUAL_LUMINANCE12_SGIS = SGIS_texture_select.DUAL_LUMINANCE12_SGIS,
+ DUAL_LUMINANCE16_SGIS = SGIS_texture_select.DUAL_LUMINANCE16_SGIS,
+ DUAL_INTENSITY4_SGIS = SGIS_texture_select.DUAL_INTENSITY4_SGIS,
+ DUAL_INTENSITY8_SGIS = SGIS_texture_select.DUAL_INTENSITY8_SGIS,
+ DUAL_INTENSITY12_SGIS = SGIS_texture_select.DUAL_INTENSITY12_SGIS,
+ DUAL_INTENSITY16_SGIS = SGIS_texture_select.DUAL_INTENSITY16_SGIS,
+ DUAL_LUMINANCE_ALPHA4_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA4_SGIS,
+ DUAL_LUMINANCE_ALPHA8_SGIS = SGIS_texture_select.DUAL_LUMINANCE_ALPHA8_SGIS,
+ QUAD_ALPHA4_SGIS = SGIS_texture_select.QUAD_ALPHA4_SGIS,
+ QUAD_ALPHA8_SGIS = SGIS_texture_select.QUAD_ALPHA8_SGIS,
+ QUAD_LUMINANCE4_SGIS = SGIS_texture_select.QUAD_LUMINANCE4_SGIS,
+ QUAD_LUMINANCE8_SGIS = SGIS_texture_select.QUAD_LUMINANCE8_SGIS,
+ QUAD_INTENSITY4_SGIS = SGIS_texture_select.QUAD_INTENSITY4_SGIS,
+ QUAD_INTENSITY8_SGIS = SGIS_texture_select.QUAD_INTENSITY8_SGIS,
+ DEPTH_COMPONENT16_SGIX = SGIX_depth_texture.DEPTH_COMPONENT16_SGIX,
+ DEPTH_COMPONENT24_SGIX = SGIX_depth_texture.DEPTH_COMPONENT24_SGIX,
+ DEPTH_COMPONENT32_SGIX = SGIX_depth_texture.DEPTH_COMPONENT32_SGIX,
+ RGB_ICC_SGIX = SGIX_icc_texture.RGB_ICC_SGIX,
+ RGBA_ICC_SGIX = SGIX_icc_texture.RGBA_ICC_SGIX,
+ ALPHA_ICC_SGIX = SGIX_icc_texture.ALPHA_ICC_SGIX,
+ LUMINANCE_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ICC_SGIX,
+ INTENSITY_ICC_SGIX = SGIX_icc_texture.INTENSITY_ICC_SGIX,
+ LUMINANCE_ALPHA_ICC_SGIX = SGIX_icc_texture.LUMINANCE_ALPHA_ICC_SGIX,
+ R5_G6_B5_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_ICC_SGIX,
+ R5_G6_B5_A8_ICC_SGIX = SGIX_icc_texture.R5_G6_B5_A8_ICC_SGIX,
+ ALPHA16_ICC_SGIX = SGIX_icc_texture.ALPHA16_ICC_SGIX,
+ LUMINANCE16_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ICC_SGIX,
+ INTENSITY16_ICC_SGIX = SGIX_icc_texture.INTENSITY16_ICC_SGIX,
+ LUMINANCE16_ALPHA8_ICC_SGIX = SGIX_icc_texture.LUMINANCE16_ALPHA8_ICC_SGIX,
+ }
+ #endregion
+ #region public enum InterleavedArrayFormat
+ public enum InterleavedArrayFormat
+ {
+ V2F = 0x2A20,
+ V3F = 0x2A21,
+ C4UB_V2F = 0x2A22,
+ C4UB_V3F = 0x2A23,
+ C3F_V3F = 0x2A24,
+ N3F_V3F = 0x2A25,
+ C4F_N3F_V3F = 0x2A26,
+ T2F_V3F = 0x2A27,
+ T4F_V4F = 0x2A28,
+ T2F_C4UB_V3F = 0x2A29,
+ T2F_C3F_V3F = 0x2A2A,
+ T2F_N3F_V3F = 0x2A2B,
+ T2F_C4F_N3F_V3F = 0x2A2C,
+ T4F_C4F_N3F_V4F = 0x2A2D,
+ }
+ #endregion
+ #region public enum VertexPointerType
+ public enum VertexPointerType
+ {
+ SHORT = DataType.SHORT,
+ INT = DataType.INT,
+ FLOAT = DataType.FLOAT,
+ DOUBLE = DataType.DOUBLE,
+ }
+ #endregion
+ #region public enum ClipPlaneName
+ public enum ClipPlaneName
+ {
+ CLIP_PLANE0 = 0x3000,
+ CLIP_PLANE1 = 0x3001,
+ CLIP_PLANE2 = 0x3002,
+ CLIP_PLANE3 = 0x3003,
+ CLIP_PLANE4 = 0x3004,
+ CLIP_PLANE5 = 0x3005,
+ }
+ #endregion
+ #region public enum LightName
+ public enum LightName
+ {
+ LIGHT0 = 0x4000,
+ LIGHT1 = 0x4001,
+ LIGHT2 = 0x4002,
+ LIGHT3 = 0x4003,
+ LIGHT4 = 0x4004,
+ LIGHT5 = 0x4005,
+ LIGHT6 = 0x4006,
+ LIGHT7 = 0x4007,
+ FRAGMENT_LIGHT0_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT0_SGIX,
+ FRAGMENT_LIGHT1_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT1_SGIX,
+ FRAGMENT_LIGHT2_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT2_SGIX,
+ FRAGMENT_LIGHT3_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT3_SGIX,
+ FRAGMENT_LIGHT4_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT4_SGIX,
+ FRAGMENT_LIGHT5_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT5_SGIX,
+ FRAGMENT_LIGHT6_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT6_SGIX,
+ FRAGMENT_LIGHT7_SGIX = SGIX_fragment_lighting.FRAGMENT_LIGHT7_SGIX,
+ }
+ #endregion
+ #region public enum EXT_abgr
+ public enum EXT_abgr
+ {
+ ABGR_EXT = 0x8000,
+ }
+ #endregion
+ #region public enum EXT_blend_color
+ public enum EXT_blend_color
+ {
+ CONSTANT_COLOR = 0x8001,
+ CONSTANT_COLOR_EXT = 0x8001,
+ ONE_MINUS_CONSTANT_COLOR = 0x8002,
+ ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002,
+ CONSTANT_ALPHA = 0x8003,
+ CONSTANT_ALPHA_EXT = 0x8003,
+ ONE_MINUS_CONSTANT_ALPHA = 0x8004,
+ ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004,
+ BLEND_COLOR = 0x8005,
+ BLEND_COLOR_EXT = 0x8005,
+ }
+ #endregion
+ #region public enum EXT_blend_minmax
+ public enum EXT_blend_minmax
+ {
+ FUNC_ADD = 0x8006,
+ FUNC_ADD_EXT = 0x8006,
+ MIN = 0x8007,
+ MIN_EXT = 0x8007,
+ MAX = 0x8008,
+ MAX_EXT = 0x8008,
+ BLEND_EQUATION = 0x8009,
+ BLEND_EQUATION_EXT = 0x8009,
+ }
+ #endregion
+ #region public enum EXT_blend_subtract
+ public enum EXT_blend_subtract
+ {
+ FUNC_SUBTRACT = 0x800A,
+ FUNC_SUBTRACT_EXT = 0x800A,
+ FUNC_REVERSE_SUBTRACT = 0x800B,
+ FUNC_REVERSE_SUBTRACT_EXT = 0x800B,
+ }
+ #endregion
+ #region public enum EXT_cmyka
+ public enum EXT_cmyka
+ {
+ CMYK_EXT = 0x800C,
+ CMYKA_EXT = 0x800D,
+ PACK_CMYK_HINT_EXT = 0x800E,
+ UNPACK_CMYK_HINT_EXT = 0x800F,
+ }
+ #endregion
+ #region public enum EXT_convolution
+ public enum EXT_convolution
+ {
+ CONVOLUTION_1D = 0x8010,
+ CONVOLUTION_1D_EXT = 0x8010,
+ CONVOLUTION_2D = 0x8011,
+ CONVOLUTION_2D_EXT = 0x8011,
+ SEPARABLE_2D = 0x8012,
+ SEPARABLE_2D_EXT = 0x8012,
+ CONVOLUTION_BORDER_MODE = 0x8013,
+ CONVOLUTION_BORDER_MODE_EXT = 0x8013,
+ CONVOLUTION_FILTER_SCALE = 0x8014,
+ CONVOLUTION_FILTER_SCALE_EXT = 0x8014,
+ CONVOLUTION_FILTER_BIAS = 0x8015,
+ CONVOLUTION_FILTER_BIAS_EXT = 0x8015,
+ REDUCE = 0x8016,
+ REDUCE_EXT = 0x8016,
+ CONVOLUTION_FORMAT = 0x8017,
+ CONVOLUTION_FORMAT_EXT = 0x8017,
+ CONVOLUTION_WIDTH = 0x8018,
+ CONVOLUTION_WIDTH_EXT = 0x8018,
+ CONVOLUTION_HEIGHT = 0x8019,
+ CONVOLUTION_HEIGHT_EXT = 0x8019,
+ MAX_CONVOLUTION_WIDTH = 0x801A,
+ MAX_CONVOLUTION_WIDTH_EXT = 0x801A,
+ MAX_CONVOLUTION_HEIGHT = 0x801B,
+ MAX_CONVOLUTION_HEIGHT_EXT = 0x801B,
+ POST_CONVOLUTION_RED_SCALE = 0x801C,
+ POST_CONVOLUTION_RED_SCALE_EXT = 0x801C,
+ POST_CONVOLUTION_GREEN_SCALE = 0x801D,
+ POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D,
+ POST_CONVOLUTION_BLUE_SCALE = 0x801E,
+ POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E,
+ POST_CONVOLUTION_ALPHA_SCALE = 0x801F,
+ POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F,
+ POST_CONVOLUTION_RED_BIAS = 0x8020,
+ POST_CONVOLUTION_RED_BIAS_EXT = 0x8020,
+ POST_CONVOLUTION_GREEN_BIAS = 0x8021,
+ POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021,
+ POST_CONVOLUTION_BLUE_BIAS = 0x8022,
+ POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022,
+ POST_CONVOLUTION_ALPHA_BIAS = 0x8023,
+ POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023,
+ }
+ #endregion
+ #region public enum EXT_histogram
+ public enum EXT_histogram
+ {
+ HISTOGRAM = 0x8024,
+ HISTOGRAM_EXT = 0x8024,
+ PROXY_HISTOGRAM = 0x8025,
+ PROXY_HISTOGRAM_EXT = 0x8025,
+ HISTOGRAM_WIDTH = 0x8026,
+ HISTOGRAM_WIDTH_EXT = 0x8026,
+ HISTOGRAM_FORMAT = 0x8027,
+ HISTOGRAM_FORMAT_EXT = 0x8027,
+ HISTOGRAM_RED_SIZE = 0x8028,
+ HISTOGRAM_RED_SIZE_EXT = 0x8028,
+ HISTOGRAM_GREEN_SIZE = 0x8029,
+ HISTOGRAM_GREEN_SIZE_EXT = 0x8029,
+ HISTOGRAM_BLUE_SIZE = 0x802A,
+ HISTOGRAM_BLUE_SIZE_EXT = 0x802A,
+ HISTOGRAM_ALPHA_SIZE = 0x802B,
+ HISTOGRAM_ALPHA_SIZE_EXT = 0x802B,
+ HISTOGRAM_LUMINANCE_SIZE = 0x802C,
+ HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C,
+ HISTOGRAM_SINK = 0x802D,
+ HISTOGRAM_SINK_EXT = 0x802D,
+ MINMAX = 0x802E,
+ MINMAX_EXT = 0x802E,
+ MINMAX_FORMAT = 0x802F,
+ MINMAX_FORMAT_EXT = 0x802F,
+ MINMAX_SINK = 0x8030,
+ MINMAX_SINK_EXT = 0x8030,
+ TABLE_TOO_LARGE = 0x8031,
+ TABLE_TOO_LARGE_EXT = 0x8031,
+ }
+ #endregion
+ #region public enum EXT_packed_pixels
+ public enum EXT_packed_pixels
+ {
+ UNSIGNED_BYTE_3_3_2 = 0x8032,
+ UNSIGNED_BYTE_3_3_2_EXT = 0x8032,
+ UNSIGNED_SHORT_4_4_4_4 = 0x8033,
+ UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033,
+ UNSIGNED_SHORT_5_5_5_1 = 0x8034,
+ UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034,
+ UNSIGNED_INT_8_8_8_8 = 0x8035,
+ UNSIGNED_INT_8_8_8_8_EXT = 0x8035,
+ UNSIGNED_INT_10_10_10_2 = 0x8036,
+ UNSIGNED_INT_10_10_10_2_EXT = 0x8036,
+ UNSIGNED_BYTE_2_3_3_REV = 0x8362,
+ UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362,
+ UNSIGNED_SHORT_5_6_5 = 0x8363,
+ UNSIGNED_SHORT_5_6_5_EXT = 0x8363,
+ UNSIGNED_SHORT_5_6_5_REV = 0x8364,
+ UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364,
+ UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
+ UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365,
+ UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
+ UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366,
+ UNSIGNED_INT_8_8_8_8_REV = 0x8367,
+ UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367,
+ UNSIGNED_INT_2_10_10_10_REV = 0x8368,
+ UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368,
+ }
+ #endregion
+ #region public enum EXT_polygon_offset
+ public enum EXT_polygon_offset
+ {
+ POLYGON_OFFSET_EXT = 0x8037,
+ POLYGON_OFFSET_FACTOR_EXT = 0x8038,
+ POLYGON_OFFSET_BIAS_EXT = 0x8039,
+ }
+ #endregion
+ #region public enum EXT_rescale_normal
+ public enum EXT_rescale_normal
+ {
+ RESCALE_NORMAL = 0x803A,
+ RESCALE_NORMAL_EXT = 0x803A,
+ }
+ #endregion
+ #region public enum EXT_texture
+ public enum EXT_texture
+ {
+ ALPHA4_EXT = 0x803B,
+ ALPHA8_EXT = 0x803C,
+ ALPHA12_EXT = 0x803D,
+ ALPHA16_EXT = 0x803E,
+ LUMINANCE4_EXT = 0x803F,
+ LUMINANCE8_EXT = 0x8040,
+ LUMINANCE12_EXT = 0x8041,
+ LUMINANCE16_EXT = 0x8042,
+ LUMINANCE4_ALPHA4_EXT = 0x8043,
+ LUMINANCE6_ALPHA2_EXT = 0x8044,
+ LUMINANCE8_ALPHA8_EXT = 0x8045,
+ LUMINANCE12_ALPHA4_EXT = 0x8046,
+ LUMINANCE12_ALPHA12_EXT = 0x8047,
+ LUMINANCE16_ALPHA16_EXT = 0x8048,
+ INTENSITY_EXT = 0x8049,
+ INTENSITY4_EXT = 0x804A,
+ INTENSITY8_EXT = 0x804B,
+ INTENSITY12_EXT = 0x804C,
+ INTENSITY16_EXT = 0x804D,
+ RGB2_EXT = 0x804E,
+ RGB4_EXT = 0x804F,
+ RGB5_EXT = 0x8050,
+ RGB8_EXT = 0x8051,
+ RGB10_EXT = 0x8052,
+ RGB12_EXT = 0x8053,
+ RGB16_EXT = 0x8054,
+ RGBA2_EXT = 0x8055,
+ RGBA4_EXT = 0x8056,
+ RGB5_A1_EXT = 0x8057,
+ RGBA8_EXT = 0x8058,
+ RGB10_A2_EXT = 0x8059,
+ RGBA12_EXT = 0x805A,
+ RGBA16_EXT = 0x805B,
+ TEXTURE_RED_SIZE_EXT = 0x805C,
+ TEXTURE_GREEN_SIZE_EXT = 0x805D,
+ TEXTURE_BLUE_SIZE_EXT = 0x805E,
+ TEXTURE_ALPHA_SIZE_EXT = 0x805F,
+ TEXTURE_LUMINANCE_SIZE_EXT = 0x8060,
+ TEXTURE_INTENSITY_SIZE_EXT = 0x8061,
+ REPLACE_EXT = 0x8062,
+ PROXY_TEXTURE_1D_EXT = 0x8063,
+ PROXY_TEXTURE_2D_EXT = 0x8064,
+ TEXTURE_TOO_LARGE_EXT = 0x8065,
+ }
+ #endregion
+ #region public enum EXT_texture_object
+ public enum EXT_texture_object
+ {
+ TEXTURE_PRIORITY_EXT = 0x8066,
+ TEXTURE_RESIDENT_EXT = 0x8067,
+ TEXTURE_1D_BINDING_EXT = 0x8068,
+ TEXTURE_2D_BINDING_EXT = 0x8069,
+ TEXTURE_3D_BINDING_EXT = 0x806A,
+ }
+ #endregion
+ #region public enum EXT_texture3D
+ public enum EXT_texture3D
+ {
+ PACK_SKIP_IMAGES = 0x806B,
+ PACK_SKIP_IMAGES_EXT = 0x806B,
+ PACK_IMAGE_HEIGHT = 0x806C,
+ PACK_IMAGE_HEIGHT_EXT = 0x806C,
+ UNPACK_SKIP_IMAGES = 0x806D,
+ UNPACK_SKIP_IMAGES_EXT = 0x806D,
+ UNPACK_IMAGE_HEIGHT = 0x806E,
+ UNPACK_IMAGE_HEIGHT_EXT = 0x806E,
+ TEXTURE_3D = 0x806F,
+ TEXTURE_3D_EXT = 0x806F,
+ PROXY_TEXTURE_3D = 0x8070,
+ PROXY_TEXTURE_3D_EXT = 0x8070,
+ TEXTURE_DEPTH = 0x8071,
+ TEXTURE_DEPTH_EXT = 0x8071,
+ TEXTURE_WRAP_R = 0x8072,
+ TEXTURE_WRAP_R_EXT = 0x8072,
+ MAX_3D_TEXTURE_SIZE = 0x8073,
+ MAX_3D_TEXTURE_SIZE_EXT = 0x8073,
+ }
+ #endregion
+ #region public enum EXT_vertex_array
+ public enum EXT_vertex_array
+ {
+ VERTEX_ARRAY_EXT = 0x8074,
+ NORMAL_ARRAY_EXT = 0x8075,
+ COLOR_ARRAY_EXT = 0x8076,
+ INDEX_ARRAY_EXT = 0x8077,
+ TEXTURE_COORD_ARRAY_EXT = 0x8078,
+ EDGE_FLAG_ARRAY_EXT = 0x8079,
+ VERTEX_ARRAY_SIZE_EXT = 0x807A,
+ VERTEX_ARRAY_TYPE_EXT = 0x807B,
+ VERTEX_ARRAY_STRIDE_EXT = 0x807C,
+ VERTEX_ARRAY_COUNT_EXT = 0x807D,
+ NORMAL_ARRAY_TYPE_EXT = 0x807E,
+ NORMAL_ARRAY_STRIDE_EXT = 0x807F,
+ NORMAL_ARRAY_COUNT_EXT = 0x8080,
+ COLOR_ARRAY_SIZE_EXT = 0x8081,
+ COLOR_ARRAY_TYPE_EXT = 0x8082,
+ COLOR_ARRAY_STRIDE_EXT = 0x8083,
+ COLOR_ARRAY_COUNT_EXT = 0x8084,
+ INDEX_ARRAY_TYPE_EXT = 0x8085,
+ INDEX_ARRAY_STRIDE_EXT = 0x8086,
+ INDEX_ARRAY_COUNT_EXT = 0x8087,
+ TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088,
+ TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089,
+ TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A,
+ TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B,
+ EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C,
+ EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D,
+ VERTEX_ARRAY_POINTER_EXT = 0x808E,
+ NORMAL_ARRAY_POINTER_EXT = 0x808F,
+ COLOR_ARRAY_POINTER_EXT = 0x8090,
+ INDEX_ARRAY_POINTER_EXT = 0x8091,
+ TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092,
+ EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093,
+ }
+ #endregion
+ #region public enum SGIX_interlace
+ public enum SGIX_interlace
+ {
+ INTERLACE_SGIX = 0x8094,
+ }
+ #endregion
+ #region public enum SGIS_detail_texture
+ public enum SGIS_detail_texture
+ {
+ DETAIL_TEXTURE_2D_SGIS = 0x8095,
+ DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096,
+ LINEAR_DETAIL_SGIS = 0x8097,
+ LINEAR_DETAIL_ALPHA_SGIS = 0x8098,
+ LINEAR_DETAIL_COLOR_SGIS = 0x8099,
+ DETAIL_TEXTURE_LEVEL_SGIS = 0x809A,
+ DETAIL_TEXTURE_MODE_SGIS = 0x809B,
+ DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C,
+ }
+ #endregion
+ #region public enum ARB_multisample
+ public enum ARB_multisample
+ {
+ MULTISAMPLE = 0x809D,
+ MULTISAMPLE_ARB = 0x809D,
+ SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
+ SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E,
+ SAMPLE_ALPHA_TO_ONE = 0x809F,
+ SAMPLE_ALPHA_TO_ONE_ARB = 0x809F,
+ SAMPLE_COVERAGE = 0x80A0,
+ SAMPLE_COVERAGE_ARB = 0x80A0,
+ SAMPLE_BUFFERS = 0x80A8,
+ SAMPLE_BUFFERS_ARB = 0x80A8,
+ SAMPLES = 0x80A9,
+ SAMPLES_ARB = 0x80A9,
+ SAMPLE_COVERAGE_VALUE = 0x80AA,
+ SAMPLE_COVERAGE_VALUE_ARB = 0x80AA,
+ SAMPLE_COVERAGE_INVERT = 0x80AB,
+ SAMPLE_COVERAGE_INVERT_ARB = 0x80AB,
+ MULTISAMPLE_BIT_ARB = 0x20000000,
+ }
+ #endregion
+ #region public enum SGIS_multisample
+ public enum SGIS_multisample
+ {
+ MULTISAMPLE_SGIS = 0x809D,
+ SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E,
+ SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F,
+ SAMPLE_MASK_SGIS = 0x80A0,
+ _1PASS_SGIS = 0x80A1,
+ _2PASS_0_SGIS = 0x80A2,
+ _2PASS_1_SGIS = 0x80A3,
+ _4PASS_0_SGIS = 0x80A4,
+ _4PASS_1_SGIS = 0x80A5,
+ _4PASS_2_SGIS = 0x80A6,
+ _4PASS_3_SGIS = 0x80A7,
+ SAMPLE_BUFFERS_SGIS = 0x80A8,
+ SAMPLES_SGIS = 0x80A9,
+ SAMPLE_MASK_VALUE_SGIS = 0x80AA,
+ SAMPLE_MASK_INVERT_SGIS = 0x80AB,
+ SAMPLE_PATTERN_SGIS = 0x80AC,
+ }
+ #endregion
+ #region public enum SGIS_sharpen_texture
+ public enum SGIS_sharpen_texture
+ {
+ LINEAR_SHARPEN_SGIS = 0x80AD,
+ LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE,
+ LINEAR_SHARPEN_COLOR_SGIS = 0x80AF,
+ SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0,
+ }
+ #endregion
+ #region public enum SGI_color_matrix
+ public enum SGI_color_matrix
+ {
+ COLOR_MATRIX = 0x80B1,
+ COLOR_MATRIX_SGI = 0x80B1,
+ COLOR_MATRIX_STACK_DEPTH = 0x80B2,
+ COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2,
+ MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3,
+ MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3,
+ POST_COLOR_MATRIX_RED_SCALE = 0x80B4,
+ POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4,
+ POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5,
+ POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5,
+ POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6,
+ POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6,
+ POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7,
+ POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7,
+ POST_COLOR_MATRIX_RED_BIAS = 0x80B8,
+ POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8,
+ POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9,
+ POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9,
+ POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA,
+ POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA,
+ POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB,
+ POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB,
+ }
+ #endregion
+ #region public enum SGI_texture_color_table
+ public enum SGI_texture_color_table
+ {
+ TEXTURE_COLOR_TABLE_SGI = 0x80BC,
+ PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD,
+ }
+ #endregion
+ #region public enum SGIX_texture_add_env
+ public enum SGIX_texture_add_env
+ {
+ TEXTURE_ENV_BIAS_SGIX = 0x80BE,
+ }
+ #endregion
+ #region public enum SGIX_shadow_ambient
+ public enum SGIX_shadow_ambient
+ {
+ SHADOW_AMBIENT_SGIX = 0x80BF,
+ }
+ #endregion
+ #region public enum SGI_color_table
+ public enum SGI_color_table
+ {
+ COLOR_TABLE = 0x80D0,
+ COLOR_TABLE_SGI = 0x80D0,
+ POST_CONVOLUTION_COLOR_TABLE = 0x80D1,
+ POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1,
+ POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2,
+ POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2,
+ PROXY_COLOR_TABLE = 0x80D3,
+ PROXY_COLOR_TABLE_SGI = 0x80D3,
+ PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
+ PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4,
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5,
+ COLOR_TABLE_SCALE = 0x80D6,
+ COLOR_TABLE_SCALE_SGI = 0x80D6,
+ COLOR_TABLE_BIAS = 0x80D7,
+ COLOR_TABLE_BIAS_SGI = 0x80D7,
+ COLOR_TABLE_FORMAT = 0x80D8,
+ COLOR_TABLE_FORMAT_SGI = 0x80D8,
+ COLOR_TABLE_WIDTH = 0x80D9,
+ COLOR_TABLE_WIDTH_SGI = 0x80D9,
+ COLOR_TABLE_RED_SIZE = 0x80DA,
+ COLOR_TABLE_RED_SIZE_SGI = 0x80DA,
+ COLOR_TABLE_GREEN_SIZE = 0x80DB,
+ COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB,
+ COLOR_TABLE_BLUE_SIZE = 0x80DC,
+ COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC,
+ COLOR_TABLE_ALPHA_SIZE = 0x80DD,
+ COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD,
+ COLOR_TABLE_LUMINANCE_SIZE = 0x80DE,
+ COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE,
+ COLOR_TABLE_INTENSITY_SIZE = 0x80DF,
+ COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF,
+ }
+ #endregion
+ #region public enum EXT_bgra
+ public enum EXT_bgra
+ {
+ BGR = 0x80E0,
+ BGR_EXT = 0x80E0,
+ BGRA = 0x80E1,
+ BGRA_EXT = 0x80E1,
+ }
+ #endregion
+ #region public enum VERSION_1_2
+ public enum VERSION_1_2
+ {
+ MAX_ELEMENTS_VERTICES = 0x80E8,
+ MAX_ELEMENTS_INDICES = 0x80E9,
+ SMOOTH_POINT_SIZE_RANGE = 0x0B12,
+ SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13,
+ SMOOTH_LINE_WIDTH_RANGE = 0x0B22,
+ SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23,
+ ALIASED_POINT_SIZE_RANGE = 0x846D,
+ ALIASED_LINE_WIDTH_RANGE = 0x846E,
+ UNSIGNED_BYTE_3_3_2 = 0x8032,
+ UNSIGNED_SHORT_4_4_4_4 = 0x8033,
+ UNSIGNED_SHORT_5_5_5_1 = 0x8034,
+ UNSIGNED_INT_8_8_8_8 = 0x8035,
+ UNSIGNED_INT_10_10_10_2 = 0x8036,
+ RESCALE_NORMAL = 0x803A,
+ TEXTURE_BINDING_3D = 0x806A,
+ PACK_SKIP_IMAGES = 0x806B,
+ PACK_IMAGE_HEIGHT = 0x806C,
+ UNPACK_SKIP_IMAGES = 0x806D,
+ UNPACK_IMAGE_HEIGHT = 0x806E,
+ TEXTURE_3D = 0x806F,
+ PROXY_TEXTURE_3D = 0x8070,
+ TEXTURE_DEPTH = 0x8071,
+ TEXTURE_WRAP_R = 0x8072,
+ MAX_3D_TEXTURE_SIZE = 0x8073,
+ UNSIGNED_BYTE_2_3_3_REV = 0x8362,
+ UNSIGNED_SHORT_5_6_5 = 0x8363,
+ UNSIGNED_SHORT_5_6_5_REV = 0x8364,
+ UNSIGNED_SHORT_4_4_4_4_REV = 0x8365,
+ UNSIGNED_SHORT_1_5_5_5_REV = 0x8366,
+ UNSIGNED_INT_8_8_8_8_REV = 0x8367,
+ UNSIGNED_INT_2_10_10_10_REV = 0x8368,
+ BGR = 0x80E0,
+ BGRA = 0x80E1,
+ CLAMP_TO_EDGE = 0x812F,
+ TEXTURE_MIN_LOD = 0x813A,
+ TEXTURE_MAX_LOD = 0x813B,
+ TEXTURE_BASE_LEVEL = 0x813C,
+ TEXTURE_MAX_LEVEL = 0x813D,
+ LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
+ SINGLE_COLOR = 0x81F9,
+ SEPARATE_SPECULAR_COLOR = 0x81FA,
+ }
+ #endregion
+ #region public enum SGIS_texture_select
+ public enum SGIS_texture_select
+ {
+ DUAL_ALPHA4_SGIS = 0x8110,
+ DUAL_ALPHA8_SGIS = 0x8111,
+ DUAL_ALPHA12_SGIS = 0x8112,
+ DUAL_ALPHA16_SGIS = 0x8113,
+ DUAL_LUMINANCE4_SGIS = 0x8114,
+ DUAL_LUMINANCE8_SGIS = 0x8115,
+ DUAL_LUMINANCE12_SGIS = 0x8116,
+ DUAL_LUMINANCE16_SGIS = 0x8117,
+ DUAL_INTENSITY4_SGIS = 0x8118,
+ DUAL_INTENSITY8_SGIS = 0x8119,
+ DUAL_INTENSITY12_SGIS = 0x811A,
+ DUAL_INTENSITY16_SGIS = 0x811B,
+ DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C,
+ DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D,
+ QUAD_ALPHA4_SGIS = 0x811E,
+ QUAD_ALPHA8_SGIS = 0x811F,
+ QUAD_LUMINANCE4_SGIS = 0x8120,
+ QUAD_LUMINANCE8_SGIS = 0x8121,
+ QUAD_INTENSITY4_SGIS = 0x8122,
+ QUAD_INTENSITY8_SGIS = 0x8123,
+ DUAL_TEXTURE_SELECT_SGIS = 0x8124,
+ QUAD_TEXTURE_SELECT_SGIS = 0x8125,
+ }
+ #endregion
+ #region public enum SGIS_point_parameters
+ public enum SGIS_point_parameters
+ {
+ POINT_SIZE_MIN = 0x8126,
+ POINT_SIZE_MIN_ARB = 0x8126,
+ POINT_SIZE_MIN_EXT = 0x8126,
+ POINT_SIZE_MIN_SGIS = 0x8126,
+ POINT_SIZE_MAX = 0x8127,
+ POINT_SIZE_MAX_ARB = 0x8127,
+ POINT_SIZE_MAX_EXT = 0x8127,
+ POINT_SIZE_MAX_SGIS = 0x8127,
+ POINT_FADE_THRESHOLD_SIZE = 0x8128,
+ POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128,
+ POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128,
+ POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128,
+ POINT_DISTANCE_ATTENUATION = 0x8129,
+ POINT_DISTANCE_ATTENUATION_ARB = 0x8129,
+ DISTANCE_ATTENUATION_EXT = 0x8129,
+ DISTANCE_ATTENUATION_SGIS = 0x8129,
+ }
+ #endregion
+ #region public enum SGIS_fog_function
+ public enum SGIS_fog_function
+ {
+ FOG_FUNC_SGIS = 0x812A,
+ FOG_FUNC_POINTS_SGIS = 0x812B,
+ MAX_FOG_FUNC_POINTS_SGIS = 0x812C,
+ }
+ #endregion
+ #region public enum SGIS_texture_border_clamp
+ public enum SGIS_texture_border_clamp
+ {
+ CLAMP_TO_BORDER = 0x812D,
+ CLAMP_TO_BORDER_ARB = 0x812D,
+ CLAMP_TO_BORDER_SGIS = 0x812D,
+ }
+ #endregion
+ #region public enum SGIX_texture_multi_buffer
+ public enum SGIX_texture_multi_buffer
+ {
+ TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E,
+ }
+ #endregion
+ #region public enum SGIS_texture_edge_clamp
+ public enum SGIS_texture_edge_clamp
+ {
+ CLAMP_TO_EDGE = 0x812F,
+ CLAMP_TO_EDGE_SGIS = 0x812F,
+ }
+ #endregion
+ #region public enum SGIS_texture4D
+ public enum SGIS_texture4D
+ {
+ PACK_SKIP_VOLUMES_SGIS = 0x8130,
+ PACK_IMAGE_DEPTH_SGIS = 0x8131,
+ UNPACK_SKIP_VOLUMES_SGIS = 0x8132,
+ UNPACK_IMAGE_DEPTH_SGIS = 0x8133,
+ TEXTURE_4D_SGIS = 0x8134,
+ PROXY_TEXTURE_4D_SGIS = 0x8135,
+ TEXTURE_4DSIZE_SGIS = 0x8136,
+ TEXTURE_WRAP_Q_SGIS = 0x8137,
+ MAX_4D_TEXTURE_SIZE_SGIS = 0x8138,
+ TEXTURE_4D_BINDING_SGIS = 0x814F,
+ }
+ #endregion
+ #region public enum SGIX_pixel_texture
+ public enum SGIX_pixel_texture
+ {
+ PIXEL_TEX_GEN_SGIX = 0x8139,
+ PIXEL_TEX_GEN_MODE_SGIX = 0x832B,
+ }
+ #endregion
+ #region public enum SGIS_texture_lod
+ public enum SGIS_texture_lod
+ {
+ TEXTURE_MIN_LOD = 0x813A,
+ TEXTURE_MIN_LOD_SGIS = 0x813A,
+ TEXTURE_MAX_LOD = 0x813B,
+ TEXTURE_MAX_LOD_SGIS = 0x813B,
+ TEXTURE_BASE_LEVEL = 0x813C,
+ TEXTURE_BASE_LEVEL_SGIS = 0x813C,
+ TEXTURE_MAX_LEVEL = 0x813D,
+ TEXTURE_MAX_LEVEL_SGIS = 0x813D,
+ }
+ #endregion
+ #region public enum SGIX_pixel_tiles
+ public enum SGIX_pixel_tiles
+ {
+ PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E,
+ PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F,
+ PIXEL_TILE_WIDTH_SGIX = 0x8140,
+ PIXEL_TILE_HEIGHT_SGIX = 0x8141,
+ PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142,
+ PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143,
+ PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144,
+ PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145,
+ }
+ #endregion
+ #region public enum SGIS_texture_filter4
+ public enum SGIS_texture_filter4
+ {
+ FILTER4_SGIS = 0x8146,
+ TEXTURE_FILTER4_SIZE_SGIS = 0x8147,
+ }
+ #endregion
+ #region public enum SGIX_sprite
+ public enum SGIX_sprite
+ {
+ SPRITE_SGIX = 0x8148,
+ SPRITE_MODE_SGIX = 0x8149,
+ SPRITE_AXIS_SGIX = 0x814A,
+ SPRITE_TRANSLATION_SGIX = 0x814B,
+ SPRITE_AXIAL_SGIX = 0x814C,
+ SPRITE_OBJECT_ALIGNED_SGIX = 0x814D,
+ SPRITE_EYE_ALIGNED_SGIX = 0x814E,
+ }
+ #endregion
+ #region public enum HP_convolution_border_modes
+ public enum HP_convolution_border_modes
+ {
+ IGNORE_BORDER_HP = 0x8150,
+ CONSTANT_BORDER = 0x8151,
+ CONSTANT_BORDER_HP = 0x8151,
+ REPLICATE_BORDER = 0x8153,
+ REPLICATE_BORDER_HP = 0x8153,
+ CONVOLUTION_BORDER_COLOR = 0x8154,
+ CONVOLUTION_BORDER_COLOR_HP = 0x8154,
+ }
+ #endregion
+ #region public enum SGIX_clipmap
+ public enum SGIX_clipmap
+ {
+ LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170,
+ TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171,
+ TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172,
+ TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173,
+ TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174,
+ TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175,
+ TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176,
+ MAX_CLIPMAP_DEPTH_SGIX = 0x8177,
+ MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178,
+ NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D,
+ NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E,
+ LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F,
+ }
+ #endregion
+ #region public enum SGIX_texture_scale_bias
+ public enum SGIX_texture_scale_bias
+ {
+ POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179,
+ POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A,
+ POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B,
+ POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C,
+ }
+ #endregion
+ #region public enum SGIX_reference_plane
+ public enum SGIX_reference_plane
+ {
+ REFERENCE_PLANE_SGIX = 0x817D,
+ REFERENCE_PLANE_EQUATION_SGIX = 0x817E,
+ }
+ #endregion
+ #region public enum SGIX_ir_instrument1
+ public enum SGIX_ir_instrument1
+ {
+ IR_INSTRUMENT1_SGIX = 0x817F,
+ }
+ #endregion
+ #region public enum SGIX_instruments
+ public enum SGIX_instruments
+ {
+ INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180,
+ INSTRUMENT_MEASUREMENTS_SGIX = 0x8181,
+ }
+ #endregion
+ #region public enum SGIX_list_priority
+ public enum SGIX_list_priority
+ {
+ LIST_PRIORITY_SGIX = 0x8182,
+ }
+ #endregion
+ #region public enum SGIX_calligraphic_fragment
+ public enum SGIX_calligraphic_fragment
+ {
+ CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183,
+ }
+ #endregion
+ #region public enum SGIX_impact_pixel_texture
+ public enum SGIX_impact_pixel_texture
+ {
+ PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184,
+ PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185,
+ PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186,
+ PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187,
+ PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188,
+ PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189,
+ PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A,
+ }
+ #endregion
+ #region public enum SGIX_framezoom
+ public enum SGIX_framezoom
+ {
+ FRAMEZOOM_SGIX = 0x818B,
+ FRAMEZOOM_FACTOR_SGIX = 0x818C,
+ MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D,
+ }
+ #endregion
+ #region public enum SGIX_texture_lod_bias
+ public enum SGIX_texture_lod_bias
+ {
+ TEXTURE_LOD_BIAS_S_SGIX = 0x818E,
+ TEXTURE_LOD_BIAS_T_SGIX = 0x818F,
+ TEXTURE_LOD_BIAS_R_SGIX = 0x8190,
+ }
+ #endregion
+ #region public enum SGIS_generate_mipmap
+ public enum SGIS_generate_mipmap
+ {
+ GENERATE_MIPMAP = 0x8191,
+ GENERATE_MIPMAP_SGIS = 0x8191,
+ GENERATE_MIPMAP_HINT = 0x8192,
+ GENERATE_MIPMAP_HINT_SGIS = 0x8192,
+ GEOMETRY_DEFORMATION_SGIX = 0x8194,
+ TEXTURE_DEFORMATION_SGIX = 0x8195,
+ DEFORMATIONS_MASK_SGIX = 0x8196,
+ MAX_DEFORMATION_ORDER_SGIX = 0x8197,
+ }
+ #endregion
+ #region public enum SGIX_fog_offset
+ public enum SGIX_fog_offset
+ {
+ FOG_OFFSET_SGIX = 0x8198,
+ FOG_OFFSET_VALUE_SGIX = 0x8199,
+ }
+ #endregion
+ #region public enum SGIX_shadow
+ public enum SGIX_shadow
+ {
+ TEXTURE_COMPARE_SGIX = 0x819A,
+ TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B,
+ TEXTURE_LEQUAL_R_SGIX = 0x819C,
+ TEXTURE_GEQUAL_R_SGIX = 0x819D,
+ }
+ #endregion
+ #region public enum SGIX_depth_texture
+ public enum SGIX_depth_texture
+ {
+ DEPTH_COMPONENT16 = 0x81A5,
+ DEPTH_COMPONENT16_SGIX = 0x81A5,
+ DEPTH_COMPONENT24 = 0x81A6,
+ DEPTH_COMPONENT24_SGIX = 0x81A6,
+ DEPTH_COMPONENT32 = 0x81A7,
+ DEPTH_COMPONENT32_SGIX = 0x81A7,
+ }
+ #endregion
+ #region public enum SGIX_ycrcb
+ public enum SGIX_ycrcb
+ {
+ YCRCB_422_SGIX = 0x81BB,
+ YCRCB_444_SGIX = 0x81BC,
+ }
+ #endregion
+ #region public enum SGIS_texture_color_mask
+ public enum SGIS_texture_color_mask
+ {
+ TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF,
+ }
+ #endregion
+ #region public enum SGIS_point_line_texgen
+ public enum SGIS_point_line_texgen
+ {
+ EYE_DISTANCE_TO_POINT_SGIS = 0x81F0,
+ OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1,
+ EYE_DISTANCE_TO_LINE_SGIS = 0x81F2,
+ OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3,
+ EYE_POINT_SGIS = 0x81F4,
+ OBJECT_POINT_SGIS = 0x81F5,
+ EYE_LINE_SGIS = 0x81F6,
+ OBJECT_LINE_SGIS = 0x81F7,
+ }
+ #endregion
+ #region public enum EXT_separate_specular_color
+ public enum EXT_separate_specular_color
+ {
+ LIGHT_MODEL_COLOR_CONTROL = 0x81F8,
+ LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8,
+ SINGLE_COLOR = 0x81F9,
+ SINGLE_COLOR_EXT = 0x81F9,
+ SEPARATE_SPECULAR_COLOR = 0x81FA,
+ SEPARATE_SPECULAR_COLOR_EXT = 0x81FA,
+ }
+ #endregion
+ #region public enum EXT_shared_texture_palette
+ public enum EXT_shared_texture_palette
+ {
+ SHARED_TEXTURE_PALETTE_EXT = 0x81FB,
+ }
+ #endregion
+ #region public enum SGIX_convolution_accuracy
+ public enum SGIX_convolution_accuracy
+ {
+ CONVOLUTION_HINT_SGIX = 0x8316,
+ }
+ #endregion
+ #region public enum SGIX_blend_alpha_minmax
+ public enum SGIX_blend_alpha_minmax
+ {
+ ALPHA_MIN_SGIX = 0x8320,
+ ALPHA_MAX_SGIX = 0x8321,
+ ASYNC_MARKER_SGIX = 0x8329,
+ }
+ #endregion
+ #region public enum SGIX_async_histogram
+ public enum SGIX_async_histogram
+ {
+ ASYNC_HISTOGRAM_SGIX = 0x832C,
+ MAX_ASYNC_HISTOGRAM_SGIX = 0x832D,
+ }
+ #endregion
+ #region public enum EXT_pixel_transform
+ public enum EXT_pixel_transform
+ {
+ PIXEL_TRANSFORM_2D_EXT = 0x8330,
+ PIXEL_MAG_FILTER_EXT = 0x8331,
+ PIXEL_MIN_FILTER_EXT = 0x8332,
+ PIXEL_CUBIC_WEIGHT_EXT = 0x8333,
+ CUBIC_EXT = 0x8334,
+ AVERAGE_EXT = 0x8335,
+ PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336,
+ MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337,
+ PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338,
+ }
+ #endregion
+ #region public enum SGIS_pixel_texture
+ public enum SGIS_pixel_texture
+ {
+ PIXEL_TEXTURE_SGIS = 0x8353,
+ PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354,
+ PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355,
+ PIXEL_GROUP_COLOR_SGIS = 0x8356,
+ }
+ #endregion
+ #region public enum SGIX_async_pixel
+ public enum SGIX_async_pixel
+ {
+ ASYNC_TEX_IMAGE_SGIX = 0x835C,
+ ASYNC_DRAW_PIXELS_SGIX = 0x835D,
+ ASYNC_READ_PIXELS_SGIX = 0x835E,
+ MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F,
+ MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360,
+ MAX_ASYNC_READ_PIXELS_SGIX = 0x8361,
+ }
+ #endregion
+ #region public enum SGIX_texture_coordinate_clamp
+ public enum SGIX_texture_coordinate_clamp
+ {
+ TEXTURE_MAX_CLAMP_S_SGIX = 0x8369,
+ TEXTURE_MAX_CLAMP_T_SGIX = 0x836A,
+ TEXTURE_MAX_CLAMP_R_SGIX = 0x836B,
+ FOG_FACTOR_TO_ALPHA_SGIX = 0x836F,
+ }
+ #endregion
+ #region public enum SGIX_vertex_preclip
+ public enum SGIX_vertex_preclip
+ {
+ VERTEX_PRECLIP_SGIX = 0x83EE,
+ VERTEX_PRECLIP_HINT_SGIX = 0x83EF,
+ }
+ #endregion
+ #region public enum EXT_texture_compression_s3tc
+ public enum EXT_texture_compression_s3tc
+ {
+ COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0,
+ COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1,
+ COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2,
+ COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3,
+ }
+ #endregion
+ #region public enum INTEL_parallel_arrays
+ public enum INTEL_parallel_arrays
+ {
+ PARALLEL_ARRAYS_INTEL = 0x83F4,
+ VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5,
+ NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6,
+ COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7,
+ TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8,
+ }
+ #endregion
+ #region public enum SGIX_fragment_lighting
+ public enum SGIX_fragment_lighting
+ {
+ FRAGMENT_LIGHTING_SGIX = 0x8400,
+ FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401,
+ FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402,
+ FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403,
+ MAX_FRAGMENT_LIGHTS_SGIX = 0x8404,
+ MAX_ACTIVE_LIGHTS_SGIX = 0x8405,
+ CURRENT_RASTER_NORMAL_SGIX = 0x8406,
+ LIGHT_ENV_MODE_SGIX = 0x8407,
+ FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408,
+ FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409,
+ FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A,
+ FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B,
+ FRAGMENT_LIGHT0_SGIX = 0x840C,
+ FRAGMENT_LIGHT1_SGIX = 0x840D,
+ FRAGMENT_LIGHT2_SGIX = 0x840E,
+ FRAGMENT_LIGHT3_SGIX = 0x840F,
+ FRAGMENT_LIGHT4_SGIX = 0x8410,
+ FRAGMENT_LIGHT5_SGIX = 0x8411,
+ FRAGMENT_LIGHT6_SGIX = 0x8412,
+ FRAGMENT_LIGHT7_SGIX = 0x8413,
+ }
+ #endregion
+ #region public enum SGIX_resample
+ public enum SGIX_resample
+ {
+ PACK_RESAMPLE_SGIX = 0x842C,
+ UNPACK_RESAMPLE_SGIX = 0x842D,
+ RESAMPLE_REPLICATE_SGIX = 0x842E,
+ RESAMPLE_ZERO_FILL_SGIX = 0x842F,
+ RESAMPLE_DECIMATE_SGIX = 0x8430,
+ }
+ #endregion
+ #region public enum SGIX_subsample
+ public enum SGIX_subsample
+ {
+ PACK_SUBSAMPLE_RATE_SGIX = 0x85A0,
+ UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1,
+ PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2,
+ PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3,
+ PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4,
+ }
+ #endregion
+ #region public enum ARB_imaging
+ public enum ARB_imaging
+ {
+ CONSTANT_COLOR = 0x8001,
+ ONE_MINUS_CONSTANT_COLOR = 0x8002,
+ CONSTANT_ALPHA = 0x8003,
+ ONE_MINUS_CONSTANT_ALPHA = 0x8004,
+ BLEND_COLOR = 0x8005,
+ FUNC_ADD = 0x8006,
+ MIN = 0x8007,
+ MAX = 0x8008,
+ BLEND_EQUATION = 0x8009,
+ FUNC_SUBTRACT = 0x800A,
+ FUNC_REVERSE_SUBTRACT = 0x800B,
+ CONVOLUTION_1D = 0x8010,
+ CONVOLUTION_2D = 0x8011,
+ SEPARABLE_2D = 0x8012,
+ CONVOLUTION_BORDER_MODE = 0x8013,
+ CONVOLUTION_FILTER_SCALE = 0x8014,
+ CONVOLUTION_FILTER_BIAS = 0x8015,
+ REDUCE = 0x8016,
+ CONVOLUTION_FORMAT = 0x8017,
+ CONVOLUTION_WIDTH = 0x8018,
+ CONVOLUTION_HEIGHT = 0x8019,
+ MAX_CONVOLUTION_WIDTH = 0x801A,
+ MAX_CONVOLUTION_HEIGHT = 0x801B,
+ POST_CONVOLUTION_RED_SCALE = 0x801C,
+ POST_CONVOLUTION_GREEN_SCALE = 0x801D,
+ POST_CONVOLUTION_BLUE_SCALE = 0x801E,
+ POST_CONVOLUTION_ALPHA_SCALE = 0x801F,
+ POST_CONVOLUTION_RED_BIAS = 0x8020,
+ POST_CONVOLUTION_GREEN_BIAS = 0x8021,
+ POST_CONVOLUTION_BLUE_BIAS = 0x8022,
+ POST_CONVOLUTION_ALPHA_BIAS = 0x8023,
+ HISTOGRAM = 0x8024,
+ PROXY_HISTOGRAM = 0x8025,
+ HISTOGRAM_WIDTH = 0x8026,
+ HISTOGRAM_FORMAT = 0x8027,
+ HISTOGRAM_RED_SIZE = 0x8028,
+ HISTOGRAM_GREEN_SIZE = 0x8029,
+ HISTOGRAM_BLUE_SIZE = 0x802A,
+ HISTOGRAM_ALPHA_SIZE = 0x802B,
+ HISTOGRAM_LUMINANCE_SIZE = 0x802C,
+ HISTOGRAM_SINK = 0x802D,
+ MINMAX = 0x802E,
+ MINMAX_FORMAT = 0x802F,
+ MINMAX_SINK = 0x8030,
+ TABLE_TOO_LARGE = 0x8031,
+ COLOR_MATRIX = 0x80B1,
+ COLOR_MATRIX_STACK_DEPTH = 0x80B2,
+ MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3,
+ POST_COLOR_MATRIX_RED_SCALE = 0x80B4,
+ POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5,
+ POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6,
+ POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7,
+ POST_COLOR_MATRIX_RED_BIAS = 0x80B8,
+ POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9,
+ POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA,
+ POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB,
+ COLOR_TABLE = 0x80D0,
+ POST_CONVOLUTION_COLOR_TABLE = 0x80D1,
+ POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2,
+ PROXY_COLOR_TABLE = 0x80D3,
+ PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4,
+ PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5,
+ COLOR_TABLE_SCALE = 0x80D6,
+ COLOR_TABLE_BIAS = 0x80D7,
+ COLOR_TABLE_FORMAT = 0x80D8,
+ COLOR_TABLE_WIDTH = 0x80D9,
+ COLOR_TABLE_RED_SIZE = 0x80DA,
+ COLOR_TABLE_GREEN_SIZE = 0x80DB,
+ COLOR_TABLE_BLUE_SIZE = 0x80DC,
+ COLOR_TABLE_ALPHA_SIZE = 0x80DD,
+ COLOR_TABLE_LUMINANCE_SIZE = 0x80DE,
+ COLOR_TABLE_INTENSITY_SIZE = 0x80DF,
+ CONSTANT_BORDER = 0x8151,
+ REPLICATE_BORDER = 0x8153,
+ CONVOLUTION_BORDER_COLOR = 0x8154,
+ }
+ #endregion
+ #region public enum VERSION_1_3
+ public enum VERSION_1_3
+ {
+ TEXTURE0 = 0x84C0,
+ TEXTURE1 = 0x84C1,
+ TEXTURE2 = 0x84C2,
+ TEXTURE3 = 0x84C3,
+ TEXTURE4 = 0x84C4,
+ TEXTURE5 = 0x84C5,
+ TEXTURE6 = 0x84C6,
+ TEXTURE7 = 0x84C7,
+ TEXTURE8 = 0x84C8,
+ TEXTURE9 = 0x84C9,
+ TEXTURE10 = 0x84CA,
+ TEXTURE11 = 0x84CB,
+ TEXTURE12 = 0x84CC,
+ TEXTURE13 = 0x84CD,
+ TEXTURE14 = 0x84CE,
+ TEXTURE15 = 0x84CF,
+ TEXTURE16 = 0x84D0,
+ TEXTURE17 = 0x84D1,
+ TEXTURE18 = 0x84D2,
+ TEXTURE19 = 0x84D3,
+ TEXTURE20 = 0x84D4,
+ TEXTURE21 = 0x84D5,
+ TEXTURE22 = 0x84D6,
+ TEXTURE23 = 0x84D7,
+ TEXTURE24 = 0x84D8,
+ TEXTURE25 = 0x84D9,
+ TEXTURE26 = 0x84DA,
+ TEXTURE27 = 0x84DB,
+ TEXTURE28 = 0x84DC,
+ TEXTURE29 = 0x84DD,
+ TEXTURE30 = 0x84DE,
+ TEXTURE31 = 0x84DF,
+ ACTIVE_TEXTURE = 0x84E0,
+ CLIENT_ACTIVE_TEXTURE = 0x84E1,
+ MAX_TEXTURE_UNITS = 0x84E2,
+ TRANSPOSE_MODELVIEW_MATRIX = 0x84E3,
+ TRANSPOSE_PROJECTION_MATRIX = 0x84E4,
+ TRANSPOSE_TEXTURE_MATRIX = 0x84E5,
+ TRANSPOSE_COLOR_MATRIX = 0x84E6,
+ MULTISAMPLE = 0x809D,
+ SAMPLE_ALPHA_TO_COVERAGE = 0x809E,
+ SAMPLE_ALPHA_TO_ONE = 0x809F,
+ SAMPLE_COVERAGE = 0x80A0,
+ SAMPLE_BUFFERS = 0x80A8,
+ SAMPLES = 0x80A9,
+ SAMPLE_COVERAGE_VALUE = 0x80AA,
+ SAMPLE_COVERAGE_INVERT = 0x80AB,
+ MULTISAMPLE_BIT = 0x20000000,
+ NORMAL_MAP = 0x8511,
+ REFLECTION_MAP = 0x8512,
+ TEXTURE_CUBE_MAP = 0x8513,
+ TEXTURE_BINDING_CUBE_MAP = 0x8514,
+ TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515,
+ TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516,
+ TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517,
+ TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518,
+ TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519,
+ TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A,
+ PROXY_TEXTURE_CUBE_MAP = 0x851B,
+ MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C,
+ COMPRESSED_ALPHA = 0x84E9,
+ COMPRESSED_LUMINANCE = 0x84EA,
+ COMPRESSED_LUMINANCE_ALPHA = 0x84EB,
+ COMPRESSED_INTENSITY = 0x84EC,
+ COMPRESSED_RGB = 0x84ED,
+ COMPRESSED_RGBA = 0x84EE,
+ TEXTURE_COMPRESSION_HINT = 0x84EF,
+ TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0,
+ TEXTURE_COMPRESSED = 0x86A1,
+ NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2,
+ COMPRESSED_TEXTURE_FORMATS = 0x86A3,
+ CLAMP_TO_BORDER = 0x812D,
+ COMBINE = 0x8570,
+ COMBINE_RGB = 0x8571,
+ COMBINE_ALPHA = 0x8572,
+ SOURCE0_RGB = 0x8580,
+ SOURCE1_RGB = 0x8581,
+ SOURCE2_RGB = 0x8582,
+ SOURCE0_ALPHA = 0x8588,
+ SOURCE1_ALPHA = 0x8589,
+ SOURCE2_ALPHA = 0x858A,
+ OPERAND0_RGB = 0x8590,
+ OPERAND1_RGB = 0x8591,
+ OPERAND2_RGB = 0x8592,
+ OPERAND0_ALPHA = 0x8598,
+ OPERAND1_ALPHA = 0x8599,
+ OPERAND2_ALPHA = 0x859A,
+ RGB_SCALE = 0x8573,
+ ADD_SIGNED = 0x8574,
+ INTERPOLATE = 0x8575,
+ SUBTRACT = 0x84E7,
+ CONSTANT = 0x8576,
+ PRIMARY_COLOR = 0x8577,
+ PREVIOUS = 0x8578,
+ DOT3_RGB = 0x86AE,
+ DOT3_RGBA = 0x86AF,
+ }
+ #endregion
+ #region public enum VERSION_1_4
+ public enum VERSION_1_4
+ {
+ BLEND_DST_RGB = 0x80C8,
+ BLEND_SRC_RGB = 0x80C9,
+ BLEND_DST_ALPHA = 0x80CA,
+ BLEND_SRC_ALPHA = 0x80CB,
+ POINT_SIZE_MIN = 0x8126,
+ POINT_SIZE_MAX = 0x8127,
+ POINT_FADE_THRESHOLD_SIZE = 0x8128,
+ POINT_DISTANCE_ATTENUATION = 0x8129,
+ GENERATE_MIPMAP = 0x8191,
+ GENERATE_MIPMAP_HINT = 0x8192,
+ DEPTH_COMPONENT16 = 0x81A5,
+ DEPTH_COMPONENT24 = 0x81A6,
+ DEPTH_COMPONENT32 = 0x81A7,
+ MIRRORED_REPEAT = 0x8370,
+ FOG_COORDINATE_SOURCE = 0x8450,
+ FOG_COORDINATE = 0x8451,
+ FRAGMENT_DEPTH = 0x8452,
+ CURRENT_FOG_COORDINATE = 0x8453,
+ FOG_COORDINATE_ARRAY_TYPE = 0x8454,
+ FOG_COORDINATE_ARRAY_STRIDE = 0x8455,
+ FOG_COORDINATE_ARRAY_POINTER = 0x8456,
+ FOG_COORDINATE_ARRAY = 0x8457,
+ COLOR_SUM = 0x8458,
+ CURRENT_SECONDARY_COLOR = 0x8459,
+ SECONDARY_COLOR_ARRAY_SIZE = 0x845A,
+ SECONDARY_COLOR_ARRAY_TYPE = 0x845B,
+ SECONDARY_COLOR_ARRAY_STRIDE = 0x845C,
+ SECONDARY_COLOR_ARRAY_POINTER = 0x845D,
+ SECONDARY_COLOR_ARRAY = 0x845E,
+ MAX_TEXTURE_LOD_BIAS = 0x84FD,
+ TEXTURE_FILTER_CONTROL = 0x8500,
+ TEXTURE_LOD_BIAS = 0x8501,
+ INCR_WRAP = 0x8507,
+ DECR_WRAP = 0x8508,
+ TEXTURE_DEPTH_SIZE = 0x884A,
+ DEPTH_TEXTURE_MODE = 0x884B,
+ TEXTURE_COMPARE_MODE = 0x884C,
+ TEXTURE_COMPARE_FUNC = 0x884D,
+ COMPARE_R_TO_TEXTURE = 0x884E,
+ }
+ #endregion
+ #region public enum VERSION_1_5
+ public enum VERSION_1_5
+ {
+ BUFFER_SIZE = 0x8764,
+ BUFFER_USAGE = 0x8765,
+ QUERY_COUNTER_BITS = 0x8864,
+ CURRENT_QUERY = 0x8865,
+ QUERY_RESULT = 0x8866,
+ QUERY_RESULT_AVAILABLE = 0x8867,
+ ARRAY_BUFFER = 0x8892,
+ ELEMENT_ARRAY_BUFFER = 0x8893,
+ ARRAY_BUFFER_BINDING = 0x8894,
+ ELEMENT_ARRAY_BUFFER_BINDING = 0x8895,
+ VERTEX_ARRAY_BUFFER_BINDING = 0x8896,
+ NORMAL_ARRAY_BUFFER_BINDING = 0x8897,
+ COLOR_ARRAY_BUFFER_BINDING = 0x8898,
+ INDEX_ARRAY_BUFFER_BINDING = 0x8899,
+ TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A,
+ EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B,
+ SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C,
+ FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D,
+ WEIGHT_ARRAY_BUFFER_BINDING = 0x889E,
+ VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F,
+ READ_ONLY = 0x88B8,
+ WRITE_ONLY = 0x88B9,
+ READ_WRITE = 0x88BA,
+ BUFFER_ACCESS = 0x88BB,
+ BUFFER_MAPPED = 0x88BC,
+ BUFFER_MAP_POINTER = 0x88BD,
+ STREAM_DRAW = 0x88E0,
+ STREAM_READ = 0x88E1,
+ STREAM_COPY = 0x88E2,
+ STATIC_DRAW = 0x88E4,
+ STATIC_READ = 0x88E5,
+ STATIC_COPY = 0x88E6,
+ DYNAMIC_DRAW = 0x88E8,
+ DYNAMIC_READ = 0x88E9,
+ DYNAMIC_COPY = 0x88EA,
+ SAMPLES_PASSED = 0x8914,
+ FOG_COORD_SRC = VERSION_1_4.FOG_COORDINATE_SOURCE,
+ FOG_COORD = VERSION_1_4.FOG_COORDINATE,
+ CURRENT_FOG_COORD = VERSION_1_4.CURRENT_FOG_COORDINATE,
+ FOG_COORD_ARRAY_TYPE = VERSION_1_4.FOG_COORDINATE_ARRAY_TYPE,
+ FOG_COORD_ARRAY_STRIDE = VERSION_1_4.FOG_COORDINATE_ARRAY_STRIDE,
+ FOG_COORD_ARRAY_POINTER = VERSION_1_4.FOG_COORDINATE_ARRAY_POINTER,
+ FOG_COORD_ARRAY = VERSION_1_4.FOG_COORDINATE_ARRAY,
+ FOG_COORD_ARRAY_BUFFER_BINDING = VERSION_1_5.FOG_COORDINATE_ARRAY_BUFFER_BINDING,
+ SRC0_RGB = VERSION_1_3.SOURCE0_RGB,
+ SRC1_RGB = VERSION_1_3.SOURCE1_RGB,
+ SRC2_RGB = VERSION_1_3.SOURCE2_RGB,
+ SRC0_ALPHA = VERSION_1_3.SOURCE0_ALPHA,
+ SRC1_ALPHA = VERSION_1_3.SOURCE1_ALPHA,
+ SRC2_ALPHA = VERSION_1_3.SOURCE2_ALPHA,
+ }
+ #endregion
+ #region public enum VERSION_2_0
+ public enum VERSION_2_0
+ {
+ BLEND_EQUATION_RGB = ARB_imaging.BLEND_EQUATION,
+ VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622,
+ VERTEX_ATTRIB_ARRAY_SIZE = 0x8623,
+ VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624,
+ VERTEX_ATTRIB_ARRAY_TYPE = 0x8625,
+ CURRENT_VERTEX_ATTRIB = 0x8626,
+ VERTEX_PROGRAM_POINT_SIZE = 0x8642,
+ VERTEX_PROGRAM_TWO_SIDE = 0x8643,
+ VERTEX_ATTRIB_ARRAY_POINTER = 0x8645,
+ STENCIL_BACK_FUNC = 0x8800,
+ STENCIL_BACK_FAIL = 0x8801,
+ STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802,
+ STENCIL_BACK_PASS_DEPTH_PASS = 0x8803,
+ MAX_DRAW_BUFFERS = 0x8824,
+ DRAW_BUFFER0 = 0x8825,
+ DRAW_BUFFER1 = 0x8826,
+ DRAW_BUFFER2 = 0x8827,
+ DRAW_BUFFER3 = 0x8828,
+ DRAW_BUFFER4 = 0x8829,
+ DRAW_BUFFER5 = 0x882A,
+ DRAW_BUFFER6 = 0x882B,
+ DRAW_BUFFER7 = 0x882C,
+ DRAW_BUFFER8 = 0x882D,
+ DRAW_BUFFER9 = 0x882E,
+ DRAW_BUFFER10 = 0x882F,
+ DRAW_BUFFER11 = 0x8830,
+ DRAW_BUFFER12 = 0x8831,
+ DRAW_BUFFER13 = 0x8832,
+ DRAW_BUFFER14 = 0x8833,
+ DRAW_BUFFER15 = 0x8834,
+ BLEND_EQUATION_ALPHA = 0x883D,
+ POINT_SPRITE = 0x8861,
+ COORD_REPLACE = 0x8862,
+ MAX_VERTEX_ATTRIBS = 0x8869,
+ VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A,
+ MAX_TEXTURE_COORDS = 0x8871,
+ MAX_TEXTURE_IMAGE_UNITS = 0x8872,
+ FRAGMENT_SHADER = 0x8B30,
+ VERTEX_SHADER = 0x8B31,
+ MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49,
+ MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A,
+ MAX_VARYING_FLOATS = 0x8B4B,
+ MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C,
+ MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D,
+ SHADER_TYPE = 0x8B4F,
+ FLOAT_VEC2 = 0x8B50,
+ FLOAT_VEC3 = 0x8B51,
+ FLOAT_VEC4 = 0x8B52,
+ INT_VEC2 = 0x8B53,
+ INT_VEC3 = 0x8B54,
+ INT_VEC4 = 0x8B55,
+ BOOL = 0x8B56,
+ BOOL_VEC2 = 0x8B57,
+ BOOL_VEC3 = 0x8B58,
+ BOOL_VEC4 = 0x8B59,
+ FLOAT_MAT2 = 0x8B5A,
+ FLOAT_MAT3 = 0x8B5B,
+ FLOAT_MAT4 = 0x8B5C,
+ SAMPLER_1D = 0x8B5D,
+ SAMPLER_2D = 0x8B5E,
+ SAMPLER_3D = 0x8B5F,
+ SAMPLER_CUBE = 0x8B60,
+ SAMPLER_1D_SHADOW = 0x8B61,
+ SAMPLER_2D_SHADOW = 0x8B62,
+ DELETE_STATUS = 0x8B80,
+ COMPILE_STATUS = 0x8B81,
+ LINK_STATUS = 0x8B82,
+ VALIDATE_STATUS = 0x8B83,
+ INFO_LOG_LENGTH = 0x8B84,
+ ATTACHED_SHADERS = 0x8B85,
+ ACTIVE_UNIFORMS = 0x8B86,
+ ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87,
+ SHADER_SOURCE_LENGTH = 0x8B88,
+ ACTIVE_ATTRIBUTES = 0x8B89,
+ ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A,
+ FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B,
+ SHADING_LANGUAGE_VERSION = 0x8B8C,
+ CURRENT_PROGRAM = 0x8B8D,
+ POINT_SPRITE_COORD_ORIGIN = 0x8CA0,
+ LOWER_LEFT = 0x8CA1,
+ UPPER_LEFT = 0x8CA2,
+ STENCIL_BACK_REF = 0x8CA3,
+ STENCIL_BACK_VALUE_MASK = 0x8CA4,
+ STENCIL_BACK_WRITEMASK = 0x8CA5,
+ }
+ #endregion
+ #region public enum VERSION_2_1
+ public enum VERSION_2_1
+ {
+ CURRENT_RASTER_SECONDARY_COLOR = 0x845F,
+ PIXEL_PACK_BUFFER = 0x88EB,
+ PIXEL_UNPACK_BUFFER = 0x88EC,
+ PIXEL_PACK_BUFFER_BINDING = 0x88ED,
+ PIXEL_UNPACK_BUFFER_BINDING = 0x88EF,
+ FLOAT_MAT2x3 = 0x8B65,
+ FLOAT_MAT2x4 = 0x8B66,
+ FLOAT_MAT3x2 = 0x8B67,
+ FLOAT_MAT3x4 = 0x8B68,
+ FLOAT_MAT4x2 = 0x8B69,
+ FLOAT_MAT4x3 = 0x8B6A,
+ SRGB = 0x8C40,
+ SRGB8 = 0x8C41,
+ SRGB_ALPHA = 0x8C42,
+ SRGB8_ALPHA8 = 0x8C43,
+ SLUMINANCE_ALPHA = 0x8C44,
+ SLUMINANCE8_ALPHA8 = 0x8C45,
+ SLUMINANCE = 0x8C46,
+ SLUMINANCE8 = 0x8C47,
+ COMPRESSED_SRGB = 0x8C48,
+ COMPRESSED_SRGB_ALPHA = 0x8C49,
+ COMPRESSED_SLUMINANCE = 0x8C4A,
+ COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B,
+ }
+ #endregion
+ #region public enum ARB_multitexture
+ public enum ARB_multitexture
+ {
+ TEXTURE0_ARB = 0x84C0,
+ TEXTURE1_ARB = 0x84C1,
+ TEXTURE2_ARB = 0x84C2,
+ TEXTURE3_ARB = 0x84C3,
+ TEXTURE4_ARB = 0x84C4,
+ TEXTURE5_ARB = 0x84C5,
+ TEXTURE6_ARB = 0x84C6,
+ TEXTURE7_ARB = 0x84C7,
+ TEXTURE8_ARB = 0x84C8,
+ TEXTURE9_ARB = 0x84C9,
+ TEXTURE10_ARB = 0x84CA,
+ TEXTURE11_ARB = 0x84CB,
+ TEXTURE12_ARB = 0x84CC,
+ TEXTURE13_ARB = 0x84CD,
+ TEXTURE14_ARB = 0x84CE,
+ TEXTURE15_ARB = 0x84CF,
+ TEXTURE16_ARB = 0x84D0,
+ TEXTURE17_ARB = 0x84D1,
+ TEXTURE18_ARB = 0x84D2,
+ TEXTURE19_ARB = 0x84D3,
+ TEXTURE20_ARB = 0x84D4,
+ TEXTURE21_ARB = 0x84D5,
+ TEXTURE22_ARB = 0x84D6,
+ TEXTURE23_ARB = 0x84D7,
+ TEXTURE24_ARB = 0x84D8,
+ TEXTURE25_ARB = 0x84D9,
+ TEXTURE26_ARB = 0x84DA,
+ TEXTURE27_ARB = 0x84DB,
+ TEXTURE28_ARB = 0x84DC,
+ TEXTURE29_ARB = 0x84DD,
+ TEXTURE30_ARB = 0x84DE,
+ TEXTURE31_ARB = 0x84DF,
+ ACTIVE_TEXTURE_ARB = 0x84E0,
+ CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1,
+ MAX_TEXTURE_UNITS_ARB = 0x84E2,
+ }
+ #endregion
+ #region public enum ARB_transpose_matrix
+ public enum ARB_transpose_matrix
+ {
+ TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3,
+ TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4,
+ TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5,
+ TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6,
+ }
+ #endregion
+ #region public enum ARB_texture_env_add
+ public enum ARB_texture_env_add
+ {
+ }
+ #endregion
+ #region public enum ARB_texture_cube_map
+ public enum ARB_texture_cube_map
+ {
+ NORMAL_MAP_ARB = 0x8511,
+ REFLECTION_MAP_ARB = 0x8512,
+ TEXTURE_CUBE_MAP_ARB = 0x8513,
+ TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514,
+ TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515,
+ TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516,
+ TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517,
+ TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518,
+ TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519,
+ TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A,
+ PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B,
+ MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C,
+ }
+ #endregion
+ #region public enum ARB_texture_compression
+ public enum ARB_texture_compression
+ {
+ COMPRESSED_ALPHA_ARB = 0x84E9,
+ COMPRESSED_LUMINANCE_ARB = 0x84EA,
+ COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB,
+ COMPRESSED_INTENSITY_ARB = 0x84EC,
+ COMPRESSED_RGB_ARB = 0x84ED,
+ COMPRESSED_RGBA_ARB = 0x84EE,
+ TEXTURE_COMPRESSION_HINT_ARB = 0x84EF,
+ TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0,
+ TEXTURE_COMPRESSED_ARB = 0x86A1,
+ NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2,
+ COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3,
+ }
+ #endregion
+ #region public enum ARB_texture_border_clamp
+ public enum ARB_texture_border_clamp
+ {
+ CLAMP_TO_BORDER_ARB = 0x812D,
+ }
+ #endregion
+ #region public enum ARB_point_parameters
+ public enum ARB_point_parameters
+ {
+ POINT_SIZE_MIN_ARB = 0x8126,
+ POINT_SIZE_MAX_ARB = 0x8127,
+ POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128,
+ POINT_DISTANCE_ATTENUATION_ARB = 0x8129,
+ }
+ #endregion
+ #region public enum ARB_vertex_blend
+ public enum ARB_vertex_blend
+ {
+ MAX_VERTEX_UNITS_ARB = 0x86A4,
+ ACTIVE_VERTEX_UNITS_ARB = 0x86A5,
+ WEIGHT_SUM_UNITY_ARB = 0x86A6,
+ VERTEX_BLEND_ARB = 0x86A7,
+ CURRENT_WEIGHT_ARB = 0x86A8,
+ WEIGHT_ARRAY_TYPE_ARB = 0x86A9,
+ WEIGHT_ARRAY_STRIDE_ARB = 0x86AA,
+ WEIGHT_ARRAY_SIZE_ARB = 0x86AB,
+ WEIGHT_ARRAY_POINTER_ARB = 0x86AC,
+ WEIGHT_ARRAY_ARB = 0x86AD,
+ MODELVIEW0_ARB = 0x1700,
+ MODELVIEW1_ARB = 0x850A,
+ MODELVIEW2_ARB = 0x8722,
+ MODELVIEW3_ARB = 0x8723,
+ MODELVIEW4_ARB = 0x8724,
+ MODELVIEW5_ARB = 0x8725,
+ MODELVIEW6_ARB = 0x8726,
+ MODELVIEW7_ARB = 0x8727,
+ MODELVIEW8_ARB = 0x8728,
+ MODELVIEW9_ARB = 0x8729,
+ MODELVIEW10_ARB = 0x872A,
+ MODELVIEW11_ARB = 0x872B,
+ MODELVIEW12_ARB = 0x872C,
+ MODELVIEW13_ARB = 0x872D,
+ MODELVIEW14_ARB = 0x872E,
+ MODELVIEW15_ARB = 0x872F,
+ MODELVIEW16_ARB = 0x8730,
+ MODELVIEW17_ARB = 0x8731,
+ MODELVIEW18_ARB = 0x8732,
+ MODELVIEW19_ARB = 0x8733,
+ MODELVIEW20_ARB = 0x8734,
+ MODELVIEW21_ARB = 0x8735,
+ MODELVIEW22_ARB = 0x8736,
+ MODELVIEW23_ARB = 0x8737,
+ MODELVIEW24_ARB = 0x8738,
+ MODELVIEW25_ARB = 0x8739,
+ MODELVIEW26_ARB = 0x873A,
+ MODELVIEW27_ARB = 0x873B,
+ MODELVIEW28_ARB = 0x873C,
+ MODELVIEW29_ARB = 0x873D,
+ MODELVIEW30_ARB = 0x873E,
+ MODELVIEW31_ARB = 0x873F,
+ }
+ #endregion
+ #region public enum ARB_matrix_palette
+ public enum ARB_matrix_palette
+ {
+ MATRIX_PALETTE_ARB = 0x8840,
+ MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841,
+ MAX_PALETTE_MATRICES_ARB = 0x8842,
+ CURRENT_PALETTE_MATRIX_ARB = 0x8843,
+ MATRIX_INDEX_ARRAY_ARB = 0x8844,
+ CURRENT_MATRIX_INDEX_ARB = 0x8845,
+ MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846,
+ MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847,
+ MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848,
+ MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849,
+ }
+ #endregion
+ #region public enum ARB_texture_env_combine
+ public enum ARB_texture_env_combine
+ {
+ COMBINE_ARB = 0x8570,
+ COMBINE_RGB_ARB = 0x8571,
+ COMBINE_ALPHA_ARB = 0x8572,
+ SOURCE0_RGB_ARB = 0x8580,
+ SOURCE1_RGB_ARB = 0x8581,
+ SOURCE2_RGB_ARB = 0x8582,
+ SOURCE0_ALPHA_ARB = 0x8588,
+ SOURCE1_ALPHA_ARB = 0x8589,
+ SOURCE2_ALPHA_ARB = 0x858A,
+ OPERAND0_RGB_ARB = 0x8590,
+ OPERAND1_RGB_ARB = 0x8591,
+ OPERAND2_RGB_ARB = 0x8592,
+ OPERAND0_ALPHA_ARB = 0x8598,
+ OPERAND1_ALPHA_ARB = 0x8599,
+ OPERAND2_ALPHA_ARB = 0x859A,
+ RGB_SCALE_ARB = 0x8573,
+ ADD_SIGNED_ARB = 0x8574,
+ INTERPOLATE_ARB = 0x8575,
+ SUBTRACT_ARB = 0x84E7,
+ CONSTANT_ARB = 0x8576,
+ PRIMARY_COLOR_ARB = 0x8577,
+ PREVIOUS_ARB = 0x8578,
+ }
+ #endregion
+ #region public enum ARB_texture_env_crossbar
+ public enum ARB_texture_env_crossbar
+ {
+ }
+ #endregion
+ #region public enum ARB_texture_env_dot3
+ public enum ARB_texture_env_dot3
+ {
+ DOT3_RGB_ARB = 0x86AE,
+ DOT3_RGBA_ARB = 0x86AF,
+ }
+ #endregion
+ #region public enum ARB_texture_mirrored_repeat
+ public enum ARB_texture_mirrored_repeat
+ {
+ MIRRORED_REPEAT_ARB = 0x8370,
+ }
+ #endregion
+ #region public enum ARB_depth_texture
+ public enum ARB_depth_texture
+ {
+ DEPTH_COMPONENT16_ARB = 0x81A5,
+ DEPTH_COMPONENT24_ARB = 0x81A6,
+ DEPTH_COMPONENT32_ARB = 0x81A7,
+ TEXTURE_DEPTH_SIZE_ARB = 0x884A,
+ DEPTH_TEXTURE_MODE_ARB = 0x884B,
+ }
+ #endregion
+ #region public enum ARB_shadow
+ public enum ARB_shadow
+ {
+ TEXTURE_COMPARE_MODE_ARB = 0x884C,
+ TEXTURE_COMPARE_FUNC_ARB = 0x884D,
+ COMPARE_R_TO_TEXTURE_ARB = 0x884E,
+ }
+ #endregion
+ #region public enum ARB_shadow_ambient
+ public enum ARB_shadow_ambient
+ {
+ TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF,
+ }
+ #endregion
+ #region public enum ARB_window_pos
+ public enum ARB_window_pos
+ {
+ }
+ #endregion
+ #region public enum ARB_vertex_program
+ public enum ARB_vertex_program
+ {
+ COLOR_SUM_ARB = 0x8458,
+ VERTEX_PROGRAM_ARB = 0x8620,
+ VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622,
+ VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623,
+ VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624,
+ VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625,
+ CURRENT_VERTEX_ATTRIB_ARB = 0x8626,
+ PROGRAM_LENGTH_ARB = 0x8627,
+ PROGRAM_STRING_ARB = 0x8628,
+ MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E,
+ MAX_PROGRAM_MATRICES_ARB = 0x862F,
+ CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640,
+ CURRENT_MATRIX_ARB = 0x8641,
+ VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642,
+ VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643,
+ VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645,
+ PROGRAM_ERROR_POSITION_ARB = 0x864B,
+ PROGRAM_BINDING_ARB = 0x8677,
+ MAX_VERTEX_ATTRIBS_ARB = 0x8869,
+ VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A,
+ PROGRAM_ERROR_STRING_ARB = 0x8874,
+ PROGRAM_FORMAT_ASCII_ARB = 0x8875,
+ PROGRAM_FORMAT_ARB = 0x8876,
+ PROGRAM_INSTRUCTIONS_ARB = 0x88A0,
+ MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1,
+ PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2,
+ MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3,
+ PROGRAM_TEMPORARIES_ARB = 0x88A4,
+ MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5,
+ PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6,
+ MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7,
+ PROGRAM_PARAMETERS_ARB = 0x88A8,
+ MAX_PROGRAM_PARAMETERS_ARB = 0x88A9,
+ PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA,
+ MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB,
+ PROGRAM_ATTRIBS_ARB = 0x88AC,
+ MAX_PROGRAM_ATTRIBS_ARB = 0x88AD,
+ PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE,
+ MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF,
+ PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0,
+ MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1,
+ PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2,
+ MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3,
+ MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4,
+ MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5,
+ PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6,
+ TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7,
+ MATRIX0_ARB = 0x88C0,
+ MATRIX1_ARB = 0x88C1,
+ MATRIX2_ARB = 0x88C2,
+ MATRIX3_ARB = 0x88C3,
+ MATRIX4_ARB = 0x88C4,
+ MATRIX5_ARB = 0x88C5,
+ MATRIX6_ARB = 0x88C6,
+ MATRIX7_ARB = 0x88C7,
+ MATRIX8_ARB = 0x88C8,
+ MATRIX9_ARB = 0x88C9,
+ MATRIX10_ARB = 0x88CA,
+ MATRIX11_ARB = 0x88CB,
+ MATRIX12_ARB = 0x88CC,
+ MATRIX13_ARB = 0x88CD,
+ MATRIX14_ARB = 0x88CE,
+ MATRIX15_ARB = 0x88CF,
+ MATRIX16_ARB = 0x88D0,
+ MATRIX17_ARB = 0x88D1,
+ MATRIX18_ARB = 0x88D2,
+ MATRIX19_ARB = 0x88D3,
+ MATRIX20_ARB = 0x88D4,
+ MATRIX21_ARB = 0x88D5,
+ MATRIX22_ARB = 0x88D6,
+ MATRIX23_ARB = 0x88D7,
+ MATRIX24_ARB = 0x88D8,
+ MATRIX25_ARB = 0x88D9,
+ MATRIX26_ARB = 0x88DA,
+ MATRIX27_ARB = 0x88DB,
+ MATRIX28_ARB = 0x88DC,
+ MATRIX29_ARB = 0x88DD,
+ MATRIX30_ARB = 0x88DE,
+ MATRIX31_ARB = 0x88DF,
+ }
+ #endregion
+ #region public enum ARB_fragment_program
+ public enum ARB_fragment_program
+ {
+ FRAGMENT_PROGRAM_ARB = 0x8804,
+ PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805,
+ PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806,
+ PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807,
+ PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808,
+ PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809,
+ PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A,
+ MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B,
+ MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C,
+ MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D,
+ MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E,
+ MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F,
+ MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810,
+ MAX_TEXTURE_COORDS_ARB = 0x8871,
+ MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872,
+ }
+ #endregion
+ #region public enum ARB_vertex_buffer_object
+ public enum ARB_vertex_buffer_object
+ {
+ BUFFER_SIZE_ARB = 0x8764,
+ BUFFER_USAGE_ARB = 0x8765,
+ ARRAY_BUFFER_ARB = 0x8892,
+ ELEMENT_ARRAY_BUFFER_ARB = 0x8893,
+ ARRAY_BUFFER_BINDING_ARB = 0x8894,
+ ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895,
+ VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896,
+ NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897,
+ COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898,
+ INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899,
+ TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A,
+ EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B,
+ SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C,
+ FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D,
+ WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E,
+ VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F,
+ READ_ONLY_ARB = 0x88B8,
+ WRITE_ONLY_ARB = 0x88B9,
+ READ_WRITE_ARB = 0x88BA,
+ BUFFER_ACCESS_ARB = 0x88BB,
+ BUFFER_MAPPED_ARB = 0x88BC,
+ BUFFER_MAP_POINTER_ARB = 0x88BD,
+ STREAM_DRAW_ARB = 0x88E0,
+ STREAM_READ_ARB = 0x88E1,
+ STREAM_COPY_ARB = 0x88E2,
+ STATIC_DRAW_ARB = 0x88E4,
+ STATIC_READ_ARB = 0x88E5,
+ STATIC_COPY_ARB = 0x88E6,
+ DYNAMIC_DRAW_ARB = 0x88E8,
+ DYNAMIC_READ_ARB = 0x88E9,
+ DYNAMIC_COPY_ARB = 0x88EA,
+ }
+ #endregion
+ #region public enum ARB_occlusion_query
+ public enum ARB_occlusion_query
+ {
+ QUERY_COUNTER_BITS_ARB = 0x8864,
+ CURRENT_QUERY_ARB = 0x8865,
+ QUERY_RESULT_ARB = 0x8866,
+ QUERY_RESULT_AVAILABLE_ARB = 0x8867,
+ SAMPLES_PASSED_ARB = 0x8914,
+ }
+ #endregion
+ #region public enum ARB_shader_objects
+ public enum ARB_shader_objects
+ {
+ PROGRAM_OBJECT_ARB = 0x8B40,
+ SHADER_OBJECT_ARB = 0x8B48,
+ OBJECT_TYPE_ARB = 0x8B4E,
+ OBJECT_SUBTYPE_ARB = 0x8B4F,
+ FLOAT_VEC2_ARB = 0x8B50,
+ FLOAT_VEC3_ARB = 0x8B51,
+ FLOAT_VEC4_ARB = 0x8B52,
+ INT_VEC2_ARB = 0x8B53,
+ INT_VEC3_ARB = 0x8B54,
+ INT_VEC4_ARB = 0x8B55,
+ BOOL_ARB = 0x8B56,
+ BOOL_VEC2_ARB = 0x8B57,
+ BOOL_VEC3_ARB = 0x8B58,
+ BOOL_VEC4_ARB = 0x8B59,
+ FLOAT_MAT2_ARB = 0x8B5A,
+ FLOAT_MAT3_ARB = 0x8B5B,
+ FLOAT_MAT4_ARB = 0x8B5C,
+ SAMPLER_1D_ARB = 0x8B5D,
+ SAMPLER_2D_ARB = 0x8B5E,
+ SAMPLER_3D_ARB = 0x8B5F,
+ SAMPLER_CUBE_ARB = 0x8B60,
+ SAMPLER_1D_SHADOW_ARB = 0x8B61,
+ SAMPLER_2D_SHADOW_ARB = 0x8B62,
+ SAMPLER_2D_RECT_ARB = 0x8B63,
+ SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64,
+ OBJECT_DELETE_STATUS_ARB = 0x8B80,
+ OBJECT_COMPILE_STATUS_ARB = 0x8B81,
+ OBJECT_LINK_STATUS_ARB = 0x8B82,
+ OBJECT_VALIDATE_STATUS_ARB = 0x8B83,
+ OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84,
+ OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85,
+ OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86,
+ OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87,
+ OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88,
+ }
+ #endregion
+ #region public enum ARB_vertex_shader
+ public enum ARB_vertex_shader
+ {
+ VERTEX_SHADER_ARB = 0x8B31,
+ MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A,
+ MAX_VARYING_FLOATS_ARB = 0x8B4B,
+ MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C,
+ MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D,
+ OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89,
+ OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A,
+ }
+ #endregion
+ #region public enum ARB_fragment_shader
+ public enum ARB_fragment_shader
+ {
+ FRAGMENT_SHADER_ARB = 0x8B30,
+ MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49,
+ FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B,
+ }
+ #endregion
+ #region public enum ARB_shading_language_100
+ public enum ARB_shading_language_100
+ {
+ SHADING_LANGUAGE_VERSION_ARB = 0x8B8C,
+ }
+ #endregion
+ #region public enum ARB_texture_non_power_of_two
+ public enum ARB_texture_non_power_of_two
+ {
+ }
+ #endregion
+ #region public enum ARB_point_sprite
+ public enum ARB_point_sprite
+ {
+ POINT_SPRITE_ARB = 0x8861,
+ COORD_REPLACE_ARB = 0x8862,
+ }
+ #endregion
+ #region public enum ARB_fragment_program_shadow
+ public enum ARB_fragment_program_shadow
+ {
+ }
+ #endregion
+ #region public enum ARB_draw_buffers
+ public enum ARB_draw_buffers
+ {
+ MAX_DRAW_BUFFERS_ARB = 0x8824,
+ DRAW_BUFFER0_ARB = 0x8825,
+ DRAW_BUFFER1_ARB = 0x8826,
+ DRAW_BUFFER2_ARB = 0x8827,
+ DRAW_BUFFER3_ARB = 0x8828,
+ DRAW_BUFFER4_ARB = 0x8829,
+ DRAW_BUFFER5_ARB = 0x882A,
+ DRAW_BUFFER6_ARB = 0x882B,
+ DRAW_BUFFER7_ARB = 0x882C,
+ DRAW_BUFFER8_ARB = 0x882D,
+ DRAW_BUFFER9_ARB = 0x882E,
+ DRAW_BUFFER10_ARB = 0x882F,
+ DRAW_BUFFER11_ARB = 0x8830,
+ DRAW_BUFFER12_ARB = 0x8831,
+ DRAW_BUFFER13_ARB = 0x8832,
+ DRAW_BUFFER14_ARB = 0x8833,
+ DRAW_BUFFER15_ARB = 0x8834,
+ }
+ #endregion
+ #region public enum ARB_texture_rectangle
+ public enum ARB_texture_rectangle
+ {
+ TEXTURE_RECTANGLE_ARB = 0x84F5,
+ TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6,
+ PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7,
+ MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8,
+ }
+ #endregion
+ #region public enum ARB_color_buffer_float
+ public enum ARB_color_buffer_float
+ {
+ RGBA_FLOAT_MODE_ARB = 0x8820,
+ CLAMP_VERTEX_COLOR_ARB = 0x891A,
+ CLAMP_FRAGMENT_COLOR_ARB = 0x891B,
+ CLAMP_READ_COLOR_ARB = 0x891C,
+ FIXED_ONLY_ARB = 0x891D,
+ }
+ #endregion
+ #region public enum ARB_half_float_pixel
+ public enum ARB_half_float_pixel
+ {
+ HALF_FLOAT_ARB = 0x140B,
+ }
+ #endregion
+ #region public enum ARB_texture_float
+ public enum ARB_texture_float
+ {
+ TEXTURE_RED_TYPE_ARB = 0x8C10,
+ TEXTURE_GREEN_TYPE_ARB = 0x8C11,
+ TEXTURE_BLUE_TYPE_ARB = 0x8C12,
+ TEXTURE_ALPHA_TYPE_ARB = 0x8C13,
+ TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14,
+ TEXTURE_INTENSITY_TYPE_ARB = 0x8C15,
+ TEXTURE_DEPTH_TYPE_ARB = 0x8C16,
+ UNSIGNED_NORMALIZED_ARB = 0x8C17,
+ RGBA32F_ARB = 0x8814,
+ RGB32F_ARB = 0x8815,
+ ALPHA32F_ARB = 0x8816,
+ INTENSITY32F_ARB = 0x8817,
+ LUMINANCE32F_ARB = 0x8818,
+ LUMINANCE_ALPHA32F_ARB = 0x8819,
+ RGBA16F_ARB = 0x881A,
+ RGB16F_ARB = 0x881B,
+ ALPHA16F_ARB = 0x881C,
+ INTENSITY16F_ARB = 0x881D,
+ LUMINANCE16F_ARB = 0x881E,
+ LUMINANCE_ALPHA16F_ARB = 0x881F,
+ }
+ #endregion
+ #region public enum ARB_pixel_buffer_object
+ public enum ARB_pixel_buffer_object
+ {
+ PIXEL_PACK_BUFFER_ARB = 0x88EB,
+ PIXEL_UNPACK_BUFFER_ARB = 0x88EC,
+ PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED,
+ PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF,
+ }
+ #endregion
+ #region public enum EXT_subtexture
+ public enum EXT_subtexture
+ {
+ }
+ #endregion
+ #region public enum EXT_copy_texture
+ public enum EXT_copy_texture
+ {
+ }
+ #endregion
+ #region public enum EXT_misc_attribute
+ public enum EXT_misc_attribute
+ {
+ }
+ #endregion
+ #region public enum EXT_blend_logic_op
+ public enum EXT_blend_logic_op
+ {
+ }
+ #endregion
+ #region public enum EXT_point_parameters
+ public enum EXT_point_parameters
+ {
+ POINT_SIZE_MIN_EXT = 0x8126,
+ POINT_SIZE_MAX_EXT = 0x8127,
+ POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128,
+ DISTANCE_ATTENUATION_EXT = 0x8129,
+ }
+ #endregion
+ #region public enum SGIX_tag_sample_buffer
+ public enum SGIX_tag_sample_buffer
+ {
+ }
+ #endregion
+ #region public enum SGIX_polynomial_ffd
+ public enum SGIX_polynomial_ffd
+ {
+ GEOMETRY_DEFORMATION_SGIX = 0x8194,
+ TEXTURE_DEFORMATION_SGIX = 0x8195,
+ DEFORMATIONS_MASK_SGIX = 0x8196,
+ MAX_DEFORMATION_ORDER_SGIX = 0x8197,
+ }
+ #endregion
+ #region public enum SGIX_flush_raster
+ public enum SGIX_flush_raster
+ {
+ }
+ #endregion
+ #region public enum HP_image_transform
+ public enum HP_image_transform
+ {
+ IMAGE_SCALE_X_HP = 0x8155,
+ IMAGE_SCALE_Y_HP = 0x8156,
+ IMAGE_TRANSLATE_X_HP = 0x8157,
+ IMAGE_TRANSLATE_Y_HP = 0x8158,
+ IMAGE_ROTATE_ANGLE_HP = 0x8159,
+ IMAGE_ROTATE_ORIGIN_X_HP = 0x815A,
+ IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B,
+ IMAGE_MAG_FILTER_HP = 0x815C,
+ IMAGE_MIN_FILTER_HP = 0x815D,
+ IMAGE_CUBIC_WEIGHT_HP = 0x815E,
+ CUBIC_HP = 0x815F,
+ AVERAGE_HP = 0x8160,
+ IMAGE_TRANSFORM_2D_HP = 0x8161,
+ POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162,
+ PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163,
+ }
+ #endregion
+ #region public enum INGR_palette_buffer
+ public enum INGR_palette_buffer
+ {
+ }
+ #endregion
+ #region public enum EXT_color_subtable
+ public enum EXT_color_subtable
+ {
+ }
+ #endregion
+ #region public enum PGI_vertex_hints
+ public enum PGI_vertex_hints
+ {
+ VERTEX_DATA_HINT_PGI = 0x1A22A,
+ VERTEX_CONSISTENT_HINT_PGI = 0x1A22B,
+ MATERIAL_SIDE_HINT_PGI = 0x1A22C,
+ MAX_VERTEX_HINT_PGI = 0x1A22D,
+ COLOR3_BIT_PGI = 0x00010000,
+ COLOR4_BIT_PGI = 0x00020000,
+ EDGEFLAG_BIT_PGI = 0x00040000,
+ INDEX_BIT_PGI = 0x00080000,
+ MAT_AMBIENT_BIT_PGI = 0x00100000,
+ MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000,
+ MAT_DIFFUSE_BIT_PGI = 0x00400000,
+ MAT_EMISSION_BIT_PGI = 0x00800000,
+ MAT_COLOR_INDEXES_BIT_PGI = 0x01000000,
+ MAT_SHININESS_BIT_PGI = 0x02000000,
+ MAT_SPECULAR_BIT_PGI = 0x04000000,
+ NORMAL_BIT_PGI = 0x08000000,
+ TEXCOORD1_BIT_PGI = 0x10000000,
+ TEXCOORD2_BIT_PGI = 0x20000000,
+ TEXCOORD3_BIT_PGI = 0x40000000,
+ TEXCOORD4_BIT_PGI = unchecked((Int32)0x80000000),
+ VERTEX23_BIT_PGI = 0x00000004,
+ VERTEX4_BIT_PGI = 0x00000008,
+ }
+ #endregion
+ #region public enum PGI_misc_hints
+ public enum PGI_misc_hints
+ {
+ PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8,
+ CONSERVE_MEMORY_HINT_PGI = 0x1A1FD,
+ RECLAIM_MEMORY_HINT_PGI = 0x1A1FE,
+ NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202,
+ NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203,
+ NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204,
+ ALWAYS_FAST_HINT_PGI = 0x1A20C,
+ ALWAYS_SOFT_HINT_PGI = 0x1A20D,
+ ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E,
+ ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F,
+ ALLOW_DRAW_FRG_HINT_PGI = 0x1A210,
+ ALLOW_DRAW_MEM_HINT_PGI = 0x1A211,
+ STRICT_DEPTHFUNC_HINT_PGI = 0x1A216,
+ STRICT_LIGHTING_HINT_PGI = 0x1A217,
+ STRICT_SCISSOR_HINT_PGI = 0x1A218,
+ FULL_STIPPLE_HINT_PGI = 0x1A219,
+ CLIP_NEAR_HINT_PGI = 0x1A220,
+ CLIP_FAR_HINT_PGI = 0x1A221,
+ WIDE_LINE_HINT_PGI = 0x1A222,
+ BACK_NORMALS_HINT_PGI = 0x1A223,
+ }
+ #endregion
+ #region public enum EXT_paletted_texture
+ public enum EXT_paletted_texture
+ {
+ COLOR_INDEX1_EXT = 0x80E2,
+ COLOR_INDEX2_EXT = 0x80E3,
+ COLOR_INDEX4_EXT = 0x80E4,
+ COLOR_INDEX8_EXT = 0x80E5,
+ COLOR_INDEX12_EXT = 0x80E6,
+ COLOR_INDEX16_EXT = 0x80E7,
+ TEXTURE_INDEX_SIZE_EXT = 0x80ED,
+ }
+ #endregion
+ #region public enum EXT_clip_volume_hint
+ public enum EXT_clip_volume_hint
+ {
+ CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0,
+ }
+ #endregion
+ #region public enum EXT_index_texture
+ public enum EXT_index_texture
+ {
+ }
+ #endregion
+ #region public enum EXT_index_material
+ public enum EXT_index_material
+ {
+ INDEX_MATERIAL_EXT = 0x81B8,
+ INDEX_MATERIAL_PARAMETER_EXT = 0x81B9,
+ INDEX_MATERIAL_FACE_EXT = 0x81BA,
+ }
+ #endregion
+ #region public enum EXT_index_func
+ public enum EXT_index_func
+ {
+ INDEX_TEST_EXT = 0x81B5,
+ INDEX_TEST_FUNC_EXT = 0x81B6,
+ INDEX_TEST_REF_EXT = 0x81B7,
+ }
+ #endregion
+ #region public enum EXT_index_array_formats
+ public enum EXT_index_array_formats
+ {
+ IUI_V2F_EXT = 0x81AD,
+ IUI_V3F_EXT = 0x81AE,
+ IUI_N3F_V2F_EXT = 0x81AF,
+ IUI_N3F_V3F_EXT = 0x81B0,
+ T2F_IUI_V2F_EXT = 0x81B1,
+ T2F_IUI_V3F_EXT = 0x81B2,
+ T2F_IUI_N3F_V2F_EXT = 0x81B3,
+ T2F_IUI_N3F_V3F_EXT = 0x81B4,
+ }
+ #endregion
+ #region public enum EXT_compiled_vertex_array
+ public enum EXT_compiled_vertex_array
+ {
+ ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8,
+ ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9,
+ }
+ #endregion
+ #region public enum EXT_cull_vertex
+ public enum EXT_cull_vertex
+ {
+ CULL_VERTEX_EXT = 0x81AA,
+ CULL_VERTEX_EYE_POSITION_EXT = 0x81AB,
+ CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC,
+ }
+ #endregion
+ #region public enum IBM_rasterpos_clip
+ public enum IBM_rasterpos_clip
+ {
+ RASTER_POSITION_UNCLIPPED_IBM = 0x19262,
+ }
+ #endregion
+ #region public enum HP_texture_lighting
+ public enum HP_texture_lighting
+ {
+ TEXTURE_LIGHTING_MODE_HP = 0x8167,
+ TEXTURE_POST_SPECULAR_HP = 0x8168,
+ TEXTURE_PRE_SPECULAR_HP = 0x8169,
+ }
+ #endregion
+ #region public enum EXT_draw_range_elements
+ public enum EXT_draw_range_elements
+ {
+ MAX_ELEMENTS_VERTICES_EXT = 0x80E8,
+ MAX_ELEMENTS_INDICES_EXT = 0x80E9,
+ }
+ #endregion
+ #region public enum WIN_phong_shading
+ public enum WIN_phong_shading
+ {
+ PHONG_WIN = 0x80EA,
+ PHONG_HINT_WIN = 0x80EB,
+ }
+ #endregion
+ #region public enum WIN_specular_fog
+ public enum WIN_specular_fog
+ {
+ FOG_SPECULAR_TEXTURE_WIN = 0x80EC,
+ }
+ #endregion
+ #region public enum EXT_light_texture
+ public enum EXT_light_texture
+ {
+ FRAGMENT_MATERIAL_EXT = 0x8349,
+ FRAGMENT_NORMAL_EXT = 0x834A,
+ FRAGMENT_COLOR_EXT = 0x834C,
+ ATTENUATION_EXT = 0x834D,
+ SHADOW_ATTENUATION_EXT = 0x834E,
+ TEXTURE_APPLICATION_MODE_EXT = 0x834F,
+ TEXTURE_LIGHT_EXT = 0x8350,
+ TEXTURE_MATERIAL_FACE_EXT = 0x8351,
+ TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352,
+ FRAGMENT_DEPTH_EXT = EXT_fog_coord.FRAGMENT_DEPTH_EXT,
+ }
+ #endregion
+ #region public enum SGIX_async
+ public enum SGIX_async
+ {
+ ASYNC_MARKER_SGIX = 0x8329,
+ }
+ #endregion
+ #region public enum INTEL_texture_scissor
+ public enum INTEL_texture_scissor
+ {
+ }
+ #endregion
+ #region public enum HP_occlusion_test
+ public enum HP_occlusion_test
+ {
+ OCCLUSION_TEST_HP = 0x8165,
+ OCCLUSION_TEST_RESULT_HP = 0x8166,
+ }
+ #endregion
+ #region public enum EXT_pixel_transform_color_table
+ public enum EXT_pixel_transform_color_table
+ {
+ }
+ #endregion
+ #region public enum EXT_secondary_color
+ public enum EXT_secondary_color
+ {
+ COLOR_SUM_EXT = 0x8458,
+ CURRENT_SECONDARY_COLOR_EXT = 0x8459,
+ SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A,
+ SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B,
+ SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C,
+ SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D,
+ SECONDARY_COLOR_ARRAY_EXT = 0x845E,
+ }
+ #endregion
+ #region public enum EXT_texture_perturb_normal
+ public enum EXT_texture_perturb_normal
+ {
+ PERTURB_EXT = 0x85AE,
+ TEXTURE_NORMAL_EXT = 0x85AF,
+ }
+ #endregion
+ #region public enum EXT_multi_draw_arrays
+ public enum EXT_multi_draw_arrays
+ {
+ }
+ #endregion
+ #region public enum EXT_fog_coord
+ public enum EXT_fog_coord
+ {
+ FOG_COORDINATE_SOURCE_EXT = 0x8450,
+ FOG_COORDINATE_EXT = 0x8451,
+ FRAGMENT_DEPTH_EXT = 0x8452,
+ CURRENT_FOG_COORDINATE_EXT = 0x8453,
+ FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454,
+ FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455,
+ FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456,
+ FOG_COORDINATE_ARRAY_EXT = 0x8457,
+ }
+ #endregion
+ #region public enum REND_screen_coordinates
+ public enum REND_screen_coordinates
+ {
+ SCREEN_COORDINATES_REND = 0x8490,
+ INVERTED_SCREEN_W_REND = 0x8491,
+ }
+ #endregion
+ #region public enum EXT_coordinate_frame
+ public enum EXT_coordinate_frame
+ {
+ TANGENT_ARRAY_EXT = 0x8439,
+ BINORMAL_ARRAY_EXT = 0x843A,
+ CURRENT_TANGENT_EXT = 0x843B,
+ CURRENT_BINORMAL_EXT = 0x843C,
+ TANGENT_ARRAY_TYPE_EXT = 0x843E,
+ TANGENT_ARRAY_STRIDE_EXT = 0x843F,
+ BINORMAL_ARRAY_TYPE_EXT = 0x8440,
+ BINORMAL_ARRAY_STRIDE_EXT = 0x8441,
+ TANGENT_ARRAY_POINTER_EXT = 0x8442,
+ BINORMAL_ARRAY_POINTER_EXT = 0x8443,
+ MAP1_TANGENT_EXT = 0x8444,
+ MAP2_TANGENT_EXT = 0x8445,
+ MAP1_BINORMAL_EXT = 0x8446,
+ MAP2_BINORMAL_EXT = 0x8447,
+ }
+ #endregion
+ #region public enum EXT_texture_env_combine
+ public enum EXT_texture_env_combine
+ {
+ COMBINE_EXT = 0x8570,
+ COMBINE_RGB_EXT = 0x8571,
+ COMBINE_ALPHA_EXT = 0x8572,
+ RGB_SCALE_EXT = 0x8573,
+ ADD_SIGNED_EXT = 0x8574,
+ INTERPOLATE_EXT = 0x8575,
+ CONSTANT_EXT = 0x8576,
+ PRIMARY_COLOR_EXT = 0x8577,
+ PREVIOUS_EXT = 0x8578,
+ SOURCE0_RGB_EXT = 0x8580,
+ SOURCE1_RGB_EXT = 0x8581,
+ SOURCE2_RGB_EXT = 0x8582,
+ SOURCE0_ALPHA_EXT = 0x8588,
+ SOURCE1_ALPHA_EXT = 0x8589,
+ SOURCE2_ALPHA_EXT = 0x858A,
+ OPERAND0_RGB_EXT = 0x8590,
+ OPERAND1_RGB_EXT = 0x8591,
+ OPERAND2_RGB_EXT = 0x8592,
+ OPERAND0_ALPHA_EXT = 0x8598,
+ OPERAND1_ALPHA_EXT = 0x8599,
+ OPERAND2_ALPHA_EXT = 0x859A,
+ }
+ #endregion
+ #region public enum APPLE_specular_vector
+ public enum APPLE_specular_vector
+ {
+ LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0,
+ }
+ #endregion
+ #region public enum APPLE_transform_hint
+ public enum APPLE_transform_hint
+ {
+ TRANSFORM_HINT_APPLE = 0x85B1,
+ }
+ #endregion
+ #region public enum SGIX_fog_scale
+ public enum SGIX_fog_scale
+ {
+ FOG_SCALE_SGIX = 0x81FC,
+ FOG_SCALE_VALUE_SGIX = 0x81FD,
+ }
+ #endregion
+ #region public enum SUNX_constant_data
+ public enum SUNX_constant_data
+ {
+ UNPACK_CONSTANT_DATA_SUNX = 0x81D5,
+ TEXTURE_CONSTANT_DATA_SUNX = 0x81D6,
+ }
+ #endregion
+ #region public enum SUN_global_alpha
+ public enum SUN_global_alpha
+ {
+ GLOBAL_ALPHA_SUN = 0x81D9,
+ GLOBAL_ALPHA_FACTOR_SUN = 0x81DA,
+ }
+ #endregion
+ #region public enum SUN_triangle_list
+ public enum SUN_triangle_list
+ {
+ RESTART_SUN = 0x0001,
+ REPLACE_MIDDLE_SUN = 0x0002,
+ REPLACE_OLDEST_SUN = 0x0003,
+ TRIANGLE_LIST_SUN = 0x81D7,
+ REPLACEMENT_CODE_SUN = 0x81D8,
+ REPLACEMENT_CODE_ARRAY_SUN = 0x85C0,
+ REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1,
+ REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2,
+ REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3,
+ R1UI_V3F_SUN = 0x85C4,
+ R1UI_C4UB_V3F_SUN = 0x85C5,
+ R1UI_C3F_V3F_SUN = 0x85C6,
+ R1UI_N3F_V3F_SUN = 0x85C7,
+ R1UI_C4F_N3F_V3F_SUN = 0x85C8,
+ R1UI_T2F_V3F_SUN = 0x85C9,
+ R1UI_T2F_N3F_V3F_SUN = 0x85CA,
+ R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB,
+ }
+ #endregion
+ #region public enum SUN_vertex
+ public enum SUN_vertex
+ {
+ }
+ #endregion
+ #region public enum EXT_blend_func_separate
+ public enum EXT_blend_func_separate
+ {
+ BLEND_DST_RGB_EXT = 0x80C8,
+ BLEND_SRC_RGB_EXT = 0x80C9,
+ BLEND_DST_ALPHA_EXT = 0x80CA,
+ BLEND_SRC_ALPHA_EXT = 0x80CB,
+ }
+ #endregion
+ #region public enum INGR_color_clamp
+ public enum INGR_color_clamp
+ {
+ RED_MIN_CLAMP_INGR = 0x8560,
+ GREEN_MIN_CLAMP_INGR = 0x8561,
+ BLUE_MIN_CLAMP_INGR = 0x8562,
+ ALPHA_MIN_CLAMP_INGR = 0x8563,
+ RED_MAX_CLAMP_INGR = 0x8564,
+ GREEN_MAX_CLAMP_INGR = 0x8565,
+ BLUE_MAX_CLAMP_INGR = 0x8566,
+ ALPHA_MAX_CLAMP_INGR = 0x8567,
+ }
+ #endregion
+ #region public enum INGR_interlace_read
+ public enum INGR_interlace_read
+ {
+ INTERLACE_READ_INGR = 0x8568,
+ }
+ #endregion
+ #region public enum EXT_stencil_wrap
+ public enum EXT_stencil_wrap
+ {
+ INCR_WRAP_EXT = 0x8507,
+ DECR_WRAP_EXT = 0x8508,
+ }
+ #endregion
+ #region public enum EXT_422_pixels
+ public enum EXT_422_pixels
+ {
+ _422_EXT = 0x80CC,
+ _422_REV_EXT = 0x80CD,
+ _422_AVERAGE_EXT = 0x80CE,
+ _422_REV_AVERAGE_EXT = 0x80CF,
+ }
+ #endregion
+ #region public enum NV_texgen_reflection
+ public enum NV_texgen_reflection
+ {
+ NORMAL_MAP_NV = 0x8511,
+ REFLECTION_MAP_NV = 0x8512,
+ }
+ #endregion
+ #region public enum EXT_texture_cube_map
+ public enum EXT_texture_cube_map
+ {
+ NORMAL_MAP_EXT = 0x8511,
+ REFLECTION_MAP_EXT = 0x8512,
+ TEXTURE_CUBE_MAP_EXT = 0x8513,
+ TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514,
+ TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515,
+ TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516,
+ TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517,
+ TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518,
+ TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519,
+ TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A,
+ PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B,
+ MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C,
+ }
+ #endregion
+ #region public enum SUN_convolution_border_modes
+ public enum SUN_convolution_border_modes
+ {
+ WRAP_BORDER_SUN = 0x81D4,
+ }
+ #endregion
+ #region public enum EXT_texture_env_add
+ public enum EXT_texture_env_add
+ {
+ }
+ #endregion
+ #region public enum EXT_texture_lod_bias
+ public enum EXT_texture_lod_bias
+ {
+ MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD,
+ TEXTURE_FILTER_CONTROL_EXT = 0x8500,
+ TEXTURE_LOD_BIAS_EXT = 0x8501,
+ }
+ #endregion
+ #region public enum EXT_texture_filter_anisotropic
+ public enum EXT_texture_filter_anisotropic
+ {
+ TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE,
+ MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF,
+ }
+ #endregion
+ #region public enum EXT_vertex_weighting
+ public enum EXT_vertex_weighting
+ {
+ MODELVIEW0_STACK_DEPTH_EXT = GetPName.MODELVIEW_STACK_DEPTH,
+ MODELVIEW1_STACK_DEPTH_EXT = 0x8502,
+ MODELVIEW0_MATRIX_EXT = GetPName.MODELVIEW_MATRIX,
+ MODELVIEW1_MATRIX_EXT = 0x8506,
+ VERTEX_WEIGHTING_EXT = 0x8509,
+ MODELVIEW0_EXT = MatrixMode.MODELVIEW,
+ MODELVIEW1_EXT = 0x850A,
+ CURRENT_VERTEX_WEIGHT_EXT = 0x850B,
+ VERTEX_WEIGHT_ARRAY_EXT = 0x850C,
+ VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D,
+ VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E,
+ VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F,
+ VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510,
+ }
+ #endregion
+ #region public enum NV_light_max_exponent
+ public enum NV_light_max_exponent
+ {
+ MAX_SHININESS_NV = 0x8504,
+ MAX_SPOT_EXPONENT_NV = 0x8505,
+ }
+ #endregion
+ #region public enum NV_vertex_array_range
+ public enum NV_vertex_array_range
+ {
+ VERTEX_ARRAY_RANGE_NV = 0x851D,
+ VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E,
+ VERTEX_ARRAY_RANGE_VALID_NV = 0x851F,
+ MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520,
+ VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521,
+ }
+ #endregion
+ #region public enum NV_register_combiners
+ public enum NV_register_combiners
+ {
+ REGISTER_COMBINERS_NV = 0x8522,
+ VARIABLE_A_NV = 0x8523,
+ VARIABLE_B_NV = 0x8524,
+ VARIABLE_C_NV = 0x8525,
+ VARIABLE_D_NV = 0x8526,
+ VARIABLE_E_NV = 0x8527,
+ VARIABLE_F_NV = 0x8528,
+ VARIABLE_G_NV = 0x8529,
+ CONSTANT_COLOR0_NV = 0x852A,
+ CONSTANT_COLOR1_NV = 0x852B,
+ PRIMARY_COLOR_NV = 0x852C,
+ SECONDARY_COLOR_NV = 0x852D,
+ SPARE0_NV = 0x852E,
+ SPARE1_NV = 0x852F,
+ DISCARD_NV = 0x8530,
+ E_TIMES_F_NV = 0x8531,
+ SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532,
+ UNSIGNED_IDENTITY_NV = 0x8536,
+ UNSIGNED_INVERT_NV = 0x8537,
+ EXPAND_NORMAL_NV = 0x8538,
+ EXPAND_NEGATE_NV = 0x8539,
+ HALF_BIAS_NORMAL_NV = 0x853A,
+ HALF_BIAS_NEGATE_NV = 0x853B,
+ SIGNED_IDENTITY_NV = 0x853C,
+ SIGNED_NEGATE_NV = 0x853D,
+ SCALE_BY_TWO_NV = 0x853E,
+ SCALE_BY_FOUR_NV = 0x853F,
+ SCALE_BY_ONE_HALF_NV = 0x8540,
+ BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541,
+ COMBINER_INPUT_NV = 0x8542,
+ COMBINER_MAPPING_NV = 0x8543,
+ COMBINER_COMPONENT_USAGE_NV = 0x8544,
+ COMBINER_AB_DOT_PRODUCT_NV = 0x8545,
+ COMBINER_CD_DOT_PRODUCT_NV = 0x8546,
+ COMBINER_MUX_SUM_NV = 0x8547,
+ COMBINER_SCALE_NV = 0x8548,
+ COMBINER_BIAS_NV = 0x8549,
+ COMBINER_AB_OUTPUT_NV = 0x854A,
+ COMBINER_CD_OUTPUT_NV = 0x854B,
+ COMBINER_SUM_OUTPUT_NV = 0x854C,
+ MAX_GENERAL_COMBINERS_NV = 0x854D,
+ NUM_GENERAL_COMBINERS_NV = 0x854E,
+ COLOR_SUM_CLAMP_NV = 0x854F,
+ COMBINER0_NV = 0x8550,
+ COMBINER1_NV = 0x8551,
+ COMBINER2_NV = 0x8552,
+ COMBINER3_NV = 0x8553,
+ COMBINER4_NV = 0x8554,
+ COMBINER5_NV = 0x8555,
+ COMBINER6_NV = 0x8556,
+ COMBINER7_NV = 0x8557,
+ TEXTURE0_ARB = ARB_multitexture.TEXTURE0_ARB,
+ TEXTURE1_ARB = ARB_multitexture.TEXTURE1_ARB,
+ ZERO = BlendingFactorDest.ZERO,
+ NONE = DrawBufferMode.NONE,
+ FOG = GetPName.FOG,
+ }
+ #endregion
+ #region public enum NV_fog_distance
+ public enum NV_fog_distance
+ {
+ FOG_DISTANCE_MODE_NV = 0x855A,
+ EYE_RADIAL_NV = 0x855B,
+ EYE_PLANE_ABSOLUTE_NV = 0x855C,
+ EYE_PLANE = TextureGenParameter.EYE_PLANE,
+ }
+ #endregion
+ #region public enum NV_texgen_emboss
+ public enum NV_texgen_emboss
+ {
+ EMBOSS_LIGHT_NV = 0x855D,
+ EMBOSS_CONSTANT_NV = 0x855E,
+ EMBOSS_MAP_NV = 0x855F,
+ }
+ #endregion
+ #region public enum NV_blend_square
+ public enum NV_blend_square
+ {
+ }
+ #endregion
+ #region public enum NV_texture_env_combine4
+ public enum NV_texture_env_combine4
+ {
+ COMBINE4_NV = 0x8503,
+ SOURCE3_RGB_NV = 0x8583,
+ SOURCE3_ALPHA_NV = 0x858B,
+ OPERAND3_RGB_NV = 0x8593,
+ OPERAND3_ALPHA_NV = 0x859B,
+ }
+ #endregion
+ #region public enum MESA_resize_buffers
+ public enum MESA_resize_buffers
+ {
+ }
+ #endregion
+ #region public enum MESA_window_pos
+ public enum MESA_window_pos
+ {
+ }
+ #endregion
+ #region public enum IBM_cull_vertex
+ public enum IBM_cull_vertex
+ {
+ CULL_VERTEX_IBM = 103050,
+ }
+ #endregion
+ #region public enum IBM_multimode_draw_arrays
+ public enum IBM_multimode_draw_arrays
+ {
+ }
+ #endregion
+ #region public enum IBM_vertex_array_lists
+ public enum IBM_vertex_array_lists
+ {
+ VERTEX_ARRAY_LIST_IBM = 103070,
+ NORMAL_ARRAY_LIST_IBM = 103071,
+ COLOR_ARRAY_LIST_IBM = 103072,
+ INDEX_ARRAY_LIST_IBM = 103073,
+ TEXTURE_COORD_ARRAY_LIST_IBM = 103074,
+ EDGE_FLAG_ARRAY_LIST_IBM = 103075,
+ FOG_COORDINATE_ARRAY_LIST_IBM = 103076,
+ SECONDARY_COLOR_ARRAY_LIST_IBM = 103077,
+ VERTEX_ARRAY_LIST_STRIDE_IBM = 103080,
+ NORMAL_ARRAY_LIST_STRIDE_IBM = 103081,
+ COLOR_ARRAY_LIST_STRIDE_IBM = 103082,
+ INDEX_ARRAY_LIST_STRIDE_IBM = 103083,
+ TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084,
+ EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085,
+ FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086,
+ SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087,
+ }
+ #endregion
+ #region public enum SGIX_ycrcb_subsample
+ public enum SGIX_ycrcb_subsample
+ {
+ PACK_SUBSAMPLE_RATE_SGIX = 0x85A0,
+ UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1,
+ PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2,
+ PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3,
+ PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4,
+ }
+ #endregion
+ #region public enum SGIX_ycrcba
+ public enum SGIX_ycrcba
+ {
+ YCRCB_SGIX = 0x8318,
+ YCRCBA_SGIX = 0x8319,
+ }
+ #endregion
+ #region public enum SGI_depth_pass_instrument
+ public enum SGI_depth_pass_instrument
+ {
+ DEPTH_PASS_INSTRUMENT_SGIX = 0x8310,
+ DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311,
+ DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312,
+ }
+ #endregion
+ #region public enum _3DFX_texture_compression_FXT1
+ public enum _3DFX_texture_compression_FXT1
+ {
+ COMPRESSED_RGB_FXT1_3DFX = 0x86B0,
+ COMPRESSED_RGBA_FXT1_3DFX = 0x86B1,
+ }
+ #endregion
+ #region public enum _3DFX_multisample
+ public enum _3DFX_multisample
+ {
+ MULTISAMPLE_3DFX = 0x86B2,
+ SAMPLE_BUFFERS_3DFX = 0x86B3,
+ SAMPLES_3DFX = 0x86B4,
+ MULTISAMPLE_BIT_3DFX = 0x20000000,
+ }
+ #endregion
+ #region public enum _3DFX_tbuffer
+ public enum _3DFX_tbuffer
+ {
+ }
+ #endregion
+ #region public enum EXT_multisample
+ public enum EXT_multisample
+ {
+ MULTISAMPLE_EXT = 0x809D,
+ SAMPLE_ALPHA_TO_MASK_EXT = 0x809E,
+ SAMPLE_ALPHA_TO_ONE_EXT = 0x809F,
+ SAMPLE_MASK_EXT = 0x80A0,
+ _1PASS_EXT = 0x80A1,
+ _2PASS_0_EXT = 0x80A2,
+ _2PASS_1_EXT = 0x80A3,
+ _4PASS_0_EXT = 0x80A4,
+ _4PASS_1_EXT = 0x80A5,
+ _4PASS_2_EXT = 0x80A6,
+ _4PASS_3_EXT = 0x80A7,
+ SAMPLE_BUFFERS_EXT = 0x80A8,
+ SAMPLES_EXT = 0x80A9,
+ SAMPLE_MASK_VALUE_EXT = 0x80AA,
+ SAMPLE_MASK_INVERT_EXT = 0x80AB,
+ SAMPLE_PATTERN_EXT = 0x80AC,
+ MULTISAMPLE_BIT_EXT = 0x20000000,
+ }
+ #endregion
+ #region public enum EXT_texture_env_dot3
+ public enum EXT_texture_env_dot3
+ {
+ DOT3_RGB_EXT = 0x8740,
+ DOT3_RGBA_EXT = 0x8741,
+ }
+ #endregion
+ #region public enum ATI_texture_mirror_once
+ public enum ATI_texture_mirror_once
+ {
+ MIRROR_CLAMP_ATI = 0x8742,
+ MIRROR_CLAMP_TO_EDGE_ATI = 0x8743,
+ }
+ #endregion
+ #region public enum NV_fence
+ public enum NV_fence
+ {
+ ALL_COMPLETED_NV = 0x84F2,
+ FENCE_STATUS_NV = 0x84F3,
+ FENCE_CONDITION_NV = 0x84F4,
+ }
+ #endregion
+ #region public enum IBM_texture_mirrored_repeat
+ public enum IBM_texture_mirrored_repeat
+ {
+ MIRRORED_REPEAT_IBM = 0x8370,
+ }
+ #endregion
+ #region public enum NV_evaluators
+ public enum NV_evaluators
+ {
+ EVAL_2D_NV = 0x86C0,
+ EVAL_TRIANGULAR_2D_NV = 0x86C1,
+ MAP_TESSELLATION_NV = 0x86C2,
+ MAP_ATTRIB_U_ORDER_NV = 0x86C3,
+ MAP_ATTRIB_V_ORDER_NV = 0x86C4,
+ EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5,
+ EVAL_VERTEX_ATTRIB0_NV = 0x86C6,
+ EVAL_VERTEX_ATTRIB1_NV = 0x86C7,
+ EVAL_VERTEX_ATTRIB2_NV = 0x86C8,
+ EVAL_VERTEX_ATTRIB3_NV = 0x86C9,
+ EVAL_VERTEX_ATTRIB4_NV = 0x86CA,
+ EVAL_VERTEX_ATTRIB5_NV = 0x86CB,
+ EVAL_VERTEX_ATTRIB6_NV = 0x86CC,
+ EVAL_VERTEX_ATTRIB7_NV = 0x86CD,
+ EVAL_VERTEX_ATTRIB8_NV = 0x86CE,
+ EVAL_VERTEX_ATTRIB9_NV = 0x86CF,
+ EVAL_VERTEX_ATTRIB10_NV = 0x86D0,
+ EVAL_VERTEX_ATTRIB11_NV = 0x86D1,
+ EVAL_VERTEX_ATTRIB12_NV = 0x86D2,
+ EVAL_VERTEX_ATTRIB13_NV = 0x86D3,
+ EVAL_VERTEX_ATTRIB14_NV = 0x86D4,
+ EVAL_VERTEX_ATTRIB15_NV = 0x86D5,
+ MAX_MAP_TESSELLATION_NV = 0x86D6,
+ MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7,
+ }
+ #endregion
+ #region public enum NV_packed_depth_stencil
+ public enum NV_packed_depth_stencil
+ {
+ DEPTH_STENCIL_NV = 0x84F9,
+ UNSIGNED_INT_24_8_NV = 0x84FA,
+ }
+ #endregion
+ #region public enum NV_register_combiners2
+ public enum NV_register_combiners2
+ {
+ PER_STAGE_CONSTANTS_NV = 0x8535,
+ }
+ #endregion
+ #region public enum NV_texture_compression_vtc
+ public enum NV_texture_compression_vtc
+ {
+ }
+ #endregion
+ #region public enum NV_texture_rectangle
+ public enum NV_texture_rectangle
+ {
+ TEXTURE_RECTANGLE_NV = 0x84F5,
+ TEXTURE_BINDING_RECTANGLE_NV = 0x84F6,
+ PROXY_TEXTURE_RECTANGLE_NV = 0x84F7,
+ MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8,
+ }
+ #endregion
+ #region public enum NV_texture_shader
+ public enum NV_texture_shader
+ {
+ OFFSET_TEXTURE_RECTANGLE_NV = 0x864C,
+ OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D,
+ DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E,
+ RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9,
+ UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA,
+ UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB,
+ DSDT_MAG_INTENSITY_NV = 0x86DC,
+ SHADER_CONSISTENT_NV = 0x86DD,
+ TEXTURE_SHADER_NV = 0x86DE,
+ SHADER_OPERATION_NV = 0x86DF,
+ CULL_MODES_NV = 0x86E0,
+ OFFSET_TEXTURE_MATRIX_NV = 0x86E1,
+ OFFSET_TEXTURE_SCALE_NV = 0x86E2,
+ OFFSET_TEXTURE_BIAS_NV = 0x86E3,
+ OFFSET_TEXTURE_2D_MATRIX_NV = NV_texture_shader.OFFSET_TEXTURE_MATRIX_NV,
+ OFFSET_TEXTURE_2D_SCALE_NV = NV_texture_shader.OFFSET_TEXTURE_SCALE_NV,
+ OFFSET_TEXTURE_2D_BIAS_NV = NV_texture_shader.OFFSET_TEXTURE_BIAS_NV,
+ PREVIOUS_TEXTURE_INPUT_NV = 0x86E4,
+ CONST_EYE_NV = 0x86E5,
+ PASS_THROUGH_NV = 0x86E6,
+ CULL_FRAGMENT_NV = 0x86E7,
+ OFFSET_TEXTURE_2D_NV = 0x86E8,
+ DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9,
+ DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA,
+ DOT_PRODUCT_NV = 0x86EC,
+ DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED,
+ DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE,
+ DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0,
+ DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1,
+ DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2,
+ DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3,
+ HILO_NV = 0x86F4,
+ DSDT_NV = 0x86F5,
+ DSDT_MAG_NV = 0x86F6,
+ DSDT_MAG_VIB_NV = 0x86F7,
+ HILO16_NV = 0x86F8,
+ SIGNED_HILO_NV = 0x86F9,
+ SIGNED_HILO16_NV = 0x86FA,
+ SIGNED_RGBA_NV = 0x86FB,
+ SIGNED_RGBA8_NV = 0x86FC,
+ SIGNED_RGB_NV = 0x86FE,
+ SIGNED_RGB8_NV = 0x86FF,
+ SIGNED_LUMINANCE_NV = 0x8701,
+ SIGNED_LUMINANCE8_NV = 0x8702,
+ SIGNED_LUMINANCE_ALPHA_NV = 0x8703,
+ SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704,
+ SIGNED_ALPHA_NV = 0x8705,
+ SIGNED_ALPHA8_NV = 0x8706,
+ SIGNED_INTENSITY_NV = 0x8707,
+ SIGNED_INTENSITY8_NV = 0x8708,
+ DSDT8_NV = 0x8709,
+ DSDT8_MAG8_NV = 0x870A,
+ DSDT8_MAG8_INTENSITY8_NV = 0x870B,
+ SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C,
+ SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D,
+ HI_SCALE_NV = 0x870E,
+ LO_SCALE_NV = 0x870F,
+ DS_SCALE_NV = 0x8710,
+ DT_SCALE_NV = 0x8711,
+ MAGNITUDE_SCALE_NV = 0x8712,
+ VIBRANCE_SCALE_NV = 0x8713,
+ HI_BIAS_NV = 0x8714,
+ LO_BIAS_NV = 0x8715,
+ DS_BIAS_NV = 0x8716,
+ DT_BIAS_NV = 0x8717,
+ MAGNITUDE_BIAS_NV = 0x8718,
+ VIBRANCE_BIAS_NV = 0x8719,
+ TEXTURE_BORDER_VALUES_NV = 0x871A,
+ TEXTURE_HI_SIZE_NV = 0x871B,
+ TEXTURE_LO_SIZE_NV = 0x871C,
+ TEXTURE_DS_SIZE_NV = 0x871D,
+ TEXTURE_DT_SIZE_NV = 0x871E,
+ TEXTURE_MAG_SIZE_NV = 0x871F,
+ }
+ #endregion
+ #region public enum NV_texture_shader2
+ public enum NV_texture_shader2
+ {
+ DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF,
+ }
+ #endregion
+ #region public enum NV_vertex_array_range2
+ public enum NV_vertex_array_range2
+ {
+ VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533,
+ }
+ #endregion
+ #region public enum NV_vertex_program
+ public enum NV_vertex_program
+ {
+ VERTEX_PROGRAM_NV = 0x8620,
+ VERTEX_STATE_PROGRAM_NV = 0x8621,
+ ATTRIB_ARRAY_SIZE_NV = 0x8623,
+ ATTRIB_ARRAY_STRIDE_NV = 0x8624,
+ ATTRIB_ARRAY_TYPE_NV = 0x8625,
+ CURRENT_ATTRIB_NV = 0x8626,
+ PROGRAM_LENGTH_NV = 0x8627,
+ PROGRAM_STRING_NV = 0x8628,
+ MODELVIEW_PROJECTION_NV = 0x8629,
+ IDENTITY_NV = 0x862A,
+ INVERSE_NV = 0x862B,
+ TRANSPOSE_NV = 0x862C,
+ INVERSE_TRANSPOSE_NV = 0x862D,
+ MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E,
+ MAX_TRACK_MATRICES_NV = 0x862F,
+ MATRIX0_NV = 0x8630,
+ MATRIX1_NV = 0x8631,
+ MATRIX2_NV = 0x8632,
+ MATRIX3_NV = 0x8633,
+ MATRIX4_NV = 0x8634,
+ MATRIX5_NV = 0x8635,
+ MATRIX6_NV = 0x8636,
+ MATRIX7_NV = 0x8637,
+ CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640,
+ CURRENT_MATRIX_NV = 0x8641,
+ VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642,
+ VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643,
+ PROGRAM_PARAMETER_NV = 0x8644,
+ ATTRIB_ARRAY_POINTER_NV = 0x8645,
+ PROGRAM_TARGET_NV = 0x8646,
+ PROGRAM_RESIDENT_NV = 0x8647,
+ TRACK_MATRIX_NV = 0x8648,
+ TRACK_MATRIX_TRANSFORM_NV = 0x8649,
+ VERTEX_PROGRAM_BINDING_NV = 0x864A,
+ PROGRAM_ERROR_POSITION_NV = 0x864B,
+ VERTEX_ATTRIB_ARRAY0_NV = 0x8650,
+ VERTEX_ATTRIB_ARRAY1_NV = 0x8651,
+ VERTEX_ATTRIB_ARRAY2_NV = 0x8652,
+ VERTEX_ATTRIB_ARRAY3_NV = 0x8653,
+ VERTEX_ATTRIB_ARRAY4_NV = 0x8654,
+ VERTEX_ATTRIB_ARRAY5_NV = 0x8655,
+ VERTEX_ATTRIB_ARRAY6_NV = 0x8656,
+ VERTEX_ATTRIB_ARRAY7_NV = 0x8657,
+ VERTEX_ATTRIB_ARRAY8_NV = 0x8658,
+ VERTEX_ATTRIB_ARRAY9_NV = 0x8659,
+ VERTEX_ATTRIB_ARRAY10_NV = 0x865A,
+ VERTEX_ATTRIB_ARRAY11_NV = 0x865B,
+ VERTEX_ATTRIB_ARRAY12_NV = 0x865C,
+ VERTEX_ATTRIB_ARRAY13_NV = 0x865D,
+ VERTEX_ATTRIB_ARRAY14_NV = 0x865E,
+ VERTEX_ATTRIB_ARRAY15_NV = 0x865F,
+ MAP1_VERTEX_ATTRIB0_4_NV = 0x8660,
+ MAP1_VERTEX_ATTRIB1_4_NV = 0x8661,
+ MAP1_VERTEX_ATTRIB2_4_NV = 0x8662,
+ MAP1_VERTEX_ATTRIB3_4_NV = 0x8663,
+ MAP1_VERTEX_ATTRIB4_4_NV = 0x8664,
+ MAP1_VERTEX_ATTRIB5_4_NV = 0x8665,
+ MAP1_VERTEX_ATTRIB6_4_NV = 0x8666,
+ MAP1_VERTEX_ATTRIB7_4_NV = 0x8667,
+ MAP1_VERTEX_ATTRIB8_4_NV = 0x8668,
+ MAP1_VERTEX_ATTRIB9_4_NV = 0x8669,
+ MAP1_VERTEX_ATTRIB10_4_NV = 0x866A,
+ MAP1_VERTEX_ATTRIB11_4_NV = 0x866B,
+ MAP1_VERTEX_ATTRIB12_4_NV = 0x866C,
+ MAP1_VERTEX_ATTRIB13_4_NV = 0x866D,
+ MAP1_VERTEX_ATTRIB14_4_NV = 0x866E,
+ MAP1_VERTEX_ATTRIB15_4_NV = 0x866F,
+ MAP2_VERTEX_ATTRIB0_4_NV = 0x8670,
+ MAP2_VERTEX_ATTRIB1_4_NV = 0x8671,
+ MAP2_VERTEX_ATTRIB2_4_NV = 0x8672,
+ MAP2_VERTEX_ATTRIB3_4_NV = 0x8673,
+ MAP2_VERTEX_ATTRIB4_4_NV = 0x8674,
+ MAP2_VERTEX_ATTRIB5_4_NV = 0x8675,
+ MAP2_VERTEX_ATTRIB6_4_NV = 0x8676,
+ MAP2_VERTEX_ATTRIB7_4_NV = 0x8677,
+ MAP2_VERTEX_ATTRIB8_4_NV = 0x8678,
+ MAP2_VERTEX_ATTRIB9_4_NV = 0x8679,
+ MAP2_VERTEX_ATTRIB10_4_NV = 0x867A,
+ MAP2_VERTEX_ATTRIB11_4_NV = 0x867B,
+ MAP2_VERTEX_ATTRIB12_4_NV = 0x867C,
+ MAP2_VERTEX_ATTRIB13_4_NV = 0x867D,
+ MAP2_VERTEX_ATTRIB14_4_NV = 0x867E,
+ MAP2_VERTEX_ATTRIB15_4_NV = 0x867F,
+ }
+ #endregion
+ #region public enum SGIX_scalebias_hint
+ public enum SGIX_scalebias_hint
+ {
+ SCALEBIAS_HINT_SGIX = 0x8322,
+ }
+ #endregion
+ #region public enum OML_interlace
+ public enum OML_interlace
+ {
+ INTERLACE_OML = 0x8980,
+ INTERLACE_READ_OML = 0x8981,
+ }
+ #endregion
+ #region public enum OML_subsample
+ public enum OML_subsample
+ {
+ FORMAT_SUBSAMPLE_24_24_OML = 0x8982,
+ FORMAT_SUBSAMPLE_244_244_OML = 0x8983,
+ }
+ #endregion
+ #region public enum OML_resample
+ public enum OML_resample
+ {
+ PACK_RESAMPLE_OML = 0x8984,
+ UNPACK_RESAMPLE_OML = 0x8985,
+ RESAMPLE_REPLICATE_OML = 0x8986,
+ RESAMPLE_ZERO_FILL_OML = 0x8987,
+ RESAMPLE_AVERAGE_OML = 0x8988,
+ RESAMPLE_DECIMATE_OML = 0x8989,
+ }
+ #endregion
+ #region public enum NV_copy_depth_to_color
+ public enum NV_copy_depth_to_color
+ {
+ DEPTH_STENCIL_TO_RGBA_NV = 0x886E,
+ DEPTH_STENCIL_TO_BGRA_NV = 0x886F,
+ }
+ #endregion
+ #region public enum ATI_envmap_bumpmap
+ public enum ATI_envmap_bumpmap
+ {
+ BUMP_ROT_MATRIX_ATI = 0x8775,
+ BUMP_ROT_MATRIX_SIZE_ATI = 0x8776,
+ BUMP_NUM_TEX_UNITS_ATI = 0x8777,
+ BUMP_TEX_UNITS_ATI = 0x8778,
+ DUDV_ATI = 0x8779,
+ DU8DV8_ATI = 0x877A,
+ BUMP_ENVMAP_ATI = 0x877B,
+ BUMP_TARGET_ATI = 0x877C,
+ }
+ #endregion
+ #region public enum ATI_fragment_shader
+ public enum ATI_fragment_shader
+ {
+ FRAGMENT_SHADER_ATI = 0x8920,
+ REG_0_ATI = 0x8921,
+ REG_1_ATI = 0x8922,
+ REG_2_ATI = 0x8923,
+ REG_3_ATI = 0x8924,
+ REG_4_ATI = 0x8925,
+ REG_5_ATI = 0x8926,
+ REG_6_ATI = 0x8927,
+ REG_7_ATI = 0x8928,
+ REG_8_ATI = 0x8929,
+ REG_9_ATI = 0x892A,
+ REG_10_ATI = 0x892B,
+ REG_11_ATI = 0x892C,
+ REG_12_ATI = 0x892D,
+ REG_13_ATI = 0x892E,
+ REG_14_ATI = 0x892F,
+ REG_15_ATI = 0x8930,
+ REG_16_ATI = 0x8931,
+ REG_17_ATI = 0x8932,
+ REG_18_ATI = 0x8933,
+ REG_19_ATI = 0x8934,
+ REG_20_ATI = 0x8935,
+ REG_21_ATI = 0x8936,
+ REG_22_ATI = 0x8937,
+ REG_23_ATI = 0x8938,
+ REG_24_ATI = 0x8939,
+ REG_25_ATI = 0x893A,
+ REG_26_ATI = 0x893B,
+ REG_27_ATI = 0x893C,
+ REG_28_ATI = 0x893D,
+ REG_29_ATI = 0x893E,
+ REG_30_ATI = 0x893F,
+ REG_31_ATI = 0x8940,
+ CON_0_ATI = 0x8941,
+ CON_1_ATI = 0x8942,
+ CON_2_ATI = 0x8943,
+ CON_3_ATI = 0x8944,
+ CON_4_ATI = 0x8945,
+ CON_5_ATI = 0x8946,
+ CON_6_ATI = 0x8947,
+ CON_7_ATI = 0x8948,
+ CON_8_ATI = 0x8949,
+ CON_9_ATI = 0x894A,
+ CON_10_ATI = 0x894B,
+ CON_11_ATI = 0x894C,
+ CON_12_ATI = 0x894D,
+ CON_13_ATI = 0x894E,
+ CON_14_ATI = 0x894F,
+ CON_15_ATI = 0x8950,
+ CON_16_ATI = 0x8951,
+ CON_17_ATI = 0x8952,
+ CON_18_ATI = 0x8953,
+ CON_19_ATI = 0x8954,
+ CON_20_ATI = 0x8955,
+ CON_21_ATI = 0x8956,
+ CON_22_ATI = 0x8957,
+ CON_23_ATI = 0x8958,
+ CON_24_ATI = 0x8959,
+ CON_25_ATI = 0x895A,
+ CON_26_ATI = 0x895B,
+ CON_27_ATI = 0x895C,
+ CON_28_ATI = 0x895D,
+ CON_29_ATI = 0x895E,
+ CON_30_ATI = 0x895F,
+ CON_31_ATI = 0x8960,
+ MOV_ATI = 0x8961,
+ ADD_ATI = 0x8963,
+ MUL_ATI = 0x8964,
+ SUB_ATI = 0x8965,
+ DOT3_ATI = 0x8966,
+ DOT4_ATI = 0x8967,
+ MAD_ATI = 0x8968,
+ LERP_ATI = 0x8969,
+ CND_ATI = 0x896A,
+ CND0_ATI = 0x896B,
+ DOT2_ADD_ATI = 0x896C,
+ SECONDARY_INTERPOLATOR_ATI = 0x896D,
+ NUM_FRAGMENT_REGISTERS_ATI = 0x896E,
+ NUM_FRAGMENT_CONSTANTS_ATI = 0x896F,
+ NUM_PASSES_ATI = 0x8970,
+ NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971,
+ NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972,
+ NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973,
+ NUM_LOOPBACK_COMPONENTS_ATI = 0x8974,
+ COLOR_ALPHA_PAIRING_ATI = 0x8975,
+ SWIZZLE_STR_ATI = 0x8976,
+ SWIZZLE_STQ_ATI = 0x8977,
+ SWIZZLE_STR_DR_ATI = 0x8978,
+ SWIZZLE_STQ_DQ_ATI = 0x8979,
+ SWIZZLE_STRQ_ATI = 0x897A,
+ SWIZZLE_STRQ_DQ_ATI = 0x897B,
+ RED_BIT_ATI = 0x00000001,
+ GREEN_BIT_ATI = 0x00000002,
+ BLUE_BIT_ATI = 0x00000004,
+ _2X_BIT_ATI = 0x00000001,
+ _4X_BIT_ATI = 0x00000002,
+ _8X_BIT_ATI = 0x00000004,
+ HALF_BIT_ATI = 0x00000008,
+ QUARTER_BIT_ATI = 0x00000010,
+ EIGHTH_BIT_ATI = 0x00000020,
+ SATURATE_BIT_ATI = 0x00000040,
+ COMP_BIT_ATI = 0x00000002,
+ NEGATE_BIT_ATI = 0x00000004,
+ BIAS_BIT_ATI = 0x00000008,
+ }
+ #endregion
+ #region public enum ATI_pn_triangles
+ public enum ATI_pn_triangles
+ {
+ PN_TRIANGLES_ATI = 0x87F0,
+ MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1,
+ PN_TRIANGLES_POINT_MODE_ATI = 0x87F2,
+ PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3,
+ PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4,
+ PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5,
+ PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6,
+ PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7,
+ PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8,
+ }
+ #endregion
+ #region public enum ATI_vertex_array_object
+ public enum ATI_vertex_array_object
+ {
+ STATIC_ATI = 0x8760,
+ DYNAMIC_ATI = 0x8761,
+ PRESERVE_ATI = 0x8762,
+ DISCARD_ATI = 0x8763,
+ OBJECT_BUFFER_SIZE_ATI = 0x8764,
+ OBJECT_BUFFER_USAGE_ATI = 0x8765,
+ ARRAY_OBJECT_BUFFER_ATI = 0x8766,
+ ARRAY_OBJECT_OFFSET_ATI = 0x8767,
+ }
+ #endregion
+ #region public enum EXT_vertex_shader
+ public enum EXT_vertex_shader
+ {
+ VERTEX_SHADER_EXT = 0x8780,
+ VERTEX_SHADER_BINDING_EXT = 0x8781,
+ OP_INDEX_EXT = 0x8782,
+ OP_NEGATE_EXT = 0x8783,
+ OP_DOT3_EXT = 0x8784,
+ OP_DOT4_EXT = 0x8785,
+ OP_MUL_EXT = 0x8786,
+ OP_ADD_EXT = 0x8787,
+ OP_MADD_EXT = 0x8788,
+ OP_FRAC_EXT = 0x8789,
+ OP_MAX_EXT = 0x878A,
+ OP_MIN_EXT = 0x878B,
+ OP_SET_GE_EXT = 0x878C,
+ OP_SET_LT_EXT = 0x878D,
+ OP_CLAMP_EXT = 0x878E,
+ OP_FLOOR_EXT = 0x878F,
+ OP_ROUND_EXT = 0x8790,
+ OP_EXP_BASE_2_EXT = 0x8791,
+ OP_LOG_BASE_2_EXT = 0x8792,
+ OP_POWER_EXT = 0x8793,
+ OP_RECIP_EXT = 0x8794,
+ OP_RECIP_SQRT_EXT = 0x8795,
+ OP_SUB_EXT = 0x8796,
+ OP_CROSS_PRODUCT_EXT = 0x8797,
+ OP_MULTIPLY_MATRIX_EXT = 0x8798,
+ OP_MOV_EXT = 0x8799,
+ OUTPUT_VERTEX_EXT = 0x879A,
+ OUTPUT_COLOR0_EXT = 0x879B,
+ OUTPUT_COLOR1_EXT = 0x879C,
+ OUTPUT_TEXTURE_COORD0_EXT = 0x879D,
+ OUTPUT_TEXTURE_COORD1_EXT = 0x879E,
+ OUTPUT_TEXTURE_COORD2_EXT = 0x879F,
+ OUTPUT_TEXTURE_COORD3_EXT = 0x87A0,
+ OUTPUT_TEXTURE_COORD4_EXT = 0x87A1,
+ OUTPUT_TEXTURE_COORD5_EXT = 0x87A2,
+ OUTPUT_TEXTURE_COORD6_EXT = 0x87A3,
+ OUTPUT_TEXTURE_COORD7_EXT = 0x87A4,
+ OUTPUT_TEXTURE_COORD8_EXT = 0x87A5,
+ OUTPUT_TEXTURE_COORD9_EXT = 0x87A6,
+ OUTPUT_TEXTURE_COORD10_EXT = 0x87A7,
+ OUTPUT_TEXTURE_COORD11_EXT = 0x87A8,
+ OUTPUT_TEXTURE_COORD12_EXT = 0x87A9,
+ OUTPUT_TEXTURE_COORD13_EXT = 0x87AA,
+ OUTPUT_TEXTURE_COORD14_EXT = 0x87AB,
+ OUTPUT_TEXTURE_COORD15_EXT = 0x87AC,
+ OUTPUT_TEXTURE_COORD16_EXT = 0x87AD,
+ OUTPUT_TEXTURE_COORD17_EXT = 0x87AE,
+ OUTPUT_TEXTURE_COORD18_EXT = 0x87AF,
+ OUTPUT_TEXTURE_COORD19_EXT = 0x87B0,
+ OUTPUT_TEXTURE_COORD20_EXT = 0x87B1,
+ OUTPUT_TEXTURE_COORD21_EXT = 0x87B2,
+ OUTPUT_TEXTURE_COORD22_EXT = 0x87B3,
+ OUTPUT_TEXTURE_COORD23_EXT = 0x87B4,
+ OUTPUT_TEXTURE_COORD24_EXT = 0x87B5,
+ OUTPUT_TEXTURE_COORD25_EXT = 0x87B6,
+ OUTPUT_TEXTURE_COORD26_EXT = 0x87B7,
+ OUTPUT_TEXTURE_COORD27_EXT = 0x87B8,
+ OUTPUT_TEXTURE_COORD28_EXT = 0x87B9,
+ OUTPUT_TEXTURE_COORD29_EXT = 0x87BA,
+ OUTPUT_TEXTURE_COORD30_EXT = 0x87BB,
+ OUTPUT_TEXTURE_COORD31_EXT = 0x87BC,
+ OUTPUT_FOG_EXT = 0x87BD,
+ SCALAR_EXT = 0x87BE,
+ VECTOR_EXT = 0x87BF,
+ MATRIX_EXT = 0x87C0,
+ VARIANT_EXT = 0x87C1,
+ INVARIANT_EXT = 0x87C2,
+ LOCAL_CONSTANT_EXT = 0x87C3,
+ LOCAL_EXT = 0x87C4,
+ MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5,
+ MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6,
+ MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7,
+ MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8,
+ MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9,
+ MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA,
+ MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB,
+ MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC,
+ MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD,
+ MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE,
+ VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF,
+ VERTEX_SHADER_VARIANTS_EXT = 0x87D0,
+ VERTEX_SHADER_INVARIANTS_EXT = 0x87D1,
+ VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2,
+ VERTEX_SHADER_LOCALS_EXT = 0x87D3,
+ VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4,
+ X_EXT = 0x87D5,
+ Y_EXT = 0x87D6,
+ Z_EXT = 0x87D7,
+ W_EXT = 0x87D8,
+ NEGATIVE_X_EXT = 0x87D9,
+ NEGATIVE_Y_EXT = 0x87DA,
+ NEGATIVE_Z_EXT = 0x87DB,
+ NEGATIVE_W_EXT = 0x87DC,
+ ZERO_EXT = 0x87DD,
+ ONE_EXT = 0x87DE,
+ NEGATIVE_ONE_EXT = 0x87DF,
+ NORMALIZED_RANGE_EXT = 0x87E0,
+ FULL_RANGE_EXT = 0x87E1,
+ CURRENT_VERTEX_EXT = 0x87E2,
+ MVP_MATRIX_EXT = 0x87E3,
+ VARIANT_VALUE_EXT = 0x87E4,
+ VARIANT_DATATYPE_EXT = 0x87E5,
+ VARIANT_ARRAY_STRIDE_EXT = 0x87E6,
+ VARIANT_ARRAY_TYPE_EXT = 0x87E7,
+ VARIANT_ARRAY_EXT = 0x87E8,
+ VARIANT_ARRAY_POINTER_EXT = 0x87E9,
+ INVARIANT_VALUE_EXT = 0x87EA,
+ INVARIANT_DATATYPE_EXT = 0x87EB,
+ LOCAL_CONSTANT_VALUE_EXT = 0x87EC,
+ LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED,
+ }
+ #endregion
+ #region public enum ATI_vertex_streams
+ public enum ATI_vertex_streams
+ {
+ MAX_VERTEX_STREAMS_ATI = 0x876B,
+ VERTEX_STREAM0_ATI = 0x876C,
+ VERTEX_STREAM1_ATI = 0x876D,
+ VERTEX_STREAM2_ATI = 0x876E,
+ VERTEX_STREAM3_ATI = 0x876F,
+ VERTEX_STREAM4_ATI = 0x8770,
+ VERTEX_STREAM5_ATI = 0x8771,
+ VERTEX_STREAM6_ATI = 0x8772,
+ VERTEX_STREAM7_ATI = 0x8773,
+ VERTEX_SOURCE_ATI = 0x8774,
+ }
+ #endregion
+ #region public enum ATI_element_array
+ public enum ATI_element_array
+ {
+ ELEMENT_ARRAY_ATI = 0x8768,
+ ELEMENT_ARRAY_TYPE_ATI = 0x8769,
+ ELEMENT_ARRAY_POINTER_ATI = 0x876A,
+ }
+ #endregion
+ #region public enum SUN_mesh_array
+ public enum SUN_mesh_array
+ {
+ QUAD_MESH_SUN = 0x8614,
+ TRIANGLE_MESH_SUN = 0x8615,
+ }
+ #endregion
+ #region public enum SUN_slice_accum
+ public enum SUN_slice_accum
+ {
+ SLICE_ACCUM_SUN = 0x85CC,
+ }
+ #endregion
+ #region public enum NV_multisample_filter_hint
+ public enum NV_multisample_filter_hint
+ {
+ MULTISAMPLE_FILTER_HINT_NV = 0x8534,
+ }
+ #endregion
+ #region public enum NV_depth_clamp
+ public enum NV_depth_clamp
+ {
+ DEPTH_CLAMP_NV = 0x864F,
+ }
+ #endregion
+ #region public enum NV_occlusion_query
+ public enum NV_occlusion_query
+ {
+ PIXEL_COUNTER_BITS_NV = 0x8864,
+ CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865,
+ PIXEL_COUNT_NV = 0x8866,
+ PIXEL_COUNT_AVAILABLE_NV = 0x8867,
+ }
+ #endregion
+ #region public enum NV_point_sprite
+ public enum NV_point_sprite
+ {
+ POINT_SPRITE_NV = 0x8861,
+ COORD_REPLACE_NV = 0x8862,
+ POINT_SPRITE_R_MODE_NV = 0x8863,
+ }
+ #endregion
+ #region public enum NV_texture_shader3
+ public enum NV_texture_shader3
+ {
+ OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850,
+ OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851,
+ OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852,
+ OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853,
+ OFFSET_HILO_TEXTURE_2D_NV = 0x8854,
+ OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855,
+ OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856,
+ OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857,
+ DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858,
+ DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859,
+ DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A,
+ DOT_PRODUCT_PASS_THROUGH_NV = 0x885B,
+ DOT_PRODUCT_TEXTURE_1D_NV = 0x885C,
+ DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D,
+ HILO8_NV = 0x885E,
+ SIGNED_HILO8_NV = 0x885F,
+ FORCE_BLUE_TO_ONE_NV = 0x8860,
+ }
+ #endregion
+ #region public enum NV_vertex_program1_1
+ public enum NV_vertex_program1_1
+ {
+ }
+ #endregion
+ #region public enum EXT_shadow_funcs
+ public enum EXT_shadow_funcs
+ {
+ }
+ #endregion
+ #region public enum EXT_stencil_two_side
+ public enum EXT_stencil_two_side
+ {
+ STENCIL_TEST_TWO_SIDE_EXT = 0x8910,
+ ACTIVE_STENCIL_FACE_EXT = 0x8911,
+ }
+ #endregion
+ #region public enum ATI_text_fragment_shader
+ public enum ATI_text_fragment_shader
+ {
+ TEXT_FRAGMENT_SHADER_ATI = 0x8200,
+ }
+ #endregion
+ #region public enum APPLE_client_storage
+ public enum APPLE_client_storage
+ {
+ UNPACK_CLIENT_STORAGE_APPLE = 0x85B2,
+ }
+ #endregion
+ #region public enum APPLE_element_array
+ public enum APPLE_element_array
+ {
+ ELEMENT_ARRAY_APPLE = 0x8768,
+ ELEMENT_ARRAY_TYPE_APPLE = 0x8769,
+ ELEMENT_ARRAY_POINTER_APPLE = 0x876A,
+ }
+ #endregion
+ #region public enum APPLE_fence
+ public enum APPLE_fence
+ {
+ DRAW_PIXELS_APPLE = 0x8A0A,
+ FENCE_APPLE = 0x8A0B,
+ }
+ #endregion
+ #region public enum APPLE_vertex_array_object
+ public enum APPLE_vertex_array_object
+ {
+ VERTEX_ARRAY_BINDING_APPLE = 0x85B5,
+ }
+ #endregion
+ #region public enum APPLE_vertex_array_range
+ public enum APPLE_vertex_array_range
+ {
+ VERTEX_ARRAY_RANGE_APPLE = 0x851D,
+ VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E,
+ VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F,
+ VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521,
+ STORAGE_CACHED_APPLE = 0x85BE,
+ STORAGE_SHARED_APPLE = 0x85BF,
+ }
+ #endregion
+ #region public enum APPLE_ycbcr_422
+ public enum APPLE_ycbcr_422
+ {
+ YCBCR_422_APPLE = 0x85B9,
+ UNSIGNED_SHORT_8_8_APPLE = 0x85BA,
+ UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB,
+ }
+ #endregion
+ #region public enum S3_s3tc
+ public enum S3_s3tc
+ {
+ RGB_S3TC = 0x83A0,
+ RGB4_S3TC = 0x83A1,
+ RGBA_S3TC = 0x83A2,
+ RGBA4_S3TC = 0x83A3,
+ }
+ #endregion
+ #region public enum ATI_draw_buffers
+ public enum ATI_draw_buffers
+ {
+ MAX_DRAW_BUFFERS_ATI = 0x8824,
+ DRAW_BUFFER0_ATI = 0x8825,
+ DRAW_BUFFER1_ATI = 0x8826,
+ DRAW_BUFFER2_ATI = 0x8827,
+ DRAW_BUFFER3_ATI = 0x8828,
+ DRAW_BUFFER4_ATI = 0x8829,
+ DRAW_BUFFER5_ATI = 0x882A,
+ DRAW_BUFFER6_ATI = 0x882B,
+ DRAW_BUFFER7_ATI = 0x882C,
+ DRAW_BUFFER8_ATI = 0x882D,
+ DRAW_BUFFER9_ATI = 0x882E,
+ DRAW_BUFFER10_ATI = 0x882F,
+ DRAW_BUFFER11_ATI = 0x8830,
+ DRAW_BUFFER12_ATI = 0x8831,
+ DRAW_BUFFER13_ATI = 0x8832,
+ DRAW_BUFFER14_ATI = 0x8833,
+ DRAW_BUFFER15_ATI = 0x8834,
+ }
+ #endregion
+ #region public enum ATI_pixel_format_float
+ public enum ATI_pixel_format_float
+ {
+ TYPE_RGBA_FLOAT_ATI = 0x8820,
+ COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835,
+ }
+ #endregion
+ #region public enum ATI_texture_env_combine3
+ public enum ATI_texture_env_combine3
+ {
+ MODULATE_ADD_ATI = 0x8744,
+ MODULATE_SIGNED_ADD_ATI = 0x8745,
+ MODULATE_SUBTRACT_ATI = 0x8746,
+ }
+ #endregion
+ #region public enum ATI_texture_float
+ public enum ATI_texture_float
+ {
+ RGBA_FLOAT32_ATI = 0x8814,
+ RGB_FLOAT32_ATI = 0x8815,
+ ALPHA_FLOAT32_ATI = 0x8816,
+ INTENSITY_FLOAT32_ATI = 0x8817,
+ LUMINANCE_FLOAT32_ATI = 0x8818,
+ LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819,
+ RGBA_FLOAT16_ATI = 0x881A,
+ RGB_FLOAT16_ATI = 0x881B,
+ ALPHA_FLOAT16_ATI = 0x881C,
+ INTENSITY_FLOAT16_ATI = 0x881D,
+ LUMINANCE_FLOAT16_ATI = 0x881E,
+ LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F,
+ }
+ #endregion
+ #region public enum NV_float_buffer
+ public enum NV_float_buffer
+ {
+ FLOAT_R_NV = 0x8880,
+ FLOAT_RG_NV = 0x8881,
+ FLOAT_RGB_NV = 0x8882,
+ FLOAT_RGBA_NV = 0x8883,
+ FLOAT_R16_NV = 0x8884,
+ FLOAT_R32_NV = 0x8885,
+ FLOAT_RG16_NV = 0x8886,
+ FLOAT_RG32_NV = 0x8887,
+ FLOAT_RGB16_NV = 0x8888,
+ FLOAT_RGB32_NV = 0x8889,
+ FLOAT_RGBA16_NV = 0x888A,
+ FLOAT_RGBA32_NV = 0x888B,
+ TEXTURE_FLOAT_COMPONENTS_NV = 0x888C,
+ FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D,
+ FLOAT_RGBA_MODE_NV = 0x888E,
+ }
+ #endregion
+ #region public enum NV_fragment_program
+ public enum NV_fragment_program
+ {
+ MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868,
+ FRAGMENT_PROGRAM_NV = 0x8870,
+ MAX_TEXTURE_COORDS_NV = 0x8871,
+ MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872,
+ FRAGMENT_PROGRAM_BINDING_NV = 0x8873,
+ PROGRAM_ERROR_STRING_NV = 0x8874,
+ }
+ #endregion
+ #region public enum NV_half_float
+ public enum NV_half_float
+ {
+ HALF_FLOAT_NV = 0x140B,
+ }
+ #endregion
+ #region public enum NV_pixel_data_range
+ public enum NV_pixel_data_range
+ {
+ WRITE_PIXEL_DATA_RANGE_NV = 0x8878,
+ READ_PIXEL_DATA_RANGE_NV = 0x8879,
+ WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A,
+ READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B,
+ WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C,
+ READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D,
+ }
+ #endregion
+ #region public enum NV_primitive_restart
+ public enum NV_primitive_restart
+ {
+ PRIMITIVE_RESTART_NV = 0x8558,
+ PRIMITIVE_RESTART_INDEX_NV = 0x8559,
+ }
+ #endregion
+ #region public enum NV_texture_expand_normal
+ public enum NV_texture_expand_normal
+ {
+ TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F,
+ }
+ #endregion
+ #region public enum NV_vertex_program2
+ public enum NV_vertex_program2
+ {
+ }
+ #endregion
+ #region public enum ATI_map_object_buffer
+ public enum ATI_map_object_buffer
+ {
+ }
+ #endregion
+ #region public enum ATI_separate_stencil
+ public enum ATI_separate_stencil
+ {
+ STENCIL_BACK_FUNC_ATI = 0x8800,
+ STENCIL_BACK_FAIL_ATI = 0x8801,
+ STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802,
+ STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803,
+ }
+ #endregion
+ #region public enum ATI_vertex_attrib_array_object
+ public enum ATI_vertex_attrib_array_object
+ {
+ }
+ #endregion
+ #region public enum OES_read_format
+ public enum OES_read_format
+ {
+ IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A,
+ IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B,
+ }
+ #endregion
+ #region public enum EXT_depth_bounds_test
+ public enum EXT_depth_bounds_test
+ {
+ DEPTH_BOUNDS_TEST_EXT = 0x8890,
+ DEPTH_BOUNDS_EXT = 0x8891,
+ }
+ #endregion
+ #region public enum EXT_texture_mirror_clamp
+ public enum EXT_texture_mirror_clamp
+ {
+ MIRROR_CLAMP_EXT = 0x8742,
+ MIRROR_CLAMP_TO_EDGE_EXT = 0x8743,
+ MIRROR_CLAMP_TO_BORDER_EXT = 0x8912,
+ }
+ #endregion
+ #region public enum EXT_blend_equation_separate
+ public enum EXT_blend_equation_separate
+ {
+ BLEND_EQUATION_RGB_EXT = ARB_imaging.BLEND_EQUATION,
+ BLEND_EQUATION_ALPHA_EXT = 0x883D,
+ }
+ #endregion
+ #region public enum MESA_pack_invert
+ public enum MESA_pack_invert
+ {
+ PACK_INVERT_MESA = 0x8758,
+ }
+ #endregion
+ #region public enum MESA_ycbcr_texture
+ public enum MESA_ycbcr_texture
+ {
+ UNSIGNED_SHORT_8_8_MESA = 0x85BA,
+ UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB,
+ YCBCR_MESA = 0x8757,
+ }
+ #endregion
+ #region public enum EXT_pixel_buffer_object
+ public enum EXT_pixel_buffer_object
+ {
+ PIXEL_PACK_BUFFER_EXT = 0x88EB,
+ PIXEL_UNPACK_BUFFER_EXT = 0x88EC,
+ PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED,
+ PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF,
+ }
+ #endregion
+ #region public enum NV_fragment_program_option
+ public enum NV_fragment_program_option
+ {
+ }
+ #endregion
+ #region public enum NV_fragment_program2
+ public enum NV_fragment_program2
+ {
+ MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4,
+ MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5,
+ MAX_PROGRAM_IF_DEPTH_NV = 0x88F6,
+ MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7,
+ MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8,
+ }
+ #endregion
+ #region public enum NV_vertex_program2_option
+ public enum NV_vertex_program2_option
+ {
+ MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = NV_fragment_program2.MAX_PROGRAM_EXEC_INSTRUCTIONS_NV,
+ MAX_PROGRAM_CALL_DEPTH_NV = NV_fragment_program2.MAX_PROGRAM_CALL_DEPTH_NV,
+ }
+ #endregion
+ #region public enum NV_vertex_program3
+ public enum NV_vertex_program3
+ {
+ MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = ARB_vertex_shader.MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB,
+ }
+ #endregion
+ #region public enum EXT_framebuffer_object
+ public enum EXT_framebuffer_object
+ {
+ INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506,
+ MAX_RENDERBUFFER_SIZE_EXT = 0x84E8,
+ FRAMEBUFFER_BINDING_EXT = 0x8CA6,
+ RENDERBUFFER_BINDING_EXT = 0x8CA7,
+ FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0,
+ FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4,
+ FRAMEBUFFER_COMPLETE_EXT = 0x8CD5,
+ FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6,
+ FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7,
+ FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9,
+ FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA,
+ FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB,
+ FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC,
+ FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD,
+ MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF,
+ COLOR_ATTACHMENT0_EXT = 0x8CE0,
+ COLOR_ATTACHMENT1_EXT = 0x8CE1,
+ COLOR_ATTACHMENT2_EXT = 0x8CE2,
+ COLOR_ATTACHMENT3_EXT = 0x8CE3,
+ COLOR_ATTACHMENT4_EXT = 0x8CE4,
+ COLOR_ATTACHMENT5_EXT = 0x8CE5,
+ COLOR_ATTACHMENT6_EXT = 0x8CE6,
+ COLOR_ATTACHMENT7_EXT = 0x8CE7,
+ COLOR_ATTACHMENT8_EXT = 0x8CE8,
+ COLOR_ATTACHMENT9_EXT = 0x8CE9,
+ COLOR_ATTACHMENT10_EXT = 0x8CEA,
+ COLOR_ATTACHMENT11_EXT = 0x8CEB,
+ COLOR_ATTACHMENT12_EXT = 0x8CEC,
+ COLOR_ATTACHMENT13_EXT = 0x8CED,
+ COLOR_ATTACHMENT14_EXT = 0x8CEE,
+ COLOR_ATTACHMENT15_EXT = 0x8CEF,
+ DEPTH_ATTACHMENT_EXT = 0x8D00,
+ STENCIL_ATTACHMENT_EXT = 0x8D20,
+ FRAMEBUFFER_EXT = 0x8D40,
+ RENDERBUFFER_EXT = 0x8D41,
+ RENDERBUFFER_WIDTH_EXT = 0x8D42,
+ RENDERBUFFER_HEIGHT_EXT = 0x8D43,
+ RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44,
+ STENCIL_INDEX1_EXT = 0x8D46,
+ STENCIL_INDEX4_EXT = 0x8D47,
+ STENCIL_INDEX8_EXT = 0x8D48,
+ STENCIL_INDEX16_EXT = 0x8D49,
+ RENDERBUFFER_RED_SIZE_EXT = 0x8D50,
+ RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51,
+ RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52,
+ RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53,
+ RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54,
+ RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55,
+ }
+ #endregion
+ #region public enum GREMEDY_string_marker
+ public enum GREMEDY_string_marker
+ {
+ }
+ #endregion
+ #region public enum EXT_packed_depth_stencil
+ public enum EXT_packed_depth_stencil
+ {
+ DEPTH_STENCIL_EXT = 0x84F9,
+ UNSIGNED_INT_24_8_EXT = 0x84FA,
+ DEPTH24_STENCIL8_EXT = 0x88F0,
+ TEXTURE_STENCIL_SIZE_EXT = 0x88F1,
+ }
+ #endregion
+ #region public enum EXT_stencil_clear_tag
+ public enum EXT_stencil_clear_tag
+ {
+ STENCIL_TAG_BITS_EXT = 0x88F2,
+ STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3,
+ }
+ #endregion
+ #region public enum EXT_texture_sRGB
+ public enum EXT_texture_sRGB
+ {
+ SRGB_EXT = 0x8C40,
+ SRGB8_EXT = 0x8C41,
+ SRGB_ALPHA_EXT = 0x8C42,
+ SRGB8_ALPHA8_EXT = 0x8C43,
+ SLUMINANCE_ALPHA_EXT = 0x8C44,
+ SLUMINANCE8_ALPHA8_EXT = 0x8C45,
+ SLUMINANCE_EXT = 0x8C46,
+ SLUMINANCE8_EXT = 0x8C47,
+ COMPRESSED_SRGB_EXT = 0x8C48,
+ COMPRESSED_SRGB_ALPHA_EXT = 0x8C49,
+ COMPRESSED_SLUMINANCE_EXT = 0x8C4A,
+ COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B,
+ COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C,
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D,
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E,
+ COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F,
+ }
+ #endregion
+ #region public enum EXT_framebuffer_blit
+ public enum EXT_framebuffer_blit
+ {
+ READ_FRAMEBUFFER_EXT = 0x8CA8,
+ DRAW_FRAMEBUFFER_EXT = 0x8CA9,
+ READ_FRAMEBUFFER_BINDING_EXT = EXT_framebuffer_object.FRAMEBUFFER_BINDING_EXT,
+ DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CAA,
+ }
+ #endregion
+ #region public enum EXT_framebuffer_multisample
+ public enum EXT_framebuffer_multisample
+ {
+ RENDERBUFFER_SAMPLES_EXT = 0x8CAB,
+ FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56,
+ MAX_SAMPLES_EXT = 0x8D57,
+ }
+ #endregion
+ #region public enum MESAX_texture_stack
+ public enum MESAX_texture_stack
+ {
+ TEXTURE_1D_STACK_MESAX = 0x8759,
+ TEXTURE_2D_STACK_MESAX = 0x875A,
+ PROXY_TEXTURE_1D_STACK_MESAX = 0x875B,
+ PROXY_TEXTURE_2D_STACK_MESAX = 0x875C,
+ TEXTURE_1D_STACK_BINDING_MESAX = 0x875D,
+ TEXTURE_2D_STACK_BINDING_MESAX = 0x875E,
+ }
+ #endregion
+ #region public enum EXT_timer_query
+ public enum EXT_timer_query
+ {
+ TIME_ELAPSED_EXT = 0x88BF,
+ }
+ #endregion
+ #region public enum EXT_gpu_program_parameters
+ public enum EXT_gpu_program_parameters
+ {
+ }
+ #endregion
+ #region public enum APPLE_flush_buffer_range
+ public enum APPLE_flush_buffer_range
+ {
+ BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12,
+ BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13,
+ }
+ #endregion
+ #region public enum NV_gpu_program4
+ public enum NV_gpu_program4
+ {
+ MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904,
+ MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905,
+ PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906,
+ PROGRAM_RESULT_COMPONENTS_NV = 0x8907,
+ MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908,
+ MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909,
+ MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5,
+ MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6,
+ }
+ #endregion
+ #region public enum NV_geometry_program4
+ public enum NV_geometry_program4
+ {
+ LINES_ADJACENCY_EXT = 0x000A,
+ LINE_STRIP_ADJACENCY_EXT = 0x000B,
+ TRIANGLES_ADJACENCY_EXT = 0x000C,
+ TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D,
+ GEOMETRY_PROGRAM_NV = 0x8C26,
+ MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27,
+ MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28,
+ GEOMETRY_VERTICES_OUT_EXT = 0x8DDA,
+ GEOMETRY_INPUT_TYPE_EXT = 0x8DDB,
+ GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC,
+ MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29,
+ FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7,
+ FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8,
+ FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4,
+ PROGRAM_POINT_SIZE_EXT = 0x8642,
+ }
+ #endregion
+ #region public enum EXT_geometry_shader4
+ public enum EXT_geometry_shader4
+ {
+ GEOMETRY_SHADER_EXT = 0x8DD9,
+ GEOMETRY_VERTICES_OUT_EXT = NV_geometry_program4.GEOMETRY_VERTICES_OUT_EXT,
+ GEOMETRY_INPUT_TYPE_EXT = NV_geometry_program4.GEOMETRY_INPUT_TYPE_EXT,
+ GEOMETRY_OUTPUT_TYPE_EXT = NV_geometry_program4.GEOMETRY_OUTPUT_TYPE_EXT,
+ MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = NV_geometry_program4.MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT,
+ MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD,
+ MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE,
+ MAX_VARYING_COMPONENTS_EXT = 0x8B4B,
+ MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF,
+ MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0,
+ MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1,
+ LINES_ADJACENCY_EXT = NV_geometry_program4.LINES_ADJACENCY_EXT,
+ LINE_STRIP_ADJACENCY_EXT = NV_geometry_program4.LINE_STRIP_ADJACENCY_EXT,
+ TRIANGLES_ADJACENCY_EXT = NV_geometry_program4.TRIANGLES_ADJACENCY_EXT,
+ TRIANGLE_STRIP_ADJACENCY_EXT = NV_geometry_program4.TRIANGLE_STRIP_ADJACENCY_EXT,
+ FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = NV_geometry_program4.FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT,
+ FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = NV_geometry_program4.FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT,
+ FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = NV_geometry_program4.FRAMEBUFFER_ATTACHMENT_LAYERED_EXT,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = NV_geometry_program4.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT,
+ PROGRAM_POINT_SIZE_EXT = NV_geometry_program4.PROGRAM_POINT_SIZE_EXT,
+ }
+ #endregion
+ #region public enum NV_vertex_program4
+ public enum NV_vertex_program4
+ {
+ VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD,
+ }
+ #endregion
+ #region public enum EXT_gpu_shader4
+ public enum EXT_gpu_shader4
+ {
+ SAMPLER_1D_ARRAY_EXT = 0x8DC0,
+ SAMPLER_2D_ARRAY_EXT = 0x8DC1,
+ SAMPLER_BUFFER_EXT = 0x8DC2,
+ SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3,
+ SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4,
+ SAMPLER_CUBE_SHADOW_EXT = 0x8DC5,
+ UNSIGNED_INT_VEC2_EXT = 0x8DC6,
+ UNSIGNED_INT_VEC3_EXT = 0x8DC7,
+ UNSIGNED_INT_VEC4_EXT = 0x8DC8,
+ INT_SAMPLER_1D_EXT = 0x8DC9,
+ INT_SAMPLER_2D_EXT = 0x8DCA,
+ INT_SAMPLER_3D_EXT = 0x8DCB,
+ INT_SAMPLER_CUBE_EXT = 0x8DCC,
+ INT_SAMPLER_2D_RECT_EXT = 0x8DCD,
+ INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE,
+ INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF,
+ INT_SAMPLER_BUFFER_EXT = 0x8DD0,
+ UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1,
+ UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2,
+ UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3,
+ UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4,
+ UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5,
+ UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6,
+ UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7,
+ UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8,
+ }
+ #endregion
+ #region public enum EXT_draw_instanced
+ public enum EXT_draw_instanced
+ {
+ }
+ #endregion
+ #region public enum EXT_packed_float
+ public enum EXT_packed_float
+ {
+ R11F_G11F_B10F_EXT = 0x8C3A,
+ UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B,
+ RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C,
+ }
+ #endregion
+ #region public enum EXT_texture_array
+ public enum EXT_texture_array
+ {
+ TEXTURE_1D_ARRAY_EXT = 0x8C18,
+ PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19,
+ TEXTURE_2D_ARRAY_EXT = 0x8C1A,
+ PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B,
+ TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C,
+ TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D,
+ MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF,
+ COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E,
+ FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = NV_geometry_program4.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT,
+ }
+ #endregion
+ #region public enum EXT_texture_buffer_object
+ public enum EXT_texture_buffer_object
+ {
+ TEXTURE_BUFFER_EXT = 0x8C2A,
+ MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B,
+ TEXTURE_BINDING_BUFFER_EXT = 0x8C2C,
+ TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D,
+ TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E,
+ }
+ #endregion
+ #region public enum EXT_texture_compression_latc
+ public enum EXT_texture_compression_latc
+ {
+ COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70,
+ COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71,
+ COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72,
+ COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73,
+ }
+ #endregion
+ #region public enum EXT_texture_compression_rgtc
+ public enum EXT_texture_compression_rgtc
+ {
+ COMPRESSED_RED_RGTC1_EXT = 0x8DBB,
+ COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC,
+ COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD,
+ COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE,
+ }
+ #endregion
+ #region public enum EXT_texture_shared_exponent
+ public enum EXT_texture_shared_exponent
+ {
+ RGB9_E5_EXT = 0x8C3D,
+ UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E,
+ TEXTURE_SHARED_SIZE_EXT = 0x8C3F,
+ }
+ #endregion
+ #region public enum NV_depth_buffer_float
+ public enum NV_depth_buffer_float
+ {
+ DEPTH_COMPONENT32F_NV = 0x8DAB,
+ DEPTH32F_STENCIL8_NV = 0x8DAC,
+ FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD,
+ DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF,
+ }
+ #endregion
+ #region public enum NV_fragment_program4
+ public enum NV_fragment_program4
+ {
+ }
+ #endregion
+ #region public enum NV_framebuffer_multisample_coverage
+ public enum NV_framebuffer_multisample_coverage
+ {
+ RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB,
+ RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10,
+ MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11,
+ MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12,
+ }
+ #endregion
+ #region public enum EXT_framebuffer_sRGB
+ public enum EXT_framebuffer_sRGB
+ {
+ FRAMEBUFFER_SRGB_EXT = 0x8DB9,
+ FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA,
+ }
+ #endregion
+ #region public enum NV_geometry_shader4
+ public enum NV_geometry_shader4
+ {
+ }
+ #endregion
+ #region public enum NV_parameter_buffer_object
+ public enum NV_parameter_buffer_object
+ {
+ MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0,
+ MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1,
+ VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2,
+ GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3,
+ FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4,
+ }
+ #endregion
+ #region public enum EXT_draw_buffers2
+ public enum EXT_draw_buffers2
+ {
+ }
+ #endregion
+ #region public enum NV_transform_feedback
+ public enum NV_transform_feedback
+ {
+ BACK_PRIMARY_COLOR_NV = 0x8C77,
+ BACK_SECONDARY_COLOR_NV = 0x8C78,
+ TEXTURE_COORD_NV = 0x8C79,
+ CLIP_DISTANCE_NV = 0x8C7A,
+ VERTEX_ID_NV = 0x8C7B,
+ PRIMITIVE_ID_NV = 0x8C7C,
+ GENERIC_ATTRIB_NV = 0x8C7D,
+ TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E,
+ TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F,
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80,
+ ACTIVE_VARYINGS_NV = 0x8C81,
+ ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82,
+ TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83,
+ TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84,
+ TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85,
+ TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86,
+ PRIMITIVES_GENERATED_NV = 0x8C87,
+ TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88,
+ RASTERIZER_DISCARD_NV = 0x8C89,
+ MAX_TRANSFORM_FEEDBACK_INTERLEAVED_ATTRIBS_NV = 0x8C8A,
+ MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B,
+ INTERLEAVED_ATTRIBS_NV = 0x8C8C,
+ SEPARATE_ATTRIBS_NV = 0x8C8D,
+ TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E,
+ TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F,
+ }
+ #endregion
+ #region public enum EXT_bindable_uniform
+ public enum EXT_bindable_uniform
+ {
+ MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2,
+ MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3,
+ MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4,
+ MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED,
+ UNIFORM_BUFFER_EXT = 0x8DEE,
+ UNIFORM_BUFFER_BINDING_EXT = 0x8DEF,
+ }
+ #endregion
+ #region public enum EXT_texture_integer
+ public enum EXT_texture_integer
+ {
+ RGBA32UI_EXT = 0x8D70,
+ RGB32UI_EXT = 0x8D71,
+ ALPHA32UI_EXT = 0x8D72,
+ INTENSITY32UI_EXT = 0x8D73,
+ LUMINANCE32UI_EXT = 0x8D74,
+ LUMINANCE_ALPHA32UI_EXT = 0x8D75,
+ RGBA16UI_EXT = 0x8D76,
+ RGB16UI_EXT = 0x8D77,
+ ALPHA16UI_EXT = 0x8D78,
+ INTENSITY16UI_EXT = 0x8D79,
+ LUMINANCE16UI_EXT = 0x8D7A,
+ LUMINANCE_ALPHA16UI_EXT = 0x8D7B,
+ RGBA8UI_EXT = 0x8D7C,
+ RGB8UI_EXT = 0x8D7D,
+ ALPHA8UI_EXT = 0x8D7E,
+ INTENSITY8UI_EXT = 0x8D7F,
+ LUMINANCE8UI_EXT = 0x8D80,
+ LUMINANCE_ALPHA8UI_EXT = 0x8D81,
+ RGBA32I_EXT = 0x8D82,
+ RGB32I_EXT = 0x8D83,
+ ALPHA32I_EXT = 0x8D84,
+ INTENSITY32I_EXT = 0x8D85,
+ LUMINANCE32I_EXT = 0x8D86,
+ LUMINANCE_ALPHA32I_EXT = 0x8D87,
+ RGBA16I_EXT = 0x8D88,
+ RGB16I_EXT = 0x8D89,
+ ALPHA16I_EXT = 0x8D8A,
+ INTENSITY16I_EXT = 0x8D8B,
+ LUMINANCE16I_EXT = 0x8D8C,
+ LUMINANCE_ALPHA16I_EXT = 0x8D8D,
+ RGBA8I_EXT = 0x8D8E,
+ RGB8I_EXT = 0x8D8F,
+ ALPHA8I_EXT = 0x8D90,
+ INTENSITY8I_EXT = 0x8D91,
+ LUMINANCE8I_EXT = 0x8D92,
+ LUMINANCE_ALPHA8I_EXT = 0x8D93,
+ RED_INTEGER_EXT = 0x8D94,
+ GREEN_INTEGER_EXT = 0x8D95,
+ BLUE_INTEGER_EXT = 0x8D96,
+ ALPHA_INTEGER_EXT = 0x8D97,
+ RGB_INTEGER_EXT = 0x8D98,
+ RGBA_INTEGER_EXT = 0x8D99,
+ BGR_INTEGER_EXT = 0x8D9A,
+ BGRA_INTEGER_EXT = 0x8D9B,
+ LUMINANCE_INTEGER_EXT = 0x8D9C,
+ LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D,
+ RGBA_INTEGER_MODE_EXT = 0x8D9E,
+ }
+ #endregion
+ public enum SGIX_icc_texture
+ {
+ RGB_ICC_SGIX = 0x8460,
+ RGBA_ICC_SGIX = 0x8461,
+ ALPHA_ICC_SGIX = 0x8462,
+ LUMINANCE_ICC_SGIX = 0x8463,
+ INTENSITY_ICC_SGIX = 0x8464,
+ LUMINANCE_ALPHA_ICC_SGIX = 0x8465,
+ R5_G6_B5_ICC_SGIX = 0x8466,
+ R5_G6_B5_A8_ICC_SGIX = 0x8467,
+ ALPHA16_ICC_SGIX = 0x8468,
+ LUMINANCE16_ICC_SGIX = 0x8469,
+ INTENSITY16_ICC_SGIX = 0x846A,
+ LUMINANCE16_ALPHA8_ICC_SGIX = 0x846B,
+ }
+}
diff --git a/Source/OpenTK/OpenGL/DisplayList.cs b/Source/OpenTK/OpenGL/DisplayList.cs
new file mode 100644
index 00000000..8faa4305
--- /dev/null
+++ b/Source/OpenTK/OpenGL/DisplayList.cs
@@ -0,0 +1,98 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.OpenGL
+{
+ ///
+ /// Provides methods to create and render a display list.
+ ///
+ public class DisplayList : IDisposable
+ {
+ #region --- Private variables ---
+
+ private int id = -1;
+
+ #endregion
+
+ #region --- Constructors ---
+
+ ///
+ /// Allocates a new DisplayList.
+ ///
+ public DisplayList()
+ {
+ Id = GL.GenLists(1);
+ }
+
+ #endregion
+
+ #region --- Public properties ---
+
+ ///
+ /// Gets the display list number.
+ ///
+ public int Id
+ {
+ get { return id; }
+ private set { id = value; }
+ }
+
+ #endregion
+
+ #region --- Public methods ---
+
+ ///
+ /// Starts recording elements into the display list.
+ ///
+ public void Begin()
+ {
+ GL.NewList(Id, Enums.ListMode.COMPILE);
+ }
+
+ ///
+ /// Starts recording elements into the display list.
+ ///
+ /// Sets if the list is to be compiled or compiled and executed immediately.
+ public void Begin(Enums.ListMode listMode)
+ {
+ GL.NewList(Id, listMode);
+ }
+
+ ///
+ /// Stops recording elements into the display list.
+ ///
+ public void End()
+ {
+ GL.EndList();
+ }
+
+ ///
+ /// Renders the display list elements.
+ ///
+ public void Render()
+ {
+ GL.CallList(Id);
+ }
+
+ #region IDisposable Members
+
+ public void Dispose()
+ {
+ if (Id > 0)
+ GL.DeleteLists(Id, 1);
+ Id = -1;
+ }
+
+ #endregion
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/OpenGL/GLHelper.cs b/Source/OpenTK/OpenGL/GLHelper.cs
new file mode 100644
index 00000000..871a4e5b
--- /dev/null
+++ b/Source/OpenTK/OpenGL/GLHelper.cs
@@ -0,0 +1,468 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+
+#region --- Using Directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Reflection;
+
+#endregion
+
+//[assembly: CLSCompliant(true)]
+
+namespace OpenTK.OpenGL
+{
+ ///
+ /// OpenGL binding for .NET, implementing OpenGL 2.1, plus extensions.
+ ///
+ ///
+ ///
+ /// OpenTK.OpenGL.GL contains all OpenGL enums and functions defined in the 2.1 specification.
+ /// The official .spec files can be found at: http://opengl.org/registry/.
+ ///
+ ///
+ /// OpenTK.OpenGL.GL relies on static initialization to obtain the entry points for OpenGL functions.
+ /// Please ensure that a valid OpenGL context has been made current in the pertinent thread before
+ /// any OpenGL functions are called (toolkits like GLUT, SDL or GLFW will automatically take care of
+ /// the context initialization process). Without a valid OpenGL context, OpenTK.OpenGL.GL will only be able
+ /// to retrieve statically exported entry points (typically corresponding to OpenGL version 1.1 under Windows,
+ /// 1.3 under Linux and 1.4 under Windows Vista), and extension methods will need to be loaded manually.
+ ///
+ ///
+ /// If you prefer not to rely on static initialisation for the Gl class, you can use the
+ /// ReloadFunctions or ReloadFunction methods to manually force the initialisation of OpenGL entry points.
+ /// The ReloadFunctions method should be called whenever you change an existing visual or pixelformat. This
+ /// generally happens when you change the color/stencil/depth buffer associated with a window (but probably
+ /// not the resolution). This may or may not be necessary under Linux/MacOS, but is generally required for
+ /// Windows.
+ ///
+ ///
+ /// You can use the Gl.IsExtensionSupported method to check whether any given category of extension functions
+ /// exists in the current OpenGL context. The results can be cached to speed up future searches.
+ /// Keep in mind that different OpenGL contexts may support different extensions, and under different entry
+ /// points. Always check if all required extensions are still supported when changing visuals or pixel
+ /// formats.
+ ///
+ ///
+ /// You may retrieve the entry point for an OpenGL extension using the Gl.GetDelegateForExtensionMethod
+ /// and Gl.GetFunctionPointerForExtensionMethod methods. You may retrieve the entry point for an OpenGL
+ /// function using the Gl.GetDelegateForMethod method. All three methods are cross-platform.
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public static partial class GL
+ {
+ #region private enum Platform
+
+ ///
+ /// Enumerates the platforms OpenTK can run on.
+ ///
+ private enum Platform
+ {
+ Unknown,
+ Windows,
+ X11,
+ X11_ARB,
+ OSX
+ };
+
+ #endregion private enum Platform
+
+ private static Platform platform = Platform.Unknown;
+ private static System.Collections.Generic.Dictionary AvailableExtensions;
+
+ #region internal static extern IntPtr glxGetProcAddressARB(string s);
+ // also linux, for our ARB-y friends
+ [DllImport(GL_NATIVE_LIBRARY, EntryPoint = "glXGetProcAddressARB")]
+ internal static extern IntPtr glxGetProcAddressARB(string s);
+ #endregion
+
+ #region internal static IntPtr aglGetProcAddress(string s)
+ // osx gets complicated
+ [DllImport("libdl.dylib", EntryPoint = "NSIsSymbolNameDefined")]
+ internal static extern bool NSIsSymbolNameDefined(string s);
+ [DllImport("libdl.dylib", EntryPoint = "NSLookupAndBindSymbol")]
+ internal static extern IntPtr NSLookupAndBindSymbol(string s);
+ [DllImport("libdl.dylib", EntryPoint = "NSAddressOfSymbol")]
+ internal static extern IntPtr NSAddressOfSymbol(IntPtr symbol);
+
+ internal static IntPtr aglGetProcAddress(string s)
+ {
+ string fname = "_" + s;
+ if (!NSIsSymbolNameDefined(fname))
+ return IntPtr.Zero;
+
+ IntPtr symbol = NSLookupAndBindSymbol(fname);
+ if (symbol != IntPtr.Zero)
+ symbol = NSAddressOfSymbol(symbol);
+
+ return symbol;
+ }
+ #endregion
+
+ #region public static IntPtr GetFunctionPointerForExtensionMethod(string name)
+ ///
+ /// Retrieves the entry point for a dynamically exported OpenGL function.
+ ///
+ /// The function string for the OpenGL function (eg. "glNewList")
+ ///
+ /// An IntPtr contaning the address for the entry point, or IntPtr.Zero if the specified
+ /// OpenGL function is not dynamically exported.
+ ///
+ ///
+ ///
+ /// The Marshal.GetDelegateForFunctionPointer method can be used to turn the return value
+ /// into a call-able delegate.
+ ///
+ ///
+ /// This function is cross-platform. It determines the underlying platform and uses the
+ /// correct wgl, glx or agl GetAddress function to retrieve the function pointer.
+ ///
+ ///
+ ///
+ ///
+ public static IntPtr GetFunctionPointerForExtensionMethod(string name)
+ {
+ IntPtr result = IntPtr.Zero;
+
+ switch (platform)
+ {
+ case Platform.Unknown:
+ // WGL?
+ try
+ {
+ result = OpenTK.Platform.Windows.Wgl.GetProcAddress(name);
+ platform = Platform.Windows;
+ return result;
+ }
+ catch (Exception)
+ { }
+
+ // AGL? (before X11, since GLX might exist on OSX)
+ try
+ {
+ result = aglGetProcAddress(name);
+ platform = Platform.OSX;
+ return result;
+ }
+ catch (Exception)
+ { }
+
+ // X11?
+ try
+ {
+ result = OpenTK.Platform.X11.Glx.GetProcAddress(name);
+ platform = Platform.X11;
+ return result;
+ }
+ catch (Exception)
+ { }
+
+ // X11 ARB?
+ try
+ {
+ result = glxGetProcAddressARB(name);
+ platform = Platform.X11_ARB;
+ return result;
+ }
+ catch (Exception)
+ { }
+
+ // Ack!
+ throw new NotSupportedException(
+@"Could not find out how to retrive function pointers for this platform.
+Did you remember to copy OpenTK.OpenGL.dll.config to your binary's folder?
+");
+
+ case Platform.Windows:
+ return OpenTK.Platform.Windows.Wgl.GetProcAddress(name);
+
+ case Platform.OSX:
+ return aglGetProcAddress(name);
+
+ case Platform.X11:
+ return OpenTK.Platform.X11.Glx.GetProcAddress(name);
+
+ case Platform.X11_ARB:
+ return glxGetProcAddressARB(name);
+ }
+
+ throw new NotSupportedException("Internal error - please report.");
+ }
+ #endregion public static IntPtr GetFunctionPointerForExtensionMethod(string s)
+
+ #region public static Delegate GetDelegateForExtensionMethod(string name, Type signature)
+ ///
+ /// Creates a System.Delegate that can be used to call a dynamically exported OpenGL function.
+ ///
+ /// The name of the OpenGL function (eg. "glNewList")
+ /// The signature of the OpenGL function.
+ ///
+ /// A System.Delegate that can be used to call this OpenGL function or null
+ /// if the function is not available in the current OpenGL context.
+ ///
+ public static Delegate GetDelegateForExtensionMethod(string name, Type signature)
+ {
+ IntPtr address = GetFunctionPointerForExtensionMethod(name);
+
+ if (address == IntPtr.Zero ||
+ address == new IntPtr(1) || // Workaround for buggy nvidia drivers which return
+ address == new IntPtr(2)) // 1 or 2 instead of IntPtr.Zero for some extensions.
+ {
+ return null;
+ }
+ else
+ {
+ return Marshal.GetDelegateForFunctionPointer(address, signature);
+ }
+ }
+ #endregion public static Delegate GetAddress(string name, Type signature)
+
+ #region public static Delegate GetDelegateForMethod(string name, Type signature)
+ ///
+ /// Creates a System.Delegate that can be used to call an OpenGL function, core or extension.
+ ///
+ /// The name of the OpenGL function (eg. "glNewList")
+ /// The signature of the OpenGL function.
+ ///
+ /// A System.Delegate that can be used to call this OpenGL function, or null if the specified
+ /// function name did not correspond to an OpenGL function.
+ ///
+ public static Delegate GetDelegateForMethod(string name, Type signature)
+ {
+ Delegate d;
+
+ if (Assembly.Load("OpenTK.OpenGL").GetType("OpenTK.OpenGL.Imports").GetMethod(name.Substring(2)) != null)
+ {
+ d = GetDelegateForExtensionMethod(name, signature) ??
+ Delegate.CreateDelegate(signature, typeof(Imports), name.Substring(2));
+ }
+ else
+ {
+ d = GetDelegateForExtensionMethod(name, signature);
+ }
+
+ return d;
+ }
+ #endregion
+
+ #region public static bool IsExtensionSupported(string name)
+ ///
+ /// Determines whether the specified OpenGL extension category is available in
+ /// the current OpenGL context. Equivalent to IsExtensionSupported(name, true)
+ ///
+ /// The string for the OpenGL extension category (eg. "GL_ARB_multitexture")
+ /// True if the specified extension is available, false otherwise.
+ public static bool IsExtensionSupported(string name)
+ {
+ return IsExtensionSupported(name, true);
+ }
+ #endregion
+
+ #region public static bool IsExtensionSupported(string name, bool useCache)
+ ///
+ /// Determines whether the specified OpenGL extension category is available in
+ /// the current OpenGL context.
+ ///
+ /// The string for the OpenGL extension category (eg. "GL_ARB_multitexture")
+ /// If true, the results will be cached to speed up future results.
+ /// True if the specified extension is available, false otherwise.
+ public static bool IsExtensionSupported(string name, bool useCache)
+ {
+ // Use cached results
+ if (useCache)
+ {
+ // Build cache if it is not available
+ if (AvailableExtensions == null)
+ {
+ ParseAvailableExtensions();
+ }
+
+ // Search the cache for the string. Note that the cache substitutes
+ // strings "1.0" to "2.1" with "GL_VERSION_1_0" to "GL_VERSION_2_1"
+ if (AvailableExtensions.ContainsKey(name))
+ return AvailableExtensions[name];
+ else
+ return false;
+ }
+
+ // Do not use cached results
+ string extension_string = GL.GetString(Enums.StringName.EXTENSIONS);
+ if (String.IsNullOrEmpty(extension_string))
+ return false; // no extensions are available
+
+ // Check if the user searches for GL_VERSION_X_X and search glGetString(GL_VERSION) instead.
+ if (name.Contains("GL_VERSION_"))
+ {
+ return GL.GetString(OpenTK.OpenGL.Enums.StringName.VERSION).Trim().StartsWith(name.Replace("GL_VERSION_", String.Empty).Replace('_', '.'));
+ }
+
+ // Search for the string given.
+ string[] extensions = extension_string.Split(' ');
+ foreach (string s in extensions)
+ {
+ if (name == s)
+ return true;
+ }
+
+ return false;
+ }
+ #endregion
+
+ #region private static void ParseAvailableExtensions()
+ ///
+ /// Builds a cache of the supported extensions to speed up searches.
+ ///
+ private static void ParseAvailableExtensions()
+ {
+ // Assumes there is a current context.
+
+ AvailableExtensions = new Dictionary();
+
+ string version_string = GL.GetString(OpenTK.OpenGL.Enums.StringName.VERSION);
+ if (String.IsNullOrEmpty(version_string))
+ return; // this shoudn't happen
+
+ string version = version_string.Trim(' ');
+
+ if (version.StartsWith("1.2"))
+ {
+ AvailableExtensions.Add("GL_VERSION_1_2", true);
+ }
+ else if (version.StartsWith("1.3"))
+ {
+ AvailableExtensions.Add("GL_VERSION_1_2", true);
+ AvailableExtensions.Add("GL_VERSION_1_3", true);
+ }
+ else if (version.StartsWith("1.4"))
+ {
+ AvailableExtensions.Add("GL_VERSION_1_2", true);
+ AvailableExtensions.Add("GL_VERSION_1_3", true);
+ AvailableExtensions.Add("GL_VERSION_1_4", true);
+ }
+ else if (version.StartsWith("1.5"))
+ {
+ AvailableExtensions.Add("GL_VERSION_1_2", true);
+ AvailableExtensions.Add("GL_VERSION_1_3", true);
+ AvailableExtensions.Add("GL_VERSION_1_4", true);
+ AvailableExtensions.Add("GL_VERSION_1_5", true);
+ }
+ else if (version.StartsWith("2.0"))
+ {
+ AvailableExtensions.Add("GL_VERSION_1_2", true);
+ AvailableExtensions.Add("GL_VERSION_1_3", true);
+ AvailableExtensions.Add("GL_VERSION_1_4", true);
+ AvailableExtensions.Add("GL_VERSION_1_5", true);
+ AvailableExtensions.Add("GL_VERSION_2_0", true);
+ }
+ else if (version.StartsWith("2.1"))
+ {
+ AvailableExtensions.Add("GL_VERSION_1_2", true);
+ AvailableExtensions.Add("GL_VERSION_1_3", true);
+ AvailableExtensions.Add("GL_VERSION_1_4", true);
+ AvailableExtensions.Add("GL_VERSION_1_5", true);
+ AvailableExtensions.Add("GL_VERSION_2_0", true);
+ AvailableExtensions.Add("GL_VERSION_2_1", true);
+ }
+
+ string extension_string = GL.GetString(OpenTK.OpenGL.Enums.StringName.EXTENSIONS);
+ if (String.IsNullOrEmpty(extension_string))
+ return; // no extensions are available
+
+ string[] extensions = extension_string.Split(' ');
+ foreach (string ext in extensions)
+ {
+ AvailableExtensions.Add(ext, true);
+ }
+ }
+ #endregion
+
+ #region public static void ReloadFunctions()
+ ///
+ /// Reloads all OpenGL functions (core and extensions).
+ ///
+ ///
+ ///
+ /// Call this function to reload all OpenGL entry points. This should be done
+ /// whenever you change the pixelformat/visual, or in the case you cannot (or do not want)
+ /// to use the automatic initialisation.
+ ///
+ ///
+ /// Calling this function before the automatic initialisation has taken place will result
+ /// in the Gl class being initialised twice. This is harmless, but given the automatic
+ /// initialisation should be preferred.
+ ///
+ ///
+ public static void ReloadFunctions()
+ {
+ Assembly asm = Assembly.Load("OpenTK.OpenGL");
+ Type delegates_class = asm.GetType("OpenTK.OpenGL.Delegates");
+ Type imports_class = asm.GetType("OpenTK.OpenGL.Imports");
+
+ FieldInfo[] v = delegates_class.GetFields();
+ foreach (FieldInfo f in v)
+ {
+ f.SetValue(null, GetDelegateForMethod(f.Name, f.FieldType));
+ }
+
+ ParseAvailableExtensions();
+ }
+ #endregion
+
+ #region public static bool ReloadFunction(string name)
+ ///
+ /// Tries to reload the given OpenGL function (core or extension).
+ ///
+ /// The name of the OpenGL function (i.e. glShaderSource)
+ /// True if the function was found and reloaded, false otherwise.
+ ///
+ ///
+ /// Use this function if you require greater granularity when loading OpenGL entry points.
+ ///
+ ///
+ /// While the automatic initialisation will load all OpenGL entry points, in some cases
+ /// the initialisation can take place before an OpenGL Context has been established.
+ /// In this case, use this function to load the entry points for the OpenGL functions
+ /// you will need, or use ReloadFunctions() to load all available entry points.
+ ///
+ ///
+ /// This function will return true if the given OpenGL function exists, false otherwise.
+ /// A return value of "true" does not mean that any specific OpenGL function is supported;
+ /// rather it means that the string passed to this function denotes a known OpenGL function.
+ ///
+ ///
+ /// To query supported extensions use the IsExtensionSupported() function instead.
+ ///
+ ///
+ public static bool ReloadFunction(string name)
+ {
+ Assembly asm = Assembly.Load("OpenTK.OpenGL");
+ Type delegates_class = asm.GetType("OpenTK.OpenGL.Delegates");
+ Type imports_class = asm.GetType("OpenTK.OpenGL.Imports");
+
+ FieldInfo f = delegates_class.GetField(name);
+ if (f == null)
+ return false;
+
+ f.SetValue(null, GetDelegateForMethod(f.Name, f.FieldType));
+
+ return true;
+ }
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/OpenGL/Glu.cs b/Source/OpenTK/OpenGL/Glu.cs
new file mode 100644
index 00000000..9639a5a2
--- /dev/null
+++ b/Source/OpenTK/OpenGL/Glu.cs
@@ -0,0 +1,68 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace OpenTK.OpenGL
+{
+ ///
+ /// Provides access to GLU functions.
+ ///
+ public class Glu
+ {
+ #region GLU functions
+
+ private const string GLUDLLName = "glu32.dll";
+
+ [DllImport(GLUDLLName, EntryPoint = "gluOrtho2D")]
+ private static extern IntPtr ErrorString_(int errCode);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluGetString")]
+ private static extern IntPtr GetString_(int errCode);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluOrtho2D")]
+ public static extern void Ortho2D(double left, double right, double bottom, double top);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluPerspective")]
+ public static extern void Perspective(double fovy, double aspect, double zNear, double zFar);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluPickMatrix")]
+ public static extern void PickMatrix(double x, double y, double width, double height, int[] viewport);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluLookAt")]
+ public static extern void LookAt(double eyex, double eyey, double eyez, double centerx, double centery, double centerz, double upx, double upy, double upz);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluProject")]
+ public static extern int Project(double objx, double objy, double objz, double[] modelMatrix, double[] projMatrix, int[] viewport, out double winx, out double winy, out double winz);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluUnProject")]
+ public static extern int UnProject(double winx, double winy, double winz, double[] modelMatrix, double[] projMatrix, int[] viewport, out double objx, out double objy, out double objz);
+
+ [DllImport(GLUDLLName, EntryPoint = "ScaleImage")]
+ public static extern void ScaleImage(int format, int widthin, int heightin, int typein, IntPtr datain, int widthout, int heightout, int typeout, IntPtr dataout);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluBuild1DMipmaps")]
+ public static extern int Build1DMipmaps(int target, int components, int width, int format, int type, IntPtr data);
+
+ [DllImport(GLUDLLName, EntryPoint = "gluBuild2DMipmaps")]
+ public static extern int Build2DMipmaps(int target, int components, int width, int height, int format, int type, IntPtr data);
+
+ public static string GetString(int name)
+ {
+ return Marshal.PtrToStringAnsi(GetString_(name));
+ }
+
+ public static string ErrorString(int name)
+ {
+ return Marshal.PtrToStringAnsi(ErrorString_(name));
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/OpenTK.dll.config b/Source/OpenTK/OpenTK.dll.config
new file mode 100644
index 00000000..8f8d39bf
--- /dev/null
+++ b/Source/OpenTK/OpenTK.dll.config
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/Source/OpenTK/Platform/ColorDepth.cs b/Source/OpenTK/Platform/ColorDepth.cs
new file mode 100644
index 00000000..ecf4544a
--- /dev/null
+++ b/Source/OpenTK/Platform/ColorDepth.cs
@@ -0,0 +1,94 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Drawing;
+using System.Globalization;
+
+namespace OpenTK.Platform
+{
+ public class ColorDepth
+ {
+ public byte Red, Green, Blue, Alpha;
+ public bool IsIndexed = false;
+ public int BitsPerPixel;
+
+ public ColorDepth(int bpp)
+ {
+ Red = Green = Blue = Alpha = 0;
+ BitsPerPixel = bpp;
+
+ switch (bpp)
+ {
+ case 32:
+ Red = Green = Blue = Alpha = 8;
+ break;
+ case 24:
+ Red = Green = Blue = 8;
+ break;
+ case 16:
+ Red = Blue = 5;
+ Green = 6;
+ break;
+ case 15:
+ Red = Green = Blue = 5;
+ break;
+ case 8:
+ IsIndexed = true;
+ break;
+ case 4:
+ IsIndexed = true;
+ break;
+ default:
+ break;
+ }
+ }
+
+ public ColorDepth(int red, int green, int blue, int alpha)
+ {
+ Red = (byte)red;
+ Green = (byte)green;
+ Blue = (byte)blue;
+ Alpha = (byte)alpha;
+ BitsPerPixel = red + green + blue + alpha;
+ }
+
+ public override bool Equals(object obj)
+ {
+ return (obj is ColorDepth) ? (this == (ColorDepth)obj) : false;
+ }
+
+ public static bool operator ==(ColorDepth left, ColorDepth right)
+ {
+ if ((object)left == (object)null && (object)right != (object)null ||
+ (object)left != (object)null && (object)right == (object)null)
+ return false;
+
+ if ((object)left == (object)null && (object)right == (object)null)
+ return true;
+
+ return left.Red == right.Red &&
+ left.Green == right.Green &&
+ left.Blue == right.Blue &&
+ left.Alpha == right.Alpha;
+ }
+
+ public static bool operator !=(ColorDepth left, ColorDepth right)
+ {
+ return !(left == right);
+ }
+
+ public override int GetHashCode()
+ {
+ return Red ^ Green ^ Blue ^ Alpha;
+ }
+
+ public override string ToString()
+ {
+ return string.Format(CultureInfo.CurrentCulture, "{0}", BitsPerPixel + (IsIndexed ? " indexed" : String.Empty) + " bpp");
+ }
+ }
+}
\ No newline at end of file
diff --git a/Source/OpenTK/Platform/DisplayMode.cs b/Source/OpenTK/Platform/DisplayMode.cs
new file mode 100644
index 00000000..1662b3af
--- /dev/null
+++ b/Source/OpenTK/Platform/DisplayMode.cs
@@ -0,0 +1,226 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using directives ---
+
+using System;
+using System.Drawing;
+using System.Globalization;
+
+#endregion
+
+namespace OpenTK.Platform
+{
+ public sealed class DisplayMode
+ {
+ #region --- Private Variables ---
+
+ private int width, height;
+ private ColorDepth color;
+
+ private int depthBits, stencilBits, auxBits;
+
+ private float refreshRate;
+ private bool vsync;
+ private bool fullscreen;
+ private int buffers;
+ private bool stereo;
+
+ #endregion
+
+ #region --- Constructors ---
+
+ ///
+ /// Constructs a new DisplayMode from the given parameters.
+ ///
+ /// The Width of the DisplayMode, in pixels.
+ /// The Height of the DisplayMode, in pixels.
+ /// The ColorDepth of the DisplayMode.
+ /// The size of the Depth Buffer, in bits.
+ /// The size of Stencil Buffer, in bits.
+ /// The size of the Auxilliary Buffer, in bits.
+ /// Set to true for a fullscreen DisplayMode.
+ /// Set to true for a DisplayMode with stereographic capabilities.
+ /// The number of Display Buffers. Usually one, two or three.
+ /// Set to true to sync the updates to the screen refresh rate.
+ /// The desired RefreshRate. Taken into account only for Fullscreen DisplayModes.
+ public DisplayMode(
+ int width,
+ int height,
+ ColorDepth color,
+ int depth,
+ int stencil,
+ int aux,
+ int buffers,
+ bool fullscreen,
+ bool stereo,
+ bool vsync,
+ float refresh
+ )
+ {
+ this.Width = width;
+ this.Height = height;
+ this.Color = color;
+ this.DepthBits = depth;
+ this.StencilBits = stencil;
+ this.AuxBits = aux;
+ this.Buffers = buffers;
+ this.Fullscreen = fullscreen;
+ this.Stereo = stereo;
+ this.Vsync = vsync;
+ this.RefreshRate = refresh;
+ }
+
+ ///
+ /// Constructs a new DisplayMode with default values.
+ ///
+ public DisplayMode()
+ : this(0, 0, new ColorDepth(0), 0, 0, 0, 0, false, false, false, 0.0f)
+ {
+ }
+
+ ///
+ /// Creates a DisplayMode.
+ ///
+ /// The Width of the DisplayMode in pixels.
+ /// The Height of the DisplayMode in pixels.
+ public DisplayMode(int width, int height)
+ : this(width, height, new ColorDepth(0), 0, 0, 0, 0, false, false, false, 0.0f)
+ {
+ }
+ /*
+ public DisplayMode(int width, int height, int bpp, int frequency)
+ : this(width, height, 0, 0, 0, 0, frequency)
+ {
+ color = new ColorDepth(bpp);
+ }
+ */
+ /*
+ public DisplayMode(int width, int height, int r, int g, int b, int a, int frequency)
+ {
+ size = new Size(width, height);
+ color = new ColorDepth(r, g, b, a);
+ displayFrequency = frequency;
+ }
+ */
+ #endregion
+
+ #region --- Public Properties ---
+
+ #region public int Height
+
+ ///
+ /// Gets or sets the Height of the DisplayMode. Height is the vertical span measured in pixels.
+ ///
+ public int Height
+ {
+ get { return height; }
+ set
+ {
+ if (value > 0 /* && (value < Screen[0].Height) */)
+ {
+ height = value;
+ }
+ }
+ }
+
+ #endregion
+
+ #region public int Width
+
+ ///
+ /// Gets or sets the Width of the DisplayMode. Width is the horizontal span measured in pixels.
+ ///
+ public int Width
+ {
+ get { return width; }
+ set
+ {
+ if (value > 0 /* && (value < Screen[0].Width) */)
+ {
+ width = value;
+ }
+ }
+ }
+
+ #endregion
+
+ #region public ColorDepth Color
+
+ public ColorDepth Color
+ {
+ get { return this.color; }
+ set { this.color = value; }
+ }
+
+ #endregion
+
+ public int DepthBits
+ {
+ get { return this.depthBits; }
+ set { this.depthBits = value; }
+ }
+
+ public int StencilBits
+ {
+ get { return this.stencilBits; }
+ set { this.stencilBits = value; }
+ }
+
+ public int AuxBits
+ {
+ get { return this.auxBits; }
+ set { this.auxBits = value; }
+ }
+
+ public bool Stereo
+ {
+ get { return this.stereo; }
+ set { this.stereo = value; }
+ }
+
+ public bool Fullscreen
+ {
+ get { return this.fullscreen; }
+ set { this.fullscreen = value; }
+ }
+
+ public bool Vsync
+ {
+ get { return this.vsync; }
+ set { this.vsync = value; }
+ }
+
+ public int Buffers
+ {
+ get { return this.buffers; }
+ set { this.buffers = value; }
+ }
+
+ public float RefreshRate
+ {
+ get { return this.refreshRate; }
+ set { this.refreshRate = value; }
+ }
+
+
+ #endregion
+
+ public override string ToString()
+ {
+ return string.Format(
+ CultureInfo.CurrentCulture,
+ "{0}x{1}, {2}, {3}Hz",
+ Width, Height,
+ Color,
+ RefreshRate
+ );
+ }
+
+ }
+
+ public class DisplayModeMatchOptions { }
+}
diff --git a/Source/OpenTK/Platform/IGLContext.cs b/Source/OpenTK/Platform/IGLContext.cs
new file mode 100644
index 00000000..4bb6244c
--- /dev/null
+++ b/Source/OpenTK/Platform/IGLContext.cs
@@ -0,0 +1,42 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.Platform
+{
+ public interface IGLContext : IDisposable
+ {
+ ///
+ /// Swaps buffers on a context. This presents the rendered scene to the user.
+ ///
+ void SwapBuffers();
+
+ ///
+ /// Makes this context the current rendering target.
+ ///
+ void MakeCurrent();
+
+ ///
+ /// Gets the address of an OpenGL extension function.
+ ///
+ /// The name of the OpenGL function (e.g. "glGetString")
+ ///
+ /// A pointer to the specified function or IntPtr.Zero if the function isn't
+ /// available in the current opengl context.
+ ///
+ ///
+ IntPtr GetAddress(string function);
+
+ ///
+ /// Returns the display modes supported by the current opengl context.
+ ///
+ /// An array containing all supported display modes.
+ IEnumerable GetDisplayModes();
+ }
+}
diff --git a/Source/OpenTK/Platform/IGLWindow.cs b/Source/OpenTK/Platform/IGLWindow.cs
new file mode 100644
index 00000000..8923c71f
--- /dev/null
+++ b/Source/OpenTK/Platform/IGLWindow.cs
@@ -0,0 +1,28 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using OpenTK.OpenGL;
+
+namespace OpenTK.Platform
+{
+ public interface IGLControl : IDisposable
+ {
+ void ProcessEvents();
+
+ event CreateEvent Create;
+
+ bool IsIdle { get; }
+ //bool Quit { get; set; }
+ bool Fullscreen { get; set; }
+ IGLContext Context { get; }
+ }
+
+ public delegate void CreateEvent(object sender, EventArgs e);
+}
diff --git a/Source/OpenTK/Platform/IGameWindow.cs b/Source/OpenTK/Platform/IGameWindow.cs
new file mode 100644
index 00000000..e250914c
--- /dev/null
+++ b/Source/OpenTK/Platform/IGameWindow.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.Platform
+{
+ interface IGameWindow : IDisposable
+ {
+ void Run();
+
+ void RenderFrame();
+ void UpdateFrame();
+
+ event UpdateFrameEvent UpdateFrameNotify;
+ event RenderFrameEvent RenderFrameNotify;
+ }
+
+ public delegate void UpdateFrameEvent(EventArgs e);
+ public delegate void RenderFrameEvent(EventArgs e);
+}
diff --git a/Source/OpenTK/Platform/INativeWindow.cs b/Source/OpenTK/Platform/INativeWindow.cs
new file mode 100644
index 00000000..1640901e
--- /dev/null
+++ b/Source/OpenTK/Platform/INativeWindow.cs
@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.Platform
+{
+ interface INativeWindow : IResizable, IDisposable
+ {
+ void ProcessEvents();
+
+ event CreateEvent Create;
+
+ bool IsIdle { get; }
+ bool Quit { get; set; }
+ bool Fullscreen { get; set; }
+ IGLContext Context { get; }
+ }
+}
diff --git a/Source/OpenTK/Platform/IResizable.cs b/Source/OpenTK/Platform/IResizable.cs
new file mode 100644
index 00000000..94e24fe8
--- /dev/null
+++ b/Source/OpenTK/Platform/IResizable.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.Platform
+{
+ public interface IResizable
+ {
+ int Height { get; set; }
+ int Width { get; set; }
+
+ event ResizeEvent Resize;
+ }
+
+ public delegate void ResizeEvent(object sender, ResizeEventArgs e);
+
+ public class ResizeEventArgs : EventArgs
+ {
+ public int Width, Height;
+
+ public ResizeEventArgs()
+ {
+ }
+
+ public ResizeEventArgs(int width, int height)
+ {
+ this.Width = width;
+ this.Height = height;
+ }
+ }
+}
diff --git a/Source/OpenTK/Platform/IWindowInfo.cs b/Source/OpenTK/Platform/IWindowInfo.cs
new file mode 100644
index 00000000..bdb2e12e
--- /dev/null
+++ b/Source/OpenTK/Platform/IWindowInfo.cs
@@ -0,0 +1,10 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.Platform
+{
+ public interface IWindowInfo
+ {
+ }
+}
diff --git a/Source/OpenTK/Platform/Windows/API.cs b/Source/OpenTK/Platform/Windows/API.cs
new file mode 100644
index 00000000..5b80ecd8
--- /dev/null
+++ b/Source/OpenTK/Platform/Windows/API.cs
@@ -0,0 +1,1093 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * Contributions from Erik Ylvisaker
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using Directives ---
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+#endregion
+
+/* TODO: Update the description of TimeBeginPeriod and other native methods. Update Timer. */
+
+namespace OpenTK.Platform.Windows
+{
+ #region Type aliases
+
+ using HWND = System.IntPtr;
+ using HINSTANCE = System.IntPtr;
+ using HMENU = System.IntPtr;
+ using LPVOID = System.IntPtr;
+ using LONG = System.Int32;
+ using LPCTSTR = System.String;
+ using DWORD = System.Int32;
+ using BOOL = System.Boolean;
+ using UINT = System.UInt32;
+ using WPARAM = System.IntPtr;
+ using LPARAM = System.IntPtr;
+
+ #endregion
+
+ ///
+ /// For internal use by OpenTK only!
+ /// Exposes useful native WINAPI methods and structures.
+ ///
+ internal static class API
+ {
+ // Prevent BeforeFieldInit optimization.
+ static API() { }
+
+ #region Constants
+
+ internal struct Constants
+ {
+ // WM_ACTIVATE state values (found in winuser.h)
+ internal const int WA_INACTIVE = 0;
+ internal const int WA_ACTIVE = 1;
+ internal const int WA_CLICKACTIVE = 2;
+
+ // Window Messages (found in winuser.h)
+ internal const int WM_NULL = 0x0000;
+ internal const int WM_CREATE = 0x0001;
+ internal const int WM_DESTROY = 0x0002;
+ internal const int WM_MOVE = 0x0003;
+ internal const int WM_SIZE = 0x0005;
+ internal const int WM_ACTIVATE = 0x0006;
+ internal const int WM_SETFOCUS = 0x0007;
+ internal const int WM_KILLFOCUS = 0x0008;
+ internal const int WM_ENABLE = 0x000A;
+ internal const int WM_SETREDRAW = 0x000B;
+ internal const int WM_SETTEXT = 0x000C;
+ internal const int WM_GETTEXT = 0x000D;
+ internal const int WM_GETTEXTLENGTH = 0x000E;
+ internal const int WM_PAINT = 0x000F;
+ internal const int WM_CLOSE = 0x0010;
+ // _WIN32_WCE
+ internal const int WM_QUERYENDSESSION = 0x0011;
+ internal const int WM_QUERYOPEN = 0x0013;
+ internal const int WM_ENDSESSION = 0x0016;
+ internal const int WM_QUIT = 0x0012;
+ internal const int WM_ERASEBKGND = 0x0014;
+ internal const int WM_SYSCOLORCHANGE = 0x0015;
+ internal const int WM_SHOWWINDOW = 0x0018;
+ internal const int WM_WININICHANGE = 0x001A;
+ // WINVER >= 0x400
+ internal const int WM_SETTINGCHANGE = WM_WININICHANGE;
+
+ internal const int WM_DEVMODECHANGE = 0x001B;
+ internal const int WM_ACTIVATEAPP = 0x001C;
+ internal const int WM_FONTCHANGE = 0x001D;
+ internal const int WM_TIMECHANGE = 0x001E;
+ internal const int WM_CANCELMODE = 0x001F;
+ internal const int WM_SETCURSOR = 0x0020;
+ internal const int WM_MOUSEACTIVATE = 0x0021;
+ internal const int WM_CHILDACTIVATE = 0x0022;
+ internal const int WM_QUEUESYNC = 0x0023;
+
+ internal const int WM_GETMINMAXINFO = 0x0024;
+
+ internal const int WM_WINDOWPOSCHANGING = 0x0046;
+ internal const int WM_WINDOWPOSCHANGED = 0x0047;
+
+ // Keyboard events (found in winuser.h)
+ internal const int WM_KEYDOWN = 0x0100;
+ internal const int WM_KEYUP = 0x101;
+ internal const int WM_SYSKEYDOWN = 0x0104;
+ internal const int WM_SYSKEYUP = 0x0105;
+ internal const int WM_COMMAND = 0x0111;
+ internal const int WM_SYSCOMMAND = 0x0112;
+ internal const int WM_ENTERIDLE = 0x121;
+
+ // Pixel types (found in wingdi.h)
+ internal const byte PFD_TYPE_RGBA = 0;
+ internal const byte PFD_TYPE_COLORINDEX = 1;
+
+ // Layer types (found in wingdi.h)
+ internal const byte PFD_MAIN_PLANE = 0;
+ internal const byte PFD_OVERLAY_PLANE = 1;
+ internal const byte PFD_UNDERLAY_PLANE = unchecked((byte)-1);
+
+ // Device mode types (found in wingdi.h)
+ internal const int DM_BITSPERPEL = 0x00040000;
+ internal const int DM_PELSWIDTH = 0x00080000;
+ internal const int DM_PELSHEIGHT = 0x00100000;
+ internal const int DM_DISPLAYFLAGS = 0x00200000;
+ internal const int DM_DISPLAYFREQUENCY = 0x00400000;
+
+ // ChangeDisplaySettings types (found in winuser.h)
+ internal const int CDS_UPDATEREGISTRY = 0x00000001;
+ internal const int CDS_TEST = 0x00000002;
+ internal const int CDS_FULLSCREEN = 0x00000004;
+
+ // ChangeDisplaySettings results (found in winuser.h)
+ internal const int DISP_CHANGE_SUCCESSFUL = 0;
+ internal const int DISP_CHANGE_RESTART = 1;
+ internal const int DISP_CHANGE_FAILED = -1;
+
+ // (found in winuser.h)
+ internal const int ENUM_REGISTRY_SETTINGS = -2;
+ internal const int ENUM_CURRENT_SETTINGS = -1;
+
+ public const int VK_ESCAPE = 0x1B;
+ }
+
+ #endregion
+
+ #region WINAPI methods
+
+ #region PeekMessage
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct Message
+ {
+ internal IntPtr hWnd;
+ internal int msg;
+ internal IntPtr wParam;
+ internal IntPtr lParam;
+ internal int time;
+ internal System.Drawing.Point p;
+ //System.Drawing.
+ }
+
+ ///
+ /// Low-level WINAPI function that checks the next message in the queue.
+ ///
+ /// The pending message (if any) is stored here.
+ /// Not used
+ /// Not used
+ /// Not used
+ /// Not used
+ /// True if there is a message pending.
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport("User32.dll", CharSet = CharSet.Auto)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool PeekMessage(
+ out Message msg,
+ IntPtr hWnd,
+ int messageFilterMin,
+ int messageFilterMax,
+ int flags
+ );
+
+ ///
+ /// Low-level WINAPI function that checks the next message in the queue.
+ ///
+ /// The pending message (if any) is stored here.
+ /// Not used
+ /// Not used
+ /// Not used
+ /// Not used
+ /// True if there is a message pending.
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport("User32.dll", CharSet = CharSet.Auto)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool PeekMessage(
+ out System.Windows.Forms.Message msg,
+ IntPtr hWnd,
+ int messageFilterMin,
+ int messageFilterMax,
+ int flags
+ );
+
+ #endregion
+
+ #region GetMessage
+
+ ///
+ /// Low-level WINAPI function that retriives the next message in the queue.
+ ///
+ /// The pending message (if any) is stored here.
+ /// Not used
+ /// Not used
+ /// Not used
+ /// Not used
+ ///
+ /// Nonzero indicates that the function retrieves a message other than WM_QUIT.
+ /// Zero indicates that the function retrieves the WM_QUIT message, or that lpMsg is an invalid pointer.
+ /// –1 indicates that an error occurred — for example, the function fails if hWnd is an invalid window handle.
+ /// To get extended error information, call GetLastError.
+ ///
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport("User32.dll", CharSet = CharSet.Auto)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern BOOL GetMessage(
+ out System.Windows.Forms.Message msg,
+ IntPtr windowHandle,
+ int messageFilterMin,
+ int messageFilterMax
+ );
+
+ #endregion
+
+ #region PostMessage
+
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport("User32.dll", CharSet = CharSet.Auto)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern BOOL PostMessage(
+ HWND hWnd,
+ UINT Msg,
+ WPARAM wParam,
+ LPARAM lParam
+ );
+
+ #endregion
+
+ #region PostQuitMessage
+
+ [DllImport("User32.dll", CharSet = CharSet.Auto)]
+ internal static extern void PostQuitMessage(int exitCode);
+
+ #endregion
+
+ #region TimeBeginPeriod
+
+ ///
+ /// Sets the timing resolution of the GetTime (?) method.
+ ///
+ /// Timing resolution in msec (?)
+ /// (?)
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport("winmm.dll")]
+ internal static extern IntPtr TimeBeginPeriod(int period);
+
+ #endregion
+
+ #region QueryPerformanceFrequency
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport("kernel32.dll")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool QueryPerformanceFrequency(ref long PerformanceFrequency);
+
+ #endregion
+
+ #region QueryPerformanceCounter
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport("kernel32.dll")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool QueryPerformanceCounter(ref long PerformanceCount);
+
+ #endregion
+
+ #region GetDC
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("user32.dll")]
+ internal static extern IntPtr GetDC(IntPtr hwnd);
+
+ #endregion
+
+ #region ReleaseDC
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("user32.dll")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool ReleaseDC(IntPtr hwnd, IntPtr DC);
+
+ #endregion
+
+ #region ChoosePixelFormat
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("gdi32.dll")]
+ internal static extern int ChoosePixelFormat(IntPtr dc, [In, MarshalAs(UnmanagedType.LPStruct)]PixelFormatDescriptor pfd);
+
+ #endregion
+
+ #region SetPixelFormat
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("gdi32.dll")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool SetPixelFormat(
+ IntPtr dc,
+ int format,
+ [In, MarshalAs(UnmanagedType.LPStruct)]PixelFormatDescriptor pfd
+ );
+
+
+ #endregion
+
+ #region SetWindowPos
+
+ // WINUSERAPI BOOL WINAPI SetWindowPos(__in HWND hWnd, __in_opt HWND hWndInsertAfter,
+ // __in int X, __in int Y, __in int cx, __in int cy, __in UINT uFlags);
+
+ [DllImport("user32.dll")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool SetWindowPos(
+ IntPtr handle,
+ WindowPlacementOptions placement,
+ int x, int y, int cx, int cy,
+ SetWindowPosFlags flags
+ );
+
+ #endregion
+
+ #region SwapBuffers
+
+ ///
+ ///
+ ///
+ ///
+ [DllImport("gdi32.dll")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool SwapBuffers(IntPtr dc);
+
+ #endregion
+
+ #region GetProcAddress
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("kernel32.dll")]
+ internal static extern IntPtr GetProcAddress(IntPtr handle, string funcname);
+
+ #endregion
+
+ #region LoadLibrary
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("kernel32.dll", SetLastError = true)]
+ internal static extern IntPtr LoadLibrary(string dllName);
+
+ #endregion
+
+ #region FreeLibrary
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("kernel32.dll")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool FreeLibrary(IntPtr handle);
+
+ #endregion
+
+ #region CreateWindowEx
+
+ [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+ internal static extern IntPtr CreateWindowEx(
+ [In]ExtendedWindowStyle ExStyle,
+ [In]string className,
+ [In]string windowName,
+ [In]WindowStyle Style,
+ [In]int X, int Y,
+ [In]int Width, int Height,
+ [In]IntPtr HandleToParentWindow,
+ [In]IntPtr Menu,
+ [In]IntPtr Instance,
+ [In]IntPtr Param);
+ /*
+ [DllImport("user32.dll", SetLastError = true)]
+ internal static extern int CreateWindowEx(
+ [In]ExtendedWindowStyle ExStyle,
+ [In]IntPtr ClassName,
+ [In]IntPtr WindowName,
+ [In]WindowStyle Style,
+ [In]int X, [In]int Y,
+ [In]int Width, [In]int Height,
+ [In]IntPtr HandleToParentWindow,
+ [In]IntPtr Menu,
+ [In]IntPtr Instance,
+ [In]IntPtr Param);
+ */
+ [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+ internal static extern IntPtr CreateWindowEx(
+ ExtendedWindowStyle ExStyle,
+ IntPtr ClassName,
+ IntPtr WindowName,
+ WindowStyle Style,
+ int X, int Y,
+ int Width, int Height,
+ IntPtr HandleToParentWindow,
+ IntPtr Menu,
+ IntPtr Instance,
+ IntPtr Param);
+
+ internal enum WindowStyle : int
+ {
+ Overlapped = 0x00000000,
+ Popup = unchecked((int)0x80000000),
+ Child = 0x40000000,
+ Minimize = 0x20000000,
+ Visible = 0x10000000,
+ Disabled = 0x08000000,
+ ClipSiblings = 0x04000000,
+ ClipChildren = 0x02000000,
+ Maximize = 0x01000000,
+ Caption = 0x00C00000, // Border | DialogFrame
+ Border = 0x00800000,
+ DialogFrame = 0x00400000,
+ VScroll = 0x00200000,
+ HScreen = 0x00100000,
+ SystemMenu = 0x00080000,
+ ThickFrame = 0x00040000,
+ Group = 0x00020000,
+ TabStop = 0x00010000,
+
+ MinimizeBox = 0x00020000,
+ MaximizeBox = 0x00010000,
+
+ Tiled = Overlapped,
+ Iconic = Minimize,
+ SizeBox = ThickFrame,
+ TiledWindow = OverlappedWindow,
+
+ // Common window styles:
+ OverlappedWindow = Overlapped | Caption | SystemMenu | ThickFrame | MinimizeBox | MaximizeBox,
+ PopupWindow = Popup | Border | SystemMenu,
+ ChildWindow = Child
+ }
+
+ [Flags]
+ internal enum ExtendedWindowStyle : int
+ {
+ DialogModalFrame = 0x00000001,
+ NoParentNotify = 0x00000004,
+ Topmost = 0x00000008,
+ AcceptFiles = 0x00000010,
+ Transparent = 0x00000020,
+
+ // #if(WINVER >= 0x0400)
+ MdiChild = 0x00000040,
+ ToolWindow = 0x00000080,
+ WindowEdge = 0x00000100,
+ ClientEdge = 0x00000200,
+ ContextHelp = 0x00000400,
+ // #endif
+
+ // #if(WINVER >= 0x0400)
+ Right = 0x00001000,
+ Left = 0x00000000,
+ RightToLeftReading = 0x00002000,
+ LeftToRightReading = 0x00000000,
+ LeftScrollbar = 0x00004000,
+ RightScrollbar = 0x00000000,
+
+ ControlParent = 0x00010000,
+ StaticEdge = 0x00020000,
+ ApplicationWindow = 0x00040000,
+
+ OverlappedWindow = WindowEdge | ClientEdge,
+ PaletteWindow = WindowEdge | ToolWindow | Topmost,
+ // #endif
+
+ // #if(_WIN32_WINNT >= 0x0500)
+ Layered = 0x00080000,
+ // #endif
+
+ // #if(WINVER >= 0x0500)
+ NoInheritLayout = 0x00100000, // Disable inheritence of mirroring by children
+ RightToLeftLayout = 0x00400000, // Right to left mirroring
+ // #endif /* WINVER >= 0x0500 */
+
+ // #if(_WIN32_WINNT >= 0x0501)
+ Composited = 0x02000000,
+ // #endif /* _WIN32_WINNT >= 0x0501 */
+
+ // #if(_WIN32_WINNT >= 0x0500)
+ NoActivate = 0x08000000
+ // #endif /* _WIN32_WINNT >= 0x0500 */
+ }
+
+ #endregion
+
+ #region DestroyWindow
+
+ [DllImport("user32.dll", SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ internal static extern bool DestroyWindow(IntPtr windowHandle);
+
+ #endregion
+
+ #region GetModuleHandle
+
+ [DllImport("kernel32.dll")]
+ internal static extern IntPtr GetModuleHandle([MarshalAs(UnmanagedType.LPTStr)]string module_name);
+
+ #endregion
+
+ #region RegisterClass
+
+ [DllImport("user32.dll", SetLastError = true)]
+ internal static extern short RegisterClass(WindowClass window_class);
+
+ #endregion
+
+ #region
+
+ [DllImport("user32.dll", SetLastError = true)]
+ internal static extern short UnregisterClass(string className, IntPtr instance);
+
+ [DllImport("user32.dll", SetLastError = true)]
+ internal static extern short UnregisterClass(IntPtr className, IntPtr instance);
+
+ #endregion
+
+ #region int ChangeDisplaySettings(ref Gdi.DEVMODE devMode, int flags)
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ [DllImport("user32.dll", SetLastError = true)]
+ internal static extern int ChangeDisplaySettings(DeviceMode device_mode, int flags);
+ #endregion int ChangeDisplaySettings(ref Gdi.DEVMODE devMode, int flags)
+
+ #region EnumDisplaySettings
+
+ [DllImport("user32.dll", SetLastError = true)]
+ internal static extern int EnumDisplaySettings([MarshalAs(UnmanagedType.LPTStr)] string device_name,
+ int graphics_mode, IntPtr device_mode);
+
+ #endregion
+
+
+ // *********** Never use GetLastError! ************
+
+ //#region GetLastError
+
+ //[DllImport("kernel32.dll")]
+ //internal static extern int GetLastError();
+
+ //#endregion
+
+ //#region SetLastError
+
+ //[DllImport("kernel32.dll")]
+ //internal static extern void SetLastError(int error_code);
+
+ //#endregion
+
+ //#region FormatMessage
+
+ //#endregion
+
+ // ************************************************
+ #endregion
+
+ #region WINAPI structs
+
+ #region internal struct CreateStruct
+
+ internal struct CreateStruct
+ {
+ ///
+ /// Contains additional data which may be used to create the window.
+ ///
+ ///
+ /// If the window is being created as a result of a call to the CreateWindow
+ /// or CreateWindowEx function, this member contains the value of the lpParam
+ /// parameter specified in the function call.
+ ///
+ /// If the window being created is a multiple-document interface (MDI) client window,
+ /// this member contains a pointer to a CLIENTCREATESTRUCT structure. If the window
+ /// being created is a MDI child window, this member contains a pointer to an
+ /// MDICREATESTRUCT structure.
+ ///
+ ///
+ /// Windows NT/2000/XP: If the window is being created from a dialog template,
+ /// this member is the address of a SHORT value that specifies the size, in bytes,
+ /// of the window creation data. The value is immediately followed by the creation data.
+ ///
+ ///
+ /// Windows NT/2000/XP: You should access the data represented by the lpCreateParams member
+ /// using a pointer that has been declared using the UNALIGNED type, because the pointer
+ /// may not be DWORD aligned.
+ ///
+ ///
+ internal LPVOID lpCreateParams;
+ ///
+ /// Handle to the module that owns the new window.
+ ///
+ internal HINSTANCE hInstance;
+ ///
+ /// Handle to the menu to be used by the new window.
+ ///
+ internal HMENU hMenu;
+ ///
+ /// Handle to the parent window, if the window is a child window.
+ /// If the window is owned, this member identifies the owner window.
+ /// If the window is not a child or owned window, this member is NULL.
+ ///
+ internal HWND hwndParent;
+ ///
+ /// Specifies the height of the new window, in pixels.
+ ///
+ internal int cy;
+ ///
+ /// Specifies the width of the new window, in pixels.
+ ///
+ internal int cx;
+ ///
+ /// Specifies the y-coordinate of the upper left corner of the new window.
+ /// If the new window is a child window, coordinates are relative to the parent window.
+ /// Otherwise, the coordinates are relative to the screen origin.
+ ///
+ internal int y;
+ ///
+ /// Specifies the x-coordinate of the upper left corner of the new window.
+ /// If the new window is a child window, coordinates are relative to the parent window.
+ /// Otherwise, the coordinates are relative to the screen origin.
+ ///
+ internal int x;
+ ///
+ /// Specifies the style for the new window.
+ ///
+ internal LONG style;
+ ///
+ /// Pointer to a null-terminated string that specifies the name of the new window.
+ ///
+ [MarshalAs(UnmanagedType.LPTStr)]
+ internal LPCTSTR lpszName;
+ ///
+ /// Either a pointer to a null-terminated string or an atom that specifies the class name
+ /// of the new window.
+ ///
+ /// Note Because the lpszClass member can contain a pointer to a local (and thus inaccessable) atom,
+ /// do not obtain the class name by using this member. Use the GetClassName function instead.
+ ///
+ ///
+ [MarshalAs(UnmanagedType.LPTStr)]
+ internal LPCTSTR lpszClass;
+ ///
+ /// Specifies the extended window style for the new window.
+ ///
+ internal DWORD dwExStyle;
+ }
+
+ #endregion
+
+ #region PixelFormatDescriptor struct
+ ///
+ /// Describes a pixel format. It is used when interfacing with the WINAPI to create a new Context.
+ /// Found in WinGDI.h
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ internal class PixelFormatDescriptor
+ {
+ short Size = 40; // No need for the user to set the size, since it is predefined.
+ internal short Version = 1;
+ internal PixelFormatDescriptorFlags Flags =
+ //PixelFormatDescriptorFlags.DOUBLEBUFFER |
+ PixelFormatDescriptorFlags.DRAW_TO_WINDOW |
+ PixelFormatDescriptorFlags.SUPPORT_OPENGL;
+ internal byte PixelType = Constants.PFD_TYPE_RGBA;
+ internal byte ColorBits = 0;
+ internal byte RedBits = 0;
+ internal byte RedShift = 0;
+ internal byte GreenBits = 0;
+ internal byte GreenShift = 0;
+ internal byte BlueBits = 0;
+ internal byte BlueShift = 0;
+ internal byte AlphaBits = 8;
+ internal byte AlphaShift = 0;
+ internal byte AccumBits = 0;
+ internal byte AccumRedBits = 0;
+ internal byte AccumGreenBits = 0;
+ internal byte AccumBlueBits = 0;
+ internal byte AccumAlphaBits = 0;
+ internal byte DepthBits = 0;
+ internal byte StencilBits = 0;
+ internal byte AuxBuffers = 0;
+ internal byte LayerType = unchecked((byte)Constants.PFD_MAIN_PLANE);
+ byte Reserved = 0;
+ internal int LayerMask = 0;
+ internal int VisibleMask = 0;
+ internal int DamageMask = 0;
+ }
+ #endregion
+
+ #region PixelFormatDescriptorFlags enum
+ [Flags]
+ internal enum PixelFormatDescriptorFlags : int
+ {
+ // PixelFormatDescriptor flags
+ DOUBLEBUFFER,
+ STEREO,
+ DRAW_TO_WINDOW,
+ DRAW_TO_BITMAP,
+ SUPPORT_GDI,
+ SUPPORT_OPENGL,
+ GENERIC_FORMAT,
+ NEED_PALETTE,
+ NEED_SYSTEM_PALETTE,
+ SWAP_EXCHANGE,
+ SWAP_COPY,
+ SWAP_LAYER_BUFFERS,
+ GENERIC_ACCELERATED,
+ SUPPORT_DIRECTDRAW,
+
+ // PixelFormatDescriptor flags for use in ChoosePixelFormat only
+ DEPTH_DONTCARE = unchecked((int)0x20000000),
+ DOUBLEBUFFER_DONTCARE = unchecked((int)0x40000000),
+ STEREO_DONTCARE = unchecked((int)0x80000000)
+ }
+ #endregion
+
+ #region WindowPlacementOptions enum
+
+ internal enum WindowPlacementOptions
+ {
+ TOP = 0,
+ BOTTOM = 1,
+ TOPMOST = -1,
+ NOTOPMOST = -2
+ }
+
+ #endregion
+
+ #region WindowClass
+ [StructLayout(LayoutKind.Sequential)]
+ internal class WindowClass
+ {
+ internal WindowClassStyle style = WindowClassStyle.VRedraw | WindowClassStyle.HRedraw | WindowClassStyle.OwnDC;
+ [MarshalAs(UnmanagedType.FunctionPtr)]
+ internal WindowProcedureEventHandler WindowProcedure;
+ internal int ClassExtraBytes;
+ internal int WindowExtraBytes;
+ //[MarshalAs(UnmanagedType.
+ internal IntPtr Instance;
+ internal IntPtr Icon;
+ internal IntPtr Cursor;
+ internal IntPtr BackgroundBrush;
+ //[MarshalAs(UnmanagedType.LPStr)]
+ internal IntPtr MenuName;
+ //[MarshalAs(UnmanagedType.LPStr)]
+ internal IntPtr ClassName;
+ //internal string ClassName;
+ }
+ #endregion
+
+ #region WindowClassStyle enum
+ [Flags]
+ internal enum WindowClassStyle
+ {
+ //None = 0x0000,
+ VRedraw = 0x0001,
+ HRedraw = 0x0002,
+ DoubleClicks = 0x0008,
+ OwnDC = 0x0020,
+ ClassDC = 0x0040,
+ ParentDC = 0x0080,
+ NoClose = 0x0200,
+ SaveBits = 0x0800,
+ ByteAlignClient = 0x1000,
+ ByteAlignWindow = 0x2000,
+ GlobalClass = 0x4000,
+
+ Ime = 0x00010000,
+
+ // #if(_WIN32_WINNT >= 0x0501)
+ DropShadow = 0x00020000
+ // #endif /* _WIN32_WINNT >= 0x0501 */
+ }
+ #endregion
+
+ #region DeviceMode class
+ /*
+ typedef struct _devicemode {
+ BCHAR dmDeviceName[CCHDEVICENAME];
+ WORD dmSpecVersion;
+ WORD dmDriverVersion;
+ WORD dmSize;
+ WORD dmDriverExtra;
+ DWORD dmFields;
+ union {
+ struct {
+ short dmOrientation;
+ short dmPaperSize;
+ short dmPaperLength;
+ short dmPaperWidth;
+ short dmScale;
+ short dmCopies;
+ short dmDefaultSource;
+ short dmPrintQuality;
+ };
+ POINTL dmPosition;
+ DWORD dmDisplayOrientation;
+ DWORD dmDisplayFixedOutput;
+ };
+
+ short dmColor;
+ short dmDuplex;
+ short dmYResolution;
+ short dmTTOption;
+ short dmCollate;
+ BYTE dmFormName[CCHFORMNAME];
+ WORD dmLogPixels;
+ DWORD dmBitsPerPel;
+ DWORD dmPelsWidth;
+ DWORD dmPelsHeight;
+ union {
+ DWORD dmDisplayFlags;
+ DWORD dmNup;
+ }
+ DWORD dmDisplayFrequency;
+ #if(WINVER >= 0x0400)
+ DWORD dmICMMethod;
+ DWORD dmICMIntent;
+ DWORD dmMediaType;
+ DWORD dmDitherType;
+ DWORD dmReserved1;
+ DWORD dmReserved2;
+ #if (WINVER >= 0x0500) || (_WIN32_WINNT >= 0x0400)
+ DWORD dmPanningWidth;
+ DWORD dmPanningHeight;
+ #endif
+ #endif
+ } DEVMODE;
+ */
+ [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+ internal class DeviceMode
+ {
+ internal DeviceMode()
+ {
+ Size = (short)Marshal.SizeOf(this);
+ }
+
+ [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+ internal string DeviceName;
+ internal short SpecVersion;
+ internal short DriverVersion;
+ private short Size;
+ internal short DriverExtra;
+ internal int Fields;
+
+ internal short Orientation;
+ internal short PaperSize;
+ internal short PaperLength;
+ internal short PaperWidth;
+ internal short Scale;
+ internal short Copies;
+ internal short DefaultSource;
+ internal short PrintQuality;
+
+ internal short Color;
+ internal short Duplex;
+ internal short YResolution;
+ internal short TTOption;
+ internal short Collate;
+ [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+ internal string FormName;
+ internal short LogPixels;
+ internal int BitsPerPel;
+ internal int PelsWidth;
+ internal int PelsHeight;
+ internal int DisplayFlags;
+ internal int DisplayFrequency;
+ internal int ICMMethod;
+ internal int ICMIntent;
+ internal int MediaType;
+ internal int DitherType;
+ internal int Reserved1;
+ internal int Reserved2;
+ internal int PanningWidth;
+ internal int PanningHeight;
+ }
+
+ #endregion DeviceMode class
+
+ #region public struct MinMaxInfo
+
+ ///
+ /// Struct pointed to by WM_GETMINMAXINFO lParam
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ public struct MINMAXINFO
+ {
+ System.Drawing.Point ptReserved;
+ System.Drawing.Point ptMaxSize;
+ System.Drawing.Point ptMaxPosition;
+ System.Drawing.Point ptMinTrackSize;
+ System.Drawing.Point ptMaxTrackSize;
+ }
+
+ #endregion
+
+ #region public struct WindowPosition
+
+ ///
+ /// The WindowPosition structure contains information about the size and position of a window.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ public struct WindowPosition
+ {
+ ///
+ /// Handle to the window.
+ ///
+ public HWND hwnd;
+ ///
+ /// Specifies the position of the window in Z order (front-to-back position).
+ /// This member can be a handle to the window behind which this window is placed,
+ /// or can be one of the special values listed with the SetWindowPos function.
+ ///
+ public HWND hwndInsertAfter;
+ ///
+ /// Specifies the position of the left edge of the window.
+ ///
+ public int x;
+ ///
+ /// Specifies the position of the top edge of the window.
+ ///
+ public int y;
+ ///
+ /// Specifies the window width, in pixels.
+ ///
+ public int cx;
+ ///
+ /// Specifies the window height, in pixels.
+ ///
+ public int cy;
+ ///
+ /// Specifies the window position.
+ ///
+ [MarshalAs(UnmanagedType.U4)]
+ public SetWindowPosFlags flags;
+ }
+
+ #region public enum SetWindowPosFlags
+
+ [Flags]
+ public enum SetWindowPosFlags : int
+ {
+ ///
+ /// Retains the current size (ignores the cx and cy parameters).
+ ///
+ NOSIZE = 0x0001,
+ ///
+ /// Retains the current position (ignores the x and y parameters).
+ ///
+ NOMOVE = 0x0002,
+ ///
+ /// Retains the current Z order (ignores the hwndInsertAfter parameter).
+ ///
+ NOZORDER = 0x0004,
+ ///
+ /// Does not redraw changes. If this flag is set, no repainting of any kind occurs.
+ /// This applies to the client area, the nonclient area (including the title bar and scroll bars),
+ /// and any part of the parent window uncovered as a result of the window being moved.
+ /// When this flag is set, the application must explicitly invalidate or redraw any parts
+ /// of the window and parent window that need redrawing.
+ ///
+ NOREDRAW = 0x0008,
+ ///
+ /// Does not activate the window. If this flag is not set,
+ /// the window is activated and moved to the top of either the topmost or non-topmost group
+ /// (depending on the setting of the hwndInsertAfter member).
+ ///
+ NOACTIVATE = 0x0010,
+ ///
+ /// Sends a WM_NCCALCSIZE message to the window, even if the window's size is not being changed.
+ /// If this flag is not specified, WM_NCCALCSIZE is sent only when the window's size is being changed.
+ ///
+ FRAMECHANGED = 0x0020, /* The frame changed: send WM_NCCALCSIZE */
+ ///
+ /// Displays the window.
+ ///
+ SHOWWINDOW = 0x0040,
+ ///
+ /// Hides the window.
+ ///
+ HIDEWINDOW = 0x0080,
+ ///
+ /// Discards the entire contents of the client area. If this flag is not specified,
+ /// the valid contents of the client area are saved and copied back into the client area
+ /// after the window is sized or repositioned.
+ ///
+ NOCOPYBITS = 0x0100,
+ ///
+ /// Does not change the owner window's position in the Z order.
+ ///
+ NOOWNERZORDER = 0x0200, /* Don't do owner Z ordering */
+ ///
+ /// Prevents the window from receiving the WM_WINDOWPOSCHANGING message.
+ ///
+ NOSENDCHANGING = 0x0400, /* Don't send WM_WINDOWPOSCHANGING */
+
+ ///
+ /// Draws a frame (defined in the window's class description) around the window.
+ ///
+ DRAWFRAME = FRAMECHANGED,
+ ///
+ /// Same as the NOOWNERZORDER flag.
+ ///
+ NOREPOSITION = NOOWNERZORDER,
+
+ DEFERERASE = 0x2000,
+ ASYNCWINDOWPOS = 0x4000
+ }
+
+ #endregion
+
+ #endregion
+
+ #endregion
+
+ #region Callbacks
+
+ [UnmanagedFunctionPointerAttribute(CallingConvention.Winapi)]
+ internal delegate void WindowProcedureEventHandler(object sender, WindowProcedureEventArgs e);
+
+ internal class WindowProcedureEventArgs : EventArgs
+ {
+ private Message msg;
+ internal Message Message
+ {
+ get { return msg; }
+ set { msg = value; }
+ }
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Platform/Windows/Wgl.cs b/Source/OpenTK/Platform/Windows/Wgl.cs
new file mode 100644
index 00000000..1a96d83e
--- /dev/null
+++ b/Source/OpenTK/Platform/Windows/Wgl.cs
@@ -0,0 +1,304 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * Contributions from Erik Ylvisaker
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace OpenTK.Platform.Windows
+{
+ ///
+ /// Provides access to WGL functions.
+ ///
+ internal static class Wgl
+ {
+ // Disable BeforeFieldInit optimization.
+ static Wgl() { }
+
+ const string _dll_name = "OPENGL32.DLL";
+
+ ///
+ /// Contains all WGL constants.
+ ///
+ public class Constant
+ {
+ #region WGL constants
+
+ public const int WGLEXT_VERSION = 4;
+ public const int FRONT_COLOR_BUFFER_BIT_ARB = 0x00000001;
+ public const int BACK_COLOR_BUFFER_BIT_ARB = 0x00000002;
+ public const int DEPTH_BUFFER_BIT_ARB = 0x00000004;
+ public const int STENCIL_BUFFER_BIT_ARB = 0x00000008;
+ public const int SAMPLE_BUFFERS_ARB = 0x2041;
+ public const int SAMPLES_ARB = 0x2042;
+ public const int NUMBER_PIXEL_FORMATS_ARB = 0x2000;
+ public const int DRAW_TO_WINDOW_ARB = 0x2001;
+ public const int DRAW_TO_BITMAP_ARB = 0x2002;
+ public const int ACCELERATION_ARB = 0x2003;
+ public const int NEED_PALETTE_ARB = 0x2004;
+ public const int NEED_SYSTEM_PALETTE_ARB = 0x2005;
+ public const int SWAP_LAYER_BUFFERS_ARB = 0x2006;
+ public const int SWAP_METHOD_ARB = 0x2007;
+ public const int NUMBER_OVERLAYS_ARB = 0x2008;
+ public const int NUMBER_UNDERLAYS_ARB = 0x2009;
+ public const int TRANSPARENT_ARB = 0x200A;
+ public const int TRANSPARENT_RED_VALUE_ARB = 0x2037;
+ public const int TRANSPARENT_GREEN_VALUE_ARB = 0x2038;
+ public const int TRANSPARENT_BLUE_VALUE_ARB = 0x2039;
+ public const int TRANSPARENT_ALPHA_VALUE_ARB = 0x203A;
+ public const int TRANSPARENT_INDEX_VALUE_ARB = 0x203B;
+ public const int SHARE_DEPTH_ARB = 0x200C;
+ public const int SHARE_STENCIL_ARB = 0x200D;
+ public const int SHARE_ACCUM_ARB = 0x200E;
+ public const int SUPPORT_GDI_ARB = 0x200F;
+ public const int SUPPORT_OPENGL_ARB = 0x2010;
+ public const int DOUBLE_BUFFER_ARB = 0x2011;
+ public const int STEREO_ARB = 0x2012;
+ public const int PIXEL_TYPE_ARB = 0x2013;
+ public const int COLOR_BITS_ARB = 0x2014;
+ public const int RED_BITS_ARB = 0x2015;
+ public const int RED_SHIFT_ARB = 0x2016;
+ public const int GREEN_BITS_ARB = 0x2017;
+ public const int GREEN_SHIFT_ARB = 0x2018;
+ public const int BLUE_BITS_ARB = 0x2019;
+ public const int BLUE_SHIFT_ARB = 0x201A;
+ public const int ALPHA_BITS_ARB = 0x201B;
+ public const int ALPHA_SHIFT_ARB = 0x201C;
+ public const int ACCUM_BITS_ARB = 0x201D;
+ public const int ACCUM_RED_BITS_ARB = 0x201E;
+ public const int ACCUM_GREEN_BITS_ARB = 0x201F;
+ public const int ACCUM_BLUE_BITS_ARB = 0x2020;
+ public const int ACCUM_ALPHA_BITS_ARB = 0x2021;
+ public const int DEPTH_BITS_ARB = 0x2022;
+ public const int STENCIL_BITS_ARB = 0x2023;
+ public const int AUX_BUFFERS_ARB = 0x2024;
+ public const int NO_ACCELERATION_ARB = 0x2025;
+ public const int GENERIC_ACCELERATION_ARB = 0x2026;
+ public const int FULL_ACCELERATION_ARB = 0x2027;
+ public const int SWAP_EXCHANGE_ARB = 0x2028;
+ public const int SWAP_COPY_ARB = 0x2029;
+ public const int SWAP_UNDEFINED_ARB = 0x202A;
+ public const int TYPE_RGBA_ARB = 0x202B;
+ public const int TYPE_COLORINDEX_ARB = 0x202C;
+ public const int ERROR_INVALID_PIXEL_TYPE_ARB = 0x2043;
+ public const int ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = 0x2054;
+ public const int DRAW_TO_PBUFFER_ARB = 0x202D;
+ public const int MAX_PBUFFER_PIXELS_ARB = 0x202E;
+ public const int MAX_PBUFFER_WIDTH_ARB = 0x202F;
+ public const int MAX_PBUFFER_HEIGHT_ARB = 0x2030;
+ public const int PBUFFER_LARGEST_ARB = 0x2033;
+ public const int PBUFFER_WIDTH_ARB = 0x2034;
+ public const int PBUFFER_HEIGHT_ARB = 0x2035;
+ public const int PBUFFER_LOST_ARB = 0x2036;
+ public const int BIND_TO_TEXTURE_RGB_ARB = 0x2070;
+ public const int BIND_TO_TEXTURE_RGBA_ARB = 0x2071;
+ public const int TEXTURE_FORMAT_ARB = 0x2072;
+ public const int TEXTURE_TARGET_ARB = 0x2073;
+ public const int MIPMAP_TEXTURE_ARB = 0x2074;
+ public const int TEXTURE_RGB_ARB = 0x2075;
+ public const int TEXTURE_RGBA_ARB = 0x2076;
+ public const int NO_TEXTURE_ARB = 0x2077;
+ public const int TEXTURE_CUBE_MAP_ARB = 0x2078;
+ public const int TEXTURE_1D_ARB = 0x2079;
+ public const int TEXTURE_2D_ARB = 0x207A;
+ public const int MIPMAP_LEVEL_ARB = 0x207B;
+ public const int CUBE_MAP_FACE_ARB = 0x207C;
+ public const int TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x207D;
+ public const int TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x207E;
+ public const int TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x207F;
+ public const int TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x2080;
+ public const int TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x2081;
+ public const int TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x2082;
+ public const int FRONT_LEFT_ARB = 0x2083;
+ public const int FRONT_RIGHT_ARB = 0x2084;
+ public const int BACK_LEFT_ARB = 0x2085;
+ public const int BACK_RIGHT_ARB = 0x2086;
+ public const int AUX0_ARB = 0x2087;
+ public const int AUX1_ARB = 0x2088;
+ public const int AUX2_ARB = 0x2089;
+ public const int AUX3_ARB = 0x208A;
+ public const int AUX4_ARB = 0x208B;
+ public const int AUX5_ARB = 0x208C;
+ public const int AUX6_ARB = 0x208D;
+ public const int AUX7_ARB = 0x208E;
+ public const int AUX8_ARB = 0x208F;
+ public const int AUX9_ARB = 0x2090;
+ public const int ERROR_INVALID_PIXEL_TYPE_EXT = 0x2043;
+ public const int NUMBER_PIXEL_FORMATS_EXT = 0x2000;
+ public const int DRAW_TO_WINDOW_EXT = 0x2001;
+ public const int DRAW_TO_BITMAP_EXT = 0x2002;
+ public const int ACCELERATION_EXT = 0x2003;
+ public const int NEED_PALETTE_EXT = 0x2004;
+ public const int NEED_SYSTEM_PALETTE_EXT = 0x2005;
+ public const int SWAP_LAYER_BUFFERS_EXT = 0x2006;
+ public const int SWAP_METHOD_EXT = 0x2007;
+ public const int NUMBER_OVERLAYS_EXT = 0x2008;
+ public const int NUMBER_UNDERLAYS_EXT = 0x2009;
+ public const int TRANSPARENT_EXT = 0x200A;
+ public const int TRANSPARENT_VALUE_EXT = 0x200B;
+ public const int SHARE_DEPTH_EXT = 0x200C;
+ public const int SHARE_STENCIL_EXT = 0x200D;
+ public const int SHARE_ACCUM_EXT = 0x200E;
+ public const int SUPPORT_GDI_EXT = 0x200F;
+ public const int SUPPORT_OPENGL_EXT = 0x2010;
+ public const int DOUBLE_BUFFER_EXT = 0x2011;
+ public const int STEREO_EXT = 0x2012;
+ public const int PIXEL_TYPE_EXT = 0x2013;
+ public const int COLOR_BITS_EXT = 0x2014;
+ public const int RED_BITS_EXT = 0x2015;
+ public const int RED_SHIFT_EXT = 0x2016;
+ public const int GREEN_BITS_EXT = 0x2017;
+ public const int GREEN_SHIFT_EXT = 0x2018;
+ public const int BLUE_BITS_EXT = 0x2019;
+ public const int BLUE_SHIFT_EXT = 0x201A;
+ public const int ALPHA_BITS_EXT = 0x201B;
+ public const int ALPHA_SHIFT_EXT = 0x201C;
+ public const int ACCUM_BITS_EXT = 0x201D;
+ public const int ACCUM_RED_BITS_EXT = 0x201E;
+ public const int ACCUM_GREEN_BITS_EXT = 0x201F;
+ public const int ACCUM_BLUE_BITS_EXT = 0x2020;
+ public const int ACCUM_ALPHA_BITS_EXT = 0x2021;
+ public const int DEPTH_BITS_EXT = 0x2022;
+ public const int STENCIL_BITS_EXT = 0x2023;
+ public const int AUX_BUFFERS_EXT = 0x2024;
+ public const int NO_ACCELERATION_EXT = 0x2025;
+ public const int GENERIC_ACCELERATION_EXT = 0x2026;
+ public const int FULL_ACCELERATION_EXT = 0x2027;
+ public const int SWAP_EXCHANGE_EXT = 0x2028;
+ public const int SWAP_COPY_EXT = 0x2029;
+ public const int SWAP_UNDEFINED_EXT = 0x202A;
+ public const int TYPE_RGBA_EXT = 0x202B;
+ public const int TYPE_COLORINDEX_EXT = 0x202C;
+ public const int DRAW_TO_PBUFFER_EXT = 0x202D;
+ public const int MAX_PBUFFER_PIXELS_EXT = 0x202E;
+ public const int MAX_PBUFFER_WIDTH_EXT = 0x202F;
+ public const int MAX_PBUFFER_HEIGHT_EXT = 0x2030;
+ public const int OPTIMAL_PBUFFER_WIDTH_EXT = 0x2031;
+ public const int OPTIMAL_PBUFFER_HEIGHT_EXT = 0x2032;
+ public const int PBUFFER_LARGEST_EXT = 0x2033;
+ public const int PBUFFER_WIDTH_EXT = 0x2034;
+ public const int PBUFFER_HEIGHT_EXT = 0x2035;
+ public const int DEPTH_FLOAT_EXT = 0x2040;
+ public const int SAMPLE_BUFFERS_3DFX = 0x2060;
+ public const int SAMPLES_3DFX = 0x2061;
+ public const int SAMPLE_BUFFERS_EXT = 0x2041;
+ public const int SAMPLES_EXT = 0x2042;
+ public const int DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = 0x2051;
+ public const int DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = 0x2052;
+ public const int DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = 0x2053;
+ public const int GAMMA_TABLE_SIZE_I3D = 0x204E;
+ public const int GAMMA_EXCLUDE_DESKTOP_I3D = 0x204F;
+ public const int GENLOCK_SOURCE_MULTIVIEW_I3D = 0x2044;
+ public const int GENLOCK_SOURCE_EXTENAL_SYNC_I3D = 0x2045;
+ public const int GENLOCK_SOURCE_EXTENAL_FIELD_I3D = 0x2046;
+ public const int GENLOCK_SOURCE_EXTENAL_TTL_I3D = 0x2047;
+ public const int GENLOCK_SOURCE_DIGITAL_SYNC_I3D = 0x2048;
+ public const int GENLOCK_SOURCE_DIGITAL_FIELD_I3D = 0x2049;
+ public const int GENLOCK_SOURCE_EDGE_FALLING_I3D = 0x204A;
+ public const int GENLOCK_SOURCE_EDGE_RISING_I3D = 0x204B;
+ public const int GENLOCK_SOURCE_EDGE_BOTH_I3D = 0x204C;
+ public const int IMAGE_BUFFER_MIN_ACCESS_I3D = 0x00000001;
+ public const int IMAGE_BUFFER_LOCK_I3D = 0x00000002;
+ public const int BIND_TO_TEXTURE_DEPTH_NV = 0x20A3;
+ public const int BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = 0x20A4;
+ public const int DEPTH_TEXTURE_FORMAT_NV = 0x20A5;
+ public const int TEXTURE_DEPTH_COMPONENT_NV = 0x20A6;
+ public const int DEPTH_COMPONENT_NV = 0x20A7;
+ public const int BIND_TO_TEXTURE_RECTANGLE_RGB_NV = 0x20A0;
+ public const int BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = 0x20A1;
+ public const int TEXTURE_RECTANGLE_NV = 0x20A2;
+ public const int FLOAT_COMPONENTS_NV = 0x20B0;
+ public const int TEXTURE_FLOAT_R_NV = 0x20B5;
+ public const int TEXTURE_FLOAT_RG_NV = 0x20B6;
+ public const int TEXTURE_FLOAT_RGB_NV = 0x20B7;
+ public const int TEXTURE_FLOAT_RGBA_NV = 0x20B8;
+
+ #endregion
+ }
+
+ #region WGL functions
+
+ [DllImport(_dll_name)]
+ public static extern IntPtr GetProcAddress(IntPtr hwnd);
+
+ [DllImport(_dll_name, EntryPoint = "wglGetProcAddress", SetLastError=true)]
+ public static extern IntPtr GetProcAddress(string funcname);
+
+ #region public static extern IntPtr CreateContext(IntPtr dc);
+
+ [DllImport(_dll_name, EntryPoint = "wglCreateContext")]
+ public static extern IntPtr CreateContext(IntPtr dc);
+
+ #endregion
+
+ #region public static extern bool MakeCurrent(IntPtr dc, IntPtr rc)
+
+ ///
+ /// The wglMakeCurrent function makes a specified OpenGL rendering context the calling thread's current rendering context.
+ /// All subsequent OpenGL calls made by the thread are drawn on the device identified by hdc.
+ /// You can also use wglMakeCurrent to change the calling thread's current rendering context so it's no longer current.
+ ///
+ /// Device context of device that OpenGL calls are to be drawn on
+ /// OpenGL rendering context to be made the calling thread's current rendering context
+ ///
+ /// When the wglMakeCurrent function succeeds, the return value is TRUE; otherwise the return value is FALSE.
+ /// To get extended error information, call GetLastError.
+ ///
+ ///
+ ///
+ /// The hdc parameter must refer to a drawing surface supported by OpenGL. It need not be the same hdc
+ /// that was passed to wglCreateContext when hglrc was created, but it must be on the same device and have
+ /// the same pixel format. GDI transformation and clipping in hdc are not supported by the rendering context.
+ /// The current rendering context uses the hdc device context until the rendering context is no longer current.
+ ///
+ ///
+ /// Before switching to the new rendering context, OpenGL flushes any previous rendering context
+ /// that was current to the calling thread.
+ ///
+ ///
+ /// A thread can have one current rendering context. A process can have multiple rendering contexts
+ /// by means of multithreading. A thread must set a current rendering context before calling any OpenGL functions.
+ /// Otherwise, all OpenGL calls are ignored.
+ ///
+ ///
+ /// A rendering context can be current to only one thread at a time. You cannot make a rendering context current
+ /// to multiple threads.
+ ///
+ ///
+ /// An application can perform multithread drawing by making different rendering contexts current
+ /// to different threads, supplying each thread with its own rendering context and device context.
+ ///
+ ///
+ /// If an error occurs, the wglMakeCurrent function makes the thread's current rendering context not current
+ /// before returning.
+ ///
+ ///
+ [DllImport(_dll_name, EntryPoint = "wglMakeCurrent")]
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool MakeCurrent(IntPtr dc, IntPtr rc);
+
+ #endregion
+
+ [DllImport(_dll_name, EntryPoint = "wglDeleteContext", SetLastError = true)]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool DeleteContext(IntPtr rc);
+
+ [DllImport(_dll_name, EntryPoint = "wglGetCurrentContext")]
+ public static extern IntPtr GetCurrentContext();
+
+ [DllImport(_dll_name, EntryPoint = "wglGetCurrentDC")]
+ public static extern IntPtr GetCurrentDC();
+
+ [DllImport(_dll_name, EntryPoint = "wglShareLists")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ public static extern bool ShareLists(IntPtr r1, IntPtr r2);
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Platform/Windows/WinGLContext.cs b/Source/OpenTK/Platform/Windows/WinGLContext.cs
new file mode 100644
index 00000000..4945b90d
--- /dev/null
+++ b/Source/OpenTK/Platform/Windows/WinGLContext.cs
@@ -0,0 +1,276 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * Contributions from Erik Ylvisaker
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+using OpenTK.OpenGL;
+using System.Diagnostics;
+
+
+namespace OpenTK.Platform.Windows
+{
+ public sealed class WinGLContext : OpenTK.Platform.IGLContext, IDisposable
+ {
+ private IntPtr deviceContext;
+ private IntPtr renderContext;
+ static private IntPtr opengl32Handle;
+ static private readonly string opengl32Name = "OPENGL32.DLL";
+ private IntPtr windowHandle;
+
+ private bool disposed;
+
+ #region --- Contructors ---
+
+ public WinGLContext(IntPtr windowHandle)
+ : this(windowHandle, new DisplayMode(640, 480, new ColorDepth(32), 16, 0, 0, 2, false, false, false, 0.0f))
+ {
+ }
+
+ public WinGLContext(IntPtr windowHandle, DisplayMode mode)
+ {
+ Trace.WriteLine(String.Format("Creating opengl context (driver: {0})", this.ToString()));
+ Trace.Indent();
+
+ this.windowHandle = windowHandle;
+ Trace.WriteLine(String.Format("Window handle: {0}", windowHandle));
+
+ PrepareContext(mode);
+
+ CreateContext();
+
+ Trace.Unindent();
+ }
+
+ #endregion
+
+ public void CreateContext()
+ {
+ Trace.Write("Creating render context... ");
+ renderContext = Wgl.CreateContext(deviceContext);
+ Trace.WriteLine(String.Format("done! (id: {0})", renderContext));
+ }
+
+ public void PrepareContext(DisplayMode mode)
+ {
+ // Dynamically load the OpenGL32.dll in order to use the extension loading capabilities of Wgl.
+ if (opengl32Handle == IntPtr.Zero)
+ {
+ opengl32Handle = API.LoadLibrary(opengl32Name);
+ if (opengl32Handle == IntPtr.Zero)
+ {
+ //System.Diagnostics.Debug.WriteLine("LoadLibrary({0}) set error code: {1}. Will not load extensions.", _dll_name, error_code);
+ throw new ApplicationException(
+ String.Format(
+ "LoadLibrary(\"{0}\") call failed with code {1}",
+ opengl32Name,
+ Marshal.GetLastWin32Error()
+ )
+ );
+ }
+ Trace.WriteLine(String.Format("Loaded opengl32.dll: {0}", opengl32Handle));
+ }
+
+ deviceContext = API.GetDC(windowHandle);
+ Trace.WriteLine(String.Format("Device context: {0}", deviceContext));
+
+ Trace.Write("Setting pixel format... ");
+ API.PixelFormatDescriptor pixelFormat = new API.PixelFormatDescriptor();
+
+ pixelFormat.ColorBits = (byte)(mode.Color.Red + mode.Color.Green + mode.Color.Blue);
+ pixelFormat.RedBits = (byte)mode.Color.Red;
+ pixelFormat.GreenBits = (byte)mode.Color.Green;
+ pixelFormat.BlueBits = (byte)mode.Color.Blue;
+ pixelFormat.AlphaBits = (byte)mode.Color.Alpha;
+ /*
+ if (accum != null)
+ {
+ pixelFormat.AccumBits = (byte)(accum.Red + accum.Green + accum.Blue);
+ pixelFormat.AccumRedBits = (byte)accum.Red;
+ pixelFormat.AccumGreenBits = (byte)accum.Green;
+ pixelFormat.AccumBlueBits = (byte)accum.Blue;
+ pixelFormat.AccumAlphaBits = (byte)accum.Alpha;
+ }
+ */
+ pixelFormat.DepthBits = (byte)mode.DepthBits;
+ pixelFormat.StencilBits = (byte)mode.StencilBits;
+
+ if (mode.DepthBits <= 0)
+ {
+ pixelFormat.Flags |= API.PixelFormatDescriptorFlags.DEPTH_DONTCARE;
+ }
+
+ if (mode.Stereo)
+ {
+ pixelFormat.Flags |= API.PixelFormatDescriptorFlags.STEREO;
+ }
+
+ if (mode.Buffers > 1)
+ {
+ pixelFormat.Flags |= API.PixelFormatDescriptorFlags.DOUBLEBUFFER;
+ }
+
+ // TODO: More elaborate mode setting, using DescribePixelFormat.
+
+ int pixel = API.ChoosePixelFormat(deviceContext, pixelFormat);
+
+ if (pixel == 0)
+ {
+ throw new ApplicationException("The requested pixel format is not supported by the hardware configuration.");
+ }
+
+ API.SetPixelFormat(deviceContext, pixel, pixelFormat);
+
+ Trace.WriteLine(String.Format("done! (format: {0})", pixel));
+ }
+
+ #region --- IGLContext Members ---
+
+ #region public void SwapBuffers()
+
+ public void SwapBuffers()
+ {
+ API.SwapBuffers(deviceContext);
+ }
+
+ #endregion
+
+ #region public IntPtr GetAddress(string function_string)
+
+ public IntPtr GetAddress(string function_string)
+ {
+ return Wgl.GetProcAddress(function_string);
+ }
+
+ #endregion
+
+ #region public void MakeCurrent()
+
+ public void MakeCurrent()
+ {
+ Wgl.MakeCurrent(deviceContext, renderContext);
+ }
+
+ #endregion
+
+ #region public DisplayMode[] GetDisplayModes()
+
+ public IEnumerable GetDisplayModes()
+ {
+ List modes = new List();
+ bool done = false;
+ int index = 0;
+
+ while (!done)
+ {
+ API.DeviceMode currentMode = new API.DeviceMode();
+ IntPtr handle = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(API.DeviceMode)));
+ Marshal.StructureToPtr(currentMode, handle, true);
+
+ done = (API.EnumDisplaySettings(null, index++, handle) != 0) ? false : true;
+ int error = Marshal.GetLastWin32Error();
+
+ Marshal.PtrToStructure(handle, currentMode);
+ Marshal.FreeHGlobal(handle);
+
+ if (error != 0)
+ {
+ Console.WriteLine("Error: {0}", error);
+ continue;
+ }
+ if (done)
+ break;
+
+ //DisplayMode mode = new DisplayMode(currentMode.PelsWidth, currentMode.PelsHeight);
+ DisplayMode mode = new DisplayMode(
+ currentMode.PelsWidth,
+ currentMode.PelsHeight,
+ new ColorDepth(currentMode.BitsPerPel),
+ 0,
+ 0,
+ 0,
+ 0,
+ false,
+ false,
+ false,
+ currentMode.DisplayFrequency
+ );
+
+ modes.Add(mode);
+ }
+
+ return modes.ToArray();
+ }
+
+ #endregion
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private void Dispose(bool calledManually)
+ {
+ if (!disposed)
+ {
+ // Clean unmanaged resources here:
+ Wgl.DeleteContext(renderContext);
+ API.ReleaseDC(windowHandle, deviceContext);
+ API.FreeLibrary(opengl32Handle);
+
+ if (calledManually)
+ {
+ // Safe to clean managed resources
+ }
+ disposed = true;
+ }
+ }
+
+ ~WinGLContext()
+ {
+ Dispose(false);
+ }
+
+ #region public void ReleaseResources()
+
+ private void ReleaseResources()
+ {
+ if (renderContext != IntPtr.Zero)
+ {
+ if (!Wgl.DeleteContext(renderContext))
+ {
+ throw new ApplicationException(
+ "Could not destroy the OpenGL render context. Error: " + Marshal.GetLastWin32Error()
+ );
+ }
+ renderContext = IntPtr.Zero;
+ }
+
+ if (opengl32Handle != IntPtr.Zero)
+ {
+ if (!API.FreeLibrary(opengl32Handle))
+ {
+ throw new ApplicationException(
+ "FreeLibray call failed ('opengl32.dll'), Error: " + Marshal.GetLastWin32Error()
+ );
+ }
+ opengl32Handle = IntPtr.Zero;
+ }
+ }
+
+ #endregion
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Platform/Windows/WinGLControl.cs b/Source/OpenTK/Platform/Windows/WinGLControl.cs
new file mode 100644
index 00000000..71e40491
--- /dev/null
+++ b/Source/OpenTK/Platform/Windows/WinGLControl.cs
@@ -0,0 +1,132 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * Contributions from Erik Ylvisaker
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+
+#endregion
+
+namespace OpenTK.Platform.Windows
+{
+ sealed class WinGLControl : OpenTK.Platform.IGLControl
+ {
+ private WinGLContext glContext;
+ private bool fullscreen;
+ private ResizeEventArgs resizeEventArgs = new ResizeEventArgs();
+
+ private bool disposed;
+
+ #region --- Constructors ---
+
+ public WinGLControl(Control c, int width, int height, bool fullscreen)
+ {
+ glContext = new WinGLContext(
+ c.Handle,
+ new DisplayMode(
+ width, height,
+ new ColorDepth(32),
+ 16, 0, 0, 2,
+ fullscreen,
+ false,
+ false,
+ 0.0f
+ )
+ );
+ }
+
+ #endregion
+
+ #region --- IGLControl membmers ---
+
+ public event CreateEvent Create;
+
+ #region public void ProcessEvents()
+
+ private API.Message msg;
+ public void ProcessEvents()
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+
+ #endregion
+
+ #region public bool IsIdle
+
+ public bool IsIdle
+ {
+ get
+ {
+ return !API.PeekMessage(out msg, IntPtr.Zero, 0, 0, 0);
+ }
+ }
+
+ #endregion
+
+ #region public OpenTK.Platform.IGLContext Context
+
+ public OpenTK.Platform.IGLContext Context
+ {
+ get { return glContext; }
+ }
+
+ #endregion
+
+ #region public bool Fullscreen
+
+ public bool Fullscreen
+ {
+ get
+ {
+ return fullscreen;
+ }
+ set
+ {
+ throw new NotImplementedException();
+ fullscreen = true;
+ }
+ }
+
+ #endregion
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+
+ }
+
+ private void Dispose(bool calledManually)
+ {
+ if (!disposed)
+ {
+ // Clean unmanaged resources here:
+
+ if (calledManually)
+ {
+ // Safe to clean managed resources
+ glContext.Dispose();
+ }
+ disposed = true;
+ }
+ }
+
+ ~WinGLControl()
+ {
+ Dispose(false);
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Platform/Windows/WinGLNative.cs b/Source/OpenTK/Platform/Windows/WinGLNative.cs
new file mode 100644
index 00000000..e741ed61
--- /dev/null
+++ b/Source/OpenTK/Platform/Windows/WinGLNative.cs
@@ -0,0 +1,404 @@
+#region --- License ---
+/* Copyright (c) 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+#region --- Using directives ---
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using OpenTK.Input;
+
+#endregion
+
+namespace OpenTK.Platform.Windows
+{
+ sealed class WinGLNative : NativeWindow, OpenTK.Platform.INativeWindow, IDisposable
+ {
+ private WinGLContext glContext;
+ private DisplayMode mode = new DisplayMode();
+
+ private bool disposed;
+
+ #region --- Contructors ---
+
+ ///
+ /// Constructs a new WinGLNative window, using safe defaults for the DisplayMode.
+ ///
+ public WinGLNative()
+ {
+ mode = new DisplayMode();
+ mode.Width = 640;
+ mode.Height = 480;
+
+ this.CreateWindow(mode);
+ }
+
+ #endregion
+
+ #region private void CreateWindow()
+
+ private void CreateWindow(DisplayMode mode)
+ {
+
+ CreateParams cp = new CreateParams();
+ cp.ClassStyle =
+ (int)API.WindowClassStyle.OwnDC |
+ (int)API.WindowClassStyle.VRedraw |
+ (int)API.WindowClassStyle.HRedraw;
+ cp.Style =
+ (int)API.WindowStyle.Visible |
+ (int)API.WindowStyle.ClipChildren |
+ (int)API.WindowStyle.ClipSiblings |
+ (int)API.WindowStyle.OverlappedWindow;
+ cp.Width = mode.Width;
+ cp.Height = mode.Height;
+ cp.Caption = "OpenTK Game Window";
+ base.CreateHandle(cp);
+
+ glContext = new WinGLContext(
+ this.Handle,
+ new DisplayMode(
+ width, height,
+ new ColorDepth(32),
+ 16, 0, 0, 2,
+ fullscreen,
+ false,
+ false,
+ 0.0f
+ )
+ );
+ }
+
+ /*
+ private void CreateWindow()
+ {
+ WinApi.WindowClass wc = new WinApi.WindowClass();
+ wc.style =
+ WinApi.WindowClassStyle.HRedraw |
+ WinApi.WindowClassStyle.VRedraw |
+ WinApi.WindowClassStyle.OwnDC;
+ wc.WindowProcedure = new WinApi.WindowProcedureEventHandler(WndProc);
+ wc.Instance = instance;
+ //wc.ClassName = Marshal.StringToHGlobalAuto(className);
+ wc.ClassName = className;
+
+ classAtom = WinApi.RegisterClass(wc);
+
+ if (classAtom == 0)
+ {
+ throw new Exception("Could not register class, error: " + Marshal.GetLastWin32Error());
+ }
+
+ // Change for fullscreen!
+ handle = WinApi.CreateWindowEx(
+ WinApi.ExtendedWindowStyle.ApplicationWindow |
+ WinApi.ExtendedWindowStyle.OverlappedWindow |
+ WinApi.ExtendedWindowStyle.Topmost,
+ className,
+ //Marshal.StringToHGlobalAuto("OpenTK Game Window"),
+ "OpenTK Game Window",
+ WinApi.WindowStyle.OverlappedWindow |
+ WinApi.WindowStyle.ClipChildren |
+ WinApi.WindowStyle.ClipSiblings,
+ 0, 0,
+ 640, 480,
+ IntPtr.Zero,
+ IntPtr.Zero,
+ instance,
+ IntPtr.Zero
+ );
+
+ if (handle == IntPtr.Zero)
+ {
+ throw new Exception("Could not create window, error: " + Marshal.GetLastWin32Error());
+ }
+ }
+ */
+ #endregion
+
+ #region protected override void WndProc(ref Message m)
+
+ ///
+ /// For use in WndProc only.
+ ///
+ private int width, height;
+
+ ///
+ /// Processes incoming WM_* messages.
+ ///
+ /// Reference to the incoming Windows Message.
+ protected override void WndProc(ref Message m)
+ {
+ switch (m.Msg)
+ {
+ case API.Constants.WM_WINDOWPOSCHANGED:
+ // Get window size
+ width = Marshal.ReadInt32(m.LParam, (int)Marshal.OffsetOf(typeof(API.WindowPosition), "cx"));
+ height = Marshal.ReadInt32(m.LParam, (int)Marshal.OffsetOf(typeof(API.WindowPosition), "cy"));
+ //if (resizeEventArgs.Width != width || resizeEventArgs.Height != height)
+ if (mode.Width != width || mode.Height != height)
+ {
+ // If the size has changed, raise the ResizeEvent.
+ resizeEventArgs.Width = width;
+ resizeEventArgs.Height = height;
+ this.OnResize(resizeEventArgs);
+ // The message was processed.
+ return;
+ }
+ // If the message was not a resize notification, send it to the default WndProc.
+ break;
+
+ case API.Constants.WM_CREATE:
+ // Set the window width and height:
+ mode.Width = Marshal.ReadInt32(m.LParam, (int)Marshal.OffsetOf(typeof(API.CreateStruct), "cx"));
+ mode.Height = Marshal.ReadInt32(m.LParam, (int)Marshal.OffsetOf(typeof(API.CreateStruct), "cy"));
+
+ // Raise the Create event
+ this.OnCreate(EventArgs.Empty);
+
+ // Raise the resize event:
+ //resizeEventArgs.Width = width;
+ //resizeEventArgs.Height = height;
+ //this.OnResize(resizeEventArgs);
+ return;
+
+ case API.Constants.WM_KEYDOWN:
+ case API.Constants.WM_KEYUP:
+ if (this.ProcessKey(ref m))
+ return;
+ else
+ break;
+
+ case API.Constants.WM_CLOSE:
+ API.PostQuitMessage(0);
+ return;
+
+ case API.Constants.WM_QUIT:
+ quit = true;
+ break;
+ }
+
+ base.WndProc(ref m);
+ }
+
+ private bool ProcessKey(ref Message m)
+ {
+ switch ((int)m.WParam)
+ {
+ case API.Constants.VK_ESCAPE:
+ Key.Escape = (m.Msg == API.Constants.WM_KEYDOWN) ? true : false;
+ return true;
+ }
+
+ return false;
+ }
+
+ #endregion
+
+ #region --- IGLWindow Members ---
+
+ #region public void ProcessEvents()
+
+ private System.Windows.Forms.Message msg;
+ public void ProcessEvents()
+ {
+ while (API.PeekMessage(out msg, IntPtr.Zero, 0, 0, 0))
+ {
+ API.GetMessage(out msg, IntPtr.Zero, 0, 0);
+ WndProc(ref msg);
+ }
+ }
+
+ #endregion
+
+ #region public event CreateEvent Create;
+
+ public event CreateEvent Create;
+
+ private void OnCreate(EventArgs e)
+ {
+ if (this.Create != null)
+ {
+ this.Create(this, e);
+ }
+ }
+
+ #endregion
+
+ #region public bool Quit
+
+ private bool quit;
+ public bool Quit
+ {
+ get { return quit; }
+ set
+ {
+ if (value)
+ {
+ API.PostQuitMessage(0);
+ //quit = true;
+ }
+ }
+ }
+
+ #endregion
+
+ #region public IGLContext Context
+
+ public IGLContext Context
+ {
+ get { return glContext; }
+ }
+
+ #endregion
+
+ #region public bool Fullscreen
+
+ bool fullscreen;
+ public bool Fullscreen
+ {
+ get
+ {
+ throw new NotImplementedException();
+ }
+ set
+ {
+ throw new NotImplementedException();
+ }
+ }
+
+ #endregion
+
+ #region public bool IsIdle
+
+ public bool IsIdle
+ {
+ get
+ {
+ return !API.PeekMessage(out msg, IntPtr.Zero, 0, 0, 0);
+ }
+ }
+
+ #endregion
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+
+ }
+
+ private void Dispose(bool calledManually)
+ {
+ if (!disposed)
+ {
+ // Clean unmanaged resources here:
+
+ if (calledManually)
+ {
+ // Safe to clean managed resources
+ glContext.Dispose();
+ base.DestroyHandle();
+ }
+ disposed = true;
+ }
+ }
+
+ ~WinGLNative()
+ {
+ Dispose(false);
+ }
+
+ #endregion
+
+ #region --- IResizable Members ---
+
+ #region public int Width
+
+ public int Width
+ {
+ get
+ {
+ return mode.Width;
+ }
+ set
+ {
+ throw new NotImplementedException();
+ //WinApi.PostMessage(
+ // this.Handle,
+ // WinApi.Constants.WM_WINDOWPOSCHANGING,
+
+ //mode.Width = value;
+ }
+ }
+
+ #endregion
+
+ #region public int Height
+
+ public int Height
+ {
+ get
+ {
+ return mode.Height;
+ }
+ set
+ {
+ throw new NotImplementedException();
+ //WinApi.PostMessage(
+ // this.Handle,
+ // WinApi.Constants.WM_WINDOWPOSCHANGING,
+
+ //mode.Height = value;
+ }
+ }
+
+ #endregion
+
+ #region public event ResizeEvent Resize
+ public event ResizeEvent Resize;
+ private ResizeEventArgs resizeEventArgs = new ResizeEventArgs();
+ public void OnResize(ResizeEventArgs e)
+ {
+ mode.Width = e.Width;
+ mode.Height = e.Height;
+ if (this.Resize != null)
+ this.Resize(this, e);
+ }
+
+ #endregion
+
+ #endregion
+ }
+
+ #region class WindowHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid
+
+ /*
+ class WindowHandle : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid
+ {
+ protected override bool ReleaseHandle()
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+
+ public override bool IsInvalid
+ {
+ get
+ {
+ return base.IsInvalid;
+ }
+ }
+ }
+ */
+
+ #endregion
+}
diff --git a/Source/OpenTK/Platform/X11/API.cs b/Source/OpenTK/Platform/X11/API.cs
new file mode 100644
index 00000000..aee31ba8
--- /dev/null
+++ b/Source/OpenTK/Platform/X11/API.cs
@@ -0,0 +1,938 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * Contributions from Erik Ylvisaker
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace OpenTK.Platform.X11
+{
+ #region Types
+
+ // using XID = System.Int32;
+ using Window = System.IntPtr;
+ using Drawable = System.IntPtr;
+ using Font = System.IntPtr;
+ using Pixmap = System.IntPtr;
+ using Cursor = System.IntPtr;
+ using Colormap = System.IntPtr;
+ using GContext = System.IntPtr;
+ using KeySym = System.IntPtr;
+ using Mask = System.IntPtr;
+ using Atom = System.IntPtr;
+ using VisualID = System.IntPtr;
+ using Time = System.UInt32;
+ using KeyCode = System.IntPtr; /* In order to use IME, the Macintosh needs
+ * to pack 3 bytes into the keyCode field in
+ * the XEvent. In the real X.h, a KeyCode is
+ * defined as a short, which wouldn't be big
+ * enough. */
+ using Display = System.IntPtr;
+
+ #endregion
+
+ #region internal static class API
+
+ internal static class API
+ {
+ // Prevent BeforeFieldInit optimization.
+ static API() { }
+
+ private const string _dll_name = "libX11";
+ private const string _dll_name_vid = "libXxf86vm";
+
+ // Display management
+ [DllImport(_dll_name, EntryPoint = "XOpenDisplay")]
+ extern internal static IntPtr OpenDisplay([MarshalAs(UnmanagedType.LPTStr)] string display_name);
+
+ [DllImport(_dll_name, EntryPoint = "XCloseDisplay")]
+ extern internal static void CloseDisplay(Display display);
+
+ [DllImport(_dll_name, EntryPoint = "XCreateColormap")]
+ extern internal static IntPtr CreateColormap(Display display, Window window, IntPtr visual, int alloc);
+
+ #region Window handling
+
+ [DllImport(_dll_name, EntryPoint = "XRootWindow")]
+ internal static extern Window RootWindow(Display display, int screen);
+
+ [DllImport(_dll_name, EntryPoint = "XCreateWindow")]
+ internal extern static Window CreateWindow(
+ Display display,
+ Window parent,
+ int x, int y,
+ uint width, uint height,
+ uint border_width,
+ int depth,
+ uint @class,
+ IntPtr visual,
+ [MarshalAs(UnmanagedType.SysUInt)] CreateWindowMask valuemask,
+ SetWindowAttributes attributes
+ );
+
+ [DllImport(_dll_name, EntryPoint = "XCreateSimpleWindow")]
+ internal extern static Window CreateSimpleWindow(
+ Display display,
+ Window parent,
+ int x, int y,
+ int width, int height,
+ int border_width,
+ long border,
+ long background
+ );
+
+ [DllImport(_dll_name, EntryPoint = "XResizeWindow")]
+ internal extern static int XResizeWindow(Display display, Window window, int width, int height);
+
+ [DllImport(_dll_name, EntryPoint = "XDestroyWindow")]
+ internal extern static void DestroyWindow(Display display, Window window);
+
+ [DllImport(_dll_name, EntryPoint = "XMapWindow")]
+ extern internal static void MapWindow(Display display, Window window);
+
+ [DllImport(_dll_name, EntryPoint = "XMapRaised")]
+ extern internal static void MapRaised(Display display, Window window);
+
+ #endregion
+
+ [DllImport(_dll_name, EntryPoint = "XDefaultScreen")]
+ extern internal static int DefaultScreen(Display display);
+
+ [DllImport(_dll_name, EntryPoint = "XDefaultVisual")]
+ extern internal static IntPtr DefaultVisual(Display display, int screen_number);
+
+ #region XFree
+
+ ///
+ /// Frees the memory used by an X structure. Only use on unmanaged structures!
+ ///
+ /// A pointer to the structure that will be freed.
+ [DllImport(_dll_name, EntryPoint = "XFree")]
+ extern internal static void Free(IntPtr data);
+
+ #endregion
+
+ #region Event queue management
+
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport(_dll_name, EntryPoint = "XEventsQueued")]
+ extern internal static int EventsQueued(Display display, int mode);
+
+ [System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport(_dll_name, EntryPoint = "XPending")]
+ extern internal static int Pending(Display display);
+
+ //[System.Security.SuppressUnmanagedCodeSecurity]
+ [DllImport(_dll_name, EntryPoint = "XNextEvent")]
+ extern internal static void NextEvent(
+ Display display,
+ [MarshalAs(UnmanagedType.AsAny)][In, Out]object e);
+
+ [DllImport(_dll_name, EntryPoint = "XNextEvent")]
+ extern internal static void NextEvent(Display display, [In, Out] IntPtr e);
+
+ [DllImport(_dll_name, EntryPoint = "XPeekEvent")]
+ extern internal static void PeekEvent(
+ Display display,
+ [MarshalAs(UnmanagedType.AsAny)][In, Out]object event_return
+ );
+
+ [DllImport(_dll_name, EntryPoint = "XPeekEvent")]
+ extern internal static void PeekEvent(
+ Display display,
+ [In, Out]Event event_return
+ );
+
+ [DllImport(_dll_name, EntryPoint = "XSendEvent")]
+ [return: MarshalAs(UnmanagedType.Bool)]
+ extern internal static bool SendEvent(
+ Display display,
+ Window window,
+ bool propagate,
+ [MarshalAs(UnmanagedType.SysInt)]
+ EventMask event_mask,
+ ref Event event_send
+ );
+
+ #endregion
+
+ #region Thing grabbin'
+
+ [DllImport(_dll_name, EntryPoint = "XGrabPointer")]
+ extern internal static ErrorCodes XGrabPointer(
+ Display display,
+ IntPtr grab_window,
+ bool owner_events, int event_mask,
+ GrabMode pointer_mode,
+ GrabMode keyboard_mode,
+ IntPtr confine_to,
+ IntPtr cursor,
+ int time
+ );
+
+ [DllImport(_dll_name, EntryPoint = "XUngrabPointer")]
+ extern internal static ErrorCodes XUngrabPointer(Display display, int time);
+
+ [DllImport(_dll_name, EntryPoint = "XGrabKeyboard")]
+ extern internal static ErrorCodes XGrabKeyboard(Display display, IntPtr grab_window,
+ bool owner_events, GrabMode pointer_mode, GrabMode keyboard_mode, int time);
+
+ [DllImport(_dll_name, EntryPoint = "XUngrabKeyboard")]
+ extern internal static void XUngrabKeyboard(Display display, int time);
+
+ #endregion
+
+ #region Xf86VidMode internal structures
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct XF86VidModeModeLine
+ {
+ short hdisplay; /* Number of display pixels horizontally */
+ short hsyncstart; /* Horizontal sync start */
+ short hsyncend; /* Horizontal sync end */
+ short htotal; /* Total horizontal pixels */
+ short vdisplay; /* Number of display pixels vertically */
+ short vsyncstart; /* Vertical sync start */
+ short vsyncend; /* Vertical sync start */
+ short vtotal; /* Total vertical pixels */
+ int flags; /* Mode flags */
+ int privsize; /* Size of private */
+ IntPtr _private; /* Server privates */
+ }
+
+ ///
+ /// Specifies an XF86 display mode.
+ ///
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct XF86VidModeModeInfo
+ {
+ ///
+ /// Pixel clock.
+ ///
+ internal int dotclock;
+
+ ///
+ /// Number of display pixels horizontally
+ ///
+ internal short hdisplay;
+
+ ///
+ /// Horizontal sync start
+ ///
+ internal short hsyncstart;
+
+ ///
+ /// Horizontal sync end
+ ///
+ internal short hsyncend;
+
+ ///
+ /// Total horizontal pixel
+ ///
+ internal short htotal;
+
+ ///
+ ///
+ ///
+ internal short hskew;
+
+ ///
+ /// Number of display pixels vertically
+ ///
+ internal short vdisplay;
+
+ ///
+ /// Vertical sync start
+ ///
+ internal short vsyncstart;
+
+ ///
+ /// Vertical sync end
+ ///
+ internal short vsyncend;
+
+ ///
+ /// Total vertical pixels
+ ///
+ internal short vtotal;
+
+ ///
+ ///
+ ///
+ internal short vskew;
+
+ ///
+ /// Mode flags
+ ///
+ internal int flags;
+
+ int privsize; /* Size of private */
+ IntPtr _private; /* Server privates */
+ }
+
+ //Monitor information:
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct XF86VidModeMonitor
+ {
+ [MarshalAs(UnmanagedType.LPStr)]
+ string vendor; /* Name of manufacturer */
+ [MarshalAs(UnmanagedType.LPStr)]
+ string model; /* Model name */
+ float EMPTY; /* unused, for backward compatibility */
+ byte nhsync; /* Number of horiz sync ranges */
+ /*XF86VidModeSyncRange* */
+ IntPtr hsync;/* Horizontal sync ranges */
+ byte nvsync; /* Number of vert sync ranges */
+ /*XF86VidModeSyncRange* */
+ IntPtr vsync;/* Vertical sync ranges */
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct XF86VidModeSyncRange
+ {
+ float hi; /* Top of range */
+ float lo; /* Bottom of range */
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct XF86VidModeNotifyEvent
+ {
+ int type; /* of event */
+ ulong serial; /* # of last request processed by server */
+ bool send_event; /* true if this came from a SendEvent req */
+ Display display; /* Display the event was read from */
+ IntPtr root; /* root window of event screen */
+ int state; /* What happened */
+ int kind; /* What happened */
+ bool forced; /* extents of new region */
+ /* Time */
+ IntPtr time; /* event timestamp */
+ }
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct XF86VidModeGamma
+ {
+ float red; /* Red Gamma value */
+ float green; /* Green Gamma value */
+ float blue; /* Blue Gamma value */
+ }
+ #endregion
+
+ #region libXxf86vm Functions
+
+ [DllImport(_dll_name_vid)]
+ extern internal static bool XF86VidModeQueryExtension(
+ Display display,
+ out int event_base_return,
+ out int error_base_return);
+ /*
+ [DllImport(_dll_name_vid)]
+ extern internal static bool XF86VidModeSwitchMode(
+ Display display,
+ int screen,
+ int zoom);
+ */
+
+ [DllImport(_dll_name_vid)]
+ extern internal static bool XF86VidModeSwitchToMode(
+ Display display,
+ int screen,
+ IntPtr
+ /*XF86VidModeModeInfo* */ modeline);
+
+
+ [DllImport(_dll_name_vid)]
+ extern internal static bool XF86VidModeQueryVersion(
+ Display display,
+ out int major_version_return,
+ out int minor_version_return);
+
+ [DllImport(_dll_name_vid)]
+ extern internal static bool XF86VidModeGetAllModeLines(
+ Display display,
+ int screen,
+ out int modecount_return,
+ /*XF86VidModeModeInfo*** <-- yes, that's three *'s. */
+ out IntPtr modesinfo);
+
+ [DllImport(_dll_name_vid)]
+ extern internal static bool XF86VidModeSetViewPort(
+ Display display,
+ int screen,
+ int x,
+ int y);
+
+ /*
+Bool XF86VidModeSetClientVersion(
+ Display *display);
+
+Bool XF86VidModeGetModeLine(
+ Display *display,
+ int screen,
+ int *dotclock_return,
+ XF86VidModeModeLine *modeline);
+
+Bool XF86VidModeDeleteModeLine(
+ Display *display,
+ int screen,
+ XF86VidModeModeInfo *modeline);
+
+Bool XF86VidModeModModeLine(
+ Display *display,
+ int screen,
+ XF86VidModeModeLine *modeline);
+
+Status XF86VidModeValidateModeLine(
+ Display *display,
+ int screen,
+ XF86VidModeModeLine *modeline);
+
+
+Bool XF86VidModeLockModeSwitch(
+ Display *display,
+ int screen,
+ int lock);
+
+Bool XF86VidModeGetMonitor(
+ Display *display,
+ int screen,
+ XF86VidModeMonitor *monitor);
+
+Bool XF86VidModeGetViewPort(
+ Display *display,
+ int screen,
+ int *x_return,
+ int *y_return);
+
+
+XF86VidModeGetDotClocks(
+ Display *display,
+ int screen,
+ int *flags return,
+ int *number of clocks return,
+ int *max dot clock return,
+ int **clocks return);
+
+XF86VidModeGetGamma(
+ Display *display,
+ int screen,
+ XF86VidModeGamma *Gamma);
+
+XF86VidModeSetGamma(
+ Display *display,
+ int screen,
+ XF86VidModeGamma *Gamma);
+
+XF86VidModeGetGammaRamp(
+ Display *display,
+ int screen,
+ int size,
+ unsigned short *red array,
+ unsigned short *green array,
+ unsigned short *blue array);
+
+XF86VidModeSetGammaRamp(
+ Display *display,
+ int screen,
+ int size,
+ unsigned short *red array,
+ unsigned short *green array,
+ unsigned short *blue array);
+
+XF86VidModeGetGammaRampSize(
+ Display *display,
+ int screen,
+ int *size);
+ * */
+
+ #endregion
+ }
+
+ #endregion
+
+ #region X11 Structures
+
+ #region internal class VisualInfo
+
+ [StructLayout(LayoutKind.Sequential)]
+ public class VisualInfo
+ {
+ internal IntPtr visual;
+ internal int visualid;
+ internal int screen;
+ internal int depth;
+ internal int @class;
+ internal long redMask;
+ internal long greenMask;
+ internal long blueMask;
+ internal int colormap_size;
+ internal int bits_per_rgb;
+
+ public override string ToString()
+ {
+ return base.ToString();
+ }
+ }
+
+ #endregion
+
+ #region internal class SetWindowAttributes
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class SetWindowAttributes
+ {
+ ///
+ /// background, None, or ParentRelative
+ ///
+ internal Pixmap background_pixmap;
+ ///
+ /// background pixel
+ ///
+ internal long background_pixel;
+ ///
+ /// border of the window or CopyFromParent
+ ///
+ internal Pixmap border_pixmap;
+ ///
+ /// border pixel value
+ ///
+ internal long border_pixel;
+ ///
+ /// one of bit gravity values
+ ///
+ internal int bit_gravity;
+ ///
+ /// one of the window gravity values
+ ///
+ internal int win_gravity;
+ ///
+ /// NotUseful, WhenMapped, Always
+ ///
+ internal int backing_store;
+ ///
+ /// planes to be preserved if possible
+ ///
+ internal long backing_planes;
+ ///
+ /// value to use in restoring planes
+ ///
+ internal long backing_pixel;
+ ///
+ /// should bits under be saved? (popups)
+ ///
+ internal bool save_under;
+ ///
+ /// set of events that should be saved
+ ///
+ internal EventMask event_mask;
+ ///
+ /// set of events that should not propagate
+ ///
+ internal long do_not_propagate_mask;
+ ///
+ /// boolean value for override_redirect
+ ///
+ internal bool override_redirect;
+ ///
+ /// color map to be associated with window
+ ///
+ internal Colormap colormap;
+ ///
+ /// cursor to be displayed (or None)
+ ///
+ internal Cursor cursor;
+ }
+
+ #endregion
+
+ #region internal struct SizeHints
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal struct SizeHints
+ {
+ internal long flags; /* marks which fields in this structure are defined */
+ internal int x, y; /* Obsolete */
+ internal int width, height; /* Obsolete */
+ internal int min_width, min_height;
+ internal int max_width, max_height;
+ internal int width_inc, height_inc;
+ internal struct min_aspect
+ {
+ internal int x; /* numerator */
+ internal int y; /* denominator */
+ }
+ internal struct max_aspect
+ {
+ internal int x; /* numerator */
+ internal int y; /* denominator */
+ }
+ internal int base_width, base_height;
+ internal int win_gravity;
+ /* this structure may be extended in the future */
+ }
+
+ #endregion
+
+ #region Event structures
+
+ #region XEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ //[StructLayout(LayoutKind.Explicit)]
+ internal class Event
+ {
+ internal EventType Type;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+ /*[FieldOffset(0)]internal EventType Type;*/
+ /*[FieldOffset(0)]
+ IntPtr
+ pad1 , pad2 , pad3 , pad4 , pad5 , pad6 ,
+ pad7 , pad8 , pad9 , pad10, pad11, pad12,
+ pad13, pad14, pad15, pad16, pad17, pad18,
+ pad19, pad20, pad21, pad22, pad23, pad24;*/
+
+ /*private ConfigureNotifyEvent cne = new ConfigureNotifyEvent();
+ internal ConfigureNotifyEvent ConfigureEvent
+ {
+ get
+ {
+ cne.type = this.Type;
+ cne.serial = this.pad1;
+ }
+ }*/
+
+ //[FieldOffset(0)]internal AnyEvent Any;
+ //[FieldOffset(0)]internal KeyEvent Key;
+ //[FieldOffset(0)]internal DestroyWindowEvent DestroyWindow;
+ //[FieldOffset(0)]internal CreateWindowEvent CreateWindow;
+ //[FieldOffset(0)]internal ResizeRequestEvent ResizeRequest;
+ //[FieldOffset(0)]internal ConfigureNotifyEvent ConfigureNotify;
+ //[FieldOffset(0)]internal ReparentNotifyEvent ReparentNotify;
+ //[FieldOffset(0)]internal ExposeEvent Expose;
+ }
+
+ #endregion
+
+ #region XAnyEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class AnyEvent
+ {
+ internal EventType type;
+ //[MarshalAs(UnmanagedType.SysUInt)]
+ internal IntPtr serial; /* # of last request processed by server */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window window;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+
+ }
+
+ #endregion
+
+ #region XKeyEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class KeyEvent
+ {
+ internal EventType type; /* KeyPress or KeyRelease */
+ [MarshalAs(UnmanagedType.SysUInt)]
+ internal ulong serial; /* # of last request processed by server */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window window; /* ``event'' window it is reported relative to */
+ internal Window root; /* root window that the event occurred on */
+ internal Window subwindow; /* child window */
+ [MarshalAs(UnmanagedType.SysUInt)]
+ internal Time time; /* milliseconds */
+ internal int x, y; /* pointer x, y coordinates in event window */
+ internal int x_root, y_root; /* coordinates relative to root */
+ internal uint state; /* key or button mask */
+ internal uint keycode; /* detail */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool same_screen; /* same screen flag */
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+ }
+
+ #endregion
+
+ #region XDestroyWindowEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class DestroyWindowEvent
+ {
+ internal EventType type; /* DestroyNotify */
+ internal ulong serial; /* # of last request processed by server */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window @event;
+ internal Window window;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+ }
+
+ #endregion
+
+ #region XCreateWindowEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class CreateWindowEvent
+ {
+ internal EventType type; /* CreateNotify */
+ internal ulong serial; /* # of last request processed by server */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window parent; /* parent of the window */
+ internal Window window; /* window id of window created */
+ internal int x, y; /* window location */
+ internal int width, height; /* size of window */
+ internal int border_width; /* border width */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool override_redirect; /* creation should be overridden */
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+ }
+
+ #endregion
+
+ #region XResizeRequestEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class ResizeRequestEvent
+ {
+ internal EventType type; /* ResizeRequest */
+ internal ulong serial; /* # of last request processed by server */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window window;
+ internal int width, height;
+ }
+
+ #endregion
+
+ #region XConfigureNotifyEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class ConfigureNotifyEvent
+ {
+ internal EventType type; /* ConfigureNotify */
+ internal ulong serial; /* # of last request processed by server */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window @event;
+ internal Window window;
+ internal int x, y;
+ internal int width, height;
+ internal int border_width;
+ internal Window above;
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool override_redirect;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+ }
+
+ #endregion
+
+ #region XReparentNotifyEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class ReparentNotifyEvent
+ {
+ internal EventType type; /* ReparentNotify */
+ //[MarshalAs(UnmanagedType.SysUInt)]
+ internal IntPtr serial; /* # of last request processed by server */
+ //[MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window @event;
+ internal Window window;
+ internal Window parent;
+ internal int x, y;
+ //[MarshalAs(UnmanagedType.Bool)]
+ internal bool override_redirect;
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+ }
+
+ #endregion
+
+ #region XExposeEvent
+
+ [StructLayout(LayoutKind.Sequential)]
+ internal class ExposeEvent
+ {
+ internal EventType type; /* Expose */
+ internal ulong serial; /* # of last request processed by server */
+ [MarshalAs(UnmanagedType.Bool)]
+ internal bool send_event; /* true if this came from a SendEvent request */
+ internal Display display; /* Display the event was read from */
+ internal Window window;
+ internal int x, y;
+ internal int width, height;
+ internal int count; /* if nonzero, at least this many more */
+ [MarshalAs(UnmanagedType.ByValArray, SizeConst=192)]
+ byte[] pad = new byte[192];
+ }
+
+ #endregion
+
+ #endregion
+
+ #endregion
+
+ #region X11 Constants and Enums
+
+ internal struct Constants
+ {
+ internal const int QueuedAlready = 0;
+ internal const int QueuedAfterReading = 1;
+ internal const int QueuedAfterFlush = 2;
+
+ internal const int CopyFromParent = 0;
+ internal const int CWX = 1;
+ internal const int InputOutput = 1;
+ internal const int InputOnly = 2;
+ }
+
+ internal enum EventType : int
+ {
+ NoEventMask = 0,
+ FocusOut = 10,
+ KeymapNotify = 11,
+ Expose = 12,
+ GraphicsExpose = 13,
+ NoExpose = 14,
+ VisibilityNotify = 15,
+ CreateNotify = 16,
+ DestroyNotify = 17,
+ UnmapNotify = 18,
+ MapNotify = 19,
+ KeyPress = 2,
+ MapRequest = 20,
+ ReparentNotify = 21,
+ ConfigureNotify = 22,
+ ConfigureRequest = 23,
+ GravityNotify = 24,
+ ResizeRequest = 25,
+ CirculateNotify = 26,
+ CirculateRequest = 27,
+ PropertyNotify = 28,
+ SelectionClear = 29,
+ KeyRelease = 3,
+ SelectionRequest = 30,
+ SelectionNotify = 31,
+ ColormapNotify = 32,
+ ClientMessage = 33,
+ MappingNotify = 34,
+ LASTEvent = 35,
+ ButtonPress = 4,
+ ButtonRelease = 5,
+ MotionNotify = 6,
+ EnterNotify = 7,
+ LeaveNotify = 8,
+ FocusIn = 9,
+ }
+
+ internal enum ErrorCodes : int
+ {
+ Success = 0,
+ BadRequest = 1,
+ BadValue = 2,
+ BadWindow = 3,
+ BadPixmap = 4,
+ BadAtom = 5,
+ BadCursor = 6,
+ BadFont = 7,
+ BadMatch = 8,
+ BadDrawable = 9,
+ BadAccess = 10,
+ BadAlloc = 11,
+ BadColor = 12,
+ BadGC = 13,
+ BadIDChoice = 14,
+ BadName = 15,
+ BadLength = 16,
+ BadImplementation = 17,
+ }
+
+ internal enum GrabMode : int
+ {
+ Sync = 0,
+ Async = 1,
+ }
+
+ [Flags]
+ internal enum EventMask : ulong
+ {
+ NoEventMask = 0,
+ KeyPressMask = (1L<<0),
+ KeyReeaseMask = (1L<<1),
+ Button3MotionMask = (1L<<10),
+ Button4MotionMask = (1L<<11),
+ Button5MotionMask = (1L<<12),
+ ButtonMotionMask = (1L<<13),
+ KeymapStateMask = (1L<<14),
+ ExposureMask = (1L<<15),
+ VisibiityChangeMask = (1L<<16),
+ StructureNotifyMask = (1L<<17),
+ ResizeRedirectMask = (1L<<18),
+ SubstructureNotifyMask = (1L<<19),
+ ButtonPressMask = (1L<<2),
+ SubstructureRedirectMask = (1L<<20),
+ FocusChangeMask = (1L<<21),
+ PropertyChangeMask = (1L<<22),
+ CoormapChangeMask = (1L<<23),
+ ButtonReeaseMask = (1L<<3),
+ EnterWindowMask = (1L<<4),
+ eaveWindowMask = (1L<<5),
+ PointerMotionMask = (1L<<6),
+ PointerMotionHintMask = (1L<<7),
+ Button1MotionMask = (1L<<8),
+ Button2MotionMask = (1L<<9),
+ }
+
+ [Flags]
+ internal enum CreateWindowMask : ulong
+ {
+ CWBackPixmap = (1L<<0),
+ CWBackPixel = (1L<<1),
+ CWSaveUnder = (1L<<10),
+ CWEventMask = (1L<<11),
+ CWDontPropagate = (1L<<12),
+ CWColormap = (1L<<13),
+ CWCursor = (1L<<14),
+ CWBorderPixmap = (1L<<2),
+ CWBorderPixel = (1L<<3),
+ CWBitGravity = (1L<<4),
+ CWWinGravity = (1L<<5),
+ CWBackingStore = (1L<<6),
+ CWBackingPlanes = (1L<<7),
+ CWBackingPixel = (1L<<8),
+ CWOverrideRedirect = (1L<<9),
+
+ /*
+ CWY = (1<<1),
+ CWWidth = (1<<2),
+ CWHeight = (1<<3),
+ CWBorderWidth = (1<<4),
+ CWSibling = (1<<5),
+ CWStackMode = (1<<6),
+ */
+ }
+
+ #endregion
+}
diff --git a/Source/OpenTK/Platform/X11/Glx.cs b/Source/OpenTK/Platform/X11/Glx.cs
new file mode 100644
index 00000000..bb5f1af0
--- /dev/null
+++ b/Source/OpenTK/Platform/X11/Glx.cs
@@ -0,0 +1,324 @@
+#region --- License ---
+/* Copyright (c) 2006, 2007 Stefanos Apostolopoulos
+ * Contributions from Erik Ylvisaker
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+
+namespace OpenTK.Platform.X11
+{
+ #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 GLsizei = System.Int32;
+ 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.Byte;
+ using GLubyte = System.Byte;
+ using GLshort = System.Int16;
+ using GLushort = System.Int16;
+ using GLint = System.Int32;
+ using GLuint = System.Int32;
+ using GLfloat = System.Single;
+ using GLclampf = System.Single;
+ using GLdouble = System.Double;
+ using GLclampd = System.Double;
+ using GLstring = System.String;
+ #endregion
+
+ ///
+ /// Provides access to GLX functions.
+ ///
+ internal static class Glx
+ {
+ // Disable BeforeFieldInit optimization.
+ static Glx() { }
+
+ const string _dll_name = "libGL.so.1";
+
+ #region Enums
+
+ public struct Enums
+ {
+ public enum GLXAttribute : int
+ {
+ TRANSPARENT_BLUE_VALUE_EXT = 0x27,
+ GRAY_SCALE = 0x8006,
+ RGBA_TYPE = 0x8014,
+ TRANSPARENT_RGB_EXT = 0x8008,
+ ACCUM_BLUE_SIZE = 16,
+ SHARE_CONTEXT_EXT = 0x800A,
+ STEREO = 6,
+ ALPHA_SIZE = 11,
+ FLOAT_COMPONENTS_NV = 0x20B0,
+ NONE = 0x8000,
+ DEPTH_SIZE = 12,
+ TRANSPARENT_INDEX_VALUE_EXT = 0x24,
+ MAX_PBUFFER_WIDTH_SGIX = 0x8016,
+ GREEN_SIZE = 9,
+ X_RENDERABLE_SGIX = 0x8012,
+ LARGEST_PBUFFER = 0x801C,
+ DONT_CARE = unchecked((int)0xFFFFFFFF),
+ TRANSPARENT_ALPHA_VALUE_EXT = 0x28,
+ PSEUDO_COLOR_EXT = 0x8004,
+ USE_GL = 1,
+ SAMPLE_BUFFERS_SGIS = 100000,
+ TRANSPARENT_GREEN_VALUE_EXT = 0x26,
+ HYPERPIPE_ID_SGIX = 0x8030,
+ COLOR_INDEX_TYPE_SGIX = 0x8015,
+ SLOW_CONFIG = 0x8001,
+ PRESERVED_CONTENTS = 0x801B,
+ ACCUM_RED_SIZE = 14,
+ EVENT_MASK = 0x801F,
+ VISUAL_ID_EXT = 0x800B,
+ EVENT_MASK_SGIX = 0x801F,
+ SLOW_VISUAL_EXT = 0x8001,
+ TRANSPARENT_GREEN_VALUE = 0x26,
+ MAX_PBUFFER_WIDTH = 0x8016,
+ DIRECT_COLOR_EXT = 0x8003,
+ VISUAL_ID = 0x800B,
+ ACCUM_GREEN_SIZE = 15,
+ DRAWABLE_TYPE_SGIX = 0x8010,
+ SCREEN_EXT = 0x800C,
+ SAMPLES = 100001,
+ HEIGHT = 0x801E,
+ TRANSPARENT_INDEX_VALUE = 0x24,
+ SAMPLE_BUFFERS_ARB = 100000,
+ PBUFFER = 0x8023,
+ RGBA_TYPE_SGIX = 0x8014,
+ MAX_PBUFFER_HEIGHT = 0x8017,
+ FBCONFIG_ID_SGIX = 0x8013,
+ DRAWABLE_TYPE = 0x8010,
+ SCREEN = 0x800C,
+ RED_SIZE = 8,
+ VISUAL_SELECT_GROUP_SGIX = 0x8028,
+ VISUAL_CAVEAT_EXT = 0x20,
+ PSEUDO_COLOR = 0x8004,
+ PBUFFER_HEIGHT = 0x8040,
+ STATIC_GRAY = 0x8007,
+ PRESERVED_CONTENTS_SGIX = 0x801B,
+ RGBA_FLOAT_TYPE_ARB = 0x20B9,
+ TRANSPARENT_RED_VALUE = 0x25,
+ TRANSPARENT_ALPHA_VALUE = 0x28,
+ WINDOW = 0x8022,
+ X_RENDERABLE = 0x8012,
+ STENCIL_SIZE = 13,
+ TRANSPARENT_RGB = 0x8008,
+ LARGEST_PBUFFER_SGIX = 0x801C,
+ STATIC_GRAY_EXT = 0x8007,
+ TRANSPARENT_BLUE_VALUE = 0x27,
+ DIGITAL_MEDIA_PBUFFER_SGIX = 0x8024,
+ BLENDED_RGBA_SGIS = 0x8025,
+ NON_CONFORMANT_VISUAL_EXT = 0x800D,
+ COLOR_INDEX_TYPE = 0x8015,
+ TRANSPARENT_RED_VALUE_EXT = 0x25,
+ GRAY_SCALE_EXT = 0x8006,
+ WINDOW_SGIX = 0x8022,
+ X_VISUAL_TYPE = 0x22,
+ MAX_PBUFFER_HEIGHT_SGIX = 0x8017,
+ DOUBLEBUFFER = 5,
+ OPTIMAL_PBUFFER_WIDTH_SGIX = 0x8019,
+ X_VISUAL_TYPE_EXT = 0x22,
+ WIDTH_SGIX = 0x801D,
+ STATIC_COLOR_EXT = 0x8005,
+ BUFFER_SIZE = 2,
+ DIRECT_COLOR = 0x8003,
+ MAX_PBUFFER_PIXELS = 0x8018,
+ NONE_EXT = 0x8000,
+ HEIGHT_SGIX = 0x801E,
+ RENDER_TYPE = 0x8011,
+ FBCONFIG_ID = 0x8013,
+ TRANSPARENT_INDEX_EXT = 0x8009,
+ TRANSPARENT_INDEX = 0x8009,
+ TRANSPARENT_TYPE_EXT = 0x23,
+ ACCUM_ALPHA_SIZE = 17,
+ PBUFFER_SGIX = 0x8023,
+ MAX_PBUFFER_PIXELS_SGIX = 0x8018,
+ OPTIMAL_PBUFFER_HEIGHT_SGIX = 0x801A,
+ DAMAGED = 0x8020,
+ SAVED_SGIX = 0x8021,
+ TRANSPARENT_TYPE = 0x23,
+ MULTISAMPLE_SUB_RECT_WIDTH_SGIS = 0x8026,
+ NON_CONFORMANT_CONFIG = 0x800D,
+ BLUE_SIZE = 10,
+ TRUE_COLOR_EXT = 0x8002,
+ SAMPLES_SGIS = 100001,
+ SAMPLES_ARB = 100001,
+ TRUE_COLOR = 0x8002,
+ RGBA = 4,
+ AUX_BUFFERS = 7,
+ SAMPLE_BUFFERS = 100000,
+ SAVED = 0x8021,
+ MULTISAMPLE_SUB_RECT_HEIGHT_SGIS = 0x8027,
+ DAMAGED_SGIX = 0x8020,
+ STATIC_COLOR = 0x8005,
+ PBUFFER_WIDTH = 0x8041,
+ WIDTH = 0x801D,
+ LEVEL = 3,
+ CONFIG_CAVEAT = 0x20,
+ RENDER_TYPE_SGIX = 0x8011,
+ }
+
+ public enum GLXHyperpipeAttrib : int
+ {
+ PIPE_RECT_LIMITS_SGIX = 0x00000002,
+ PIPE_RECT_SGIX = 0x00000001,
+ HYPERPIPE_STEREO_SGIX = 0x00000003,
+ HYPERPIPE_PIXEL_AVERAGE_SGIX = 0x00000004,
+ }
+
+ public enum GLXStringName : int
+ {
+ EXTENSIONS = 0x3,
+ VERSION = 0x2,
+ VENDOR = 0x1,
+ }
+
+ public enum GLXEventMask : int
+ {
+ PBUFFER_CLOBBER_MASK = 0x08000000,
+ BUFFER_CLOBBER_MASK_SGIX = 0x08000000,
+ }
+
+ public enum GLXRenderTypeMask : int
+ {
+ COLOR_INDEX_BIT_SGIX = 0x00000002,
+ RGBA_BIT = 0x00000001,
+ RGBA_FLOAT_BIT_ARB = 0x00000004,
+ RGBA_BIT_SGIX = 0x00000001,
+ COLOR_INDEX_BIT = 0x00000002,
+ }
+
+ public enum GLXHyperpipeTypeMask : int
+ {
+ HYPERPIPE_RENDER_PIPE_SGIX = 0x00000002,
+ HYPERPIPE_DISPLAY_PIPE_SGIX = 0x00000001,
+ }
+
+ public enum GLXPbufferClobberMask : int
+ {
+ ACCUM_BUFFER_BIT_SGIX = 0x00000080,
+ FRONT_LEFT_BUFFER_BIT = 0x00000001,
+ BACK_RIGHT_BUFFER_BIT = 0x00000008,
+ FRONT_RIGHT_BUFFER_BIT_SGIX = 0x00000002,
+ STENCIL_BUFFER_BIT_SGIX = 0x00000040,
+ SAMPLE_BUFFERS_BIT_SGIX = 0x00000100,
+ STENCIL_BUFFER_BIT = 0x00000040,
+ BACK_RIGHT_BUFFER_BIT_SGIX = 0x00000008,
+ BACK_LEFT_BUFFER_BIT_SGIX = 0x00000004,
+ AUX_BUFFERS_BIT = 0x00000010,
+ DEPTH_BUFFER_BIT_SGIX = 0x00000020,
+ ACCUM_BUFFER_BIT = 0x00000080,
+ AUX_BUFFERS_BIT_SGIX = 0x00000010,
+ DEPTH_BUFFER_BIT = 0x00000020,
+ FRONT_LEFT_BUFFER_BIT_SGIX = 0x00000001,
+ BACK_LEFT_BUFFER_BIT = 0x00000004,
+ FRONT_RIGHT_BUFFER_BIT = 0x00000002,
+ }
+
+ public enum GLXHyperpipeMisc : int
+ {
+ HYPERPIPE_PIPE_NAME_LENGTH_SGIX = 80,
+ }
+
+ public enum GLXErrorCode : int
+ {
+ BAD_CONTEXT = 5,
+ NO_EXTENSION = 3,
+ BAD_HYPERPIPE_SGIX = 92,
+ BAD_ENUM = 7,
+ BAD_SCREEN = 1,
+ BAD_VALUE = 6,
+ BAD_ATTRIBUTE = 2,
+ BAD_VISUAL = 4,
+ BAD_HYPERPIPE_CONFIG_SGIX = 91,
+ }
+
+ public enum GLXSyncType : int
+ {
+ SYNC_SWAP_SGIX = 0x00000001,
+ SYNC_FRAME_SGIX = 0x00000000,
+ }
+
+ public enum GLXDrawableTypeMask : int
+ {
+ WINDOW_BIT = 0x00000001,
+ PIXMAP_BIT = 0x00000002,
+ PBUFFER_BIT_SGIX = 0x00000004,
+ PBUFFER_BIT = 0x00000004,
+ WINDOW_BIT_SGIX = 0x00000001,
+ PIXMAP_BIT_SGIX = 0x00000002,
+ }
+
+ }
+
+ #endregion
+
+ #region GLX functions
+
+ [DllImport(_dll_name, EntryPoint = "glXCreateContext")]
+ internal static extern IntPtr CreateContext(IntPtr dpy, IntPtr vis, IntPtr shareList, bool direct);
+
+ internal static IntPtr CreateContext(IntPtr dpy, VisualInfo vis, IntPtr shareList, bool direct)
+ {
+ GCHandle h0 = GCHandle.Alloc(vis, GCHandleType.Pinned);
+
+ try
+ {
+ return CreateContext(dpy, h0.AddrOfPinnedObject(), shareList, direct);
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+
+ [DllImport(_dll_name, EntryPoint = "glXDestroyContext")]
+ public static extern void DestroyContext(IntPtr dpy, IntPtr context);
+
+ [DllImport(_dll_name, EntryPoint = "glXMakeCurrent")]
+ public static extern bool MakeCurrent(IntPtr display, IntPtr drawable, IntPtr context);
+
+ [DllImport(_dll_name, EntryPoint = "glXSwapBuffers")]
+ public static extern void SwapBuffers(IntPtr display, IntPtr drawable);
+
+ [DllImport(_dll_name, EntryPoint = "glXGetProcAddress")]
+ public static extern IntPtr GetProcAddress([MarshalAs(UnmanagedType.LPTStr)] string procName);
+
+ #region glXChooseVisual
+
+ [DllImport(_dll_name, EntryPoint = "glXChooseVisual")]
+ internal extern static IntPtr ChooseVisual(IntPtr dpy, int screen, IntPtr attriblist);
+
+ internal static IntPtr ChooseVisual(IntPtr dpy, int screen, int[] attriblist)
+ {
+ GCHandle h0 = GCHandle.Alloc(attriblist, GCHandleType.Pinned);
+
+ try
+ {
+ return ChooseVisual(dpy, screen, h0.AddrOfPinnedObject());
+ }
+ finally
+ {
+ h0.Free();
+ }
+ }
+
+ #endregion
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Platform/X11/X11GLContext.cs b/Source/OpenTK/Platform/X11/X11GLContext.cs
new file mode 100644
index 00000000..3bdf8396
--- /dev/null
+++ b/Source/OpenTK/Platform/X11/X11GLContext.cs
@@ -0,0 +1,302 @@
+#region --- License ---
+/* Copyright (c) 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+
+using OpenTK.OpenGL;
+
+namespace OpenTK.Platform.X11
+{
+ public class X11GLContext : OpenTK.Platform.IGLContext
+ {
+ private IntPtr x11context;
+ private IntPtr display;
+ private int screenNo;
+
+ private DisplayMode mode;// = new DisplayMode();
+ internal X11WindowInfo windowInfo = new X11WindowInfo();
+ private VisualInfo visualInfo;
+
+ //private IntPtr desktopResolution = IntPtr.Zero;
+
+ //private int depthBits;
+ //private int stencilBits;
+
+ // These have to be used by the X11GLControl.
+ internal IntPtr visual;
+ internal IntPtr colormap;
+
+ private bool disposed;
+
+ #region --- Public Constructor ---
+
+ private X11GLContext()
+ {
+ this.mode = new DisplayMode();
+ }
+
+ public X11GLContext(IWindowInfo info, DisplayMode mode)
+ {
+ X11WindowInfo xInfo = info as X11WindowInfo;
+ this.windowInfo.Window = xInfo.Window;
+ this.windowInfo.RootWindow = xInfo.RootWindow;
+ this.windowInfo.TopLevelWindow = xInfo.TopLevelWindow;
+ this.windowInfo.Display = xInfo.Display;
+ this.windowInfo.Screen = xInfo.Screen;
+
+ this.mode = mode;
+ }
+
+ public X11GLContext(
+ IntPtr handle,
+ IntPtr display,
+ IntPtr rootWindow,
+ int screenNo,
+ IntPtr handleToTopLevelControl,
+ ColorDepth color,
+ ColorDepth accum,
+ int depthBits,
+ int stencilBits,
+ int auxBits,
+ bool stereo,
+ bool doublebuffer
+ )
+ {
+ Trace.WriteLine("Creating opengl context (X11GLContext driver)");
+ Trace.Indent();
+
+ this.display = display;
+ this.screenNo = screenNo;
+ //this.depthBits = depthBits;
+ //this.stencilBits = stencilBits;
+
+ this.CreateVisual();
+ }
+
+ #endregion
+
+ #region --- IGLContext Members ---
+
+ #region public void SwapBuffers()
+
+ public void SwapBuffers()
+ {
+ Glx.SwapBuffers(windowInfo.Display, windowInfo.Window);
+ }
+
+ #endregion
+
+ #region public void MakeCurrent()
+
+ public void MakeCurrent()
+ {
+ Debug.Write(
+ String.Format(
+ "Making context {0} current on thread {1} (display: {2}, window: {3})... ",
+ x11context,
+ System.Threading.Thread.CurrentThread.ManagedThreadId,
+ windowInfo.Display,
+ windowInfo.Window
+ )
+ );
+ bool result = Glx.MakeCurrent(windowInfo.Display, windowInfo.Window, x11context);
+
+ if (!result)
+ {
+ Debug.WriteLine(String.Format("Failed to make context {0} current.", x11context));
+ // probably need to recreate context here.
+ throw new Exception(String.Format("Failed to make context {0} current.", x11context));
+ }
+ else
+ {
+ Debug.WriteLine("done!");
+ }
+ }
+
+ #endregion
+
+ public bool IsCurrent()
+ {
+ throw new NotImplementedException();
+ }
+
+ #region public IntPtr GetAddress(string function)
+
+ public IntPtr GetAddress(string function)
+ {
+ return Glx.GetProcAddress(function);
+ }
+
+ #endregion
+
+ public IEnumerable GetDisplayModes()
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private void Dispose(bool manuallyCalled)
+ {
+ if (!disposed)
+ {
+ // Clean unmanaged resources:
+ Glx.DestroyContext(windowInfo.Display, x11context);
+ API.Free(visual);
+
+ if (manuallyCalled)
+ {
+ // Safe to clean managed resources, too
+ }
+ }
+ disposed = true;
+ }
+
+ ~X11GLContext()
+ {
+ this.Dispose(false);
+ }
+
+ #endregion
+
+ #region public void CreateContext(X11GLContext shareContext, bool direct)
+
+ public void CreateContext(X11GLContext shareContext, bool direct)
+ {
+ Trace.WriteLine("Creating opengl context.");
+ Trace.Indent();
+
+ IntPtr shareHandle = shareContext != null ? shareContext.Handle : IntPtr.Zero;
+ Trace.WriteLine(
+ shareHandle == IntPtr.Zero ?
+ "Context is not shared." :
+ String.Format("Context is shared with context: {0}", shareHandle)
+ );
+ Trace.WriteLine(
+ direct ?
+ "Context is direct." :
+ "Context is indirect."
+ );
+ x11context = Glx.CreateContext(
+ windowInfo.Display,
+ visual,
+ shareHandle,
+ direct
+ );
+ Trace.WriteLine(String.Format("New opengl context created. (id: {0})", x11context));
+ Trace.Unindent();
+
+ //MakeCurrent();
+ }
+
+ #endregion
+
+ #region public void CreateVisual()
+
+ public void CreateVisual()
+ {
+ Trace.WriteLine("Creating visual.");
+ Trace.Indent();
+
+ ColorDepth color = new ColorDepth(24);
+ int depthBits = 16;
+
+ // Create the Visual
+ List visualAttributes = new List();
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.RGBA);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.RED_SIZE);
+ visualAttributes.Add((int)color.Red);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.GREEN_SIZE);
+ visualAttributes.Add((int)color.Green);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.BLUE_SIZE);
+ visualAttributes.Add((int)color.Blue);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.ALPHA_SIZE);
+ visualAttributes.Add((int)color.Alpha);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.DEPTH_SIZE);
+ visualAttributes.Add((int)depthBits);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.DOUBLEBUFFER);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.NONE);
+
+ /*
+ List visualAttributes = new List();
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.RGBA);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.RED_SIZE);
+ visualAttributes.Add((int)mode.Color.Red);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.GREEN_SIZE);
+ visualAttributes.Add((int)mode.Color.Green);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.BLUE_SIZE);
+ visualAttributes.Add((int)mode.Color.Blue);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.ALPHA_SIZE);
+ visualAttributes.Add((int)mode.Color.Alpha);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.DEPTH_SIZE);
+ visualAttributes.Add((int)depthBits);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.DOUBLEBUFFER);
+ visualAttributes.Add((int)Glx.Enums.GLXAttribute.NONE);
+ */
+ Trace.Write(
+ String.Format(
+ "Requesting visual: {0} ({1}{2}{3}{4})... ",
+ mode.ToString(),
+ mode.Color.Red,
+ mode.Color.Green,
+ mode.Color.Blue,
+ mode.Color.Alpha
+ )
+ );
+
+ visual = Glx.ChooseVisual(windowInfo.Display, windowInfo.Screen, visualAttributes.ToArray());
+ if (visual == IntPtr.Zero)
+ {
+ throw new Exception("Requested visual not available.");
+ }
+ visualInfo = (VisualInfo)Marshal.PtrToStructure(visual, typeof(VisualInfo));
+
+ Trace.WriteLine(String.Format("done! (id: {0})", x11context));
+ Trace.Unindent();
+ }
+
+ #endregion
+
+ public IntPtr XVisual
+ {
+ get { return this.visual; }
+ }
+
+ public VisualInfo XVisualInfo
+ {
+ get { return this.visualInfo; }
+ }
+
+ public IntPtr XColormap
+ {
+ get { return colormap; }
+ }
+
+ public IntPtr Handle
+ {
+ get { return this.x11context; }
+ }
+/*
+ public IntPtr ContainingWindow
+ {
+ get { return windowInfo.Window; }
+ internal set { windowInfo.Window = value; }
+ }
+*/
+ }
+}
diff --git a/Source/OpenTK/Platform/X11/X11GLControl.cs b/Source/OpenTK/Platform/X11/X11GLControl.cs
new file mode 100644
index 00000000..9e8dc498
--- /dev/null
+++ b/Source/OpenTK/Platform/X11/X11GLControl.cs
@@ -0,0 +1,219 @@
+#region --- License ---
+/* Copyright (c) 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows.Forms;
+using System.Drawing;
+using System.Diagnostics;
+
+namespace OpenTK.Platform.X11
+{
+ sealed class X11GLControl : IGLControl
+ {
+ X11WindowInfo info = new X11WindowInfo();
+ private Type xplatui;
+ X11GLContext glContext;
+
+ private bool quit;
+
+ private bool disposed;
+
+ #region --- Contructors ---
+
+ public X11GLControl(UserControl c, int width, int height, bool fullscreen)
+ {
+ Trace.WriteLine("Creating opengl control (X11GLControl driver)");
+ Trace.Indent();
+
+ c.ParentChanged += new EventHandler(c_ParentChanged);
+ if (c.ParentForm != null)
+ throw new Exception("I was stupid!");
+
+ if (c == null/* || c.TopLevelControl == null*/)
+ {
+ throw new Exception("Attempted to bind to non-existent control.");
+ }
+
+ info.Window = c.Handle;
+ Trace.WriteLine(
+ String.Format(
+ "Binding to control: {0}",
+ String.IsNullOrEmpty(c.Name) ? c.Text : c.Name
+ )
+ );
+
+ xplatui = Type.GetType("System.Windows.Forms.XplatUIX11, System.Windows.Forms");
+ Trace.WriteLine("Acquired System.Windows.Forms.XplatUIX11 type.");
+
+ if (xplatui != null)
+ {
+ info.Display = (IntPtr)xplatui.GetField("DisplayHandle",
+ System.Reflection.BindingFlags.Static |
+ System.Reflection.BindingFlags.NonPublic).GetValue(null);
+
+ info.RootWindow = (IntPtr)xplatui.GetField("RootWindow",
+ System.Reflection.BindingFlags.Static |
+ System.Reflection.BindingFlags.NonPublic).GetValue(null);
+
+ info.Screen = (int)xplatui.GetField("ScreenNo",
+ System.Reflection.BindingFlags.Static |
+ System.Reflection.BindingFlags.NonPublic).GetValue(null);
+
+ Trace.WriteLine(
+ String.Format(
+ "Screen: {0}, Display: {1}, Root Window: {2}, Control: {3}",
+ info.Screen,
+ info.Display,
+ info.RootWindow,
+ info.Window
+ )
+ );
+
+ glContext = new X11GLContext(info, new DisplayMode(
+ width, height, new ColorDepth(24), 16, 0, 0, 2, false, false, false, 0.0f)
+ );
+ glContext.CreateVisual();
+
+ xplatui.GetField(
+ "CustomVisual",
+ System.Reflection.BindingFlags.Static |
+ System.Reflection.BindingFlags.NonPublic).SetValue(
+ null,
+ glContext.XVisual
+ );
+
+ xplatui.GetField(
+ "CustomColormap",
+ System.Reflection.BindingFlags.Static |
+ System.Reflection.BindingFlags.NonPublic).SetValue(
+ null,
+ glContext.XColormap
+ );
+
+ glContext.CreateContext(null, true);
+ }
+ }
+
+ void c_ParentChanged(object sender, EventArgs e)
+ {
+ UserControl c = sender as UserControl;
+ Trace.WriteLine(
+ String.Format(
+ "TopLevel control is {0}",
+ c.TopLevelControl != null ? c.TopLevelControl.ToString() : "not available"
+ )
+ );
+
+ if (c.TopLevelControl == null)
+ {
+ info.TopLevelWindow = c.Handle;
+ throw new Exception("GLControl does not have a parent.");
+ }
+ else
+ {
+ info.TopLevelWindow = c.TopLevelControl.Handle;
+ }
+
+ Trace.WriteLine(String.Format("Mapping window to top level: {0}", info.TopLevelWindow));
+ API.MapRaised(info.Display, info.TopLevelWindow);
+ Trace.Unindent();
+ }
+
+ #endregion
+
+ #region --- IGLControl Members ---
+
+ public event CreateEvent Create;
+
+ private void OnCreate(object sender, EventArgs e)
+ {
+ if (this.Create != null)
+ this.Create(sender, e);
+ }
+
+ #region public bool Quit
+
+ public bool Quit
+ {
+ get { return quit; }
+ set
+ {
+ throw new NotImplementedException();
+ quit = value;
+ }
+ }
+
+ #endregion
+
+ public bool IsIdle
+ {
+ get
+ {
+ return API.Pending(info.Display) == 0;
+ }
+ }
+
+ public bool Fullscreen
+ {
+ get
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+ set
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+ }
+
+ public OpenTK.Platform.IGLContext Context
+ {
+ get
+ {
+ return glContext;
+ }
+ }
+
+ public void ProcessEvents()
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private void Dispose(bool manuallyCalled)
+ {
+ if (!disposed)
+ {
+ // Clean unmanaged resources:
+
+
+ if (manuallyCalled)
+ {
+ // Clean managed resources, too
+ glContext.Dispose();
+ }
+ }
+ disposed = true;
+ }
+
+ ~X11GLControl()
+ {
+ this.Dispose(false);
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Platform/X11/X11GLNative.cs b/Source/OpenTK/Platform/X11/X11GLNative.cs
new file mode 100644
index 00000000..6b39ad76
--- /dev/null
+++ b/Source/OpenTK/Platform/X11/X11GLNative.cs
@@ -0,0 +1,438 @@
+#region --- License ---
+/* Copyright (c) 2007 Stefanos Apostolopoulos
+ * See license.txt for license info
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+
+//using OpenTK.OpenGL;
+
+namespace OpenTK.Platform.X11
+{
+ sealed class X11GLNative : OpenTK.Platform.INativeWindow, IDisposable
+ {
+ #region --- Private Fields ---
+
+ private X11GLContext glContext;
+ private X11WindowInfo windowInfo = new X11WindowInfo();
+ private IntPtr display;
+ private int screen;
+ private IntPtr rootWindow;
+ private IntPtr window;
+
+ private DisplayMode mode = new DisplayMode();
+
+ // Number of pending events.
+ private int pending = 0;
+ // C# ResizeEventArgs
+ private ResizeEventArgs resizeEventArgs = new ResizeEventArgs();
+ // Low level X11 resize request
+ private X11.Event xresize = new Event();
+ // This is never written in the code. If at some point it gets != 0,
+ // then memory corruption is taking place from the xresize struct.
+ // Event used for event loop.
+ private Event e = new Event();
+ private ConfigureNotifyEvent configure = new ConfigureNotifyEvent();
+ private ReparentNotifyEvent reparent = new ReparentNotifyEvent();
+ private ExposeEvent expose = new ExposeEvent();
+ private CreateWindowEvent createWindow = new CreateWindowEvent();
+ private DestroyWindowEvent destroyWindow = new DestroyWindowEvent();
+ // This is never written in the code. If at some point it gets != 0,
+ // then memory corruption is taking place from the xresize struct.
+ int memGuard = 0;
+
+ //private int width, height;
+
+ private bool disposed;
+
+ #endregion
+
+ #region --- Public Constructors ---
+
+ ///
+ /// Constructs a new X11GLNative window, with its associated context.
+ /// Safe defaults for visual, colormap, etc.
+ ///
+ public X11GLNative()
+ {
+ Trace.WriteLine("Creating GameWindow (X11GLNative driver)");
+ Trace.Indent();
+
+ // Set default (safe) DisplayMode.
+ mode.Width = 640;
+ mode.Height = 480;
+ mode.Color = new ColorDepth(24);
+ mode.DepthBits = 16;
+ mode.Buffers = 2;
+
+ Trace.WriteLine(String.Format("Display mode: {0}", mode));
+
+ windowInfo.Display = display = API.OpenDisplay(null); // null == default display
+ if (display == IntPtr.Zero)
+ {
+ throw new Exception("Could not open connection to X");
+ }
+ windowInfo.Screen = screen = API.DefaultScreen(display);
+ windowInfo.RootWindow = rootWindow = API.RootWindow(display, screen);
+
+ Trace.WriteLine(
+ String.Format(
+ "Display: {0}, Screen {1}, Root window: {2}",
+ windowInfo.Display,
+ windowInfo.Screen,
+ windowInfo.RootWindow
+ )
+ );
+
+ glContext = new X11GLContext(windowInfo, mode);
+ glContext.CreateVisual();
+
+ // Create a window on this display using the visual above
+ Trace.Write("Creating output window... ");
+
+ SetWindowAttributes wnd_attributes = new SetWindowAttributes();
+ wnd_attributes.background_pixel = 0;
+ wnd_attributes.border_pixel = 0;
+ wnd_attributes.colormap = glContext.XColormap;
+ //API.CreateColormap(display, rootWindow, glxVisualInfo.visual, 0/*AllocNone*/);
+ wnd_attributes.event_mask =
+ EventMask.StructureNotifyMask |
+ EventMask.ExposureMask |
+ EventMask.KeyPressMask;
+
+ CreateWindowMask cw_mask =
+ CreateWindowMask.CWBackPixel |
+ CreateWindowMask.CWBorderPixel |
+ CreateWindowMask.CWColormap |
+ CreateWindowMask.CWEventMask;
+
+ window = API.CreateWindow(
+ windowInfo.Display,
+ windowInfo.RootWindow,
+ 0, 0,
+ 640, 480,
+ 0,
+ //glxVisualInfo.depth,
+ glContext.XVisualInfo.depth,
+ Constants.InputOutput,
+ //glxVisualInfo.visual,
+ glContext.XVisualInfo.visual,
+ cw_mask,
+ wnd_attributes
+ );
+
+ if (window == IntPtr.Zero)
+ {
+ throw new Exception("Could not create window.");
+ }
+
+ Trace.WriteLine("done! (id: " + window + ")");
+
+ // Set the window hints
+ /*
+ SizeHints hints = new SizeHints();
+ hints.x = 0;
+ hints.y = 0;
+ hints.width = 640;
+ hints.height = 480;
+ hints.flags = USSize | USPosition;
+ X11Api.SetNormalHints(display, window, hints);
+ X11Api.SetStandardProperties(
+ display,
+ window,
+ name,
+ name,
+ 0, // None
+ null,
+ 0,
+ hints
+ );
+ */
+
+ //glContext.ContainingWindow = windowInfo.Window;
+ glContext.windowInfo.Window = window;
+ glContext.CreateContext(null, true);
+
+ API.MapRaised(display, window);
+
+ Trace.WriteLine("Mapped window.");
+
+ //glContext.MakeCurrent();
+
+ Trace.WriteLine("Our shiny new context is now current - ready to rock 'n' roll!");
+ Trace.Unindent();
+ }
+
+ #endregion
+
+ #region --- IGLWindow Members ---
+
+ #region public void ProcessEvents()
+
+ public void ProcessEvents()
+ {
+ // Process all pending events
+ while (true)
+ {
+ pending = API.Pending(display);
+
+ if (pending == 0)
+ return;
+
+ //API.NextEvent(display, e);
+ API.PeekEvent(display, e);
+ //API.NextEvent(display, eventPtr);
+
+
+ Debug.WriteLine(String.Format("Event: {0} ({1} pending)", e.Type, pending));
+ //Debug.WriteLine(String.Format("Event: {0} ({1} pending)", eventPtr, pending));
+
+ // Check whether memory was corrupted by the NextEvent call.
+ Debug.Assert(memGuard == 0, "memGuard2 tripped", String.Format("Guard: {0}", memGuard));
+ memGuard = 0;
+
+ // Respond to the event e
+ switch (e.Type)
+ {
+ case EventType.ReparentNotify:
+ API.NextEvent(display, reparent);
+ // Do nothing
+ break;
+
+ case EventType.CreateNotify:
+ API.NextEvent(display, createWindow);
+
+ // Set window width/height
+ mode.Width = createWindow.width;
+ mode.Height = createWindow.height;
+ this.OnCreate(EventArgs.Empty);
+ Debug.WriteLine(
+ String.Format("OnCreate fired: {0}x{1}", mode.Width, mode.Height)
+ );
+ break;
+
+ case EventType.DestroyNotify:
+ API.NextEvent(display, destroyWindow);
+ quit = true;
+ Debug.WriteLine("Window destroyed, shutting down.");
+ break;
+
+
+ case EventType.ConfigureNotify:
+ API.NextEvent(display, configure);
+
+ // If the window size changed, raise the C# Resize event.
+ if (configure.width != mode.Width ||
+ configure.height != mode.Height)
+ {
+ Debug.WriteLine(
+ String.Format(
+ "New res: {0}x{1}",
+ configure.width,
+ configure.height
+ )
+ );
+
+ resizeEventArgs.Width = configure.width;
+ resizeEventArgs.Height = configure.height;
+ this.OnResize(resizeEventArgs);
+ }
+ break;
+
+ default:
+ API.NextEvent(display, e);
+ Debug.WriteLine(String.Format("{0} event was not handled", e.Type));
+ break;
+ }
+ }
+ }
+
+ #endregion
+
+ #region public event CreateEvent Create;
+
+ public event CreateEvent Create;
+
+ private void OnCreate(EventArgs e)
+ {
+ if (this.Create != null)
+ {
+ this.Create(this, e);
+ }
+ }
+
+ #endregion
+
+ #region public bool Quit
+
+ private bool quit;
+ public bool Quit
+ {
+ get { return quit; }
+ set
+ {
+ if (value)
+ {
+ /*Event e = new Event();
+ X11Api.SendEvent(
+ display,
+ window,
+ false,
+ 0,*/
+ //quit = true;
+ }
+ }
+ }
+
+ #endregion
+
+ #region public bool IsIdle
+
+ public bool IsIdle
+ {
+ get { throw new Exception("The method or operation is not implemented."); }
+ }
+
+ #endregion
+
+ #region public bool Fullscreen
+
+ public bool Fullscreen
+ {
+ get
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+ set
+ {
+ throw new Exception("The method or operation is not implemented.");
+ }
+ }
+
+ #endregion
+
+ #region public IGLContext Context
+
+ public OpenTK.Platform.IGLContext Context
+ {
+ get { return glContext; }
+ }
+
+ #endregion
+
+ #endregion
+
+ #region --- IResizable Members ---
+
+ #region public int Width
+
+ public int Width
+ {
+ get
+ {
+ return mode.Width;
+ }
+ set
+ {/*
+ // Clear event struct
+ //Array.Clear(xresize.pad, 0, xresize.pad.Length);
+ // Set requested parameters
+ xresize.ResizeRequest.type = EventType.ResizeRequest;
+ xresize.ResizeRequest.display = this.display;
+ xresize.ResizeRequest.width = value;
+ xresize.ResizeRequest.height = mode.Width;
+ API.SendEvent(
+ this.display,
+ this.window,
+ false,
+ EventMask.StructureNotifyMask,
+ ref xresize
+ );*/
+ }
+ }
+
+ #endregion
+
+ #region public int Height
+
+ public int Height
+ {
+ get
+ {
+ return mode.Height;
+ }
+ set
+ {/*
+ // Clear event struct
+ //Array.Clear(xresize.pad, 0, xresize.pad.Length);
+ // Set requested parameters
+ xresize.ResizeRequest.type = EventType.ResizeRequest;
+ xresize.ResizeRequest.display = this.display;
+ xresize.ResizeRequest.width = mode.Width;
+ xresize.ResizeRequest.height = value;
+ API.SendEvent(
+ this.display,
+ this.window,
+ false,
+ EventMask.StructureNotifyMask,
+ ref xresize
+ );*/
+ }
+ }
+
+ #endregion
+
+ #region public event ResizeEvent Resize
+
+ public event ResizeEvent Resize;
+
+ private void OnResize(ResizeEventArgs e)
+ {
+ mode.Width = e.Width;
+ mode.Height = e.Height;
+ if (this.Resize != null)
+ {
+ this.Resize(this, e);
+ }
+ }
+
+ #endregion
+
+ #endregion
+
+ #region --- IDisposable Members ---
+
+ public void Dispose()
+ {
+ this.Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ private void Dispose(bool manuallyCalled)
+ {
+ if (!disposed)
+ {
+ API.DestroyWindow(display, window);
+ API.CloseDisplay(display);
+
+ if (manuallyCalled)
+ {
+ glContext.Dispose();
+ }
+ disposed = true;
+ }
+ }
+
+ ~X11GLNative()
+ {
+ this.Dispose(false);
+ }
+
+ #endregion
+ }
+}
diff --git a/Source/OpenTK/Platform/X11/X11WindowInfo.cs b/Source/OpenTK/Platform/X11/X11WindowInfo.cs
new file mode 100644
index 00000000..5622133a
--- /dev/null
+++ b/Source/OpenTK/Platform/X11/X11WindowInfo.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenTK.Platform.X11
+{
+ public class X11WindowInfo : IWindowInfo
+ {
+ public IntPtr RootWindow;
+ public IntPtr Window;
+ public IntPtr TopLevelWindow;
+ public IntPtr Display;
+ public int Screen;
+ }
+}
diff --git a/Source/OpenTK/Properties/AssemblyInfo.cs b/Source/OpenTK/Properties/AssemblyInfo.cs
new file mode 100644
index 00000000..0eab9ce1
--- /dev/null
+++ b/Source/OpenTK/Properties/AssemblyInfo.cs
@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+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("OpenTK Framework")]
+[assembly: AssemblyDescription("Create OpenGL applications in C#.")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("OpenTK.Framework")]
+[assembly: AssemblyCopyright("Copyright © 2006-2007 Stefanos Apostolopoulos")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7652241e-158d-4eb1-85f4-ed40ee356791")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// 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.8.0")]
+[assembly: AssemblyFileVersion("0.3.8.0")]