OpenGL 4.3
authorsaschawillems <webmaster@saschawillems.de>
Thu, 8 May 2014 19:03:26 +0000 (21:03 +0200)
committersaschawillems <webmaster@saschawillems.de>
Thu, 8 May 2014 19:03:26 +0000 (21:03 +0200)
dglOpenGL.html [new file with mode: 0644]
dglOpenGL.pas [new file with mode: 0644]

diff --git a/dglOpenGL.html b/dglOpenGL.html
new file mode 100644 (file)
index 0000000..fa3ce8a
--- /dev/null
@@ -0,0 +1,185 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="de" >
+<head>
+  <title>Delphi/Free Pascal OpenGL Community - OpenGL Header</title>
+
+  <style type="text/css" media="all">
+<!--
+  body {
+    color: #000000; 
+    background: #FFFFFF; 
+    font-family: lucida sans, sans, verdana, tahoma;
+    font-size: 12px;
+    margin: 10px;
+  }
+
+  #content {
+    margin: 0 0 0 10px;
+  }
+
+  #content pre {
+    font-family: monospace; 
+    font-size: 90%; 
+    color: #000000; 
+    background: #F7F7F7; 
+    border-width: 1px; 
+    border-color: #AAAAAA; 
+    border-style: solid;
+    margin-left: 15px;
+    padding-left: 3px;
+  }
+
+  #content p {
+    margin: 0 0 10px 15px;
+  }
+
+  #content ul {
+    margin-top: 0;
+    margin-bottom: 0;
+  }
+
+  h1 {
+    margin: 0 0 5px;
+    font-size: 195%;
+    font-weight: bold;
+  }
+
+  h2 {
+    margin: 15px 0 5px;
+    font-size: 125%;
+    border-bottom: 1px solid #888;
+  }
+
+  h3 {
+    font-style: italic;
+    margin: 5px 0 5px;
+    font-size: 100%;
+  }
+-->
+  </style>
+</head>
+<body>
+  <div id="header">
+    <h1>Delphi/Free Pascal OpenGL Header for OpenGL 4.4a - Readme -</h1>
+    <div id="content">
+      <p>(obtained and maintained through <a href="http://www.delphigl.com" target="_blank">www.delphigl.com</a>)</p>
+    </div>
+  </div>
+  
+  <div id="content">
+    <h2>Content</h2>
+    <p><a href="#desc">Description</a><br>
+    <a href="#howto">How to use</a><br>
+    <a href="#support">Support</a><br>
+    <a href="#credits">Credits</a><br>
+    <a href="#copyright">Copyright</a><br></p>
+  </div>
+
+  <div id="content">
+    <a name="desc" />
+    <h2>Description</h2>
+    <p>This is the readme for the OpenGL-Headers for Delphi/FreePascal that has been developed by DGL's OpenGL2.0-Portteam. Please read carefully through this file before using the header to avoid common problems and faults.
+       
+       The changelog is included in the source file itself.
+       </p>
+    </p>
+  </div>
+
+  <div id="content">
+    <h2>Note</h2>
+    <p>OpenGL-Header is for Borland Delphi 4 and above (tested with Delphi 7) and FreePascal.<br />
+    Containts the translations of glext.h, gl_1_1.h, glu.h and weglext.h.<br />
+    It also contains some helperfunctions that were inspired by those found in Mike Lischke's OpenGL12.pas.</p>
+  </div>
+
+  <div id="content">
+    <a name="howto" />
+    <h2>How to use</h2>
+    <p>Before you can use any of the gl-functions contained in the header, you'll have to call InitOpenGL to initialize the functionpointers. In your app it should look something like that :</p>
+
+    <pre id="code">
+procedure MyGLInit;
+begin
+  InitOpenGL; // Don't forget, or first gl-Call will result in an access violation!
+  MyDC := GetDC(...);
+  MyRC := CreateRenderingContext(...);
+  ActivateRenderingContext(MyDC, MyRC); // Necessary, will also read some extension
+  ...
+end;</pre>
+    <p>After doing the above initialisation, you're ready to use all OpenGL-Functions and extensions your card supports. And also don't forget to release your context properly when exiting :</p>
+    <pre id="code">
+procedure MyDeInit;
+begin
+  DeactivateRenderingContext; // Deactivates the current context
+  wglDeleteContext(myRC);
+  ReleaseDC(Handle, myDC);
+end;</pre>
+  </div>
+  
+<div id="content">
+    <a name="howto" />
+    <h2>Creating a versioned rendering context</h2>
+    <p>As of OpenGL version 4.4, the header offers an additional way of creating a rendercontext, that allows for setting the desired OpenGL version and (if applicable) wether to create a forward compatible context (see OpenGL man pages on what that means) :
+    <pre id="code">
+procedure MyGLInit;
+begin
+  DC := GetDC(...);
+  RC := CreateRenderingContextVersion(DC, [opDoubleBuffered], 4, 2, True, 32, 24, 8, 0, 0, 0); // Creates an OpenGL 4.2 forward-compatible context
+  InitOpenGL; // Don't forget, or first gl-Call will result in an access violation!
+  ...
+end;</pre>
+Only use this method of creating a rendering context if you're sure what you're doing. Trying to create a versioned rendering context that's not supported by the target OpenGL implementation may fail!
+
+       </p>
+  </div>
+  
+
+  <div id="content">
+    <a name="support" />
+    <h2>Support</h2>
+    <p>If you have problems, want to ask a question or think you may have encountered a bug in the header, please feel free to use the support-threads in our forums :<br />
+    <a href="http://www.delphigl.com/forum/viewtopic.php?t=2207" target="_blank">English support</a><br />
+    <a href="http://www.delphigl.com/forum/viewtopic.php?t=1863" target="_blank">German support</a></p>
+  </div>
+
+  <div id="content">
+    <a name="credits" />
+    <h2>Credits</h2>
+    <div id="content">
+      <p><h3>Converted and maintained by DGL's GL2.0-Team :</h3>
+      <p>Sascha Willems (<a href="http://www.delphigl.de" target="_blank">http://www.delphigl.de</a>)<br>
+      Steffen Xonna (Lossy eX, <a href="http://www.dev-center.de" target="_blank">http://www.dev-center.de</a>)<br>
+         </p>
+      <h3>Additional input :</h3>
+      <p> Andrey Gruzdev for the Mac OS X patch for XE2 / FPC
+         Lars Middendorf
+Martin Waldegger (Mars)<br>
+      Nico Michaelis (Delphic) for the Linux version of the header (<a href="http://www.delphigl.com/forum/viewtopic.php?t=2577" target="_blank">see here</a>)<br>
+      Benjamin Rosseaux (BeRo) for expanding the header for use with Free Pascal<br>
+      And thanks to all who helps us to make the header better</p></p>
+    </div>
+  </div>
+
+  <div id="content">
+    <a name="copyright" />
+    <h2>Copyright</h2>
+    <p>The contents of this file are used with permission, subject to<br>
+    the Mozilla Public License Version 1.1 (the "License"); you may<br>
+    not use this file except in compliance with the License. You may<br>
+    obtain a copy of the License at<br>
+    <a href="http://www.mozilla.org/MPL/MPL-1.1.html" target="_blank">http://www.mozilla.org/MPL/MPL-1.1.html</a></p>
+    <p>Software distributed under the License is distributed on an<br>
+    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or<br>
+    implied. See the License for the specific language governing<br>
+    rights and limitations under the License.</p>
+  </div>
+
+  <div id="content">
+    Copyright © 2003-2014 DGL-OpenGL-Portteam - All Rights Reserved
+  </div>
+</div>
+  
+</body>
+</html>
+    
diff --git a/dglOpenGL.pas b/dglOpenGL.pas
new file mode 100644 (file)
index 0000000..13386b6
--- /dev/null
@@ -0,0 +1,20073 @@
+{ ============================================================================
+
+       OpenGL 4.4 - Headertranslation
+       Version 4.4a
+       Date : 2014/04/30
+
+       Supported environments and targets :
+        - (Win32) Delphi 4 and up
+        - (Win32, Win64) Delphi XE2
+        - (Win32, Win64, Linux, MacOSX) FreePascal (1.9.3 and up)
+
+==============================================================================
+
+       Containts the translations of glext.h, gl_1_1.h, glu.h and weglext.h.
+       It also contains some helperfunctions that were inspired by those
+       found in Mike Lischke's OpenGL12.pas.
+
+       Copyright (C) DGL-OpenGL2-Portteam
+       All Rights Reserved
+
+       Obtained through:
+       Delphi OpenGL Community(DGL) - www.delphigl.com
+
+       Converted and maintained by DGL's GL2.0-Team :
+         - Sascha Willems             - http://www.saschawillems.de
+         - Steffen Xonna (Lossy eX)   - http://www.dev-center.de
+       Additional input :
+         - Andrey Gruzdev (Mac OS X patch for XE2 / FPC)
+         - Lars Middendorf
+         - Martin Waldegger (Mars)
+         - Benjamin Rosseaux (BeRo)   - http://www.0ok.de
+       Additional thanks:
+           sigsegv (libdl.so)
+
+==============================================================================
+ You may retrieve the latest version of this file at the Delphi OpenGL
+ Community home page, located at http://www.delphigl.com/
+
+ The contents of this file are used with permission, subject to
+ the Mozilla Public License Version 1.1 (the "License"); you may
+ not use this file except in compliance with the License. You may
+ obtain a copy of the License at
+ http://www.mozilla.org/MPL/MPL-1.1.html
+
+ Software distributed under the License is distributed on an
+ "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ implied. See the License for the specific language governing
+ rights and limitations under the License.
+
+==============================================================================
+ History :
+ Version 1.0    Initial Release
+ Version 1.1    Added PPointer in Tpyessection for compatiblity with Delphi
+                versions lower than 7                                    (SW)
+                Added a function named RaiseLastOSError including a comment
+                on how to make it run under Delphi versions lower than 7 (SW)
+                Added some data types according to the GL-Syntax         (SW)
+ Version 1.2    Fixed some problems with getting the addresses of some
+                Extensions (e.g. glTexImage3D) where the EXT/ARB did work
+                but not the core-functions                               (SW)
+ Version 1.3    A second call to ReadimplementationProperties won't
+                revert to the default libs anymore                       (MW)
+                Libraries now will be released if necessary              (MW)
+ Version 1.3a   Small fixes for glSlang-functions                        (SW)
+ Version 1.3b   Fixed a small bug with GL_ARB_shader_objects, that lead
+                lead to that extension not loaded correctly              (SW)
+ Version 1.3c   more GL 1.5 compliance by FOG_COORD_xx and
+                ARB less VBO and occlusion query routines                (MW)
+ Version 1.3d   Fixed linebreaks (should now be corrected under D5)      (SW)
+ Version 1.4    Changed header to correspond to the OpenGL-Shading
+                Language specification 1.10 :
+                - Added new GL_SAMPLER_*-Constants
+                - Added Constant GL_SHADING_LANGUAGE_VERSION_ARB
+                - Added Constant GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB
+                - Added Constant GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB  (SW)
+ Version 1.4a   Fixed a missing stdcall for glBindAttribLocationARB      (SW)
+ Version 1.4b   Fixed declaration for glUniform*(f/i)vARB (added count)  (MW)
+                glCompileShaderARB changed from function to procedure    (MW)
+ Version 1.5    Added support for FreePascal                             (BR)
+                Added type TGLVectorf3/TGLVector3f                       (SW)
+ Version 1.6    Added Extension GL_EXT_framebuffer_object                (SX)
+ Version 1.7    Added Extension GL_ARB_fragment_program_shadow           (SX)
+                Added Extension GL_ARB_draw_buffers                      (SX)
+                Added Extension GL_ARB_texture_rectangle                 (SX)
+                Added Extension GL_ARB_color_buffer_float                (SX)
+                Added Extension GL_ARB_half_float_pixel                  (SX)
+                Added Extension GL_ARB_texture_float                     (SX)
+                Added Extension GL_ARB_pixel_buffer_object               (SX)
+                Added Extension GL_EXT_depth_bounds_test                 (SX)
+                Added Extension GL_EXT_texture_mirror_clamp              (SX)
+                Added Extension GL_EXT_blend_equation_separate           (SX)
+                Added Extension GL_EXT_pixel_buffer_object               (SX)
+                Added Extension GL_EXT_texture_compression_dxt1          (SX)
+                Added Extension GL_NV_fragment_program_option            (SX)
+                Added Extension GL_NV_fragment_program2                  (SX)
+                Added Extension GL_NV_vertex_program2_option             (SX)
+                Added Extension GL_NV_vertex_program3                    (SX)
+ Version 1.8    Added explicit delegate type definitions                 (LM)
+                Added .Net 1.1 Support                                   (LM)
+                Added .Net overloaded functions                          (LM)
+                Added delayed extension loading and stubs                (LM)
+                Added automatic InitOpenGL call in CreateRenderingContext(LM)
+                Added extra Read_* function                              (LM)
+ Version 2.0    fixed some Problem with version string and damn drivers.
+                String 1.15 identified as OpenGL 1.5 not as OpenGL 1.1   (SX)
+                Removed unexisting extension GL_ARB_texture_mirror_repeat(SX)
+                Added Extension WGL_ARB_pixel_format_float               (SX)
+                Added Extension GL_EXT_stencil_clear_tag                 (SX)
+                Added Extension GL_EXT_texture_rectangle                 (SX)
+                Added Extension GL_EXT_texture_edge_clamp                (SX)
+                Some 1.5 Core Consts added (now completed)               (SX)
+                gluProject need pointer for not .net                     (SX)
+                gluUnProject need pointer for not .net                   (SX)
+                wglUseFontOutlines* need pointer for not .net            (SX)
+                wglSwapMultipleBuffers need pointer for not .net         (SX)
+                Bug with wglGetExtensionsStringEXT removed
+                different type for .net                                  (SX)
+                Added OpenGL 2.0 Core                                    (SX)
+ Version 2.0.1  fixed some problems with glGetActiveAttrib in 2.0 Core   (SX)
+                fixes some problems with gluProject                      (SX)
+                fixes some problems with gluUnProject                    (SX)
+                fixes some problems with gluTessVertex                   (SX)
+                fixes some problems with gluLoadSamplingMatrices         (SX)
+ Version 2.1    Removed .NET Support                                     (SX)
+                Better support for Linux                                 (SX)
+                Better Codeformation                                     (SX)
+                Added some more Vector/Matrix types                      (SX)
+                Added OpenGL 2.1 Core                                    (SX)
+                Added Extension GL_EXT_packed_depth_stencil              (SX)
+                Added Extension GL_EXT_texture_sRGB                      (SX)
+                Added Extension GL_EXT_framebuffer_blit                  (SX)
+                Added Extension GL_EXT_framebuffer_multisample           (SX)
+                Added Extension GL_EXT_timer_query                       (SX)
+                Added Extension GL_EXT_gpu_program_parameters            (SX)
+                Added Extension GL_EXT_bindable_uniform                  (SX)
+                Added Extension GL_EXT_draw_buffers2                     (SX)
+                Added Extension GL_EXT_draw_instanced                    (SX)
+                Added Extension GL_EXT_framebuffer_sRGB                  (SX)
+                Added Extension GL_EXT_geometry_shader4                  (SX)
+                Added Extension GL_EXT_gpu_shader4                       (SX)
+                Added Extension GL_EXT_packed_float                      (SX)
+                Added Extension GL_EXT_texture_array                     (SX)
+                Added Extension GL_EXT_texture_buffer_object             (SX)
+                Added Extension GL_EXT_texture_compression_latc          (SX)
+                Added Extension GL_EXT_texture_compression_rgtc          (SX)
+                Added Extension GL_EXT_texture_integer                   (SX)
+                Added Extension GL_EXT_texture_shared_exponent           (SX)
+                Added Extension GL_NV_depth_buffer_float                 (SX)
+                Added Extension GL_NV_fragment_program4                  (SX)
+                Added Extension GL_NV_framebuffer_multisample_coverage   (SX)
+                Added Extension GL_NV_geometry_program4                  (SX)
+                Added Extension GL_NV_gpu_program4                       (SX)
+                Added Extension GL_NV_parameter_buffer_object            (SX)
+                Added Extension GL_NV_transform_feedback                 (SX)
+                Added Extension GL_NV_vertex_program4                    (SX)
+ Version 3.0    fixed some const of GL_EXT_texture_shared_exponent       (SX)
+                possible better support for mac                          (SX)
+                Added OpenGL 3.0 Core                                    (SX)
+                Added Extension GL_ARB_depth_buffer_float                (SX)
+                Added Extension GL_ARB_draw_instanced                    (SX)
+                Added Extension GL_ARB_framebuffer_object                (SX)
+                Added Extension GL_ARB_framebuffer_sRGB                  (SX)
+                Added Extension GL_ARB_geometry_shader4                  (SX)
+                Added Extension GL_ARB_half_float_vertex                 (SX)
+                Added Extension GL_ARB_instanced_arrays                  (SX)
+                Added Extension GL_ARB_map_buffer_range                  (SX)
+                Added Extension GL_ARB_texture_buffer_object             (SX)
+                Added Extension GL_ARB_texture_compression_rgtc          (SX)
+                Added Extension GL_ARB_texture_rg                        (SX)
+                Added Extension GL_ARB_vertex_array_object               (SX)
+                Added Extension GL_NV_conditional_render                 (SX)
+                Added Extension GL_NV_present_video                      (SX)
+                Added Extension GL_EXT_transform_feedback                (SX)
+                Added Extension GL_EXT_direct_state_access               (SX)
+                Added Extension GL_EXT_vertex_array_bgra                 (SX)
+                Added Extension GL_EXT_texture_swizzle                   (SX)
+                Added Extension GL_NV_explicit_multisample               (SX)
+                Added Extension GL_NV_transform_feedback2                (SX)
+                Added Extension WGL_ARB_create_context                   (SX)
+                Added Extension WGL_NV_present_video                     (SX)
+                Added Extension WGL_NV_video_out                         (SX)
+                Added Extension WGL_NV_swap_group                        (SX)
+                Added Extension WGL_NV_gpu_affinity                      (SX)
+                Added define DGL_TINY_HEADER to suppress automatic
+                function loading                                         (SX)
+                glProcedure renamed to dglGetProcAddress and now it's
+                visible from outside the unit to custom load functions   (SX)
+                dglCheckExtension added to check if an extension exists  (SX)
+                Read_GL_ARB_buffer_object renamed to
+                Read_GL_ARB_vertex_buffer_object                         (SX)
+ Version 3.0.1  fixed an problem with fpc                                (SX)
+ Version 3.0.2  fixed an problem with WGL_ARB_create_context             (SX)
+ Version 3.2    Functions from GL_VERSION_3_0 where updated              (SX)
+                Functions from GL_ARB_map_buffer_range where updated     (SX)
+                Functions from GL_NV_present_video where added           (SX)
+                Added consts of GL_ARB_instanced_arrays                  (SX)
+                Defines to identify Delphi was changed (prevent for
+                feature maintenance)                                     (SX)
+                Added Extension GL_ATI_meminfo                           (SX)
+                Added Extension GL_AMD_performance_monitor               (SX)
+                Added Extension GL_AMD_texture_texture4                  (SX)
+                Added Extension GL_AMD_vertex_shader_tesselator          (SX)
+                Added Extension GL_EXT_provoking_vertex                  (SX)
+                Added Extension WGL_AMD_gpu_association                  (SX)
+                Added OpenGL 3.1 Core                                    (SX)
+                All deprecated stuff can be disabled if you undef the
+                define DGL_DEPRECATED                                    (SX)
+                Added Extension GL_ARB_uniform_buffer_object             (SX)
+                Added Extension GL_ARB_compatibility                     (SX)
+                Added Extension GL_ARB_copy_buffer                       (SX)
+                Added Extension GL_ARB_shader_texture_lod                (SX)
+                Remove function from GL_NV_present_video                 (SX)
+                Added Extension WGL_3DL_stereo_control                   (SX)
+                Added Extension GL_EXT_texture_snorm                     (SX)
+                Added Extension GL_AMD_draw_buffers_blend                (SX)
+                Added Extension GL_APPLE_texture_range                   (SX)
+                Added Extension GL_APPLE_float_pixels                    (SX)
+                Added Extension GL_APPLE_vertex_program_evaluators       (SX)
+                Added Extension GL_APPLE_aux_depth_stencil               (SX)
+                Added Extension GL_APPLE_object_purgeable                (SX)
+                Added Extension GL_APPLE_row_bytes                       (SX)
+                Added OpenGL 3.2 Core                                    (SX)
+                Added Extension GL_ARB_depth_clamp                       (SX)
+                Added Extension GL_ARB_draw_elements_base_vertex         (SX)
+                Added Extension GL_ARB_fragment_coord_conventions        (SX)
+                Added Extension GL_ARB_provoking_vertex                  (SX)
+                Added Extension GL_ARB_seamless_cube_map                 (SX)
+                Added Extension GL_ARB_sync                              (SX)
+                Added Extension GL_ARB_texture_multisample               (SX)
+                Added Extension GL_ARB_vertex_array_bgra                 (SX)
+                Added Extension GL_ARB_draw_buffers_blend                (SX)
+                Added Extension GL_ARB_sample_shading                    (SX)
+                Added Extension GL_ARB_texture_cube_map_array            (SX)
+                Added Extension GL_ARB_texture_gather                    (SX)
+                Added Extension GL_ARB_texture_query_lod                 (SX)
+                Added Extension WGL_ARB_create_context_profile           (SX)
+                Added GLX Core up to Version 1.4                         (SX)
+                Added Extension GLX_ARB_multisample                      (SX)
+                Added Extension GLX_ARB_fbconfig_float                   (SX)
+                Added Extension GLX_ARB_get_proc_address                 (SX)
+                Added Extension GLX_ARB_create_context                   (SX)
+                Added Extension GLX_ARB_create_context_profile           (SX)
+                Added Extension GLX_EXT_visual_info                      (SX)
+                Added Extension GLX_EXT_visual_rating                    (SX)
+                Added Extension GLX_EXT_import_context                   (SX)
+                Added Extension GLX_EXT_fbconfig_packed_float            (SX)
+                Added Extension GLX_EXT_framebuffer_sRGB                 (SX)
+                Added Extension GLX_EXT_texture_from_pixmap              (SX)
+ Version 3.2.1  Fixed some problems with Delphi < 6                      (SX)
+ Version 3.2.2  Added Extension GL_APPLE_rgb_422                         (SX)
+                Added Extension GL_EXT_separate_shader_objects           (SX)
+                Added Extension GL_NV_video_capture                      (SX)
+                Added Extension GL_NV_copy_image                         (SX)
+                Added Extension GL_NV_parameter_buffer_object2           (SX)
+                Added Extension GL_NV_shader_buffer_load                 (SX)
+                Added Extension GL_NV_vertex_buffer_unified_memory       (SX)
+                Added Extension GL_NV_texture_barrier                    (SX)
+                Variable GL_EXT_texture_snorm will be filled             (SX)
+                Variable GL_APPLE_row_bytes will be filled               (SX)
+                Added Extension WGL_NV_video_capture                     (SX)
+                Added Extension WGL_NV_copy_image                        (SX)
+                WGL_NV_video_out now named WGL_NV_video_output           (SX)
+                Added Extension GLX_EXT_swap_control                     (SX)
+ Version 3.2.3  Fixed an Problem with glGetAttribLocation                (SX)
+                Added const GL_UNIFORM_BUFFER_EXT                        (SX)
+                Functions of GL_NV_texture_barrier now will be loaded    (SX)
+ Version 4.0    Changes on Extension GL_ARB_texture_gather               (SX)
+                Changes on Extension GL_NV_shader_buffer_load            (SX)
+                Added OpenGL 3.3 Core                                    (SX)
+                Added OpenGL 4.0 Core                                    (SX)
+                Added Extension GL_AMD_shader_stencil_export             (SX)
+                Added Extension GL_AMD_seamless_cubemap_per_texture      (SX)
+                Added Extension GL_ARB_shading_language_include          (SX)
+                Added Extension GL_ARB_texture_compression_bptc          (SX)
+                Added Extension GL_ARB_blend_func_extended               (SX)
+                Added Extension GL_ARB_explicit_attrib_location          (SX)
+                Added Extension GL_ARB_occlusion_query2                  (SX)
+                Added Extension GL_ARB_sampler_objects                   (SX)
+                Added Extension GL_ARB_shader_bit_encoding               (SX)
+                Added Extension GL_ARB_texture_rgb10_a2ui                (SX)
+                Added Extension GL_ARB_texture_swizzle                   (SX)
+                Added Extension GL_ARB_timer_query                       (SX)
+                Added Extension GL_ARB_vertex_type_2_10_10_10_rev        (SX)
+                Added Extension GL_ARB_draw_indirect                     (SX)
+                Added Extension GL_ARB_gpu_shader5                       (SX)
+                Added Extension GL_ARB_gpu_shader_fp64                   (SX)
+                Added Extension GL_ARB_shader_subroutine                 (SX)
+                Added Extension GL_ARB_tessellation_shader               (SX)
+                Added Extension GL_ARB_texture_buffer_object_rgb32       (SX)
+                Added Extension GL_ARB_transform_feedback2               (SX)
+                Added Extension GL_ARB_transform_feedback3               (SX)
+ Version 4.1    Possible fix some strange linux behavior                 (SX)
+                All function uses GL instead of TGL types                (SX)
+                GL_AMD_vertex_shader_tesselator will be read now         (SX)
+                GL_AMD_draw_buffers_blend will be read now               (SX)
+                Changes on glStencilFuncSeparate (GL_2_0)                (SX)
+                Changes on GL_VERSION_3_2                                (SX)
+                Changes on GL_VERSION_3_3                                (SX)
+                Changes on GL_VERSION_4_0                                (SX)
+                Changes on GL_ARB_sample_shading                         (SX)
+                Changes on GL_ARB_texture_cube_map_array                 (SX)
+                Changes on GL_ARB_gpu_shader5                            (SX)
+                Changes on GL_ARB_transform_feedback3                    (SX)
+                Changes on GL_ARB_sampler_objects                        (SX)
+                Changes on GL_ARB_gpu_shader_fp64                        (SX)
+                Changes on GL_APPLE_element_array                        (SX)
+                Changes on GL_APPLE_vertex_array_range                   (SX)
+                Changes on GL_NV_transform_feedback                      (SX)
+                Changes on GL_NV_vertex_buffer_unified_memory            (SX)
+                Changes on GL_EXT_multi_draw_arrays                      (SX)
+                Changes on GL_EXT_direct_state_access                    (SX)
+                Changes on GL_AMD_performance_monitor                    (SX)
+                Changes on GL_AMD_seamless_cubemap_per_texture           (SX)
+                Changes on GL_EXT_geometry_shader4                       (SX)
+                Added OpenGL 4.1 Core                                    (SX)
+                Added Extension GL_ARB_ES2_compatibility                 (SX)
+                Added Extension GL_ARB_get_program_binary                (SX)
+                Added Extension GL_ARB_separate_shader_objects           (SX)
+                Added Extension GL_ARB_shader_precision                  (SX)
+                Added Extension GL_ARB_vertex_attrib_64bit               (SX)
+                Added Extension GL_ARB_viewport_array                    (SX)
+                Added Extension GL_ARB_cl_event                          (SX)
+                Added Extension GL_ARB_debug_output                      (SX)
+                Added Extension GL_ARB_robustness                        (SX)
+                Added Extension GL_ARB_shader_stencil_export             (SX)
+                Added Extension GL_AMD_conservative_depth                (SX)
+                Added Extension GL_EXT_shader_image_load_store           (SX)
+                Added Extension GL_EXT_vertex_attrib_64bit               (SX)
+                Added Extension GL_NV_gpu_program5                       (SX)
+                Added Extension GL_NV_gpu_shader5                        (SX)
+                Added Extension GL_NV_shader_buffer_store                (SX)
+                Added Extension GL_NV_tessellation_program5              (SX)
+                Added Extension GL_NV_vertex_attrib_integer_64bit        (SX)
+                Added Extension GL_NV_multisample_coverage               (SX)
+                Added Extension GL_AMD_name_gen_delete                   (SX)
+                Added Extension GL_AMD_debug_output                      (SX)
+                Added Extension GL_NV_vdpau_interop                      (SX)
+                Added Extension GL_AMD_transform_feedback3_lines_triangles (SX)
+                Added Extension GL_AMD_depth_clamp_separate              (SX)
+                Added Extension GL_EXT_texture_sRGB_decode               (SX)
+                Added Extension WGL_ARB_framebuffer_sRGB                 (SX)
+                Added Extension WGL_ARB_create_context_robustness        (SX)
+                Added Extension WGL_EXT_create_context_es2_profile       (SX)
+                Added Extension WGL_NV_multisample_coverage              (SX)
+                Added Extension GLX_ARB_vertex_buffer_object             (SX)
+                Added Extension GLX_ARB_framebuffer_sRGB                 (SX)
+                Added Extension GLX_ARB_create_context_robustness        (SX)
+                Added Extension GLX_EXT_create_context_es2_profile       (SX)
+ Version 4.1a   Fix for dglGetProcAddress with FPC and linux (def param) (SW)
+ Version 4.2    Added OpenGL 4.2 Core                                    (SW)
+                Added Extension GL_ARB_base_instance                     (SW)
+                Added Extension GL_ARB_shading_language_420pack          (SW)
+                Added Extension GL_ARB_transform_feedback_instanced      (SW)
+                Added Extension GL_ARB_compressed_texture_pixel_storage  (SW)
+                Added Extension GL_ARB_conservative_depth                (SW)
+                Added Extension GL_ARB_internalformat_query              (SW)
+                Added Extension GL_ARB_map_buffer_alignment              (SW)
+                Added Extension GL_ARB_shader_atomic_counters            (SW)
+                Added Extension GL_ARB_shader_image_load_store           (SW)
+                Added Extension GL_ARB_shading_language_packing          (SW)
+                Added Extension GL_ARB_texture_storage                   (SW)
+                Added Extension WGL_NV_DX_interop                        (SW)
+                Added Define for WGL_EXT_create_context_es2_profile      (SW)
+ Version 4.2a   Added Mac OS X patch by Andrey Gruzdev                   (SW)
+ Version 4.3    Added OpenGL 4.3 Core                                    (SW)
+                                                       Added GL_ARB_arrays_of_arrays                                    (SW)
+                                                       Added GL_ARB_fragment_layer_viewport                     (SW)
+                                                       Added GL_ARB_shader_image_size                           (SW)
+                                                       Added GL_ARB_ES3_compatibility                           (SW)
+                                                       Added GL_ARB_clear_buffer_object                         (SW)
+                                                       Added GL_ARB_compute_shader                              (SW)
+                                                       Added GL_ARB_copy_image                                  (SW)
+                                                       Added GL_KHR_debug                                       (SW)
+                                                       Added GL_ARB_explicit_uniform_location,                  (SW)
+                                                       Added GL_ARB_framebuffer_no_attachments                  (SW)
+                                                       Added GL_ARB_internalformat_query2                       (SW)
+                                                       Added GL_ARB_invalidate_subdata                          (SW)
+                                                       Added GL_ARB_multi_draw_indirect                         (SW)
+                                                       Added GL_ARB_program_interface_query                     (SW)
+                                                       Added GL_ARB_robust_buffer_access_behavior               (SW)
+                                                       Added GL_ARB_shader_storage_buffer_object                (SW)
+                                                       Added GL_ARB_stencil_texturing                           (SW)
+                                                       Added GL_ARB_texture_buffer_range                        (SW)
+                                                       Added GL_ARB_texture_query_levels                        (SW)
+                                                       Added GL_ARB_texture_storage_multisample                 (SW)
+                                                       Added GL_ARB_texture_view                                (SW)
+                                                       Added GL_ARB_vertex_attrib_binding                       (SW)
+                Added new vendor-specific extensions                                                                            (SW)
+                                                               Added GL_NV_path_rendering                               (SW)
+                                                       Added GL_AMD_pinned_memory                               (SW)
+                Added GL_AMD_stencil_operation_extended                  (SW)
+                Added GL_AMD_vertex_shader_viewport_index                (SW)
+                Added GL_AMD_vertex_shader_layer                         (SW)
+                Added GL_NV_bindless_texture                             (SW)
+                Added GL_NV_shader_atomic_float                          (SW)
+                Added GL_AMD_query_buffer_object                         (SW)
+                Added CreateRenderingContextVersion                      (SW)
+ Version 4.4    Added ARB_buffer_storage                                 (SW)
+                Added ARB_clear_texture extension                        (SW)
+                Added ARB_enhanced_layouts extension                     (SW)
+                Added ARB_multi_bind extension                           (SW)
+                Added ARB_query_buffer_object extension                  (SW)
+                Added ARB_texture_mirror_clamp_to_edge extension         (SW)
+                Added ARB_texture_stencil8 extension                     (SW)
+                Added ARB_vertex_type_10f_11f_11f_rev extension          (SW)
+                Added MAX_VERTEX_ATTRIB_STRIDE stat                      (SW)
+                Added missing functions for GL_EXT_direct_state_access   (SW)
+                GL3.0+ uses non-deprecated way of getting extensions
+                (thanks to frenK)                                                                               (SW)
+                Added missing cdecl for TglXGetVisualFromFBConfig        (SW)
+ Version 4.4a  Fixed parameter type for glGetProgramInfoLog                     (SW)
+                               (thanks to glAwesome)
+
+
+==============================================================================
+ Header based on glext.h  rev 87 (2012-08-06)
+ Header based on wglext.h rev 24 (2012/01/04)
+ Header based on glxext.h rev 33 (2012/02/29)  (only Core/ARB/EXT)
+
+ This is an important notice for maintaining. Dont remove it. And make sure
+ to keep it up to date
+============================================================================== }
+
+{$define DGL_DEPRECATED}
+{
+  This define defines if the header should use deprecated ARB stuff or not.
+  per Default the Header use deprecated Stuff.
+}
+
+
+{.$define DGL_TINY_HEADER}
+{
+  If you enable the define DGL_TINY_HEADER no function automatically will be loaded if you
+  call ActivateRenderingContext. This may some bit faster and the smart linker can delete
+  all non used functions. This will reduce the filesize of your binary file. But in this
+  case you have to load the functions by yourself. There are two ways to do this.
+
+  1. You can load whole extension by calling the func Read_Extensionname. But if you do
+     this it's possible to load functions you dont use. So you have the same "problem"
+     like before. But it's only an bit smaler.
+     > Read_GL_ARB_multitexture;
+
+  2. You are able to load only the functions you exactly need. In this case you are able
+     to use the variables of the dglOpenGL.pas. So you only need to load the functions
+     and you can use the header like before.
+     To do this you have to created and activated an opengl context and than you can load
+     the needed functions.
+     > ActivateRenderingContext(fDC, fRC);
+     > glActiveTextureARB := dglGetProcAddress('glActiveTextureARB');
+     > glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB');
+
+     So only the function "glActiveTextureARB" and "glMultiTexCoord2fARB" will be loaded.
+
+
+  Please notice that the extension variables won't be loaded if this define is active. But
+  you can call dglCheckExtension to check if any extension exists. You can assign them to
+  the variables of the dglOpenGL.pas so all code they use this will find them.
+
+  > GL_ARB_shading_language_100 := dglCheckExtension('GL_ARB_shading_language_100');
+}
+
+
+unit dglOpenGL;
+
+interface
+
+// defines to configure freepascal
+{$IFDEF FPC}
+  {$MODE Delphi}
+
+  {$IFNDEF WINDOWS}
+    {$LINKLIB c}
+  {$ENDIF}
+{$ENDIF}
+
+// known delphi versions
+{$IFNDEF FPC}       // if freepascal isnt defined
+  {$IFDEF VER140}   // Delphi 6
+    {$DEFINE DELPHI6_AND_DOWN}
+  {$ENDIF}
+
+  {$IFDEF VER130}   // Delphi 5
+    {$DEFINE DELPHI6_AND_DOWN}
+  {$ENDIF}
+
+  {$IFDEF VER120}   // Delphi 4
+    {$DEFINE DELPHI6_AND_DOWN}
+  {$ENDIF}
+
+  {$IFDEF VER110}   // C++ Builder 3
+    {$DEFINE DELPHI6_AND_DOWN}
+  {$ENDIF}
+
+  {$IFDEF VER100}   // Delphi 3
+    {$DEFINE DELPHI6_AND_DOWN}
+  {$ENDIF}
+{$ENDIF}
+
+// Options for Delphi < 5
+{$IFDEF DELPHI6_AND_DOWN}
+  {$A+}
+{$ELSE}
+  {$A4}
+{$ENDIF}
+
+// generell options
+{$H+,O+,X+}
+
+// detecting Windows
+{$IFDEF Win32}          // Delphi and fpc of 32 Bit Windows
+  {$DEFINE DGL_WIN}
+{$ENDIF}
+
+{$IFDEF Win64}          // Delphi and fpc of 32 Bit Windows
+  {$DEFINE DGL_WIN}
+{$ENDIF}
+
+// detecting Linux
+{$IFDEF linux}          // Linux
+  {$DEFINE DGL_LINUX}
+{$ENDIF}
+
+{$IFDEF DARWIN}  // Mac OS X and FPC
+   {$DEFINE DGL_MAC}
+{$ENDIF}   
+
+{$IFDEF DELPHI}  // Mac OS X add Delphi 
+{$IFDEF MACOS}
+   {$DEFINE DGL_MAC}
+{$ENDIF}   
+{$ENDIF}   
+
+
+// detecting 64 Bit CPU
+{$IFDEF CPU64}          // fpc on 64 bit cpus
+  {$DEFINE DGL_64BIT}   // dgl define for 64 bit
+{$ENDIF}
+
+
+
+uses
+  {$IFDEF FPC}{$IFDEF DARWIN}dynlibs,{$ENDIF}{$ENDIF}  // LoadLibrary functions 
+  SysUtils
+  {$IFDEF DGL_WIN}, Windows{$ENDIF}
+  {$IFDEF DGL_LINUX}, X, XLib, XUtil{$ENDIF}
+  ;
+
+type
+  // Needed for Delphi 6 and less (defined in system.pas for Delphi 7)
+  PPointer = ^Pointer;
+  PCardinal = ^Cardinal;
+
+  GLenum = Cardinal;
+  GLboolean = BYTEBOOL;
+  GLbitfield = Cardinal;
+  GLbyte = Shortint;
+  GLshort = SmallInt;
+  GLint = Integer;
+  GLsizei = Integer;
+  GLubyte = Byte;
+  GLushort = Word;
+  GLuint = Cardinal;
+  GLfloat = Single;
+  GLclampf = Single;
+  GLdouble = Double;
+  GLclampd = Double;
+  GLvoid = Pointer;
+  GLint64 = Int64;
+  GLuint64 = {$IFDEF DELPHI6_AND_DOWN} Int64 {$ELSE} UInt64 {$ENDIF};
+  
+  TGLenum = GLenum;
+  TGLboolean = GLboolean;
+  TGLbitfield = GLbitfield;
+  TGLbyte = GLbyte;
+  TGLshort = GLshort;
+  TGLint = GLint;
+  TGLsizei = GLsizei;
+  TGLubyte = GLubyte;
+  TGLushort = GLushort;
+  TGLuint = GLuint;
+  TGLfloat = GLfloat;
+  TGLclampf = GLclampf;
+  TGLdouble = GLdouble;
+  TGLclampd = GLclampd;
+  TGLvoid = GLvoid;
+  TGLint64 = GLint64;
+  TGLuint64 = GLuint64;
+
+  PGLboolean = ^GLboolean;
+  PGLbyte = ^GLbyte;
+  PGLshort = ^GLshort;
+  PGLint = ^GLint;
+  PGLsizei = ^GLsizei;
+  PGLubyte = ^GLubyte;
+  PGLushort = ^GLushort;
+  PGLuint = ^GLuint;
+  PGLclampf = ^GLclampf;
+  PGLfloat = ^GLfloat;
+  PGLdouble = ^GLdouble;
+  PGLclampd = ^GLclampd;
+  PGLenum = ^GLenum;
+  PGLvoid = Pointer;
+  PPGLvoid = ^PGLvoid;
+  PGLint64 = ^GLint64;
+  PGLuint64 = ^GLuint64;
+
+  // GL_NV_half_float
+  GLhalfNV = WORD;
+  TGLhalfNV = GLhalfNV;
+  PGLhalfNV = ^GLhalfNV;
+
+  // GL_ARB_shader_objects
+  PGLHandleARB = ^GLHandleARB;
+  GLHandleARB = Integer;
+  GLcharARB = AnsiChar;
+  PGLcharARB = PAnsiChar;
+  PPGLcharARB = ^PGLcharARB;
+
+  // GL_VERSION_1_5
+  GLintptr = GLint;
+  GLsizeiptr = GLsizei;
+
+  // GL_ARB_vertex_buffer_object
+  GLintptrARB = GLint;
+  GLsizeiptrARB = GLsizei;
+
+  // GL_VERSION_2_0
+  GLHandle = Integer;
+  PGLchar = PAnsiChar;
+  PPGLchar = ^PGLChar;
+
+  // GL_EXT_timer_query
+  GLint64EXT = Int64;
+  TGLint64EXT = GLint64EXT;
+  PGLint64EXT = ^GLint64EXT;
+
+  GLuint64EXT = GLuint64;
+  TGLuint64EXT = GLuint64EXT;
+  PGLuint64EXT = ^GLuint64EXT;
+
+  // WGL_ARB_pbuffer
+  HPBUFFERARB = THandle;
+
+  // WGL_EXT_pbuffer
+  HPBUFFEREXT = THandle;
+
+  // WGL_NV_present_video
+  PHVIDEOOUTPUTDEVICENV = ^HVIDEOOUTPUTDEVICENV;
+  HVIDEOOUTPUTDEVICENV = THandle;
+
+  // WGL_NV_video_output
+  PHPVIDEODEV = ^HPVIDEODEV;
+  HPVIDEODEV = THandle;
+
+  // WGL_NV_gpu_affinity
+  PHPGPUNV = ^HPGPUNV;
+  PHGPUNV = ^HGPUNV;
+
+  // WGL_NV_video_capture
+  HVIDEOINPUTDEVICENV = THandle;
+  PHVIDEOINPUTDEVICENV = ^HVIDEOINPUTDEVICENV;
+  
+  HPGPUNV = THandle;
+  HGPUNV = THandle;
+
+  // GL_ARB_sync
+  GLsync = Pointer;
+
+  // GL_ARB_cl_event
+  { These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event }
+  _cl_context = record end;
+  _cl_event = record end;
+  p_cl_context = ^_cl_context;
+  p_cl_event = ^_cl_event;
+
+  // GL_ARB_debug_output
+  TglDebugProcARB = procedure (source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_debug_output
+  TglDebugProcAMD = procedure (id: GLuint; category: GLenum; severity: GLenum; length: GLsizei; const message_: PGLchar; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+       // (4.3) GL_KHR_debug
+  TglDebugProc = procedure(source : GLEnum; type_ : GLEnum; id : GLUInt; severity : GLUInt; length : GLsizei; const message_ : PGLCHar; userParam : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_vdpau_interop
+  GLvdpauSurfaceNV = GLintptr;
+  PGLvdpauSurfaceNV = ^GLvdpauSurfaceNV;
+  
+  
+  // GLX
+  {$IFDEF DGL_LINUX}
+    GLXContext = Pointer;
+    GLXContextID = TXID;
+    GLXDrawable = TXID;
+    GLXFBConfig = Pointer;
+    GLXPbuffer = TXID;
+    GLXPixmap = TXID;
+    GLXWindow = TXID;
+
+    Window = TXID;
+    Colormap = TXID;
+    Pixmap = TXID;
+    Font = TXID;
+  {$ENDIF}
+
+  // Datatypes corresponding to GL's types TGL(name)(type)(count)
+  TGLVectorub2 = array[0..1] of GLubyte;
+  TGLVectori2  = array[0..1] of GLint;
+  TGLVectorf2  = array[0..1] of GLfloat;
+  TGLVectord2  = array[0..1] of GLdouble;
+  TGLVectorp2  = array[0..1] of Pointer;
+
+  TGLVectorub3 = array[0..2] of GLubyte;
+  TGLVectori3  = array[0..2] of GLint;
+  TGLVectorf3  = array[0..2] of GLfloat;
+  TGLVectord3  = array[0..2] of GLdouble;
+  TGLVectorp3  = array[0..2] of Pointer;
+
+  TGLVectorub4 = array[0..3] of GLubyte;
+  TGLVectori4  = array[0..3] of GLint;
+  TGLVectorf4  = array[0..3] of GLfloat;
+  TGLVectord4  = array[0..3] of GLdouble;
+  TGLVectorp4  = array[0..3] of Pointer;
+
+  TGLArrayf4 = TGLVectorf4;
+  TGLArrayf3 = TGLVectorf3;
+  TGLArrayd3 = TGLVectord3;
+  TGLArrayi4 = TGLVectori4;
+  TGLArrayp4 = TGLVectorp4;
+
+  TGlMatrixub3 = array[0..2, 0..2] of GLubyte;
+  TGlMatrixi3  = array[0..2, 0..2] of GLint;
+  TGLMatrixf3  = array[0..2, 0..2] of GLfloat;
+  TGLMatrixd3  = array[0..2, 0..2] of GLdouble;
+
+  TGlMatrixub4 = array[0..3, 0..3] of GLubyte;
+  TGlMatrixi4  = array[0..3, 0..3] of GLint;
+  TGLMatrixf4  = array[0..3, 0..3] of GLfloat;
+  TGLMatrixd4  = array[0..3, 0..3] of GLdouble;
+
+  TGLVector3f = TGLVectorf3;
+
+  // Datatypes corresponding to OpenGL12.pas for easy porting
+  TVector3d = TGLVectord3;
+
+  TVector4i = TGLVectori4;
+  TVector4f = TGLVectorf4;
+  TVector4p = TGLVectorp4;
+
+  TMatrix4f = TGLMatrixf4;
+  TMatrix4d = TGLMatrixd4;
+
+  PGLMatrixd4 = ^TGLMatrixd4;
+  PVector4i = ^TVector4i;
+
+
+
+{$IFDEF FPC}
+  TRect = packed record
+    Left, Top, Right, Bottom: Longint;
+  end;
+{$ENDIF}
+
+
+  PGPU_DEVICE = ^GPU_DEVICE;
+  GPU_DEVICE = record
+    cb: DWORD;
+    DeviceName: array [0..31] of AnsiChar;
+    DeviceString: array [0..127] of AnsiChar;
+    Flags: DWORD;
+    rcVirtualScreen: TRect;
+  end;
+  
+
+type
+{$IFDEF FPC}
+  {$IFDEF DGL_WIN}
+    PWGLSwap = ^TWGLSwap;
+    {$EXTERNALSYM _WGLSWAP}
+      _WGLSWAP = packed record
+        hdc: HDC;
+        uiFlags: UINT;
+      end;
+
+    TWGLSwap = _WGLSWAP;
+  {$EXTERNALSYM WGLSWAP}
+    WGLSWAP = _WGLSWAP;
+
+  {$ENDIF}
+{$ENDIF}
+
+  // GLU types
+  TGLUNurbs = record
+  end;
+  TGLUQuadric = record
+  end;
+  TGLUTesselator = record
+  end;
+  PGLUNurbs = ^TGLUNurbs;
+  PGLUQuadric = ^TGLUQuadric;
+  PGLUTesselator = ^TGLUTesselator;
+  // backwards compatibility
+  TGLUNurbsObj = TGLUNurbs;
+  TGLUQuadricObj = TGLUQuadric;
+  TGLUTesselatorObj = TGLUTesselator;
+  TGLUTriangulatorObj = TGLUTesselator;
+  PGLUNurbsObj = PGLUNurbs;
+  PGLUQuadricObj = PGLUQuadric;
+  PGLUTesselatorObj = PGLUTesselator;
+  PGLUTriangulatorObj = PGLUTesselator;
+
+  // GLUQuadricCallback
+  TGLUQuadricErrorProc = procedure(errorCode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  // GLUTessCallback
+  TGLUTessBeginProc = procedure(AType: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessEdgeFlagProc = procedure(Flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessVertexProc = procedure(VertexData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessEndProc = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessErrorProc = procedure(ErrNo: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessCombineProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessBeginDataProc = procedure(AType: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessEdgeFlagDataProc = procedure(Flag: GLboolean; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessVertexDataProc = procedure(VertexData: Pointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessEndDataProc = procedure(UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessErrorDataProc = procedure(ErrNo: GLenum; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TGLUTessCombineDataProc = procedure(Coords: TGLArrayd3; VertexData: TGLArrayp4; Weight: TGLArrayf4; OutData: PPointer; UserData: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  // GLUNurbsCallback
+  TGLUNurbsErrorProc = procedure(ErrorCode: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+var
+  GL_VERSION_1_0,
+  GL_VERSION_1_1,
+  GL_VERSION_1_2,
+  GL_VERSION_1_3,
+  GL_VERSION_1_4,
+  GL_VERSION_1_5,
+  GL_VERSION_2_0,
+  GL_VERSION_2_1,
+  GL_VERSION_3_0,
+  GL_VERSION_3_1,
+  GL_VERSION_3_2,
+  GL_VERSION_3_3,
+  GL_VERSION_4_0,
+  GL_VERSION_4_1,
+  GL_VERSION_4_2,
+  GL_VERSION_4_3,
+  GL_VERSION_4_4,
+  GLU_VERSION_1_1,
+  GLU_VERSION_1_2,
+  GLU_VERSION_1_3,
+  GL_3DFX_multisample,
+  GL_3DFX_tbuffer,
+  GL_3DFX_texture_compression_FXT1,
+  GL_APPLE_client_storage,
+  GL_APPLE_element_array,
+  GL_APPLE_fence,
+  GL_APPLE_specular_vector,
+  GL_APPLE_transform_hint,
+  GL_APPLE_vertex_array_object,
+  GL_APPLE_vertex_array_range,
+  GL_APPLE_ycbcr_422,
+  GL_APPLE_texture_range,
+  GL_APPLE_float_pixels,
+  GL_APPLE_vertex_program_evaluators,
+  GL_APPLE_aux_depth_stencil,
+  GL_APPLE_object_purgeable,
+  GL_APPLE_row_bytes,
+  GL_APPLE_rgb_422,
+  GL_ARB_depth_texture,
+  GL_ARB_fragment_program,
+  GL_ARB_imaging,
+  GL_ARB_matrix_palette,
+  GL_ARB_multisample,
+  GL_ARB_multitexture,
+  GL_ARB_point_parameters,
+  GL_ARB_shadow,
+  GL_ARB_shadow_ambient,
+  GL_ARB_texture_border_clamp,
+  GL_ARB_texture_compression,
+  GL_ARB_texture_cube_map,
+  GL_ARB_texture_env_add,
+  GL_ARB_texture_env_combine,
+  GL_ARB_texture_env_crossbar,
+  GL_ARB_texture_env_dot3,
+  GL_ARB_texture_mirrored_repeat,
+  GL_ARB_transpose_matrix,
+  GL_ARB_vertex_blend,
+  GL_ARB_vertex_buffer_object,
+  GL_ARB_vertex_program,
+  GL_ARB_window_pos,
+  GL_ARB_shader_objects,
+  GL_ARB_vertex_shader,
+  GL_ARB_fragment_shader,
+  GL_ARB_shading_language_100,
+  GL_ARB_occlusion_query,
+  GL_ARB_texture_non_power_of_two,
+  GL_ARB_point_sprite,
+  GL_ARB_fragment_program_shadow,
+  GL_ARB_draw_buffers,
+  GL_ARB_texture_rectangle,
+  GL_ARB_color_buffer_float,
+  GL_ARB_half_float_pixel,
+  GL_ARB_texture_float,
+  GL_ARB_pixel_buffer_object,
+  GL_ARB_depth_buffer_float,
+  GL_ARB_draw_instanced,
+  GL_ARB_framebuffer_object,
+  GL_ARB_framebuffer_sRGB,
+  GL_ARB_geometry_shader4,
+  GL_ARB_half_float_vertex,
+  GL_ARB_instanced_arrays,
+  GL_ARB_map_buffer_range,
+  GL_ARB_texture_buffer_object,
+  GL_ARB_texture_compression_rgtc,
+  GL_ARB_texture_rg,
+  GL_ARB_vertex_array_object,
+  GL_ARB_uniform_buffer_object,
+  GL_ARB_compatibility,
+  GL_ARB_copy_buffer,
+  GL_ARB_shader_texture_lod,
+  GL_ARB_depth_clamp,
+  GL_ARB_draw_elements_base_vertex,
+  GL_ARB_fragment_coord_conventions,
+  GL_ARB_provoking_vertex,
+  GL_ARB_seamless_cube_map,
+  GL_ARB_sync,
+  GL_ARB_texture_multisample,
+  GL_ARB_vertex_array_bgra,
+  GL_ARB_draw_buffers_blend,
+  GL_ARB_sample_shading,
+  GL_ARB_texture_cube_map_array,
+  GL_ARB_texture_gather,
+  GL_ARB_texture_query_lod,
+  GL_ARB_shading_language_include,
+  GL_ARB_texture_compression_bptc,
+  GL_ARB_blend_func_extended,
+  GL_ARB_explicit_attrib_location,
+  GL_ARB_occlusion_query2,
+  GL_ARB_sampler_objects,
+  GL_ARB_shader_bit_encoding,
+  GL_ARB_texture_rgb10_a2ui,
+  GL_ARB_texture_swizzle,
+  GL_ARB_timer_query,
+  GL_ARB_vertex_type_2_10_10_10_rev,
+  GL_ARB_draw_indirect,
+  GL_ARB_gpu_shader5,
+  GL_ARB_gpu_shader_fp64,
+  GL_ARB_shader_subroutine,
+  GL_ARB_tessellation_shader,
+  GL_ARB_texture_buffer_object_rgb32,
+  GL_ARB_transform_feedback2,
+  GL_ARB_transform_feedback3,
+  GL_ARB_ES2_compatibility,
+  GL_ARB_get_program_binary,
+  GL_ARB_separate_shader_objects,
+  GL_ARB_shader_precision,
+  GL_ARB_vertex_attrib_64bit,
+  GL_ARB_viewport_array,
+
+  // GL 4.2
+    GL_ARB_base_instance,
+    GL_ARB_shading_language_420pack,
+    GL_ARB_transform_feedback_instanced,
+    GL_ARB_compressed_texture_pixel_storage,
+    GL_ARB_conservative_depth,
+    GL_ARB_internalformat_query,
+    GL_ARB_map_buffer_alignment,
+    GL_ARB_shader_atomic_counters,
+    GL_ARB_shader_image_load_store,
+    GL_ARB_shading_language_packing,
+    GL_ARB_texture_storage,
+  // END GL 4.2
+
+  // GL 4.3
+    GL_ARB_arrays_of_arrays,
+    GL_ARB_fragment_layer_viewport,
+    GL_ARB_shader_image_size,
+    GL_ARB_ES3_compatibility,
+    GL_ARB_clear_buffer_object,
+    GL_ARB_compute_shader,
+    GL_ARB_copy_image,
+    GL_KHR_debug,
+    GL_ARB_explicit_uniform_location,
+    GL_ARB_framebuffer_no_attachments,
+    GL_ARB_internalformat_query2,
+    GL_ARB_invalidate_subdata,
+    GL_ARB_multi_draw_indirect,
+    GL_ARB_program_interface_query,
+    GL_ARB_robust_buffer_access_behavior,
+    GL_ARB_shader_storage_buffer_object,
+    GL_ARB_stencil_texturing,
+    GL_ARB_texture_buffer_range,
+    GL_ARB_texture_query_levels,
+    GL_ARB_texture_storage_multisample,
+    GL_ARB_texture_view,
+    GL_ARB_vertex_attrib_binding,
+    GL_NV_path_rendering,
+    GL_AMD_pinned_memory,
+    GL_AMD_stencil_operation_extended,
+    GL_AMD_vertex_shader_viewport_index,
+    GL_AMD_vertex_shader_layer,
+    GL_NV_bindless_texture,
+    GL_NV_shader_atomic_float,
+    GL_AMD_query_buffer_object,
+  // END GL 4.3
+
+  // GL 4.4
+    GL_ARB_buffer_storage,
+    GL_ARB_clear_texture,
+    GL_ARB_enhanced_layouts,
+    GL_ARB_multi_bind,
+    GL_ARB_query_buffer_object,
+    GL_ARB_texture_mirror_clamp_to_edge,
+    GL_ARB_texture_stencil8,
+    GL_ARB_vertex_type_10f_11f_11f_rev,
+  // END 4.4
+
+  GL_ARB_cl_event,
+  GL_ARB_debug_output,
+  GL_ARB_robustness,
+  GL_ARB_shader_stencil_export,
+  GL_ATI_draw_buffers,
+  GL_ATI_element_array,
+  GL_ATI_envmap_bumpmap,
+  GL_ATI_fragment_shader,
+  GL_ATI_map_object_buffer,
+  GL_ATI_pn_triangles,
+  GL_ATI_separate_stencil,
+  GL_ATI_text_fragment_shader,
+  GL_ATI_texture_env_combine3,
+  GL_ATI_texture_float,
+  GL_ATI_texture_mirror_once,
+  GL_ATI_vertex_array_object,
+  GL_ATI_vertex_attrib_array_object,
+  GL_ATI_vertex_streams,
+  GL_ATI_meminfo,
+  GL_AMD_performance_monitor,
+  GL_AMD_texture_texture4,
+  GL_AMD_vertex_shader_tesselator,
+  GL_AMD_draw_buffers_blend,
+  GL_AMD_shader_stencil_export,
+  GL_AMD_seamless_cubemap_per_texture,
+  GL_AMD_conservative_depth,
+  GL_AMD_name_gen_delete,
+  GL_AMD_debug_output,
+  GL_AMD_transform_feedback3_lines_triangles,
+  GL_AMD_depth_clamp_separate,
+  GL_EXT_422_pixels,
+  GL_EXT_abgr,
+  GL_EXT_bgra,
+  GL_EXT_blend_color,
+  GL_EXT_blend_func_separate,
+  GL_EXT_blend_logic_op,
+  GL_EXT_blend_minmax,
+  GL_EXT_blend_subtract,
+  GL_EXT_clip_volume_hint,
+  GL_EXT_cmyka,
+  GL_EXT_color_matrix,
+  GL_EXT_color_subtable,
+  GL_EXT_compiled_vertex_array,
+  GL_EXT_convolution,
+  GL_EXT_coordinate_frame,
+  GL_EXT_copy_texture,
+  GL_EXT_cull_vertex,
+  GL_EXT_draw_range_elements,
+  GL_EXT_fog_coord,
+  GL_EXT_framebuffer_object,
+  GL_EXT_histogram,
+  GL_EXT_index_array_formats,
+  GL_EXT_index_func,
+  GL_EXT_index_material,
+  GL_EXT_index_texture,
+  GL_EXT_light_texture,
+  GL_EXT_misc_attribute,
+  GL_EXT_multi_draw_arrays,
+  GL_EXT_multisample,
+  GL_EXT_packed_pixels,
+  GL_EXT_paletted_texture,
+  GL_EXT_pixel_transform,
+  GL_EXT_pixel_transform_color_table,
+  GL_EXT_point_parameters,
+  GL_EXT_polygon_offset,
+  GL_EXT_rescale_normal,
+  GL_EXT_secondary_color,
+  GL_EXT_separate_specular_color,
+  GL_EXT_shadow_funcs,
+  GL_EXT_shared_texture_palette,
+  GL_EXT_stencil_two_side,
+  GL_EXT_stencil_wrap,
+  GL_EXT_subtexture,
+  GL_EXT_texture,
+  GL_EXT_texture3D,
+  GL_EXT_texture_compression_s3tc,
+  GL_EXT_texture_cube_map,
+  GL_EXT_texture_edge_clamp,
+  GL_EXT_texture_env_add,
+  GL_EXT_texture_env_combine,
+  GL_EXT_texture_env_dot3,
+  GL_EXT_texture_filter_anisotropic,
+  GL_EXT_texture_lod_bias,
+  GL_EXT_texture_object,
+  GL_EXT_texture_perturb_normal,
+  GL_EXT_texture_rectangle,
+  GL_EXT_vertex_array,
+  GL_EXT_vertex_shader,
+  GL_EXT_vertex_weighting,
+  GL_EXT_depth_bounds_test,
+  GL_EXT_texture_mirror_clamp,
+  GL_EXT_blend_equation_separate,
+  GL_EXT_pixel_buffer_object,
+  GL_EXT_texture_compression_dxt1,
+  GL_EXT_stencil_clear_tag,
+  GL_EXT_packed_depth_stencil,
+  GL_EXT_texture_sRGB,
+  GL_EXT_framebuffer_blit,
+  GL_EXT_framebuffer_multisample,
+  GL_EXT_timer_query,
+  GL_EXT_gpu_program_parameters,
+  GL_EXT_bindable_uniform,
+  GL_EXT_draw_buffers2,
+  GL_EXT_draw_instanced,
+  GL_EXT_framebuffer_sRGB,
+  GL_EXT_geometry_shader4,
+  GL_EXT_gpu_shader4,
+  GL_EXT_packed_float,
+  GL_EXT_texture_array,
+  GL_EXT_texture_buffer_object,
+  GL_EXT_texture_compression_latc,
+  GL_EXT_texture_compression_rgtc,
+  GL_EXT_texture_integer,
+  GL_EXT_texture_shared_exponent,
+  GL_EXT_transform_feedback,
+  GL_EXT_direct_state_access,
+  GL_EXT_vertex_array_bgra,
+  GL_EXT_texture_swizzle,
+  GL_EXT_provoking_vertex,
+  GL_EXT_texture_snorm,
+  GL_EXT_separate_shader_objects,
+  GL_EXT_shader_image_load_store,
+  GL_EXT_vertex_attrib_64bit,
+  GL_EXT_texture_sRGB_decode,
+  GL_FfdMaskSGIX,
+  GL_HP_convolution_border_modes,
+  GL_HP_image_transform,
+  GL_HP_occlusion_test,
+  GL_HP_texture_lighting,
+  GL_IBM_cull_vertex,
+  GL_IBM_multimode_draw_arrays,
+  GL_IBM_rasterpos_clip,
+  GL_IBM_texture_mirrored_repeat,
+  GL_IBM_vertex_array_lists,
+  GL_INGR_blend_func_separate,
+  GL_INGR_color_clamp,
+  GL_INGR_interlace_read,
+  GL_INGR_palette_buffer,
+  GL_INTEL_parallel_arrays,
+  GL_INTEL_texture_scissor,
+  GL_MESA_resize_buffers,
+  GL_MESA_window_pos,
+  GL_NV_blend_square,
+  GL_NV_copy_depth_to_color,
+  GL_NV_depth_clamp,
+  GL_NV_evaluators,
+  GL_NV_fence,
+  GL_NV_float_buffer,
+  GL_NV_fog_distance,
+  GL_NV_fragment_program,
+  GL_NV_half_float,
+  GL_NV_light_max_exponent,
+  GL_NV_multisample_filter_hint,
+  GL_NV_occlusion_query,
+  GL_NV_packed_depth_stencil,
+  GL_NV_pixel_data_range,
+  GL_NV_point_sprite,
+  GL_NV_primitive_restart,
+  GL_NV_register_combiners,
+  GL_NV_register_combiners2,
+  GL_NV_texgen_emboss,
+  GL_NV_texgen_reflection,
+  GL_NV_texture_compression_vtc,
+  GL_NV_texture_env_combine4,
+  GL_NV_texture_expand_normal,
+  GL_NV_texture_rectangle,
+  GL_NV_texture_shader,
+  GL_NV_texture_shader2,
+  GL_NV_texture_shader3,
+  GL_NV_vertex_array_range,
+  GL_NV_vertex_array_range2,
+  GL_NV_vertex_program,
+  GL_NV_vertex_program1_1,
+  GL_NV_vertex_program2,
+  GL_NV_fragment_program_option,
+  GL_NV_fragment_program2,
+  GL_NV_vertex_program2_option,
+  GL_NV_vertex_program3,
+  GL_NV_depth_buffer_float,
+  GL_NV_fragment_program4,
+  GL_NV_framebuffer_multisample_coverage,
+  GL_NV_geometry_program4,
+  GL_NV_gpu_program4,
+  GL_NV_parameter_buffer_object,
+  GL_NV_transform_feedback,
+  GL_NV_vertex_program4,
+  GL_NV_conditional_render,
+  GL_NV_present_video,
+  GL_NV_explicit_multisample,
+  GL_NV_transform_feedback2,
+  GL_NV_video_capture,
+  GL_NV_copy_image,
+  GL_NV_parameter_buffer_object2,
+  GL_NV_shader_buffer_load,
+  GL_NV_vertex_buffer_unified_memory,
+  GL_NV_gpu_program5,
+  GL_NV_gpu_shader5,
+  GL_NV_shader_buffer_store,
+  GL_NV_tessellation_program5,
+  GL_NV_vertex_attrib_integer_64bit,
+  GL_NV_multisample_coverage,
+  GL_NV_vdpau_interop,
+  GL_NV_texture_barrier,
+  GL_OML_interlace,
+  GL_OML_resample,
+  GL_OML_subsample,
+  GL_PGI_misc_hints,
+  GL_PGI_vertex_hints,
+  GL_REND_screen_coordinates,
+  GL_S3_s3tc,
+  GL_SGIS_detail_texture,
+  GL_SGIS_fog_function,
+  GL_SGIS_generate_mipmap,
+  GL_SGIS_multisample,
+  GL_SGIS_pixel_texture,
+  GL_SGIS_point_line_texgen,
+  GL_SGIS_point_parameters,
+  GL_SGIS_sharpen_texture,
+  GL_SGIS_texture4D,
+  GL_SGIS_texture_border_clamp,
+  GL_SGIS_texture_color_mask,
+  GL_SGIS_texture_edge_clamp,
+  GL_SGIS_texture_filter4,
+  GL_SGIS_texture_lod,
+  GL_SGIS_texture_select,
+  GL_SGIX_async,
+  GL_SGIX_async_histogram,
+  GL_SGIX_async_pixel,
+  GL_SGIX_blend_alpha_minmax,
+  GL_SGIX_calligraphic_fragment,
+  GL_SGIX_clipmap,
+  GL_SGIX_convolution_accuracy,
+  GL_SGIX_depth_pass_instrument,
+  GL_SGIX_depth_texture,
+  GL_SGIX_flush_raster,
+  GL_SGIX_fog_offset,
+  GL_SGIX_fog_scale,
+  GL_SGIX_fragment_lighting,
+  GL_SGIX_framezoom,
+  GL_SGIX_igloo_interface,
+  GL_SGIX_impact_pixel_texture,
+  GL_SGIX_instruments,
+  GL_SGIX_interlace,
+  GL_SGIX_ir_instrument1,
+  GL_SGIX_list_priority,
+  GL_SGIX_pixel_texture,
+  GL_SGIX_pixel_tiles,
+  GL_SGIX_polynomial_ffd,
+  GL_SGIX_reference_plane,
+  GL_SGIX_resample,
+  GL_SGIX_scalebias_hint,
+  GL_SGIX_shadow,
+  GL_SGIX_shadow_ambient,
+  GL_SGIX_sprite,
+  GL_SGIX_subsample,
+  GL_SGIX_tag_sample_buffer,
+  GL_SGIX_texture_add_env,
+  GL_SGIX_texture_coordinate_clamp,
+  GL_SGIX_texture_lod_bias,
+  GL_SGIX_texture_multi_buffer,
+  GL_SGIX_texture_scale_bias,
+  GL_SGIX_texture_select,
+  GL_SGIX_vertex_preclip,
+  GL_SGIX_ycrcb,
+  GL_SGIX_ycrcb_subsample,
+  GL_SGIX_ycrcba,
+  GL_SGI_color_matrix,
+  GL_SGI_color_table,
+  GL_SGI_depth_pass_instrument,
+  GL_SGI_texture_color_table,
+  GL_SUNX_constant_data,
+  GL_SUN_convolution_border_modes,
+  GL_SUN_global_alpha,
+  GL_SUN_mesh_array,
+  GL_SUN_slice_accum,
+  GL_SUN_triangle_list,
+  GL_SUN_vertex,
+
+  GL_WIN_phong_shading,
+  GL_WIN_specular_fog,
+  WGL_3DFX_multisample,
+  WGL_ARB_buffer_region,
+  WGL_ARB_extensions_string,
+  WGL_ARB_make_current_read,
+  WGL_ARB_multisample,
+  WGL_ARB_pbuffer,
+  WGL_ARB_pixel_format,
+  WGL_ARB_pixel_format_float,
+  WGL_ARB_render_texture,
+  WGL_ARB_create_context,
+  WGL_ARB_create_context_profile,
+  WGL_ARB_framebuffer_sRGB,
+  WGL_ARB_create_context_robustness,
+  WGL_ATI_pixel_format_float,
+  WGL_AMD_gpu_association,
+  WGL_EXT_depth_float,
+  WGL_EXT_display_color_table,
+  WGL_EXT_extensions_string,
+  WGL_EXT_make_current_read,
+  WGL_EXT_multisample,
+  WGL_EXT_pbuffer,
+  WGL_EXT_pixel_format,
+  WGL_EXT_swap_control,
+  WGL_EXT_create_context_es2_profile,
+  WGL_I3D_digital_video_control,
+  WGL_I3D_gamma,
+  WGL_I3D_genlock,
+  WGL_I3D_image_buffer,
+  WGL_I3D_swap_frame_lock,
+  WGL_I3D_swap_frame_usage,
+  WGL_NV_float_buffer,
+  WGL_NV_render_depth_texture,
+  WGL_NV_render_texture_rectangle,
+  WGL_NV_vertex_array_range,
+  WGL_NV_present_video,
+  WGL_NV_video_output,
+  WGL_NV_swap_group,
+  WGL_NV_gpu_affinity,
+  WGL_NV_video_capture,
+  WGL_NV_copy_image,
+  WGL_NV_multisample_coverage,
+  WGL_NV_DX_interop,
+  WGL_OML_sync_control,
+  WGL_3DL_stereo_control,
+  WIN_draw_range_elements,
+  WIN_swap_hint,
+  
+//  GLX_VERSION_1_0,
+  GLX_VERSION_1_3,
+  GLX_VERSION_1_4,
+  GLX_ARB_multisample,
+  GLX_ARB_fbconfig_float,
+  GLX_ARB_get_proc_address,
+  GLX_ARB_create_context,
+  GLX_ARB_create_context_profile,
+  GLX_ARB_vertex_buffer_object,
+  GLX_ARB_framebuffer_sRGB,
+  GLX_ARB_create_context_robustness,
+  GLX_EXT_visual_info,
+  GLX_EXT_visual_rating,
+  GLX_EXT_import_context,
+  GLX_EXT_fbconfig_packed_float,
+  GLX_EXT_framebuffer_sRGB,
+  GLX_EXT_texture_from_pixmap,
+  GLX_EXT_swap_control,
+  GLX_EXT_create_context_es2_profile : Boolean;
+
+const
+  // GL_VERSION_1_1
+  { AttribMask }
+  GL_DEPTH_BUFFER_BIT = $00000100;
+  GL_STENCIL_BUFFER_BIT = $00000400;
+  GL_COLOR_BUFFER_BIT = $00004000;
+  { Boolean }
+  GL_TRUE = 1;
+  GL_FALSE = 0;
+  { BeginMode }
+  GL_POINTS = $0000;
+  GL_LINES = $0001;
+  GL_LINE_LOOP = $0002;
+  GL_LINE_STRIP = $0003;
+  GL_TRIANGLES = $0004;
+  GL_TRIANGLE_STRIP = $0005;
+  GL_TRIANGLE_FAN = $0006;
+  { AlphaFunction }
+  GL_NEVER = $0200;
+  GL_LESS = $0201;
+  GL_EQUAL = $0202;
+  GL_LEQUAL = $0203;
+  GL_GREATER = $0204;
+  GL_NOTEQUAL = $0205;
+  GL_GEQUAL = $0206;
+  GL_ALWAYS = $0207;
+  { BlendingFactorDest }
+  GL_ZERO = 0;
+  GL_ONE = 1;
+  GL_SRC_COLOR = $0300;
+  GL_ONE_MINUS_SRC_COLOR = $0301;
+  GL_SRC_ALPHA = $0302;
+  GL_ONE_MINUS_SRC_ALPHA = $0303;
+  GL_DST_ALPHA = $0304;
+  GL_ONE_MINUS_DST_ALPHA = $0305;
+  { BlendingFactorSrc }
+  GL_DST_COLOR = $0306;
+  GL_ONE_MINUS_DST_COLOR = $0307;
+  GL_SRC_ALPHA_SATURATE = $0308;
+  { DrawBufferMode }
+  GL_NONE = 0;
+  GL_FRONT_LEFT = $0400;
+  GL_FRONT_RIGHT = $0401;
+  GL_BACK_LEFT = $0402;
+  GL_BACK_RIGHT = $0403;
+  GL_FRONT = $0404;
+  GL_BACK = $0405;
+  GL_LEFT = $0406;
+  GL_RIGHT = $0407;
+  GL_FRONT_AND_BACK = $0408;
+  { ErrorCode }
+  GL_NO_ERROR = 0;
+  GL_INVALID_ENUM = $0500;
+  GL_INVALID_VALUE = $0501;
+  GL_INVALID_OPERATION = $0502;
+  GL_OUT_OF_MEMORY = $0505;
+  { FrontFaceDirection }
+  GL_CW = $0900;
+  GL_CCW = $0901;
+  { GetPName }
+  GL_POINT_SIZE = $0B11;
+  GL_POINT_SIZE_RANGE = $0B12;
+  GL_POINT_SIZE_GRANULARITY = $0B13;
+  GL_LINE_SMOOTH = $0B20;
+  GL_LINE_WIDTH = $0B21;
+  GL_LINE_WIDTH_RANGE = $0B22;
+  GL_LINE_WIDTH_GRANULARITY = $0B23;
+  GL_POLYGON_SMOOTH = $0B41;
+  GL_CULL_FACE = $0B44;
+  GL_CULL_FACE_MODE = $0B45;
+  GL_FRONT_FACE = $0B46;
+  GL_DEPTH_RANGE = $0B70;
+  GL_DEPTH_TEST = $0B71;
+  GL_DEPTH_WRITEMASK = $0B72;
+  GL_DEPTH_CLEAR_VALUE = $0B73;
+  GL_DEPTH_FUNC = $0B74;
+  GL_STENCIL_TEST = $0B90;
+  GL_STENCIL_CLEAR_VALUE = $0B91;
+  GL_STENCIL_FUNC = $0B92;
+  GL_STENCIL_VALUE_MASK = $0B93;
+  GL_STENCIL_FAIL = $0B94;
+  GL_STENCIL_PASS_DEPTH_FAIL = $0B95;
+  GL_STENCIL_PASS_DEPTH_PASS = $0B96;
+  GL_STENCIL_REF = $0B97;
+  GL_STENCIL_WRITEMASK = $0B98;
+  GL_VIEWPORT = $0BA2;
+  GL_DITHER = $0BD0;
+  GL_BLEND_DST = $0BE0;
+  GL_BLEND_SRC = $0BE1;
+  GL_BLEND = $0BE2;
+  GL_LOGIC_OP_MODE = $0BF0;
+  GL_COLOR_LOGIC_OP = $0BF2;
+  GL_DRAW_BUFFER = $0C01;
+  GL_READ_BUFFER = $0C02;
+  GL_SCISSOR_BOX = $0C10;
+  GL_SCISSOR_TEST = $0C11;
+  GL_COLOR_CLEAR_VALUE = $0C22;
+  GL_COLOR_WRITEMASK = $0C23;
+  GL_DOUBLEBUFFER = $0C32;
+  GL_STEREO = $0C33;
+  GL_LINE_SMOOTH_HINT = $0C52;
+  GL_POLYGON_SMOOTH_HINT = $0C53;
+  GL_UNPACK_SWAP_BYTES = $0CF0;
+  GL_UNPACK_LSB_FIRST = $0CF1;
+  GL_UNPACK_ROW_LENGTH = $0CF2;
+  GL_UNPACK_SKIP_ROWS = $0CF3;
+  GL_UNPACK_SKIP_PIXELS = $0CF4;
+  GL_UNPACK_ALIGNMENT = $0CF5;
+  GL_PACK_SWAP_BYTES = $0D00;
+  GL_PACK_LSB_FIRST = $0D01;
+  GL_PACK_ROW_LENGTH = $0D02;
+  GL_PACK_SKIP_ROWS = $0D03;
+  GL_PACK_SKIP_PIXELS = $0D04;
+  GL_PACK_ALIGNMENT = $0D05;
+  GL_MAX_TEXTURE_SIZE = $0D33;
+  GL_MAX_VIEWPORT_DIMS = $0D3A;
+  GL_SUBPIXEL_BITS = $0D50;
+  GL_TEXTURE_1D = $0DE0;
+  GL_TEXTURE_2D = $0DE1;
+  GL_POLYGON_OFFSET_UNITS = $2A00;
+  GL_POLYGON_OFFSET_POINT = $2A01;
+  GL_POLYGON_OFFSET_LINE = $2A02;
+  GL_POLYGON_OFFSET_FILL = $8037;
+  GL_POLYGON_OFFSET_FACTOR = $8038;
+  GL_TEXTURE_BINDING_1D = $8068;
+  GL_TEXTURE_BINDING_2D = $8069;
+  { GetTextureParameter }
+  GL_TEXTURE_WIDTH = $1000;
+  GL_TEXTURE_HEIGHT = $1001;
+  GL_TEXTURE_INTERNAL_FORMAT = $1003;
+  GL_TEXTURE_BORDER_COLOR = $1004;
+  GL_TEXTURE_BORDER = $1005;
+  GL_TEXTURE_RED_SIZE = $805C;
+  GL_TEXTURE_GREEN_SIZE = $805D;
+  GL_TEXTURE_BLUE_SIZE = $805E;
+  GL_TEXTURE_ALPHA_SIZE = $805F;
+  { HintMode }
+  GL_DONT_CARE = $1100;
+  GL_FASTEST = $1101;
+  GL_NICEST = $1102;
+  { DataType }
+  GL_BYTE = $1400;
+  GL_UNSIGNED_BYTE = $1401;
+  GL_SHORT = $1402;
+  GL_UNSIGNED_SHORT = $1403;
+  GL_INT = $1404;
+  GL_UNSIGNED_INT = $1405;
+  GL_FLOAT = $1406;
+  GL_DOUBLE = $140A;
+  { LogicOp }
+  GL_CLEAR = $1500;
+  GL_AND = $1501;
+  GL_AND_REVERSE = $1502;
+  GL_COPY = $1503;
+  GL_AND_INVERTED = $1504;
+  GL_NOOP = $1505;
+  GL_XOR = $1506;
+  GL_OR = $1507;
+  GL_NOR = $1508;
+  GL_EQUIV = $1509;
+  GL_INVERT = $150A;
+  GL_OR_REVERSE = $150B;
+  GL_COPY_INVERTED = $150C;
+  GL_OR_INVERTED = $150D;
+  GL_NAND = $150E;
+  GL_SET = $150F;
+  { MatrixMode (for gl3.h, FBO attachment type) }
+  GL_TEXTURE = $1702;
+  { PixelCopyType }
+  GL_COLOR = $1800;
+  GL_DEPTH = $1801;
+  GL_STENCIL = $1802;
+  { PixelFormat }
+  GL_STENCIL_INDEX = $1901;
+  GL_DEPTH_COMPONENT = $1902;
+  GL_RED = $1903;
+  GL_GREEN = $1904;
+  GL_BLUE = $1905;
+  GL_ALPHA = $1906;
+  GL_RGB = $1907;
+  GL_RGBA = $1908;
+  { PolygonMode }
+  GL_POINT = $1B00;
+  GL_LINE = $1B01;
+  GL_FILL = $1B02;
+  { StencilOp }
+  GL_KEEP = $1E00;
+  GL_REPLACE = $1E01;
+  GL_INCR = $1E02;
+  GL_DECR = $1E03;
+  { StringName }
+  GL_VENDOR = $1F00;
+  GL_RENDERER = $1F01;
+  GL_VERSION = $1F02;
+  GL_EXTENSIONS = $1F03;
+  { TextureMagFilter }
+  GL_NEAREST = $2600;
+  GL_LINEAR = $2601;
+  { TextureMinFilter }
+  GL_NEAREST_MIPMAP_NEAREST = $2700;
+  GL_LINEAR_MIPMAP_NEAREST = $2701;
+  GL_NEAREST_MIPMAP_LINEAR = $2702;
+  GL_LINEAR_MIPMAP_LINEAR = $2703;
+  { TextureParameterName }
+  GL_TEXTURE_MAG_FILTER = $2800;
+  GL_TEXTURE_MIN_FILTER = $2801;
+  GL_TEXTURE_WRAP_S = $2802;
+  GL_TEXTURE_WRAP_T = $2803;
+  { TextureTarget }
+  GL_PROXY_TEXTURE_1D = $8063;
+  GL_PROXY_TEXTURE_2D = $8064;
+  { TextureWrapMode }
+  GL_REPEAT = $2901;
+  { PixelInternalFormat }
+  GL_R3_G3_B2 = $2A10;
+  GL_RGB4 = $804F;
+  GL_RGB5 = $8050;
+  GL_RGB8 = $8051;
+  GL_RGB10 = $8052;
+  GL_RGB12 = $8053;
+  GL_RGB16 = $8054;
+  GL_RGBA2 = $8055;
+  GL_RGBA4 = $8056;
+  GL_RGB5_A1 = $8057;
+  GL_RGBA8 = $8058;
+  GL_RGB10_A2 = $8059;
+  GL_RGBA12 = $805A;
+  GL_RGBA16 = $805B;
+{$ifdef DGL_DEPRECATED}
+  GL_ACCUM = $0100;
+  GL_LOAD = $0101;
+  GL_RETURN = $0102;
+  GL_MULT = $0103;
+  GL_ADD = $0104;
+  GL_CURRENT_BIT = $00000001;
+  GL_POINT_BIT = $00000002;
+  GL_LINE_BIT = $00000004;
+  GL_POLYGON_BIT = $00000008;
+  GL_POLYGON_STIPPLE_BIT = $00000010;
+  GL_PIXEL_MODE_BIT = $00000020;
+  GL_LIGHTING_BIT = $00000040;
+  GL_FOG_BIT = $00000080;
+  GL_ACCUM_BUFFER_BIT = $00000200;
+  GL_VIEWPORT_BIT = $00000800;
+  GL_TRANSFORM_BIT = $00001000;
+  GL_ENABLE_BIT = $00002000;
+  GL_HINT_BIT = $00008000;
+  GL_EVAL_BIT = $00010000;
+  GL_LIST_BIT = $00020000;
+  GL_TEXTURE_BIT = $00040000;
+  GL_SCISSOR_BIT = $00080000;
+  GL_ALL_ATTRIB_BITS = $000FFFFF;
+  GL_QUADS = $0007;
+  GL_QUAD_STRIP = $0008;
+  GL_POLYGON = $0009;
+  GL_CLIP_PLANE0 = $3000;
+  GL_CLIP_PLANE1 = $3001;
+  GL_CLIP_PLANE2 = $3002;
+  GL_CLIP_PLANE3 = $3003;
+  GL_CLIP_PLANE4 = $3004;
+  GL_CLIP_PLANE5 = $3005;
+  GL_2_BYTES = $1407;
+  GL_3_BYTES = $1408;
+  GL_4_BYTES = $1409;
+  GL_AUX0 = $0409;
+  GL_AUX1 = $040A;
+  GL_AUX2 = $040B;
+  GL_AUX3 = $040C;
+  GL_STACK_OVERFLOW = $0503;
+  GL_STACK_UNDERFLOW = $0504;
+  GL_2D = $0600;
+  GL_3D = $0601;
+  GL_3D_COLOR = $0602;
+  GL_3D_COLOR_TEXTURE = $0603;
+  GL_4D_COLOR_TEXTURE = $0604;
+  GL_PASS_THROUGH_TOKEN = $0700;
+  GL_POINT_TOKEN = $0701;
+  GL_LINE_TOKEN = $0702;
+  GL_POLYGON_TOKEN = $0703;
+  GL_BITMAP_TOKEN = $0704;
+  GL_DRAW_PIXEL_TOKEN = $0705;
+  GL_COPY_PIXEL_TOKEN = $0706;
+  GL_LINE_RESET_TOKEN = $0707;
+  GL_EXP = $0800;
+  GL_EXP2 = $0801;
+  GL_COEFF = $0A00;
+  GL_ORDER = $0A01;
+  GL_DOMAIN = $0A02;
+  GL_CURRENT_COLOR = $0B00;
+  GL_CURRENT_INDEX = $0B01;
+  GL_CURRENT_NORMAL = $0B02;
+  GL_CURRENT_TEXTURE_COORDS = $0B03;
+  GL_CURRENT_RASTER_COLOR = $0B04;
+  GL_CURRENT_RASTER_INDEX = $0B05;
+  GL_CURRENT_RASTER_TEXTURE_COORDS = $0B06;
+  GL_CURRENT_RASTER_POSITION = $0B07;
+  GL_CURRENT_RASTER_POSITION_VALID = $0B08;
+  GL_CURRENT_RASTER_DISTANCE = $0B09;
+  GL_POINT_SMOOTH = $0B10;
+  GL_LINE_STIPPLE = $0B24;
+  GL_LINE_STIPPLE_PATTERN = $0B25;
+  GL_LINE_STIPPLE_REPEAT = $0B26;
+  GL_LIST_MODE = $0B30;
+  GL_MAX_LIST_NESTING = $0B31;
+  GL_LIST_BASE = $0B32;
+  GL_LIST_INDEX = $0B33;
+  GL_POLYGON_MODE = $0B40;
+  GL_POLYGON_STIPPLE = $0B42;
+  GL_EDGE_FLAG = $0B43;
+  GL_LIGHTING = $0B50;
+  GL_LIGHT_MODEL_LOCAL_VIEWER = $0B51;
+  GL_LIGHT_MODEL_TWO_SIDE = $0B52;
+  GL_LIGHT_MODEL_AMBIENT = $0B53;
+  GL_SHADE_MODEL = $0B54;
+  GL_COLOR_MATERIAL_FACE = $0B55;
+  GL_COLOR_MATERIAL_PARAMETER = $0B56;
+  GL_COLOR_MATERIAL = $0B57;
+  GL_FOG = $0B60;
+  GL_FOG_INDEX = $0B61;
+  GL_FOG_DENSITY = $0B62;
+  GL_FOG_START = $0B63;
+  GL_FOG_END = $0B64;
+  GL_FOG_MODE = $0B65;
+  GL_FOG_COLOR = $0B66;
+  GL_ACCUM_CLEAR_VALUE = $0B80;
+  GL_MATRIX_MODE = $0BA0;
+  GL_NORMALIZE = $0BA1;
+  GL_MODELVIEW_STACK_DEPTH = $0BA3;
+  GL_PROJECTION_STACK_DEPTH = $0BA4;
+  GL_TEXTURE_STACK_DEPTH = $0BA5;
+  GL_MODELVIEW_MATRIX = $0BA6;
+  GL_PROJECTION_MATRIX = $0BA7;
+  GL_TEXTURE_MATRIX = $0BA8;
+  GL_ATTRIB_STACK_DEPTH = $0BB0;
+  GL_CLIENT_ATTRIB_STACK_DEPTH = $0BB1;
+  GL_ALPHA_TEST = $0BC0;
+  GL_ALPHA_TEST_FUNC = $0BC1;
+  GL_ALPHA_TEST_REF = $0BC2;
+  GL_INDEX_LOGIC_OP = $0BF1;
+  GL_AUX_BUFFERS = $0C00;
+  GL_INDEX_CLEAR_VALUE = $0C20;
+  GL_INDEX_WRITEMASK = $0C21;
+  GL_INDEX_MODE = $0C30;
+  GL_RGBA_MODE = $0C31;
+  GL_RENDER_MODE = $0C40;
+  GL_PERSPECTIVE_CORRECTION_HINT = $0C50;
+  GL_POINT_SMOOTH_HINT = $0C51;
+  GL_FOG_HINT = $0C54;
+  GL_TEXTURE_GEN_S = $0C60;
+  GL_TEXTURE_GEN_T = $0C61;
+  GL_TEXTURE_GEN_R = $0C62;
+  GL_TEXTURE_GEN_Q = $0C63;
+  GL_PIXEL_MAP_I_TO_I = $0C70;
+  GL_PIXEL_MAP_S_TO_S = $0C71;
+  GL_PIXEL_MAP_I_TO_R = $0C72;
+  GL_PIXEL_MAP_I_TO_G = $0C73;
+  GL_PIXEL_MAP_I_TO_B = $0C74;
+  GL_PIXEL_MAP_I_TO_A = $0C75;
+  GL_PIXEL_MAP_R_TO_R = $0C76;
+  GL_PIXEL_MAP_G_TO_G = $0C77;
+  GL_PIXEL_MAP_B_TO_B = $0C78;
+  GL_PIXEL_MAP_A_TO_A = $0C79;
+  GL_PIXEL_MAP_I_TO_I_SIZE = $0CB0;
+  GL_PIXEL_MAP_S_TO_S_SIZE = $0CB1;
+  GL_PIXEL_MAP_I_TO_R_SIZE = $0CB2;
+  GL_PIXEL_MAP_I_TO_G_SIZE = $0CB3;
+  GL_PIXEL_MAP_I_TO_B_SIZE = $0CB4;
+  GL_PIXEL_MAP_I_TO_A_SIZE = $0CB5;
+  GL_PIXEL_MAP_R_TO_R_SIZE = $0CB6;
+  GL_PIXEL_MAP_G_TO_G_SIZE = $0CB7;
+  GL_PIXEL_MAP_B_TO_B_SIZE = $0CB8;
+  GL_PIXEL_MAP_A_TO_A_SIZE = $0CB9;
+  GL_MAP_COLOR = $0D10;
+  GL_MAP_STENCIL = $0D11;
+  GL_INDEX_SHIFT = $0D12;
+  GL_INDEX_OFFSET = $0D13;
+  GL_RED_SCALE = $0D14;
+  GL_RED_BIAS = $0D15;
+  GL_ZOOM_X = $0D16;
+  GL_ZOOM_Y = $0D17;
+  GL_GREEN_SCALE = $0D18;
+  GL_GREEN_BIAS = $0D19;
+  GL_BLUE_SCALE = $0D1A;
+  GL_BLUE_BIAS = $0D1B;
+  GL_ALPHA_SCALE = $0D1C;
+  GL_ALPHA_BIAS = $0D1D;
+  GL_DEPTH_SCALE = $0D1E;
+  GL_DEPTH_BIAS = $0D1F;
+  GL_MAX_EVAL_ORDER = $0D30;
+  GL_MAX_LIGHTS = $0D31;
+  GL_MAX_CLIP_PLANES = $0D32;
+  GL_MAX_PIXEL_MAP_TABLE = $0D34;
+  GL_MAX_ATTRIB_STACK_DEPTH = $0D35;
+  GL_MAX_MODELVIEW_STACK_DEPTH = $0D36;
+  GL_MAX_NAME_STACK_DEPTH = $0D37;
+  GL_MAX_PROJECTION_STACK_DEPTH = $0D38;
+  GL_MAX_TEXTURE_STACK_DEPTH = $0D39;
+  GL_MAX_CLIENT_ATTRIB_STACK_DEPTH = $0D3B;
+  GL_INDEX_BITS = $0D51;
+  GL_RED_BITS = $0D52;
+  GL_GREEN_BITS = $0D53;
+  GL_BLUE_BITS = $0D54;
+  GL_ALPHA_BITS = $0D55;
+  GL_DEPTH_BITS = $0D56;
+  GL_STENCIL_BITS = $0D57;
+  GL_ACCUM_RED_BITS = $0D58;
+  GL_ACCUM_GREEN_BITS = $0D59;
+  GL_ACCUM_BLUE_BITS = $0D5A;
+  GL_ACCUM_ALPHA_BITS = $0D5B;
+  GL_NAME_STACK_DEPTH = $0D70;
+  GL_AUTO_NORMAL = $0D80;
+  GL_MAP1_COLOR_4 = $0D90;
+  GL_MAP1_INDEX = $0D91;
+  GL_MAP1_NORMAL = $0D92;
+  GL_MAP1_TEXTURE_COORD_1 = $0D93;
+  GL_MAP1_TEXTURE_COORD_2 = $0D94;
+  GL_MAP1_TEXTURE_COORD_3 = $0D95;
+  GL_MAP1_TEXTURE_COORD_4 = $0D96;
+  GL_MAP1_VERTEX_3 = $0D97;
+  GL_MAP1_VERTEX_4 = $0D98;
+  GL_MAP2_COLOR_4 = $0DB0;
+  GL_MAP2_INDEX = $0DB1;
+  GL_MAP2_NORMAL = $0DB2;
+  GL_MAP2_TEXTURE_COORD_1 = $0DB3;
+  GL_MAP2_TEXTURE_COORD_2 = $0DB4;
+  GL_MAP2_TEXTURE_COORD_3 = $0DB5;
+  GL_MAP2_TEXTURE_COORD_4 = $0DB6;
+  GL_MAP2_VERTEX_3 = $0DB7;
+  GL_MAP2_VERTEX_4 = $0DB8;
+  GL_MAP1_GRID_DOMAIN = $0DD0;
+  GL_MAP1_GRID_SEGMENTS = $0DD1;
+  GL_MAP2_GRID_DOMAIN = $0DD2;
+  GL_MAP2_GRID_SEGMENTS = $0DD3;
+  GL_FEEDBACK_BUFFER_POINTER = $0DF0;
+  GL_FEEDBACK_BUFFER_SIZE = $0DF1;
+  GL_FEEDBACK_BUFFER_TYPE = $0DF2;
+  GL_SELECTION_BUFFER_POINTER = $0DF3;
+  GL_SELECTION_BUFFER_SIZE = $0DF4;
+  GL_LIGHT0 = $4000;
+  GL_LIGHT1 = $4001;
+  GL_LIGHT2 = $4002;
+  GL_LIGHT3 = $4003;
+  GL_LIGHT4 = $4004;
+  GL_LIGHT5 = $4005;
+  GL_LIGHT6 = $4006;
+  GL_LIGHT7 = $4007;
+  GL_AMBIENT = $1200;
+  GL_DIFFUSE = $1201;
+  GL_SPECULAR = $1202;
+  GL_POSITION = $1203;
+  GL_SPOT_DIRECTION = $1204;
+  GL_SPOT_EXPONENT = $1205;
+  GL_SPOT_CUTOFF = $1206;
+  GL_CONSTANT_ATTENUATION = $1207;
+  GL_LINEAR_ATTENUATION = $1208;
+  GL_QUADRATIC_ATTENUATION = $1209;
+  GL_COMPILE = $1300;
+  GL_COMPILE_AND_EXECUTE = $1301;
+  GL_EMISSION = $1600;
+  GL_SHININESS = $1601;
+  GL_AMBIENT_AND_DIFFUSE = $1602;
+  GL_COLOR_INDEXES = $1603;
+  GL_MODELVIEW = $1700;
+  GL_PROJECTION = $1701;
+  GL_COLOR_INDEX = $1900;
+  GL_LUMINANCE = $1909;
+  GL_LUMINANCE_ALPHA = $190A;
+  GL_BITMAP = $1A00;
+  GL_RENDER = $1C00;
+  GL_FEEDBACK = $1C01;
+  GL_SELECT = $1C02;
+  GL_FLAT = $1D00;
+  GL_SMOOTH = $1D01;
+  GL_S = $2000;
+  GL_T = $2001;
+  GL_R = $2002;
+  GL_Q = $2003;
+  GL_MODULATE = $2100;
+  GL_DECAL = $2101;
+  GL_TEXTURE_ENV_MODE = $2200;
+  GL_TEXTURE_ENV_COLOR = $2201;
+  GL_TEXTURE_ENV = $2300;
+  GL_EYE_LINEAR = $2400;
+  GL_OBJECT_LINEAR = $2401;
+  GL_SPHERE_MAP = $2402;
+  GL_TEXTURE_GEN_MODE = $2500;
+  GL_OBJECT_PLANE = $2501;
+  GL_EYE_PLANE = $2502;
+  GL_CLAMP = $2900;
+  GL_CLIENT_PIXEL_STORE_BIT = $00000001;
+  GL_CLIENT_VERTEX_ARRAY_BIT = $00000002;
+  GL_CLIENT_ALL_ATTRIB_BITS = $FFFFFFFF;
+  GL_ALPHA4 = $803B;
+  GL_ALPHA8 = $803C;
+  GL_ALPHA12 = $803D;
+  GL_ALPHA16 = $803E;
+  GL_LUMINANCE4 = $803F;
+  GL_LUMINANCE8 = $8040;
+  GL_LUMINANCE12 = $8041;
+  GL_LUMINANCE16 = $8042;
+  GL_LUMINANCE4_ALPHA4 = $8043;
+  GL_LUMINANCE6_ALPHA2 = $8044;
+  GL_LUMINANCE8_ALPHA8 = $8045;
+  GL_LUMINANCE12_ALPHA4 = $8046;
+  GL_LUMINANCE12_ALPHA12 = $8047;
+  GL_LUMINANCE16_ALPHA16 = $8048;
+  GL_INTENSITY = $8049;
+  GL_INTENSITY4 = $804A;
+  GL_INTENSITY8 = $804B;
+  GL_INTENSITY12 = $804C;
+  GL_INTENSITY16 = $804D;
+  GL_TEXTURE_LUMINANCE_SIZE = $8060;
+  GL_TEXTURE_INTENSITY_SIZE = $8061;
+  GL_TEXTURE_PRIORITY = $8066;
+  GL_TEXTURE_RESIDENT = $8067;
+  GL_VERTEX_ARRAY = $8074;
+  GL_NORMAL_ARRAY = $8075;
+  GL_COLOR_ARRAY = $8076;
+  GL_INDEX_ARRAY = $8077;
+  GL_TEXTURE_COORD_ARRAY = $8078;
+  GL_EDGE_FLAG_ARRAY = $8079;
+  GL_VERTEX_ARRAY_SIZE = $807A;
+  GL_VERTEX_ARRAY_TYPE = $807B;
+  GL_VERTEX_ARRAY_STRIDE = $807C;
+  GL_NORMAL_ARRAY_TYPE = $807E;
+  GL_NORMAL_ARRAY_STRIDE = $807F;
+  GL_COLOR_ARRAY_SIZE = $8081;
+  GL_COLOR_ARRAY_TYPE = $8082;
+  GL_COLOR_ARRAY_STRIDE = $8083;
+  GL_INDEX_ARRAY_TYPE = $8085;
+  GL_INDEX_ARRAY_STRIDE = $8086;
+  GL_TEXTURE_COORD_ARRAY_SIZE = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE = $808A;
+  GL_EDGE_FLAG_ARRAY_STRIDE = $808C;
+  GL_VERTEX_ARRAY_POINTER = $808E;
+  GL_NORMAL_ARRAY_POINTER = $808F;
+  GL_COLOR_ARRAY_POINTER = $8090;
+  GL_INDEX_ARRAY_POINTER = $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER = $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER = $8093;
+  GL_V2F = $2A20;
+  GL_V3F = $2A21;
+  GL_C4UB_V2F = $2A22;
+  GL_C4UB_V3F = $2A23;
+  GL_C3F_V3F = $2A24;
+  GL_N3F_V3F = $2A25;
+  GL_C4F_N3F_V3F = $2A26;
+  GL_T2F_V3F = $2A27;
+  GL_T4F_V4F = $2A28;
+  GL_T2F_C4UB_V3F = $2A29;
+  GL_T2F_C3F_V3F = $2A2A;
+  GL_T2F_N3F_V3F = $2A2B;
+  GL_T2F_C4F_N3F_V3F = $2A2C;
+  GL_T4F_C4F_N3F_V4F = $2A2D;
+  GL_COLOR_TABLE_FORMAT_EXT = $80D8;
+  GL_COLOR_TABLE_WIDTH_EXT = $80D9;
+  GL_COLOR_TABLE_RED_SIZE_EXT = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE_EXT = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE_EXT = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE_EXT = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE_EXT = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE_EXT = $80DF;
+  GL_LOGIC_OP = GL_INDEX_LOGIC_OP;
+  GL_TEXTURE_COMPONENTS = GL_TEXTURE_INTERNAL_FORMAT;
+{$endif}
+
+  // GL_VERSION_1_2
+  GL_UNSIGNED_BYTE_3_3_2 = $8032;
+  GL_UNSIGNED_SHORT_4_4_4_4 = $8033;
+  GL_UNSIGNED_SHORT_5_5_5_1 = $8034;
+  GL_UNSIGNED_INT_8_8_8_8 = $8035;
+  GL_UNSIGNED_INT_10_10_10_2 = $8036;
+  GL_TEXTURE_BINDING_3D = $806A;
+  GL_PACK_SKIP_IMAGES = $806B;
+  GL_PACK_IMAGE_HEIGHT = $806C;
+  GL_UNPACK_SKIP_IMAGES = $806D;
+  GL_UNPACK_IMAGE_HEIGHT = $806E;
+  GL_TEXTURE_3D = $806F;
+  GL_PROXY_TEXTURE_3D = $8070;
+  GL_TEXTURE_DEPTH = $8071;
+  GL_TEXTURE_WRAP_R = $8072;
+  GL_MAX_3D_TEXTURE_SIZE = $8073;
+  GL_UNSIGNED_BYTE_2_3_3_REV = $8362;
+  GL_UNSIGNED_SHORT_5_6_5 = $8363;
+  GL_UNSIGNED_SHORT_5_6_5_REV = $8364;
+  GL_UNSIGNED_SHORT_4_4_4_4_REV = $8365;
+  GL_UNSIGNED_SHORT_1_5_5_5_REV = $8366;
+  GL_UNSIGNED_INT_8_8_8_8_REV = $8367;
+  GL_UNSIGNED_INT_2_10_10_10_REV = $8368;
+  GL_BGR = $80E0;
+  GL_BGRA = $80E1;
+  GL_MAX_ELEMENTS_VERTICES = $80E8;
+  GL_MAX_ELEMENTS_INDICES = $80E9;
+  GL_CLAMP_TO_EDGE = $812F;
+  GL_TEXTURE_MIN_LOD = $813A;
+  GL_TEXTURE_MAX_LOD = $813B;
+  GL_TEXTURE_BASE_LEVEL = $813C;
+  GL_TEXTURE_MAX_LEVEL = $813D;
+  GL_SMOOTH_POINT_SIZE_RANGE = $0B12;
+  GL_SMOOTH_POINT_SIZE_GRANULARITY = $0B13;
+  GL_SMOOTH_LINE_WIDTH_RANGE = $0B22;
+  GL_SMOOTH_LINE_WIDTH_GRANULARITY = $0B23;
+  GL_ALIASED_LINE_WIDTH_RANGE = $846E;
+{$ifdef DGL_DEPRECATED}
+  GL_RESCALE_NORMAL = $803A;
+  GL_LIGHT_MODEL_COLOR_CONTROL = $81F8;
+  GL_SINGLE_COLOR = $81F9;
+  GL_SEPARATE_SPECULAR_COLOR = $81FA;
+  GL_ALIASED_POINT_SIZE_RANGE = $846D;
+{$endif}
+
+  // GL_VERSION_1_3
+  GL_TEXTURE0 = $84C0;
+  GL_TEXTURE1 = $84C1;
+  GL_TEXTURE2 = $84C2;
+  GL_TEXTURE3 = $84C3;
+  GL_TEXTURE4 = $84C4;
+  GL_TEXTURE5 = $84C5;
+  GL_TEXTURE6 = $84C6;
+  GL_TEXTURE7 = $84C7;
+  GL_TEXTURE8 = $84C8;
+  GL_TEXTURE9 = $84C9;
+  GL_TEXTURE10 = $84CA;
+  GL_TEXTURE11 = $84CB;
+  GL_TEXTURE12 = $84CC;
+  GL_TEXTURE13 = $84CD;
+  GL_TEXTURE14 = $84CE;
+  GL_TEXTURE15 = $84CF;
+  GL_TEXTURE16 = $84D0;
+  GL_TEXTURE17 = $84D1;
+  GL_TEXTURE18 = $84D2;
+  GL_TEXTURE19 = $84D3;
+  GL_TEXTURE20 = $84D4;
+  GL_TEXTURE21 = $84D5;
+  GL_TEXTURE22 = $84D6;
+  GL_TEXTURE23 = $84D7;
+  GL_TEXTURE24 = $84D8;
+  GL_TEXTURE25 = $84D9;
+  GL_TEXTURE26 = $84DA;
+  GL_TEXTURE27 = $84DB;
+  GL_TEXTURE28 = $84DC;
+  GL_TEXTURE29 = $84DD;
+  GL_TEXTURE30 = $84DE;
+  GL_TEXTURE31 = $84DF;
+  GL_ACTIVE_TEXTURE = $84E0;
+  GL_MULTISAMPLE = $809D;
+  GL_SAMPLE_ALPHA_TO_COVERAGE = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE = $809F;
+  GL_SAMPLE_COVERAGE = $80A0;
+  GL_SAMPLE_BUFFERS = $80A8;
+  GL_SAMPLES = $80A9;
+  GL_SAMPLE_COVERAGE_VALUE = $80AA;
+  GL_SAMPLE_COVERAGE_INVERT = $80AB;
+  GL_TEXTURE_CUBE_MAP = $8513;
+  GL_TEXTURE_BINDING_CUBE_MAP = $8514;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A;
+  GL_PROXY_TEXTURE_CUBE_MAP = $851B;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C;
+  GL_COMPRESSED_RGB = $84ED;
+  GL_COMPRESSED_RGBA = $84EE;
+  GL_TEXTURE_COMPRESSION_HINT = $84EF;
+  GL_TEXTURE_COMPRESSED_IMAGE_SIZE = $86A0;
+  GL_TEXTURE_COMPRESSED = $86A1;
+  GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2;
+  GL_COMPRESSED_TEXTURE_FORMATS = $86A3;
+  GL_CLAMP_TO_BORDER = $812D;
+{$ifdef DGL_DEPRECATED}
+  GL_CLIENT_ACTIVE_TEXTURE = $84E1;
+  GL_MAX_TEXTURE_UNITS = $84E2;
+  GL_TRANSPOSE_MODELVIEW_MATRIX = $84E3;
+  GL_TRANSPOSE_PROJECTION_MATRIX = $84E4;
+  GL_TRANSPOSE_TEXTURE_MATRIX = $84E5;
+  GL_TRANSPOSE_COLOR_MATRIX = $84E6;
+  GL_MULTISAMPLE_BIT = $20000000;
+  GL_NORMAL_MAP = $8511;
+  GL_REFLECTION_MAP = $8512;
+  GL_COMPRESSED_ALPHA = $84E9;
+  GL_COMPRESSED_LUMINANCE = $84EA;
+  GL_COMPRESSED_LUMINANCE_ALPHA = $84EB;
+  GL_COMPRESSED_INTENSITY = $84EC;
+  GL_COMBINE = $8570;
+  GL_COMBINE_RGB = $8571;
+  GL_COMBINE_ALPHA = $8572;
+  GL_SOURCE0_RGB = $8580;
+  GL_SOURCE1_RGB = $8581;
+  GL_SOURCE2_RGB = $8582;
+  GL_SOURCE0_ALPHA = $8588;
+  GL_SOURCE1_ALPHA = $8589;
+  GL_SOURCE2_ALPHA = $858A;
+  GL_OPERAND0_RGB = $8590;
+  GL_OPERAND1_RGB = $8591;
+  GL_OPERAND2_RGB = $8592;
+  GL_OPERAND0_ALPHA = $8598;
+  GL_OPERAND1_ALPHA = $8599;
+  GL_OPERAND2_ALPHA = $859A;
+  GL_RGB_SCALE = $8573;
+  GL_ADD_SIGNED = $8574;
+  GL_INTERPOLATE = $8575;
+  GL_SUBTRACT = $84E7;
+  GL_CONSTANT = $8576;
+  GL_PRIMARY_COLOR = $8577;
+  GL_PREVIOUS = $8578;
+  GL_DOT3_RGB = $86AE;
+  GL_DOT3_RGBA = $86AF;
+{$endif}
+
+  // GL_VERSION_1_4
+  GL_BLEND_DST_RGB = $80C8;
+  GL_BLEND_SRC_RGB = $80C9;
+  GL_BLEND_DST_ALPHA = $80CA;
+  GL_BLEND_SRC_ALPHA = $80CB;
+  GL_POINT_FADE_THRESHOLD_SIZE = $8128;
+  GL_DEPTH_COMPONENT16 = $81A5;
+  GL_DEPTH_COMPONENT24 = $81A6;
+  GL_DEPTH_COMPONENT32 = $81A7;
+  GL_MIRRORED_REPEAT = $8370;
+  GL_MAX_TEXTURE_LOD_BIAS = $84FD;
+  GL_TEXTURE_LOD_BIAS = $8501;
+  GL_INCR_WRAP = $8507;
+  GL_DECR_WRAP = $8508;
+  GL_TEXTURE_DEPTH_SIZE = $884A;
+  GL_TEXTURE_COMPARE_MODE = $884C;
+  GL_TEXTURE_COMPARE_FUNC = $884D;
+{$ifdef DGL_DEPRECATED}
+  GL_POINT_SIZE_MIN = $8126;
+  GL_POINT_SIZE_MAX = $8127;
+  GL_POINT_DISTANCE_ATTENUATION = $8129;
+  GL_GENERATE_MIPMAP = $8191;
+  GL_GENERATE_MIPMAP_HINT = $8192;
+  GL_FOG_COORDINATE_SOURCE = $8450;
+  GL_FOG_COORDINATE = $8451;
+  GL_FRAGMENT_DEPTH = $8452;
+  GL_CURRENT_FOG_COORDINATE = $8453;
+  GL_FOG_COORDINATE_ARRAY_TYPE = $8454;
+  GL_FOG_COORDINATE_ARRAY_STRIDE = $8455;
+  GL_FOG_COORDINATE_ARRAY_POINTER = $8456;
+  GL_FOG_COORDINATE_ARRAY = $8457;
+  GL_COLOR_SUM = $8458;
+  GL_CURRENT_SECONDARY_COLOR = $8459;
+  GL_SECONDARY_COLOR_ARRAY_SIZE = $845A;
+  GL_SECONDARY_COLOR_ARRAY_TYPE = $845B;
+  GL_SECONDARY_COLOR_ARRAY_STRIDE = $845C;
+  GL_SECONDARY_COLOR_ARRAY_POINTER = $845D;
+  GL_SECONDARY_COLOR_ARRAY = $845E;
+  GL_TEXTURE_FILTER_CONTROL = $8500;
+  GL_DEPTH_TEXTURE_MODE = $884B;
+  GL_COMPARE_R_TO_TEXTURE = $884E;
+{$endif}
+
+  // GL_VERSION_1_5
+  GL_BUFFER_SIZE = $8764;
+  GL_BUFFER_USAGE = $8765;
+  GL_QUERY_COUNTER_BITS = $8864;
+  GL_CURRENT_QUERY = $8865;
+  GL_QUERY_RESULT = $8866;
+  GL_QUERY_RESULT_AVAILABLE = $8867;
+  GL_ARRAY_BUFFER = $8892;
+  GL_ELEMENT_ARRAY_BUFFER = $8893;
+  GL_ARRAY_BUFFER_BINDING = $8894;
+  GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895;
+  GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F;
+  GL_READ_ONLY = $88B8;
+  GL_WRITE_ONLY = $88B9;
+  GL_READ_WRITE = $88BA;
+  GL_BUFFER_ACCESS = $88BB;
+  GL_BUFFER_MAPPED = $88BC;
+  GL_BUFFER_MAP_POINTER = $88BD;
+  GL_STREAM_DRAW = $88E0;
+  GL_STREAM_READ = $88E1;
+  GL_STREAM_COPY = $88E2;
+  GL_STATIC_DRAW = $88E4;
+  GL_STATIC_READ = $88E5;
+  GL_STATIC_COPY = $88E6;
+  GL_DYNAMIC_DRAW = $88E8;
+  GL_DYNAMIC_READ = $88E9;
+  GL_DYNAMIC_COPY = $88EA;
+  GL_SAMPLES_PASSED = $8914;
+{$ifdef DGL_DEPRECATED}
+  GL_VERTEX_ARRAY_BUFFER_BINDING = $8896;
+  GL_NORMAL_ARRAY_BUFFER_BINDING = $8897;
+  GL_COLOR_ARRAY_BUFFER_BINDING = $8898;
+  GL_INDEX_ARRAY_BUFFER_BINDING = $8899;
+  GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING = $889A;
+  GL_EDGE_FLAG_ARRAY_BUFFER_BINDING = $889B;
+  GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = $889C;
+  GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING = $889D;
+  GL_WEIGHT_ARRAY_BUFFER_BINDING = $889E;
+  GL_FOG_COORD_SRC = $8450;
+  GL_FOG_COORD = $8451;
+  GL_CURRENT_FOG_COORD = $8453;
+  GL_FOG_COORD_ARRAY_TYPE = $8454;
+  GL_FOG_COORD_ARRAY_STRIDE = $8455;
+  GL_FOG_COORD_ARRAY_POINTER = $8456;
+  GL_FOG_COORD_ARRAY = $8457;
+  GL_FOG_COORD_ARRAY_BUFFER_BINDING = $889D;
+  GL_SRC0_RGB = $8580;
+  GL_SRC1_RGB = $8581;
+  GL_SRC2_RGB = $8582;
+  GL_SRC0_ALPHA = $8588;
+  GL_SRC1_ALPHA = $8589;
+  GL_SRC2_ALPHA = $858A;
+{$endif}
+
+  // GL_VERSION_2_0
+  GL_BLEND_EQUATION_RGB = $8009;
+  GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622;
+  GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623;
+  GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624;
+  GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625;
+  GL_CURRENT_VERTEX_ATTRIB = $8626;
+  GL_VERTEX_PROGRAM_POINT_SIZE = $8642;
+  GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645;
+  GL_STENCIL_BACK_FUNC = $8800;
+  GL_STENCIL_BACK_FAIL = $8801;
+  GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802;
+  GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803;
+  GL_MAX_DRAW_BUFFERS = $8824;
+  GL_DRAW_BUFFER0 = $8825;
+  GL_DRAW_BUFFER1 = $8826;
+  GL_DRAW_BUFFER2 = $8827;
+  GL_DRAW_BUFFER3 = $8828;
+  GL_DRAW_BUFFER4 = $8829;
+  GL_DRAW_BUFFER5 = $882A;
+  GL_DRAW_BUFFER6 = $882B;
+  GL_DRAW_BUFFER7 = $882C;
+  GL_DRAW_BUFFER8 = $882D;
+  GL_DRAW_BUFFER9 = $882E;
+  GL_DRAW_BUFFER10 = $882F;
+  GL_DRAW_BUFFER11 = $8830;
+  GL_DRAW_BUFFER12 = $8831;
+  GL_DRAW_BUFFER13 = $8832;
+  GL_DRAW_BUFFER14 = $8833;
+  GL_DRAW_BUFFER15 = $8834;
+  GL_BLEND_EQUATION_ALPHA = $883D;
+  GL_MAX_VERTEX_ATTRIBS = $8869;
+  GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A;
+  GL_MAX_TEXTURE_IMAGE_UNITS = $8872;
+  GL_FRAGMENT_SHADER = $8B30;
+  GL_VERTEX_SHADER = $8B31;
+  GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49;
+  GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A;
+  GL_MAX_VARYING_FLOATS = $8B4B;
+  GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C;
+  GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D;
+  GL_SHADER_TYPE = $8B4F;
+  GL_FLOAT_VEC2 = $8B50;
+  GL_FLOAT_VEC3 = $8B51;
+  GL_FLOAT_VEC4 = $8B52;
+  GL_INT_VEC2 = $8B53;
+  GL_INT_VEC3 = $8B54;
+  GL_INT_VEC4 = $8B55;
+  GL_BOOL = $8B56;
+  GL_BOOL_VEC2 = $8B57;
+  GL_BOOL_VEC3 = $8B58;
+  GL_BOOL_VEC4 = $8B59;
+  GL_FLOAT_MAT2 = $8B5A;
+  GL_FLOAT_MAT3 = $8B5B;
+  GL_FLOAT_MAT4 = $8B5C;
+  GL_SAMPLER_1D = $8B5D;
+  GL_SAMPLER_2D = $8B5E;
+  GL_SAMPLER_3D = $8B5F;
+  GL_SAMPLER_CUBE = $8B60;
+  GL_SAMPLER_1D_SHADOW = $8B61;
+  GL_SAMPLER_2D_SHADOW = $8B62;
+  GL_DELETE_STATUS = $8B80;
+  GL_COMPILE_STATUS = $8B81;
+  GL_LINK_STATUS = $8B82;
+  GL_VALIDATE_STATUS = $8B83;
+  GL_INFO_LOG_LENGTH = $8B84;
+  GL_ATTACHED_SHADERS = $8B85;
+  GL_ACTIVE_UNIFORMS = $8B86;
+  GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87;
+  GL_SHADER_SOURCE_LENGTH = $8B88;
+  GL_ACTIVE_ATTRIBUTES = $8B89;
+  GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A;
+  GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B;
+  GL_SHADING_LANGUAGE_VERSION = $8B8C;
+  GL_CURRENT_PROGRAM = $8B8D;
+  GL_POINT_SPRITE_COORD_ORIGIN = $8CA0;
+  GL_LOWER_LEFT = $8CA1;
+  GL_UPPER_LEFT = $8CA2;
+  GL_STENCIL_BACK_REF = $8CA3;
+  GL_STENCIL_BACK_VALUE_MASK = $8CA4;
+  GL_STENCIL_BACK_WRITEMASK = $8CA5;
+{$ifdef DGL_DEPRECATED}
+  GL_VERTEX_PROGRAM_TWO_SIDE = $8643;
+  GL_POINT_SPRITE = $8861;
+  GL_COORD_REPLACE = $8862;
+  GL_MAX_TEXTURE_COORDS = $8871;
+{$endif}
+
+  // GL_VERSION_2_1
+  GL_PIXEL_PACK_BUFFER = $88EB;
+  GL_PIXEL_UNPACK_BUFFER = $88EC;
+  GL_PIXEL_PACK_BUFFER_BINDING = $88ED;
+  GL_PIXEL_UNPACK_BUFFER_BINDING = $88EF;
+  GL_FLOAT_MAT2x3 = $8B65;
+  GL_FLOAT_MAT2x4 = $8B66;
+  GL_FLOAT_MAT3x2 = $8B67;
+  GL_FLOAT_MAT3x4 = $8B68;
+  GL_FLOAT_MAT4x2 = $8B69;
+  GL_FLOAT_MAT4x3 = $8B6A;
+  GL_SRGB = $8C40;
+  GL_SRGB8 = $8C41;
+  GL_SRGB_ALPHA = $8C42;
+  GL_SRGB8_ALPHA8 = $8C43;
+  GL_COMPRESSED_SRGB = $8C48;
+  GL_COMPRESSED_SRGB_ALPHA = $8C49;
+{$ifdef DGL_DEPRECATED}
+  GL_CURRENT_RASTER_SECONDARY_COLOR = $845F;
+  GL_SLUMINANCE_ALPHA = $8C44;
+  GL_SLUMINANCE8_ALPHA8 = $8C45;
+  GL_SLUMINANCE = $8C46;
+  GL_SLUMINANCE8 = $8C47;
+  GL_COMPRESSED_SLUMINANCE = $8C4A;
+  GL_COMPRESSED_SLUMINANCE_ALPHA = $8C4B;
+{$endif}
+
+  // GL_VERSION_3_0
+  GL_COMPARE_REF_TO_TEXTURE = $884E;
+  GL_CLIP_DISTANCE0 = $3000;
+  GL_CLIP_DISTANCE1 = $3001;
+  GL_CLIP_DISTANCE2 = $3002;
+  GL_CLIP_DISTANCE3 = $3003;
+  GL_CLIP_DISTANCE4 = $3004;
+  GL_CLIP_DISTANCE5 = $3005;
+  GL_CLIP_DISTANCE6 = $3006;
+  GL_CLIP_DISTANCE7 = $3007;
+  GL_MAX_CLIP_DISTANCES = $0D32;
+  GL_MAJOR_VERSION = $821B;
+  GL_MINOR_VERSION = $821C;
+  GL_NUM_EXTENSIONS = $821D;
+  GL_CONTEXT_FLAGS = $821E;
+  GL_DEPTH_BUFFER = $8223;
+  GL_STENCIL_BUFFER = $8224;
+  GL_COMPRESSED_RED = $8225;
+  GL_COMPRESSED_RG = $8226;
+  GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = $0001;
+  GL_RGBA32F = $8814;
+  GL_RGB32F = $8815;
+  GL_RGBA16F = $881A;
+  GL_RGB16F = $881B;
+  GL_VERTEX_ATTRIB_ARRAY_INTEGER = $88FD;
+  GL_MAX_ARRAY_TEXTURE_LAYERS = $88FF;
+  GL_MIN_PROGRAM_TEXEL_OFFSET = $8904;
+  GL_MAX_PROGRAM_TEXEL_OFFSET = $8905;
+  GL_CLAMP_READ_COLOR = $891C;
+  GL_FIXED_ONLY = $891D;
+  GL_MAX_VARYING_COMPONENTS = $8B4B;
+  GL_TEXTURE_1D_ARRAY = $8C18;
+  GL_PROXY_TEXTURE_1D_ARRAY = $8C19;
+  GL_TEXTURE_2D_ARRAY = $8C1A;
+  GL_PROXY_TEXTURE_2D_ARRAY = $8C1B;
+  GL_TEXTURE_BINDING_1D_ARRAY = $8C1C;
+  GL_TEXTURE_BINDING_2D_ARRAY = $8C1D;
+  GL_R11F_G11F_B10F = $8C3A;
+  GL_UNSIGNED_INT_10F_11F_11F_REV = $8C3B;
+  GL_RGB9_E5 = $8C3D;
+  GL_UNSIGNED_INT_5_9_9_9_REV = $8C3E;
+  GL_TEXTURE_SHARED_SIZE = $8C3F;
+  GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = $8C76;
+  GL_TRANSFORM_FEEDBACK_BUFFER_MODE = $8C7F;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = $8C80;
+  GL_TRANSFORM_FEEDBACK_VARYINGS = $8C83;
+  GL_TRANSFORM_FEEDBACK_BUFFER_START = $8C84;
+  GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = $8C85;
+  GL_PRIMITIVES_GENERATED = $8C87;
+  GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = $8C88;
+  GL_RASTERIZER_DISCARD = $8C89;
+  GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = $8C8A;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = $8C8B;
+  GL_INTERLEAVED_ATTRIBS = $8C8C;
+  GL_SEPARATE_ATTRIBS = $8C8D;
+  GL_TRANSFORM_FEEDBACK_BUFFER = $8C8E;
+  GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = $8C8F;
+  GL_RGBA32UI = $8D70;
+  GL_RGB32UI = $8D71;
+  GL_RGBA16UI = $8D76;
+  GL_RGB16UI = $8D77;
+  GL_RGBA8UI = $8D7C;
+  GL_RGB8UI = $8D7D;
+  GL_RGBA32I = $8D82;
+  GL_RGB32I = $8D83;
+  GL_RGBA16I = $8D88;
+  GL_RGB16I = $8D89;
+  GL_RGBA8I = $8D8E;
+  GL_RGB8I = $8D8F;
+  GL_RED_INTEGER = $8D94;
+  GL_GREEN_INTEGER = $8D95;
+  GL_BLUE_INTEGER = $8D96;
+  GL_RGB_INTEGER = $8D98;
+  GL_RGBA_INTEGER = $8D99;
+  GL_BGR_INTEGER = $8D9A;
+  GL_BGRA_INTEGER = $8D9B;
+  GL_SAMPLER_1D_ARRAY = $8DC0;
+  GL_SAMPLER_2D_ARRAY = $8DC1;
+  GL_SAMPLER_1D_ARRAY_SHADOW = $8DC3;
+  GL_SAMPLER_2D_ARRAY_SHADOW = $8DC4;
+  GL_SAMPLER_CUBE_SHADOW = $8DC5;
+  GL_UNSIGNED_INT_VEC2 = $8DC6;
+  GL_UNSIGNED_INT_VEC3 = $8DC7;
+  GL_UNSIGNED_INT_VEC4 = $8DC8;
+  GL_INT_SAMPLER_1D = $8DC9;
+  GL_INT_SAMPLER_2D = $8DCA;
+  GL_INT_SAMPLER_3D = $8DCB;
+  GL_INT_SAMPLER_CUBE = $8DCC;
+  GL_INT_SAMPLER_1D_ARRAY = $8DCE;
+  GL_INT_SAMPLER_2D_ARRAY = $8DCF;
+  GL_UNSIGNED_INT_SAMPLER_1D = $8DD1;
+  GL_UNSIGNED_INT_SAMPLER_2D = $8DD2;
+  GL_UNSIGNED_INT_SAMPLER_3D = $8DD3;
+  GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4;
+  GL_UNSIGNED_INT_SAMPLER_1D_ARRAY = $8DD6;
+  GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7;
+  GL_QUERY_WAIT = $8E13;
+  GL_QUERY_NO_WAIT = $8E14;
+  GL_QUERY_BY_REGION_WAIT = $8E15;
+  GL_QUERY_BY_REGION_NO_WAIT = $8E16;
+  GL_BUFFER_ACCESS_FLAGS = $911F;
+  GL_BUFFER_MAP_LENGTH = $9120;
+  GL_BUFFER_MAP_OFFSET = $9121;
+  { Reuse tokens from ARB_depth_buffer_float }
+  { reuse GL_DEPTH_COMPONENT32F }
+  { reuse GL_DEPTH32F_STENCIL8 }
+  { reuse GL_FLOAT_32_UNSIGNED_INT_24_8_REV }
+  { Reuse tokens from ARB_framebuffer_object }
+  { reuse GL_INVALID_FRAMEBUFFER_OPERATION }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE }
+  { reuse GL_FRAMEBUFFER_DEFAULT }
+  { reuse GL_FRAMEBUFFER_UNDEFINED }
+  { reuse GL_DEPTH_STENCIL_ATTACHMENT }
+  { reuse GL_INDEX }
+  { reuse GL_MAX_RENDERBUFFER_SIZE }
+  { reuse GL_DEPTH_STENCIL }
+  { reuse GL_UNSIGNED_INT_24_8 }
+  { reuse GL_DEPTH24_STENCIL8 }
+  { reuse GL_TEXTURE_STENCIL_SIZE }
+  { reuse GL_TEXTURE_RED_TYPE }
+  { reuse GL_TEXTURE_GREEN_TYPE }
+  { reuse GL_TEXTURE_BLUE_TYPE }
+  { reuse GL_TEXTURE_ALPHA_TYPE }
+  { reuse GL_TEXTURE_DEPTH_TYPE }
+  { reuse GL_UNSIGNED_NORMALIZED }
+  { reuse GL_FRAMEBUFFER_BINDING }
+  { reuse GL_DRAW_FRAMEBUFFER_BINDING }
+  { reuse GL_RENDERBUFFER_BINDING }
+  { reuse GL_READ_FRAMEBUFFER }
+  { reuse GL_DRAW_FRAMEBUFFER }
+  { reuse GL_READ_FRAMEBUFFER_BINDING }
+  { reuse GL_RENDERBUFFER_SAMPLES }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
+  { reuse GL_FRAMEBUFFER_COMPLETE }
+  { reuse GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT }
+  { reuse GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT }
+  { reuse GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER }
+  { reuse GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER }
+  { reuse GL_FRAMEBUFFER_UNSUPPORTED }
+  { reuse GL_MAX_COLOR_ATTACHMENTS }
+  { reuse GL_COLOR_ATTACHMENT0 }
+  { reuse GL_COLOR_ATTACHMENT1 }
+  { reuse GL_COLOR_ATTACHMENT2 }
+  { reuse GL_COLOR_ATTACHMENT3 }
+  { reuse GL_COLOR_ATTACHMENT4 }
+  { reuse GL_COLOR_ATTACHMENT5 }
+  { reuse GL_COLOR_ATTACHMENT6 }
+  { reuse GL_COLOR_ATTACHMENT7 }
+  { reuse GL_COLOR_ATTACHMENT8 }
+  { reuse GL_COLOR_ATTACHMENT9 }
+  { reuse GL_COLOR_ATTACHMENT10 }
+  { reuse GL_COLOR_ATTACHMENT11 }
+  { reuse GL_COLOR_ATTACHMENT12 }
+  { reuse GL_COLOR_ATTACHMENT13 }
+  { reuse GL_COLOR_ATTACHMENT14 }
+  { reuse GL_COLOR_ATTACHMENT15 }
+  { reuse GL_DEPTH_ATTACHMENT }
+  { reuse GL_STENCIL_ATTACHMENT }
+  { reuse GL_FRAMEBUFFER }
+  { reuse GL_RENDERBUFFER }
+  { reuse GL_RENDERBUFFER_WIDTH }
+  { reuse GL_RENDERBUFFER_HEIGHT }
+  { reuse GL_RENDERBUFFER_INTERNAL_FORMAT }
+  { reuse GL_STENCIL_INDEX1 }
+  { reuse GL_STENCIL_INDEX4 }
+  { reuse GL_STENCIL_INDEX8 }
+  { reuse GL_STENCIL_INDEX16 }
+  { reuse GL_RENDERBUFFER_RED_SIZE }
+  { reuse GL_RENDERBUFFER_GREEN_SIZE }
+  { reuse GL_RENDERBUFFER_BLUE_SIZE }
+  { reuse GL_RENDERBUFFER_ALPHA_SIZE }
+  { reuse GL_RENDERBUFFER_DEPTH_SIZE }
+  { reuse GL_RENDERBUFFER_STENCIL_SIZE }
+  { reuse GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE }
+  { reuse GL_MAX_SAMPLES }
+  { Reuse tokens from ARB_framebuffer_sRGB }
+  { reuse GL_FRAMEBUFFER_SRGB }
+  { Reuse tokens from ARB_half_float_vertex }
+  { reuse GL_HALF_FLOAT }
+  { Reuse tokens from ARB_map_buffer_range }
+  { reuse GL_MAP_READ_BIT }
+  { reuse GL_MAP_WRITE_BIT }
+  { reuse GL_MAP_INVALIDATE_RANGE_BIT }
+  { reuse GL_MAP_INVALIDATE_BUFFER_BIT }
+  { reuse GL_MAP_FLUSH_EXPLICIT_BIT }
+  { reuse GL_MAP_UNSYNCHRONIZED_BIT }
+  { Reuse tokens from ARB_texture_compression_rgtc }
+  { reuse GL_COMPRESSED_RED_RGTC1 }
+  { reuse GL_COMPRESSED_SIGNED_RED_RGTC1 }
+  { reuse GL_COMPRESSED_RG_RGTC2 }
+  { reuse GL_COMPRESSED_SIGNED_RG_RGTC2 }
+  { Reuse tokens from ARB_texture_rg }
+  { reuse GL_RG }
+  { reuse GL_RG_INTEGER }
+  { reuse GL_R8 }
+  { reuse GL_R16 }
+  { reuse GL_RG8 }
+  { reuse GL_RG16 }
+  { reuse GL_R16F }
+  { reuse GL_R32F }
+  { reuse GL_RG16F }
+  { reuse GL_RG32F }
+  { reuse GL_R8I }
+  { reuse GL_R8UI }
+  { reuse GL_R16I }
+  { reuse GL_R16UI }
+  { reuse GL_R32I }
+  { reuse GL_R32UI }
+  { reuse GL_RG8I }
+  { reuse GL_RG8UI }
+  { reuse GL_RG16I }
+  { reuse GL_RG16UI }
+  { reuse GL_RG32I }
+  { reuse GL_RG32UI }
+  { Reuse tokens from ARB_vertex_array_object }
+  { reuse GL_VERTEX_ARRAY_BINDING }
+{$ifdef DGL_DEPRECATED}
+  GL_CLAMP_VERTEX_COLOR = $891A;
+  GL_CLAMP_FRAGMENT_COLOR = $891B;
+  GL_ALPHA_INTEGER = $8D97;
+  { Reuse tokens from ARB_framebuffer_object }
+  { reuse GL_TEXTURE_LUMINANCE_TYPE }
+  { reuse GL_TEXTURE_INTENSITY_TYPE }
+{$endif}
+
+  // GL_VERSION_3_1
+  GL_SAMPLER_2D_RECT = $8B63;
+  GL_SAMPLER_2D_RECT_SHADOW = $8B64;
+  GL_SAMPLER_BUFFER = $8DC2;
+  GL_INT_SAMPLER_2D_RECT = $8DCD;
+  GL_INT_SAMPLER_BUFFER = $8DD0;
+  GL_UNSIGNED_INT_SAMPLER_2D_RECT = $8DD5;
+  GL_UNSIGNED_INT_SAMPLER_BUFFER = $8DD8;
+  GL_TEXTURE_BUFFER = $8C2A;
+  GL_MAX_TEXTURE_BUFFER_SIZE = $8C2B;
+  GL_TEXTURE_BINDING_BUFFER = $8C2C;
+  GL_TEXTURE_BUFFER_DATA_STORE_BINDING = $8C2D;
+  GL_TEXTURE_BUFFER_FORMAT = $8C2E;
+  GL_TEXTURE_RECTANGLE = $84F5;
+  GL_TEXTURE_BINDING_RECTANGLE = $84F6;
+  GL_PROXY_TEXTURE_RECTANGLE = $84F7;
+  GL_MAX_RECTANGLE_TEXTURE_SIZE = $84F8;
+  GL_RED_SNORM = $8F90;
+  GL_RG_SNORM = $8F91;
+  GL_RGB_SNORM = $8F92;
+  GL_RGBA_SNORM = $8F93;
+  GL_R8_SNORM = $8F94;
+  GL_RG8_SNORM = $8F95;
+  GL_RGB8_SNORM = $8F96;
+  GL_RGBA8_SNORM = $8F97;
+  GL_R16_SNORM = $8F98;
+  GL_RG16_SNORM = $8F99;
+  GL_RGB16_SNORM = $8F9A;
+  GL_RGBA16_SNORM = $8F9B;
+  GL_SIGNED_NORMALIZED = $8F9C;
+  GL_PRIMITIVE_RESTART = $8F9D;
+  GL_PRIMITIVE_RESTART_INDEX = $8F9E;
+  { Reuse tokens from ARB_copy_buffer }
+  { reuse GL_COPY_READ_BUFFER }
+  { reuse GL_COPY_WRITE_BUFFER }
+  { Reuse tokens from ARB_draw_instanced (none) }
+  { Reuse tokens from ARB_uniform_buffer_object }
+  { reuse GL_UNIFORM_BUFFER }
+  { reuse GL_UNIFORM_BUFFER_BINDING }
+  { reuse GL_UNIFORM_BUFFER_START }
+  { reuse GL_UNIFORM_BUFFER_SIZE }
+  { reuse GL_MAX_VERTEX_UNIFORM_BLOCKS }
+  { reuse GL_MAX_FRAGMENT_UNIFORM_BLOCKS }
+  { reuse GL_MAX_COMBINED_UNIFORM_BLOCKS }
+  { reuse GL_MAX_UNIFORM_BUFFER_BINDINGS }
+  { reuse GL_MAX_UNIFORM_BLOCK_SIZE }
+  { reuse GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS }
+  { reuse GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS }
+  { reuse GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT }
+  { reuse GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH }
+  { reuse GL_ACTIVE_UNIFORM_BLOCKS }
+  { reuse GL_UNIFORM_TYPE }
+  { reuse GL_UNIFORM_SIZE }
+  { reuse GL_UNIFORM_NAME_LENGTH }
+  { reuse GL_UNIFORM_BLOCK_INDEX }
+  { reuse GL_UNIFORM_OFFSET }
+  { reuse GL_UNIFORM_ARRAY_STRIDE }
+  { reuse GL_UNIFORM_MATRIX_STRIDE }
+  { reuse GL_UNIFORM_IS_ROW_MAJOR }
+  { reuse GL_UNIFORM_BLOCK_BINDING }
+  { reuse GL_UNIFORM_BLOCK_DATA_SIZE }
+  { reuse GL_UNIFORM_BLOCK_NAME_LENGTH }
+  { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS }
+  { reuse GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES }
+  { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER }
+  { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER }
+  { reuse GL_INVALID_INDEX }
+
+  // GL_VERSION_3_2
+  GL_CONTEXT_CORE_PROFILE_BIT = $00000001;
+  GL_CONTEXT_COMPATIBILITY_PROFILE_BIT = $00000002;
+  GL_LINES_ADJACENCY = $000A;
+  GL_LINE_STRIP_ADJACENCY = $000B;
+  GL_TRIANGLES_ADJACENCY = $000C;
+  GL_TRIANGLE_STRIP_ADJACENCY = $000D;
+  GL_PROGRAM_POINT_SIZE = $8642;
+  GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = $8C29;
+  GL_FRAMEBUFFER_ATTACHMENT_LAYERED = $8DA7;
+  GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = $8DA8;
+  GL_GEOMETRY_SHADER = $8DD9;
+  GL_GEOMETRY_VERTICES_OUT = $8916;
+  GL_GEOMETRY_INPUT_TYPE = $8917;
+  GL_GEOMETRY_OUTPUT_TYPE = $8918;
+  GL_MAX_GEOMETRY_UNIFORM_COMPONENTS = $8DDF;
+  GL_MAX_GEOMETRY_OUTPUT_VERTICES = $8DE0;
+  GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = $8DE1;
+  GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122;
+  GL_MAX_GEOMETRY_INPUT_COMPONENTS = $9123;
+  GL_MAX_GEOMETRY_OUTPUT_COMPONENTS = $9124;
+  GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125;
+  GL_CONTEXT_PROFILE_MASK = $9126;
+  { reuse GL_MAX_VARYING_COMPONENTS }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
+  { Reuse tokens from ARB_depth_clamp }
+  { reuse GL_DEPTH_CLAMP }
+  { Reuse tokens from ARB_draw_elements_base_vertex (none) }
+  { Reuse tokens from ARB_fragment_coord_conventions (none) }
+  { Reuse tokens from ARB_provoking_vertex }
+  { reuse GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION }
+  { reuse GL_FIRST_VERTEX_CONVENTION }
+  { reuse GL_LAST_VERTEX_CONVENTION }
+  { reuse GL_PROVOKING_VERTEX }
+  { Reuse tokens from ARB_seamless_cube_map }
+  { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS }
+  { Reuse tokens from ARB_sync }
+  { reuse GL_MAX_SERVER_WAIT_TIMEOUT }
+  { reuse GL_OBJECT_TYPE }
+  { reuse GL_SYNC_CONDITION }
+  { reuse GL_SYNC_STATUS }
+  { reuse GL_SYNC_FLAGS }
+  { reuse GL_SYNC_FENCE }
+  { reuse GL_SYNC_GPU_COMMANDS_COMPLETE }
+  { reuse GL_UNSIGNALED }
+  { reuse GL_SIGNALED }
+  { reuse GL_ALREADY_SIGNALED }
+  { reuse GL_TIMEOUT_EXPIRED }
+  { reuse GL_CONDITION_SATISFIED }
+  { reuse GL_WAIT_FAILED }
+  { reuse GL_TIMEOUT_IGNORED }
+  { reuse GL_SYNC_FLUSH_COMMANDS_BIT }
+  { reuse GL_TIMEOUT_IGNORED }
+  { Reuse tokens from ARB_texture_multisample }
+  { reuse GL_SAMPLE_POSITION }
+  { reuse GL_SAMPLE_MASK }
+  { reuse GL_SAMPLE_MASK_VALUE }
+  { reuse GL_MAX_SAMPLE_MASK_WORDS }
+  { reuse GL_TEXTURE_2D_MULTISAMPLE }
+  { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE }
+  { reuse GL_TEXTURE_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE }
+  { reuse GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_TEXTURE_SAMPLES }
+  { reuse GL_TEXTURE_FIXED_SAMPLE_LOCATIONS }
+  { reuse GL_SAMPLER_2D_MULTISAMPLE }
+  { reuse GL_INT_SAMPLER_2D_MULTISAMPLE }
+  { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE }
+  { reuse GL_SAMPLER_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_MAX_COLOR_TEXTURE_SAMPLES }
+  { reuse GL_MAX_DEPTH_TEXTURE_SAMPLES }
+  { reuse GL_MAX_INTEGER_SAMPLES }
+  { Don't need to reuse tokens from ARB_vertex_array_bgra since they're already in 1.2 core }
+
+  // GL_VERSION_3_3
+  GL_VERTEX_ATTRIB_ARRAY_DIVISOR = $88FE;
+  { Reuse tokens from ARB_blend_func_extended }
+  { reuse GL_SRC1_COLOR }
+  { reuse GL_ONE_MINUS_SRC1_COLOR }
+  { reuse GL_ONE_MINUS_SRC1_ALPHA }
+  { reuse GL_MAX_DUAL_SOURCE_DRAW_BUFFERS }
+  { Reuse tokens from ARB_explicit_attrib_location (none) }
+  { Reuse tokens from ARB_occlusion_query2 }
+  { reuse GL_ANY_SAMPLES_PASSED }
+  { Reuse tokens from ARB_sampler_objects }
+  { reuse GL_SAMPLER_BINDING }
+  { Reuse tokens from ARB_shader_bit_encoding (none) }
+  { Reuse tokens from ARB_texture_rgb10_a2ui }
+  { reuse GL_RGB10_A2UI }
+  { Reuse tokens from ARB_texture_swizzle }
+  { reuse GL_TEXTURE_SWIZZLE_R }
+  { reuse GL_TEXTURE_SWIZZLE_G }
+  { reuse GL_TEXTURE_SWIZZLE_B }
+  { reuse GL_TEXTURE_SWIZZLE_A }
+  { reuse GL_TEXTURE_SWIZZLE_RGBA }
+  { Reuse tokens from ARB_timer_query }
+  { reuse GL_TIME_ELAPSED }
+  { reuse GL_TIMESTAMP }
+  { Reuse tokens from ARB_vertex_type_2_10_10_10_rev }
+  { reuse GL_INT_2_10_10_10_REV }
+
+  // GL_VERSION_4_0
+  GL_SAMPLE_SHADING = $8C36;
+  GL_MIN_SAMPLE_SHADING_VALUE = $8C37;
+  GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E;
+  GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F;
+  GL_TEXTURE_CUBE_MAP_ARRAY = $9009;
+  GL_TEXTURE_BINDING_CUBE_MAP_ARRAY = $900A;
+  GL_PROXY_TEXTURE_CUBE_MAP_ARRAY = $900B;
+  GL_SAMPLER_CUBE_MAP_ARRAY = $900C;
+  GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW = $900D;
+  GL_INT_SAMPLER_CUBE_MAP_ARRAY = $900E;
+  GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = $900F;
+  { Reuse tokens from ARB_texture_query_lod (none) }
+  { Reuse tokens from ARB_draw_buffers_blend (none) }
+  { Reuse tokens from ARB_draw_indirect }
+  { reuse GL_DRAW_INDIRECT_BUFFER }
+  { reuse GL_DRAW_INDIRECT_BUFFER_BINDING }
+  { Reuse tokens from ARB_gpu_shader5 }
+  { reuse GL_GEOMETRY_SHADER_INVOCATIONS }
+  { reuse GL_MAX_GEOMETRY_SHADER_INVOCATIONS }
+  { reuse GL_MIN_FRAGMENT_INTERPOLATION_OFFSET }
+  { reuse GL_MAX_FRAGMENT_INTERPOLATION_OFFSET }
+  { reuse GL_FRAGMENT_INTERPOLATION_OFFSET_BITS }
+  { reuse GL_MAX_VERTEX_STREAMS }
+  { Reuse tokens from ARB_gpu_shader_fp64 }
+  { reuse GL_DOUBLE_VEC2 }
+  { reuse GL_DOUBLE_VEC3 }
+  { reuse GL_DOUBLE_VEC4 }
+  { reuse GL_DOUBLE_MAT2 }
+  { reuse GL_DOUBLE_MAT3 }
+  { reuse GL_DOUBLE_MAT4 }
+  { reuse GL_DOUBLE_MAT2x3 }
+  { reuse GL_DOUBLE_MAT2x4 }
+  { reuse GL_DOUBLE_MAT3x2 }
+  { reuse GL_DOUBLE_MAT3x4 }
+  { reuse GL_DOUBLE_MAT4x2 }
+  { reuse GL_DOUBLE_MAT4x3 }
+  { Reuse tokens from ARB_shader_subroutine }
+  { reuse GL_ACTIVE_SUBROUTINES }
+  { reuse GL_ACTIVE_SUBROUTINE_UNIFORMS }
+  { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS }
+  { reuse GL_ACTIVE_SUBROUTINE_MAX_LENGTH }
+  { reuse GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH }
+  { reuse GL_MAX_SUBROUTINES }
+  { reuse GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS }
+  { reuse GL_NUM_COMPATIBLE_SUBROUTINES }
+  { reuse GL_COMPATIBLE_SUBROUTINES }
+  { Reuse tokens from ARB_tessellation_shader }
+  { reuse GL_PATCHES }
+  { reuse GL_PATCH_VERTICES }
+  { reuse GL_PATCH_DEFAULT_INNER_LEVEL }
+  { reuse GL_PATCH_DEFAULT_OUTER_LEVEL }
+  { reuse GL_TESS_CONTROL_OUTPUT_VERTICES }
+  { reuse GL_TESS_GEN_MODE }
+  { reuse GL_TESS_GEN_SPACING }
+  { reuse GL_TESS_GEN_VERTEX_ORDER }
+  { reuse GL_TESS_GEN_POINT_MODE }
+  { reuse GL_ISOLINES }
+  { reuse GL_FRACTIONAL_ODD }
+  { reuse GL_FRACTIONAL_EVEN }
+  { reuse GL_MAX_PATCH_VERTICES }
+  { reuse GL_MAX_TESS_GEN_LEVEL }
+  { reuse GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS }
+  { reuse GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS }
+  { reuse GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS }
+  { reuse GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS }
+  { reuse GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS }
+  { reuse GL_MAX_TESS_PATCH_COMPONENTS }
+  { reuse GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS }
+  { reuse GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS }
+  { reuse GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS }
+  { reuse GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS }
+  { reuse GL_MAX_TESS_CONTROL_INPUT_COMPONENTS }
+  { reuse GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS }
+  { reuse GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS }
+  { reuse GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS }
+  { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER }
+  { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER }
+  { reuse GL_TESS_EVALUATION_SHADER }
+  { reuse GL_TESS_CONTROL_SHADER }
+  { Reuse tokens from ARB_texture_buffer_object_rgb32 (none) }
+  { Reuse tokens from ARB_transform_feedback2 }
+  { reuse GL_TRANSFORM_FEEDBACK }
+  { reuse GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED }
+  { reuse GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE }
+  { reuse GL_TRANSFORM_FEEDBACK_BINDING }
+  { Reuse tokens from ARB_transform_feedback3 }
+  { reuse GL_MAX_TRANSFORM_FEEDBACK_BUFFERS }
+  { reuse GL_MAX_VERTEX_STREAMS }
+
+  // GL_VERSION_4_1
+  { Reuse tokens from ARB_ES2_compatibility }
+  { reuse GL_FIXED }
+  { reuse GL_IMPLEMENTATION_COLOR_READ_TYPE }
+  { reuse GL_IMPLEMENTATION_COLOR_READ_FORMAT }
+  { reuse GL_LOW_FLOAT }
+  { reuse GL_MEDIUM_FLOAT }
+  { reuse GL_HIGH_FLOAT }
+  { reuse GL_LOW_INT }
+  { reuse GL_MEDIUM_INT }
+  { reuse GL_HIGH_INT }
+  { reuse GL_SHADER_COMPILER }
+  { reuse GL_NUM_SHADER_BINARY_FORMATS }
+  { reuse GL_MAX_VERTEX_UNIFORM_VECTORS }
+  { reuse GL_MAX_VARYING_VECTORS }
+  { reuse GL_MAX_FRAGMENT_UNIFORM_VECTORS }
+  { reuse GL_RGB565 }
+  { Reuse tokens from ARB_get_program_binary }
+  { reuse GL_PROGRAM_BINARY_RETRIEVABLE_HINT }
+  { reuse GL_PROGRAM_BINARY_LENGTH }
+  { reuse GL_NUM_PROGRAM_BINARY_FORMATS }
+  { reuse GL_PROGRAM_BINARY_FORMATS }
+  { Reuse tokens from ARB_separate_shader_objects }
+  { reuse GL_VERTEX_SHADER_BIT }
+  { reuse GL_FRAGMENT_SHADER_BIT }
+  { reuse GL_GEOMETRY_SHADER_BIT }
+  { reuse GL_TESS_CONTROL_SHADER_BIT }
+  { reuse GL_TESS_EVALUATION_SHADER_BIT }
+  { reuse GL_ALL_SHADER_BITS }
+  { reuse GL_PROGRAM_SEPARABLE }
+  { reuse GL_ACTIVE_PROGRAM }
+  { reuse GL_PROGRAM_PIPELINE_BINDING }
+  { Reuse tokens from ARB_shader_precision (none) }
+  { Reuse tokens from ARB_vertex_attrib_64bit - all are in GL 3.0 and 4.0 already }
+  { Reuse tokens from ARB_viewport_array - some are in GL 1.1 and ARB_provoking_vertex already }
+  { reuse GL_MAX_VIEWPORTS }
+  { reuse GL_VIEWPORT_SUBPIXEL_BITS }
+  { reuse GL_VIEWPORT_BOUNDS_RANGE }
+  { reuse GL_LAYER_PROVOKING_VERTEX }
+  { reuse GL_VIEWPORT_INDEX_PROVOKING_VERTEX }
+  { reuse GL_UNDEFINED_VERTEX }
+
+  // GL_VERSION_4_2
+  { Reuse tokens from ARB_base_instance (none) }
+  { Reuse tokens from ARB_shading_language_420pack (none) }
+  { Reuse tokens from ARB_transform_feedback_instanced (none) }
+  { Reuse tokens from ARB_compressed_texture_pixel_storage }
+  { reuse GL_UNPACK_COMPRESSED_BLOCK_WIDTH }
+  { reuse GL_UNPACK_COMPRESSED_BLOCK_HEIGHT }
+  { reuse GL_UNPACK_COMPRESSED_BLOCK_DEPTH }
+  { reuse GL_UNPACK_COMPRESSED_BLOCK_SIZE }
+  { reuse GL_PACK_COMPRESSED_BLOCK_WIDTH }
+  { reuse GL_PACK_COMPRESSED_BLOCK_HEIGHT }
+  { reuse GL_PACK_COMPRESSED_BLOCK_DEPTH }
+  { reuse GL_PACK_COMPRESSED_BLOCK_SIZE }
+  { Reuse tokens from ARB_conservative_depth (none) }
+  { Reuse tokens from ARB_internalformat_query }
+  { reuse GL_NUM_SAMPLE_COUNTS }
+  { Reuse tokens from ARB_map_buffer_alignment }
+  { reuse GL_MIN_MAP_BUFFER_ALIGNMENT }
+  { Reuse tokens from ARB_shader_atomic_counters }
+  { reuse GL_ATOMIC_COUNTER_BUFFER }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_BINDING }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_START }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_SIZE }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER }
+  { reuse GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_MAX_VERTEX_ATOMIC_COUNTERS }
+  { reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS }
+  { reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS }
+  { reuse GL_MAX_GEOMETRY_ATOMIC_COUNTERS }
+  { reuse GL_MAX_FRAGMENT_ATOMIC_COUNTERS }
+  { reuse GL_MAX_COMBINED_ATOMIC_COUNTERS }
+  { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE }
+  { reuse GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS }
+  { reuse GL_ACTIVE_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX }
+  { reuse GL_UNSIGNED_INT_ATOMIC_COUNTER }
+  { Reuse tokens from ARB_shader_image_load_store }
+  { reuse GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT }
+  { reuse GL_ELEMENT_ARRAY_BARRIER_BIT }
+  { reuse GL_UNIFORM_BARRIER_BIT }
+  { reuse GL_TEXTURE_FETCH_BARRIER_BIT }
+  { reuse GL_SHADER_IMAGE_ACCESS_BARRIER_BIT }
+  { reuse GL_COMMAND_BARRIER_BIT }
+  { reuse GL_PIXEL_BUFFER_BARRIER_BIT }
+  { reuse GL_TEXTURE_UPDATE_BARRIER_BIT }
+  { reuse GL_BUFFER_UPDATE_BARRIER_BIT }
+  { reuse GL_FRAMEBUFFER_BARRIER_BIT }
+  { reuse GL_TRANSFORM_FEEDBACK_BARRIER_BIT }
+  { reuse GL_ATOMIC_COUNTER_BARRIER_BIT }
+  { reuse GL_ALL_BARRIER_BITS }
+  { reuse GL_MAX_IMAGE_UNITS }
+  { reuse GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS }
+  { reuse GL_IMAGE_BINDING_NAME }
+  { reuse GL_IMAGE_BINDING_LEVEL }
+  { reuse GL_IMAGE_BINDING_LAYERED }
+  { reuse GL_IMAGE_BINDING_LAYER }
+  { reuse GL_IMAGE_BINDING_ACCESS }
+  { reuse GL_IMAGE_1D }
+  { reuse GL_IMAGE_2D }
+  { reuse GL_IMAGE_3D }
+  { reuse GL_IMAGE_2D_RECT }
+  { reuse GL_IMAGE_CUBE }
+  { reuse GL_IMAGE_BUFFER }
+  { reuse GL_IMAGE_1D_ARRAY }
+  { reuse GL_IMAGE_2D_ARRAY }
+  { reuse GL_IMAGE_CUBE_MAP_ARRAY }
+  { reuse GL_IMAGE_2D_MULTISAMPLE }
+  { reuse GL_IMAGE_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_INT_IMAGE_1D }
+  { reuse GL_INT_IMAGE_2D }
+  { reuse GL_INT_IMAGE_3D }
+  { reuse GL_INT_IMAGE_2D_RECT }
+  { reuse GL_INT_IMAGE_CUBE }
+  { reuse GL_INT_IMAGE_BUFFER }
+  { reuse GL_INT_IMAGE_1D_ARRAY }
+  { reuse GL_INT_IMAGE_2D_ARRAY }
+  { reuse GL_INT_IMAGE_CUBE_MAP_ARRAY }
+  { reuse GL_INT_IMAGE_2D_MULTISAMPLE }
+  { reuse GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_UNSIGNED_INT_IMAGE_1D }
+  { reuse GL_UNSIGNED_INT_IMAGE_2D }
+  { reuse GL_UNSIGNED_INT_IMAGE_3D }
+  { reuse GL_UNSIGNED_INT_IMAGE_2D_RECT }
+  { reuse GL_UNSIGNED_INT_IMAGE_CUBE }
+  { reuse GL_UNSIGNED_INT_IMAGE_BUFFER }
+  { reuse GL_UNSIGNED_INT_IMAGE_1D_ARRAY }
+  { reuse GL_UNSIGNED_INT_IMAGE_2D_ARRAY }
+  { reuse GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY }
+  { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE }
+  { reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY }
+  { reuse GL_MAX_IMAGE_SAMPLES }
+  { reuse GL_IMAGE_BINDING_FORMAT }
+  { reuse GL_IMAGE_FORMAT_COMPATIBILITY_TYPE }
+  { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE }
+  { reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS }
+  { reuse GL_MAX_VERTEX_IMAGE_UNIFORMS }
+  { reuse GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS }
+  { reuse GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS }
+  { reuse GL_MAX_GEOMETRY_IMAGE_UNIFORMS }
+  { reuse GL_MAX_FRAGMENT_IMAGE_UNIFORMS }
+  { reuse GL_MAX_COMBINED_IMAGE_UNIFORMS }
+  { Reuse tokens from ARB_shading_language_packing (none) }
+  { Reuse tokens from ARB_texture_storage }
+  { reuse GL_TEXTURE_IMMUTABLE_FORMAT }
+
+  // GL_VERSION_4_3
+  GL_NUM_SHADING_LANGUAGE_VERSIONS  = $82E9;
+  GL_VERTEX_ATTRIB_ARRAY_LONG = $874E;
+  { Reuse tokens from ARB_arrays_of_arrays (none, GLSL only) }
+  { Reuse tokens from ARB_fragment_layer_viewport (none, GLSL only) }
+  { Reuse tokens from ARB_shader_image_size (none, GLSL only) }
+  { Reuse tokens from ARB_ES3_compatibility }
+  { reuse GL_COMPRESSED_RGB8_ETC2 }
+  { reuse GL_COMPRESSED_SRGB8_ETC2 }
+  { reuse GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 }
+  { reuse GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 }
+  { reuse GL_COMPRESSED_RGBA8_ETC2_EAC }
+  { reuse GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC }
+  { reuse GL_COMPRESSED_R11_EAC }
+  { reuse GL_COMPRESSED_SIGNED_R11_EAC }
+  { reuse GL_COMPRESSED_RG11_EAC }
+  { reuse GL_COMPRESSED_SIGNED_RG11_EAC }
+  { reuse GL_PRIMITIVE_RESTART_FIXED_INDEX }
+  { reuse GL_ANY_SAMPLES_PASSED_CONSERVATIVE }
+  { reuse GL_MAX_ELEMENT_INDEX }
+  { Reuse tokens from ARB_clear_buffer_object (none) }
+  { Reuse tokens from ARB_compute_shader }
+  { reuse GL_COMPUTE_SHADER }
+  { reuse GL_MAX_COMPUTE_UNIFORM_BLOCKS }
+  { reuse GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS }
+  { reuse GL_MAX_COMPUTE_IMAGE_UNIFORMS }
+  { reuse GL_MAX_COMPUTE_SHARED_MEMORY_SIZE }
+  { reuse GL_MAX_COMPUTE_UNIFORM_COMPONENTS }
+  { reuse GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS }
+  { reuse GL_MAX_COMPUTE_ATOMIC_COUNTERS }
+  { reuse GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS }
+  { reuse GL_MAX_COMPUTE_LOCAL_INVOCATIONS }
+  { reuse GL_MAX_COMPUTE_WORK_GROUP_COUNT }
+  { reuse GL_MAX_COMPUTE_WORK_GROUP_SIZE }
+  { reuse GL_COMPUTE_LOCAL_WORK_SIZE }
+  { reuse GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER }
+  { reuse GL_DISPATCH_INDIRECT_BUFFER }
+  { reuse GL_DISPATCH_INDIRECT_BUFFER_BINDING }
+  { Reuse tokens from ARB_copy_image (none) }
+  { Reuse tokens from KHR_debug }
+  { reuse GL_DEBUG_OUTPUT_SYNCHRONOUS }
+  { reuse GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH }
+  { reuse GL_DEBUG_CALLBACK_FUNCTION }
+  { reuse GL_DEBUG_CALLBACK_USER_PARAM }
+  { reuse GL_DEBUG_SOURCE_API }
+  { reuse GL_DEBUG_SOURCE_WINDOW_SYSTEM }
+  { reuse GL_DEBUG_SOURCE_SHADER_COMPILER }
+  { reuse GL_DEBUG_SOURCE_THIRD_PARTY }
+  { reuse GL_DEBUG_SOURCE_APPLICATION }
+  { reuse GL_DEBUG_SOURCE_OTHER }
+  { reuse GL_DEBUG_TYPE_ERROR }
+  { reuse GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR }
+  { reuse GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR }
+  { reuse GL_DEBUG_TYPE_PORTABILITY }
+  { reuse GL_DEBUG_TYPE_PERFORMANCE }
+  { reuse GL_DEBUG_TYPE_OTHER }
+  { reuse GL_MAX_DEBUG_MESSAGE_LENGTH }
+  { reuse GL_MAX_DEBUG_LOGGED_MESSAGES }
+  { reuse GL_DEBUG_LOGGED_MESSAGES }
+  { reuse GL_DEBUG_SEVERITY_HIGH }
+  { reuse GL_DEBUG_SEVERITY_MEDIUM }
+  { reuse GL_DEBUG_SEVERITY_LOW }
+  { reuse GL_DEBUG_TYPE_MARKER }
+  { reuse GL_DEBUG_TYPE_PUSH_GROUP }
+  { reuse GL_DEBUG_TYPE_POP_GROUP }
+  { reuse GL_DEBUG_SEVERITY_NOTIFICATION }
+  { reuse GL_MAX_DEBUG_GROUP_STACK_DEPTH }
+  { reuse GL_DEBUG_GROUP_STACK_DEPTH }
+  { reuse GL_BUFFER }
+  { reuse GL_SHADER }
+  { reuse GL_PROGRAM }
+  { reuse GL_QUERY }
+  { reuse GL_PROGRAM_PIPELINE }
+  { reuse GL_SAMPLER }
+  { reuse GL_DISPLAY_LIST }
+  { reuse GL_MAX_LABEL_LENGTH }
+  { reuse GL_DEBUG_OUTPUT }
+  { reuse GL_CONTEXT_FLAG_DEBUG_BIT }
+  { reuse GL_STACK_UNDERFLOW }
+  { reuse GL_STACK_OVERFLOW }
+  { Reuse tokens from ARB_explicit_uniform_location }
+  { reuse GL_MAX_UNIFORM_LOCATIONS }
+  { Reuse tokens from ARB_framebuffer_no_attachments }
+  { reuse GL_FRAMEBUFFER_DEFAULT_WIDTH }
+  { reuse GL_FRAMEBUFFER_DEFAULT_HEIGHT }
+  { reuse GL_FRAMEBUFFER_DEFAULT_LAYERS }
+  { reuse GL_FRAMEBUFFER_DEFAULT_SAMPLES }
+  { reuse GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS }
+  { reuse GL_MAX_FRAMEBUFFER_WIDTH }
+  { reuse GL_MAX_FRAMEBUFFER_HEIGHT }
+  { reuse GL_MAX_FRAMEBUFFER_LAYERS }
+  { reuse GL_MAX_FRAMEBUFFER_SAMPLES }
+  { Reuse tokens from ARB_internalformat_query2 }
+  { reuse GL_INTERNALFORMAT_SUPPORTED }
+  { reuse GL_INTERNALFORMAT_PREFERRED }
+  { reuse GL_INTERNALFORMAT_RED_SIZE }
+  { reuse GL_INTERNALFORMAT_GREEN_SIZE }
+  { reuse GL_INTERNALFORMAT_BLUE_SIZE }
+  { reuse GL_INTERNALFORMAT_ALPHA_SIZE }
+  { reuse GL_INTERNALFORMAT_DEPTH_SIZE }
+  { reuse GL_INTERNALFORMAT_STENCIL_SIZE }
+  { reuse GL_INTERNALFORMAT_SHARED_SIZE }
+  { reuse GL_INTERNALFORMAT_RED_TYPE }
+  { reuse GL_INTERNALFORMAT_GREEN_TYPE }
+  { reuse GL_INTERNALFORMAT_BLUE_TYPE }
+  { reuse GL_INTERNALFORMAT_ALPHA_TYPE }
+  { reuse GL_INTERNALFORMAT_DEPTH_TYPE }
+  { reuse GL_INTERNALFORMAT_STENCIL_TYPE }
+  { reuse GL_MAX_WIDTH }
+  { reuse GL_MAX_HEIGHT }
+  { reuse GL_MAX_DEPTH }
+  { reuse GL_MAX_LAYERS }
+  { reuse GL_MAX_COMBINED_DIMENSIONS }
+  { reuse GL_COLOR_COMPONENTS }
+  { reuse GL_DEPTH_COMPONENTS }
+  { reuse GL_STENCIL_COMPONENTS }
+  { reuse GL_COLOR_RENDERABLE }
+  { reuse GL_DEPTH_RENDERABLE }
+  { reuse GL_STENCIL_RENDERABLE }
+  { reuse GL_FRAMEBUFFER_RENDERABLE }
+  { reuse GL_FRAMEBUFFER_RENDERABLE_LAYERED }
+  { reuse GL_FRAMEBUFFER_BLEND }
+  { reuse GL_READ_PIXELS }
+  { reuse GL_READ_PIXELS_FORMAT }
+  { reuse GL_READ_PIXELS_TYPE }
+  { reuse GL_TEXTURE_IMAGE_FORMAT }
+  { reuse GL_TEXTURE_IMAGE_TYPE }
+  { reuse GL_GET_TEXTURE_IMAGE_FORMAT }
+  { reuse GL_GET_TEXTURE_IMAGE_TYPE }
+  { reuse GL_MIPMAP }
+  { reuse GL_MANUAL_GENERATE_MIPMAP }
+  { reuse GL_AUTO_GENERATE_MIPMAP }
+  { reuse GL_COLOR_ENCODING }
+  { reuse GL_SRGB_READ }
+  { reuse GL_SRGB_WRITE }
+  { reuse GL_FILTER }
+  { reuse GL_VERTEX_TEXTURE }
+  { reuse GL_TESS_CONTROL_TEXTURE }
+  { reuse GL_TESS_EVALUATION_TEXTURE }
+  { reuse GL_GEOMETRY_TEXTURE }
+  { reuse GL_FRAGMENT_TEXTURE }
+  { reuse GL_COMPUTE_TEXTURE }
+  { reuse GL_TEXTURE_SHADOW }
+  { reuse GL_TEXTURE_GATHER }
+  { reuse GL_TEXTURE_GATHER_SHADOW }
+  { reuse GL_SHADER_IMAGE_LOAD }
+  { reuse GL_SHADER_IMAGE_STORE }
+  { reuse GL_SHADER_IMAGE_ATOMIC }
+  { reuse GL_IMAGE_TEXEL_SIZE }
+  { reuse GL_IMAGE_COMPATIBILITY_CLASS }
+  { reuse GL_IMAGE_PIXEL_FORMAT }
+  { reuse GL_IMAGE_PIXEL_TYPE }
+  { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST }
+  { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST }
+  { reuse GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE }
+  { reuse GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE }
+  { reuse GL_TEXTURE_COMPRESSED_BLOCK_WIDTH }
+  { reuse GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT }
+  { reuse GL_TEXTURE_COMPRESSED_BLOCK_SIZE }
+  { reuse GL_CLEAR_BUFFER }
+  { reuse GL_TEXTURE_VIEW }
+  { reuse GL_VIEW_COMPATIBILITY_CLASS }
+  { reuse GL_FULL_SUPPORT }
+  { reuse GL_CAVEAT_SUPPORT }
+  { reuse GL_IMAGE_CLASS_4_X_32 }
+  { reuse GL_IMAGE_CLASS_2_X_32 }
+  { reuse GL_IMAGE_CLASS_1_X_32 }
+  { reuse GL_IMAGE_CLASS_4_X_16 }
+  { reuse GL_IMAGE_CLASS_2_X_16 }
+  { reuse GL_IMAGE_CLASS_1_X_16 }
+  { reuse GL_IMAGE_CLASS_4_X_8 }
+  { reuse GL_IMAGE_CLASS_2_X_8 }
+  { reuse GL_IMAGE_CLASS_1_X_8 }
+  { reuse GL_IMAGE_CLASS_11_11_10 }
+  { reuse GL_IMAGE_CLASS_10_10_10_2 }
+  { reuse GL_VIEW_CLASS_128_BITS }
+  { reuse GL_VIEW_CLASS_96_BITS }
+  { reuse GL_VIEW_CLASS_64_BITS }
+  { reuse GL_VIEW_CLASS_48_BITS }
+  { reuse GL_VIEW_CLASS_32_BITS }
+  { reuse GL_VIEW_CLASS_24_BITS }
+  { reuse GL_VIEW_CLASS_16_BITS }
+  { reuse GL_VIEW_CLASS_8_BITS }
+  { reuse GL_VIEW_CLASS_S3TC_DXT1_RGB }
+  { reuse GL_VIEW_CLASS_S3TC_DXT1_RGBA }
+  { reuse GL_VIEW_CLASS_S3TC_DXT3_RGBA }
+  { reuse GL_VIEW_CLASS_S3TC_DXT5_RGBA }
+  { reuse GL_VIEW_CLASS_RGTC1_RED }
+  { reuse GL_VIEW_CLASS_RGTC2_RG }
+  { reuse GL_VIEW_CLASS_BPTC_UNORM }
+  { reuse GL_VIEW_CLASS_BPTC_FLOAT }
+  { Reuse tokens from ARB_invalidate_subdata (none) }
+  { Reuse tokens from ARB_multi_draw_indirect (none) }
+  { Reuse tokens from ARB_program_interface_query }
+  { reuse GL_UNIFORM }
+  { reuse GL_UNIFORM_BLOCK }
+  { reuse GL_PROGRAM_INPUT }
+  { reuse GL_PROGRAM_OUTPUT }
+  { reuse GL_BUFFER_VARIABLE }
+  { reuse GL_SHADER_STORAGE_BLOCK }
+  { reuse GL_VERTEX_SUBROUTINE }
+  { reuse GL_TESS_CONTROL_SUBROUTINE }
+  { reuse GL_TESS_EVALUATION_SUBROUTINE }
+  { reuse GL_GEOMETRY_SUBROUTINE }
+  { reuse GL_FRAGMENT_SUBROUTINE }
+  { reuse GL_COMPUTE_SUBROUTINE }
+  { reuse GL_VERTEX_SUBROUTINE_UNIFORM }
+  { reuse GL_TESS_CONTROL_SUBROUTINE_UNIFORM }
+  { reuse GL_TESS_EVALUATION_SUBROUTINE_UNIFORM }
+  { reuse GL_GEOMETRY_SUBROUTINE_UNIFORM }
+  { reuse GL_FRAGMENT_SUBROUTINE_UNIFORM }
+  { reuse GL_COMPUTE_SUBROUTINE_UNIFORM }
+  { reuse GL_TRANSFORM_FEEDBACK_VARYING }
+  { reuse GL_ACTIVE_RESOURCES }
+  { reuse GL_MAX_NAME_LENGTH }
+  { reuse GL_MAX_NUM_ACTIVE_VARIABLES }
+  { reuse GL_MAX_NUM_COMPATIBLE_SUBROUTINES }
+  { reuse GL_NAME_LENGTH }
+  { reuse GL_TYPE }
+  { reuse GL_ARRAY_SIZE }
+  { reuse GL_OFFSET }
+  { reuse GL_BLOCK_INDEX }
+  { reuse GL_ARRAY_STRIDE }
+  { reuse GL_MATRIX_STRIDE }
+  { reuse GL_IS_ROW_MAJOR }
+  { reuse GL_ATOMIC_COUNTER_BUFFER_INDEX }
+  { reuse GL_BUFFER_BINDING }
+  { reuse GL_BUFFER_DATA_SIZE }
+  { reuse GL_NUM_ACTIVE_VARIABLES }
+  { reuse GL_ACTIVE_VARIABLES }
+  { reuse GL_REFERENCED_BY_VERTEX_SHADER }
+  { reuse GL_REFERENCED_BY_TESS_CONTROL_SHADER }
+  { reuse GL_REFERENCED_BY_TESS_EVALUATION_SHADER }
+  { reuse GL_REFERENCED_BY_GEOMETRY_SHADER }
+  { reuse GL_REFERENCED_BY_FRAGMENT_SHADER }
+  { reuse GL_REFERENCED_BY_COMPUTE_SHADER }
+  { reuse GL_TOP_LEVEL_ARRAY_SIZE }
+  { reuse GL_TOP_LEVEL_ARRAY_STRIDE }
+  { reuse GL_LOCATION }
+  { reuse GL_LOCATION_INDEX }
+  { reuse GL_IS_PER_PATCH }
+  { Reuse tokens from ARB_robust_buffer_access_behavior (none) }
+  { Reuse tokens from ARB_shader_storage_buffer_object }
+  { reuse GL_SHADER_STORAGE_BUFFER }
+  { reuse GL_SHADER_STORAGE_BUFFER_BINDING }
+  { reuse GL_SHADER_STORAGE_BUFFER_START }
+  { reuse GL_SHADER_STORAGE_BUFFER_SIZE }
+  { reuse GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS }
+  { reuse GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS }
+  { reuse GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS }
+  { reuse GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS }
+  { reuse GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS }
+  { reuse GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS }
+  { reuse GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS }
+  { reuse GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS }
+  { reuse GL_MAX_SHADER_STORAGE_BLOCK_SIZE }
+  { reuse GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT }
+  { reuse GL_SHADER_STORAGE_BARRIER_BIT }
+  { reuse GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES }
+  { Reuse tokens from ARB_stencil_texturing }
+  { reuse GL_DEPTH_STENCIL_TEXTURE_MODE }
+  { Reuse tokens from ARB_texture_buffer_range }
+  { reuse GL_TEXTURE_BUFFER_OFFSET }
+  { reuse GL_TEXTURE_BUFFER_SIZE }
+  { reuse GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT }
+  { Reuse tokens from ARB_texture_query_levels (none) }
+  { Reuse tokens from ARB_texture_storage_multisample (none) }
+  { Reuse tokens from ARB_texture_view }
+  { reuse GL_TEXTURE_VIEW_MIN_LEVEL }
+  { reuse GL_TEXTURE_VIEW_NUM_LEVELS }
+  { reuse GL_TEXTURE_VIEW_MIN_LAYER }
+  { reuse GL_TEXTURE_VIEW_NUM_LAYERS }
+  { reuse GL_TEXTURE_IMMUTABLE_LEVELS }
+  { Reuse tokens from ARB_vertex_attrib_binding }
+  { reuse GL_VERTEX_ATTRIB_BINDING }
+  { reuse GL_VERTEX_ATTRIB_RELATIVE_OFFSET }
+  { reuse GL_VERTEX_BINDING_DIVISOR }
+  { reuse GL_VERTEX_BINDING_OFFSET }
+  { reuse GL_VERTEX_BINDING_STRIDE }
+  { reuse GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET }
+  { reuse GL_MAX_VERTEX_ATTRIB_BINDINGS }
+
+
+  // GL_3DFX_multisample
+  GL_MULTISAMPLE_3DFX = $86B2;
+  GL_SAMPLE_BUFFERS_3DFX = $86B3;
+  GL_SAMPLES_3DFX = $86B4;
+  GL_MULTISAMPLE_BIT_3DFX = $20000000;
+
+  // GL_3DFX_texture_compression_FXT1
+  GL_COMPRESSED_RGB_FXT1_3DFX = $86B0;
+  GL_COMPRESSED_RGBA_FXT1_3DFX = $86B1;
+
+  // GL_APPLE_client_storage
+  GL_UNPACK_CLIENT_STORAGE_APPLE = $85B2;
+
+  // GL_APPLE_element_array
+  GL_ELEMENT_ARRAY_APPLE = $8A0C;
+  GL_ELEMENT_ARRAY_TYPE_APPLE = $8A0D;
+  GL_ELEMENT_ARRAY_POINTER_APPLE = $8A0E;
+
+  // GL_APPLE_fence
+  GL_DRAW_PIXELS_APPLE = $8A0A;
+  GL_FENCE_APPLE = $8A0B;
+
+  // GL_APPLE_specular_vector
+  GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = $85B0;
+
+  // GL_APPLE_transform_hint
+  GL_TRANSFORM_HINT_APPLE = $85B1;
+
+  // GL_APPLE_vertex_array_object
+  GL_VERTEX_ARRAY_BINDING_APPLE = $85B5;
+
+  // GL_APPLE_vertex_array_range
+  GL_VERTEX_ARRAY_RANGE_APPLE = $851D;
+  GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE = $851E;
+  GL_VERTEX_ARRAY_STORAGE_HINT_APPLE = $851F;
+  GL_VERTEX_ARRAY_RANGE_POINTER_APPLE = $8521;
+  GL_STORAGE_CLIENT_APPLE = $85B4;
+  GL_STORAGE_CACHED_APPLE = $85BE;
+  GL_STORAGE_SHARED_APPLE = $85BF;
+
+  // GL_APPLE_ycbcr_422
+  GL_YCBCR_422_APPLE = $85B9;
+  GL_UNSIGNED_SHORT_8_8_APPLE = $85BA;
+  GL_UNSIGNED_SHORT_8_8_REV_APPLE = $85BB;
+
+  // GL_APPLE_texture_range
+  GL_TEXTURE_RANGE_LENGTH_APPLE = $85B7;
+  GL_TEXTURE_RANGE_POINTER_APPLE = $85B8;
+  GL_TEXTURE_STORAGE_HINT_APPLE = $85BC;
+  GL_STORAGE_PRIVATE_APPLE = $85BD;
+  { reuse GL_STORAGE_CACHED_APPLE }
+  { reuse GL_STORAGE_SHARED_APPLE }
+
+  // GL_APPLE_float_pixels
+  GL_HALF_APPLE = $140B;
+  GL_RGBA_FLOAT32_APPLE = $8814;
+  GL_RGB_FLOAT32_APPLE = $8815;
+  GL_ALPHA_FLOAT32_APPLE = $8816;
+  GL_INTENSITY_FLOAT32_APPLE = $8817;
+  GL_LUMINANCE_FLOAT32_APPLE = $8818;
+  GL_LUMINANCE_ALPHA_FLOAT32_APPLE = $8819;
+  GL_RGBA_FLOAT16_APPLE = $881A;
+  GL_RGB_FLOAT16_APPLE = $881B;
+  GL_ALPHA_FLOAT16_APPLE = $881C;
+  GL_INTENSITY_FLOAT16_APPLE = $881D;
+  GL_LUMINANCE_FLOAT16_APPLE = $881E;
+  GL_LUMINANCE_ALPHA_FLOAT16_APPLE = $881F;
+  GL_COLOR_FLOAT_APPLE = $8A0F;
+
+  // GL_APPLE_vertex_program_evaluators
+  GL_VERTEX_ATTRIB_MAP1_APPLE = $8A00;
+  GL_VERTEX_ATTRIB_MAP2_APPLE = $8A01;
+  GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE = $8A02;
+  GL_VERTEX_ATTRIB_MAP1_COEFF_APPLE = $8A03;
+  GL_VERTEX_ATTRIB_MAP1_ORDER_APPLE = $8A04;
+  GL_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = $8A05;
+  GL_VERTEX_ATTRIB_MAP2_SIZE_APPLE = $8A06;
+  GL_VERTEX_ATTRIB_MAP2_COEFF_APPLE = $8A07;
+  GL_VERTEX_ATTRIB_MAP2_ORDER_APPLE = $8A08;
+  GL_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = $8A09;
+
+  // GL_APPLE_aux_depth_stencil
+  GL_AUX_DEPTH_STENCIL_APPLE = $8A14;
+
+  // GL_APPLE_object_purgeable
+  GL_BUFFER_OBJECT_APPLE = $85B3;
+  GL_RELEASED_APPLE = $8A19;
+  GL_VOLATILE_APPLE = $8A1A;
+  GL_RETAINED_APPLE = $8A1B;
+  GL_UNDEFINED_APPLE = $8A1C;
+  GL_PURGEABLE_APPLE = $8A1D;
+
+  // GL_APPLE_row_bytes
+  GL_PACK_ROW_BYTES_APPLE = $8A15;
+  GL_UNPACK_ROW_BYTES_APPLE = $8A16;
+  
+  // GL_APPLE_rgb_422
+  { reuse GL_UNSIGNED_SHORT_8_8_APPLE }
+  { reuse GL_UNSIGNED_SHORT_8_8_REV_APPLE }  
+  
+  // GL_ARB_depth_texture
+  GL_DEPTH_COMPONENT16_ARB = $81A5;
+  GL_DEPTH_COMPONENT24_ARB = $81A6;
+  GL_DEPTH_COMPONENT32_ARB = $81A7;
+  GL_TEXTURE_DEPTH_SIZE_ARB = $884A;
+  GL_DEPTH_TEXTURE_MODE_ARB = $884B;
+
+  // GL_ARB_fragment_program
+  GL_FRAGMENT_PROGRAM_ARB = $8804;
+  GL_PROGRAM_ALU_INSTRUCTIONS_ARB = $8805;
+  GL_PROGRAM_TEX_INSTRUCTIONS_ARB = $8806;
+  GL_PROGRAM_TEX_INDIRECTIONS_ARB = $8807;
+  GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $8808;
+  GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $8809;
+  GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $880A;
+  GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = $880B;
+  GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = $880C;
+  GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = $880D;
+  GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = $880E;
+  GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = $880F;
+  GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = $8810;
+  GL_MAX_TEXTURE_COORDS_ARB = $8871;
+  GL_MAX_TEXTURE_IMAGE_UNITS_ARB = $8872;
+
+  // GL_ARB_imaging
+  GL_CONSTANT_COLOR_ARB = $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR = $8002;
+  GL_CONSTANT_ALPHA = $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA = $8004;
+  GL_BLEND_COLOR = $8005;
+  GL_FUNC_ADD = $8006;
+  GL_MIN = $8007;
+  GL_MAX = $8008;
+  GL_BLEND_EQUATION = $8009;
+  GL_FUNC_SUBTRACT = $800A;
+  GL_FUNC_REVERSE_SUBTRACT = $800B;
+{$ifdef DGL_DEPRECATED}
+  GL_CONVOLUTION_1D = $8010;
+  GL_CONVOLUTION_2D = $8011;
+  GL_SEPARABLE_2D = $8012;
+  GL_CONVOLUTION_BORDER_MODE = $8013;
+  GL_CONVOLUTION_FILTER_SCALE = $8014;
+  GL_CONVOLUTION_FILTER_BIAS = $8015;
+  GL_REDUCE = $8016;
+  GL_CONVOLUTION_FORMAT = $8017;
+  GL_CONVOLUTION_WIDTH = $8018;
+  GL_CONVOLUTION_HEIGHT = $8019;
+  GL_MAX_CONVOLUTION_WIDTH = $801A;
+  GL_MAX_CONVOLUTION_HEIGHT = $801B;
+  GL_POST_CONVOLUTION_RED_SCALE = $801C;
+  GL_POST_CONVOLUTION_GREEN_SCALE = $801D;
+  GL_POST_CONVOLUTION_BLUE_SCALE = $801E;
+  GL_POST_CONVOLUTION_ALPHA_SCALE = $801F;
+  GL_POST_CONVOLUTION_RED_BIAS = $8020;
+  GL_POST_CONVOLUTION_GREEN_BIAS = $8021;
+  GL_POST_CONVOLUTION_BLUE_BIAS = $8022;
+  GL_POST_CONVOLUTION_ALPHA_BIAS = $8023;
+  GL_HISTOGRAM = $8024;
+  GL_PROXY_HISTOGRAM = $8025;
+  GL_HISTOGRAM_WIDTH = $8026;
+  GL_HISTOGRAM_FORMAT = $8027;
+  GL_HISTOGRAM_RED_SIZE = $8028;
+  GL_HISTOGRAM_GREEN_SIZE = $8029;
+  GL_HISTOGRAM_BLUE_SIZE = $802A;
+  GL_HISTOGRAM_ALPHA_SIZE = $802B;
+  GL_HISTOGRAM_LUMINANCE_SIZE = $802C;
+  GL_HISTOGRAM_SINK = $802D;
+  GL_MINMAX = $802E;
+  GL_MINMAX_FORMAT = $802F;
+  GL_MINMAX_SINK = $8030;
+  GL_TABLE_TOO_LARGE = $8031;
+  GL_COLOR_MATRIX = $80B1;
+  GL_COLOR_MATRIX_STACK_DEPTH = $80B2;
+  GL_MAX_COLOR_MATRIX_STACK_DEPTH = $80B3;
+  GL_POST_COLOR_MATRIX_RED_SCALE = $80B4;
+  GL_POST_COLOR_MATRIX_GREEN_SCALE = $80B5;
+  GL_POST_COLOR_MATRIX_BLUE_SCALE = $80B6;
+  GL_POST_COLOR_MATRIX_ALPHA_SCALE = $80B7;
+  GL_POST_COLOR_MATRIX_RED_BIAS = $80B8;
+  GL_POST_COLOR_MATRIX_GREEN_BIAS = $80B9;
+  GL_POST_COLOR_MATRIX_BLUE_BIAS = $80BA;
+  GL_POST_COLOR_MATRIX_ALPHA_BIAS = $80BB;
+  GL_COLOR_TABLE = $80D0;
+  GL_POST_CONVOLUTION_COLOR_TABLE = $80D1;
+  GL_POST_COLOR_MATRIX_COLOR_TABLE = $80D2;
+  GL_PROXY_COLOR_TABLE = $80D3;
+  GL_PROXY_POST_CONVOLUTION_COLOR_TABLE = $80D4;
+  GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = $80D5;
+  GL_COLOR_TABLE_SCALE = $80D6;
+  GL_COLOR_TABLE_BIAS = $80D7;
+  GL_COLOR_TABLE_FORMAT = $80D8;
+  GL_COLOR_TABLE_WIDTH = $80D9;
+  GL_COLOR_TABLE_RED_SIZE = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE = $80DF;
+  GL_CONSTANT_BORDER = $8151;
+  GL_REPLICATE_BORDER = $8153;
+  GL_CONVOLUTION_BORDER_COLOR = $8154;
+{$endif}
+
+  // GL_ARB_matrix_palette
+  GL_MATRIX_PALETTE_ARB = $8840;
+  GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = $8841;
+  GL_MAX_PALETTE_MATRICES_ARB = $8842;
+  GL_CURRENT_PALETTE_MATRIX_ARB = $8843;
+  GL_MATRIX_INDEX_ARRAY_ARB = $8844;
+  GL_CURRENT_MATRIX_INDEX_ARB = $8845;
+  GL_MATRIX_INDEX_ARRAY_SIZE_ARB = $8846;
+  GL_MATRIX_INDEX_ARRAY_TYPE_ARB = $8847;
+  GL_MATRIX_INDEX_ARRAY_STRIDE_ARB = $8848;
+  GL_MATRIX_INDEX_ARRAY_POINTER_ARB = $8849;
+
+  // GL_ARB_multisample
+  GL_MULTISAMPLE_ARB = $809D;
+  GL_SAMPLE_ALPHA_TO_COVERAGE_ARB = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE_ARB = $809F;
+  GL_SAMPLE_COVERAGE_ARB = $80A0;
+  GL_SAMPLE_BUFFERS_ARB = $80A8;
+  GL_SAMPLES_ARB = $80A9;
+  GL_SAMPLE_COVERAGE_VALUE_ARB = $80AA;
+  GL_SAMPLE_COVERAGE_INVERT_ARB = $80AB;
+  GL_MULTISAMPLE_BIT_ARB = $20000000;
+
+  // GL_ARB_multitexture
+  GL_TEXTURE0_ARB = $84C0;
+  GL_TEXTURE1_ARB = $84C1;
+  GL_TEXTURE2_ARB = $84C2;
+  GL_TEXTURE3_ARB = $84C3;
+  GL_TEXTURE4_ARB = $84C4;
+  GL_TEXTURE5_ARB = $84C5;
+  GL_TEXTURE6_ARB = $84C6;
+  GL_TEXTURE7_ARB = $84C7;
+  GL_TEXTURE8_ARB = $84C8;
+  GL_TEXTURE9_ARB = $84C9;
+  GL_TEXTURE10_ARB = $84CA;
+  GL_TEXTURE11_ARB = $84CB;
+  GL_TEXTURE12_ARB = $84CC;
+  GL_TEXTURE13_ARB = $84CD;
+  GL_TEXTURE14_ARB = $84CE;
+  GL_TEXTURE15_ARB = $84CF;
+  GL_TEXTURE16_ARB = $84D0;
+  GL_TEXTURE17_ARB = $84D1;
+  GL_TEXTURE18_ARB = $84D2;
+  GL_TEXTURE19_ARB = $84D3;
+  GL_TEXTURE20_ARB = $84D4;
+  GL_TEXTURE21_ARB = $84D5;
+  GL_TEXTURE22_ARB = $84D6;
+  GL_TEXTURE23_ARB = $84D7;
+  GL_TEXTURE24_ARB = $84D8;
+  GL_TEXTURE25_ARB = $84D9;
+  GL_TEXTURE26_ARB = $84DA;
+  GL_TEXTURE27_ARB = $84DB;
+  GL_TEXTURE28_ARB = $84DC;
+  GL_TEXTURE29_ARB = $84DD;
+  GL_TEXTURE30_ARB = $84DE;
+  GL_TEXTURE31_ARB = $84DF;
+  GL_ACTIVE_TEXTURE_ARB = $84E0;
+  GL_CLIENT_ACTIVE_TEXTURE_ARB = $84E1;
+  GL_MAX_TEXTURE_UNITS_ARB = $84E2;
+
+  // GL_ARB_point_parameters
+  GL_POINT_SIZE_MIN_ARB = $8126;
+  GL_POINT_SIZE_MAX_ARB = $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE_ARB = $8128;
+  GL_POINT_DISTANCE_ATTENUATION_ARB = $8129;
+
+  // GL_ARB_shadow
+  GL_TEXTURE_COMPARE_MODE_ARB = $884C;
+  GL_TEXTURE_COMPARE_FUNC_ARB = $884D;
+  GL_COMPARE_R_TO_TEXTURE_ARB = $884E;
+
+  // GL_ARB_shadow_ambient
+  GL_TEXTURE_COMPARE_FAIL_VALUE_ARB = $80BF;
+
+  // GL_ARB_texture_border_clamp
+  GL_CLAMP_TO_BORDER_ARB = $812D;
+
+  // GL_ARB_texture_compression
+  GL_COMPRESSED_ALPHA_ARB = $84E9;
+  GL_COMPRESSED_LUMINANCE_ARB = $84EA;
+  GL_COMPRESSED_LUMINANCE_ALPHA_ARB = $84EB;
+  GL_COMPRESSED_INTENSITY_ARB = $84EC;
+  GL_COMPRESSED_RGB_ARB = $84ED;
+  GL_COMPRESSED_RGBA_ARB = $84EE;
+  GL_TEXTURE_COMPRESSION_HINT_ARB = $84EF;
+  GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = $86A0;
+  GL_TEXTURE_COMPRESSED_ARB = $86A1;
+  GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = $86A2;
+  GL_COMPRESSED_TEXTURE_FORMATS_ARB = $86A3;
+
+  // GL_ARB_texture_cube_map
+  GL_NORMAL_MAP_ARB = $8511;
+  GL_REFLECTION_MAP_ARB = $8512;
+  GL_TEXTURE_CUBE_MAP_ARB = $8513;
+  GL_TEXTURE_BINDING_CUBE_MAP_ARB = $8514;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $851A;
+  GL_PROXY_TEXTURE_CUBE_MAP_ARB = $851B;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = $851C;
+
+  // GL_ARB_texture_env_combine
+  GL_COMBINE_ARB = $8570;
+  GL_COMBINE_RGB_ARB = $8571;
+  GL_COMBINE_ALPHA_ARB = $8572;
+  GL_SOURCE0_RGB_ARB = $8580;
+  GL_SOURCE1_RGB_ARB = $8581;
+  GL_SOURCE2_RGB_ARB = $8582;
+  GL_SOURCE0_ALPHA_ARB = $8588;
+  GL_SOURCE1_ALPHA_ARB = $8589;
+  GL_SOURCE2_ALPHA_ARB = $858A;
+  GL_OPERAND0_RGB_ARB = $8590;
+  GL_OPERAND1_RGB_ARB = $8591;
+  GL_OPERAND2_RGB_ARB = $8592;
+  GL_OPERAND0_ALPHA_ARB = $8598;
+  GL_OPERAND1_ALPHA_ARB = $8599;
+  GL_OPERAND2_ALPHA_ARB = $859A;
+  GL_RGB_SCALE_ARB = $8573;
+  GL_ADD_SIGNED_ARB = $8574;
+  GL_INTERPOLATE_ARB = $8575;
+  GL_SUBTRACT_ARB = $84E7;
+  GL_CONSTANT_ARB = $8576;
+  GL_PRIMARY_COLOR_ARB = $8577;
+  GL_PREVIOUS_ARB = $8578;
+
+  // GL_ARB_texture_env_dot3
+  GL_DOT3_RGB_ARB = $86AE;
+  GL_DOT3_RGBA_ARB = $86AF;
+
+  // GL_ARB_texture_mirrored_repeat
+  GL_MIRRORED_REPEAT_ARB = $8370;
+
+  // GL_ARB_transpose_matrix
+  GL_TRANSPOSE_MODELVIEW_MATRIX_ARB = $84E3;
+  GL_TRANSPOSE_PROJECTION_MATRIX_ARB = $84E4;
+  GL_TRANSPOSE_TEXTURE_MATRIX_ARB = $84E5;
+  GL_TRANSPOSE_COLOR_MATRIX_ARB = $84E6;
+
+  // GL_ARB_vertex_blend
+  GL_MAX_VERTEX_UNITS_ARB = $86A4;
+  GL_ACTIVE_VERTEX_UNITS_ARB = $86A5;
+  GL_WEIGHT_SUM_UNITY_ARB = $86A6;
+  GL_VERTEX_BLEND_ARB = $86A7;
+  GL_CURRENT_WEIGHT_ARB = $86A8;
+  GL_WEIGHT_ARRAY_TYPE_ARB = $86A9;
+  GL_WEIGHT_ARRAY_STRIDE_ARB = $86AA;
+  GL_WEIGHT_ARRAY_SIZE_ARB = $86AB;
+  GL_WEIGHT_ARRAY_POINTER_ARB = $86AC;
+  GL_WEIGHT_ARRAY_ARB = $86AD;
+  GL_MODELVIEW0_ARB = $1700;
+  GL_MODELVIEW1_ARB = $850A;
+  GL_MODELVIEW2_ARB = $8722;
+  GL_MODELVIEW3_ARB = $8723;
+  GL_MODELVIEW4_ARB = $8724;
+  GL_MODELVIEW5_ARB = $8725;
+  GL_MODELVIEW6_ARB = $8726;
+  GL_MODELVIEW7_ARB = $8727;
+  GL_MODELVIEW8_ARB = $8728;
+  GL_MODELVIEW9_ARB = $8729;
+  GL_MODELVIEW10_ARB = $872A;
+  GL_MODELVIEW11_ARB = $872B;
+  GL_MODELVIEW12_ARB = $872C;
+  GL_MODELVIEW13_ARB = $872D;
+  GL_MODELVIEW14_ARB = $872E;
+  GL_MODELVIEW15_ARB = $872F;
+  GL_MODELVIEW16_ARB = $8730;
+  GL_MODELVIEW17_ARB = $8731;
+  GL_MODELVIEW18_ARB = $8732;
+  GL_MODELVIEW19_ARB = $8733;
+  GL_MODELVIEW20_ARB = $8734;
+  GL_MODELVIEW21_ARB = $8735;
+  GL_MODELVIEW22_ARB = $8736;
+  GL_MODELVIEW23_ARB = $8737;
+  GL_MODELVIEW24_ARB = $8738;
+  GL_MODELVIEW25_ARB = $8739;
+  GL_MODELVIEW26_ARB = $873A;
+  GL_MODELVIEW27_ARB = $873B;
+  GL_MODELVIEW28_ARB = $873C;
+  GL_MODELVIEW29_ARB = $873D;
+  GL_MODELVIEW30_ARB = $873E;
+  GL_MODELVIEW31_ARB = $873F;
+
+  // GL_ARB_vertex_buffer_object
+  GL_BUFFER_SIZE_ARB = $8764;
+  GL_BUFFER_USAGE_ARB = $8765;
+  GL_ARRAY_BUFFER_ARB = $8892;
+  GL_ELEMENT_ARRAY_BUFFER_ARB = $8893;
+  GL_ARRAY_BUFFER_BINDING_ARB = $8894;
+  GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB = $8895;
+  GL_VERTEX_ARRAY_BUFFER_BINDING_ARB = $8896;
+  GL_NORMAL_ARRAY_BUFFER_BINDING_ARB = $8897;
+  GL_COLOR_ARRAY_BUFFER_BINDING_ARB = $8898;
+  GL_INDEX_ARRAY_BUFFER_BINDING_ARB = $8899;
+  GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = $889A;
+  GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = $889B;
+  GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = $889C;
+  GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = $889D;
+  GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB = $889E;
+  GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = $889F;
+  GL_READ_ONLY_ARB = $88B8;
+  GL_WRITE_ONLY_ARB = $88B9;
+  GL_READ_WRITE_ARB = $88BA;
+  GL_BUFFER_ACCESS_ARB = $88BB;
+  GL_BUFFER_MAPPED_ARB = $88BC;
+  GL_BUFFER_MAP_POINTER_ARB = $88BD;
+  GL_STREAM_DRAW_ARB = $88E0;
+  GL_STREAM_READ_ARB = $88E1;
+  GL_STREAM_COPY_ARB = $88E2;
+  GL_STATIC_DRAW_ARB = $88E4;
+  GL_STATIC_READ_ARB = $88E5;
+  GL_STATIC_COPY_ARB = $88E6;
+  GL_DYNAMIC_DRAW_ARB = $88E8;
+  GL_DYNAMIC_READ_ARB = $88E9;
+  GL_DYNAMIC_COPY_ARB = $88EA;
+
+  // GL_ARB_vertex_program
+  GL_COLOR_SUM_ARB = $8458;
+  GL_VERTEX_PROGRAM_ARB = $8620;
+  GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = $8622;
+  GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB = $8623;
+  GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = $8624;
+  GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB = $8625;
+  GL_CURRENT_VERTEX_ATTRIB_ARB = $8626;
+  GL_PROGRAM_LENGTH_ARB = $8627;
+  GL_PROGRAM_STRING_ARB = $8628;
+  GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = $862E;
+  GL_MAX_PROGRAM_MATRICES_ARB = $862F;
+  GL_CURRENT_MATRIX_STACK_DEPTH_ARB = $8640;
+  GL_CURRENT_MATRIX_ARB = $8641;
+  GL_VERTEX_PROGRAM_POINT_SIZE_ARB = $8642;
+  GL_VERTEX_PROGRAM_TWO_SIDE_ARB = $8643;
+  GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB = $8645;
+  GL_PROGRAM_ERROR_POSITION_ARB = $864B;
+  GL_PROGRAM_BINDING_ARB = $8677;
+  GL_MAX_VERTEX_ATTRIBS_ARB = $8869;
+  GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = $886A;
+  GL_PROGRAM_ERROR_STRING_ARB = $8874;
+  GL_PROGRAM_FORMAT_ASCII_ARB = $8875;
+  GL_PROGRAM_FORMAT_ARB = $8876;
+  GL_PROGRAM_INSTRUCTIONS_ARB = $88A0;
+  GL_MAX_PROGRAM_INSTRUCTIONS_ARB = $88A1;
+  GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A2;
+  GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = $88A3;
+  GL_PROGRAM_TEMPORARIES_ARB = $88A4;
+  GL_MAX_PROGRAM_TEMPORARIES_ARB = $88A5;
+  GL_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A6;
+  GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = $88A7;
+  GL_PROGRAM_PARAMETERS_ARB = $88A8;
+  GL_MAX_PROGRAM_PARAMETERS_ARB = $88A9;
+  GL_PROGRAM_NATIVE_PARAMETERS_ARB = $88AA;
+  GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = $88AB;
+  GL_PROGRAM_ATTRIBS_ARB = $88AC;
+  GL_MAX_PROGRAM_ATTRIBS_ARB = $88AD;
+  GL_PROGRAM_NATIVE_ATTRIBS_ARB = $88AE;
+  GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = $88AF;
+  GL_PROGRAM_ADDRESS_REGISTERS_ARB = $88B0;
+  GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = $88B1;
+  GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B2;
+  GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = $88B3;
+  GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = $88B4;
+  GL_MAX_PROGRAM_ENV_PARAMETERS_ARB = $88B5;
+  GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB = $88B6;
+  GL_TRANSPOSE_CURRENT_MATRIX_ARB = $88B7;
+  GL_MATRIX0_ARB = $88C0;
+  GL_MATRIX1_ARB = $88C1;
+  GL_MATRIX2_ARB = $88C2;
+  GL_MATRIX3_ARB = $88C3;
+  GL_MATRIX4_ARB = $88C4;
+  GL_MATRIX5_ARB = $88C5;
+  GL_MATRIX6_ARB = $88C6;
+  GL_MATRIX7_ARB = $88C7;
+  GL_MATRIX8_ARB = $88C8;
+  GL_MATRIX9_ARB = $88C9;
+  GL_MATRIX10_ARB = $88CA;
+  GL_MATRIX11_ARB = $88CB;
+  GL_MATRIX12_ARB = $88CC;
+  GL_MATRIX13_ARB = $88CD;
+  GL_MATRIX14_ARB = $88CE;
+  GL_MATRIX15_ARB = $88CF;
+  GL_MATRIX16_ARB = $88D0;
+  GL_MATRIX17_ARB = $88D1;
+  GL_MATRIX18_ARB = $88D2;
+  GL_MATRIX19_ARB = $88D3;
+  GL_MATRIX20_ARB = $88D4;
+  GL_MATRIX21_ARB = $88D5;
+  GL_MATRIX22_ARB = $88D6;
+  GL_MATRIX23_ARB = $88D7;
+  GL_MATRIX24_ARB = $88D8;
+  GL_MATRIX25_ARB = $88D9;
+  GL_MATRIX26_ARB = $88DA;
+  GL_MATRIX27_ARB = $88DB;
+  GL_MATRIX28_ARB = $88DC;
+  GL_MATRIX29_ARB = $88DD;
+  GL_MATRIX30_ARB = $88DE;
+  GL_MATRIX31_ARB = $88DF;
+
+  // GL_ARB_draw_buffers
+  GL_MAX_DRAW_BUFFERS_ARB = $8824;
+  GL_DRAW_BUFFER0_ARB = $8825;
+  GL_DRAW_BUFFER1_ARB = $8826;
+  GL_DRAW_BUFFER2_ARB = $8827;
+  GL_DRAW_BUFFER3_ARB = $8828;
+  GL_DRAW_BUFFER4_ARB = $8829;
+  GL_DRAW_BUFFER5_ARB = $882A;
+  GL_DRAW_BUFFER6_ARB = $882B;
+  GL_DRAW_BUFFER7_ARB = $882C;
+  GL_DRAW_BUFFER8_ARB = $882D;
+  GL_DRAW_BUFFER9_ARB = $882E;
+  GL_DRAW_BUFFER10_ARB = $882F;
+  GL_DRAW_BUFFER11_ARB = $8830;
+  GL_DRAW_BUFFER12_ARB = $8831;
+  GL_DRAW_BUFFER13_ARB = $8832;
+  GL_DRAW_BUFFER14_ARB = $8833;
+  GL_DRAW_BUFFER15_ARB = $8834;
+
+  // GL_ARB_texture_rectangle
+  GL_TEXTURE_RECTANGLE_ARB = $84F5;
+  GL_TEXTURE_BINDING_RECTANGLE_ARB = $84F6;
+  GL_PROXY_TEXTURE_RECTANGLE_ARB = $84F7;
+  GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB = $84F8;
+
+  // GL_ARB_color_buffer_float
+  GL_RGBA_FLOAT_MODE_ARB = $8820;
+  GL_CLAMP_VERTEX_COLOR_ARB = $891A;
+  GL_CLAMP_FRAGMENT_COLOR_ARB = $891B;
+  GL_CLAMP_READ_COLOR_ARB = $891C;
+  GL_FIXED_ONLY_ARB = $891D;
+  WGL_TYPE_RGBA_FLOAT_ARB = $21A0;
+  GLX_RGBA_FLOAT_TYPE = $20B9;
+  GLX_RGBA_FLOAT_BIT = $00000004;
+
+  // GL_ARB_half_float_pixel
+  GL_HALF_FLOAT_ARB = $140B;
+
+  // GL_ARB_texture_float
+  GL_TEXTURE_RED_TYPE_ARB = $8C10;
+  GL_TEXTURE_GREEN_TYPE_ARB = $8C11;
+  GL_TEXTURE_BLUE_TYPE_ARB = $8C12;
+  GL_TEXTURE_ALPHA_TYPE_ARB = $8C13;
+  GL_TEXTURE_LUMINANCE_TYPE_ARB = $8C14;
+  GL_TEXTURE_INTENSITY_TYPE_ARB = $8C15;
+  GL_TEXTURE_DEPTH_TYPE_ARB = $8C16;
+  GL_UNSIGNED_NORMALIZED_ARB = $8C17;
+  GL_RGBA32F_ARB = $8814;
+  GL_RGB32F_ARB = $8815;
+  GL_ALPHA32F_ARB = $8816;
+  GL_INTENSITY32F_ARB = $8817;
+  GL_LUMINANCE32F_ARB = $8818;
+  GL_LUMINANCE_ALPHA32F_ARB = $8819;
+  GL_RGBA16F_ARB = $881A;
+  GL_RGB16F_ARB = $881B;
+  GL_ALPHA16F_ARB = $881C;
+  GL_INTENSITY16F_ARB = $881D;
+  GL_LUMINANCE16F_ARB = $881E;
+  GL_LUMINANCE_ALPHA16F_ARB = $881F;
+
+  // GL_ARB_pixel_buffer_object
+  GL_PIXEL_PACK_BUFFER_ARB = $88EB;
+  GL_PIXEL_UNPACK_BUFFER_ARB = $88EC;
+  GL_PIXEL_PACK_BUFFER_BINDING_ARB = $88ED;
+  GL_PIXEL_UNPACK_BUFFER_BINDING_ARB = $88EF;
+
+  // GL_ARB_depth_buffer_float
+  GL_DEPTH_COMPONENT32F = $8CAC;
+  GL_DEPTH32F_STENCIL8 = $8CAD;
+  GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD;
+
+  // GL_ARB_framebuffer_object
+  GL_INVALID_FRAMEBUFFER_OPERATION = $0506;
+  GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = $8210;
+  GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = $8211;
+  GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = $8212;
+  GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = $8213;
+  GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = $8214;
+  GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = $8215;
+  GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = $8216;
+  GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = $8217;
+  GL_FRAMEBUFFER_DEFAULT = $8218;
+  GL_FRAMEBUFFER_UNDEFINED = $8219;
+  GL_DEPTH_STENCIL_ATTACHMENT = $821A;
+  GL_MAX_RENDERBUFFER_SIZE = $84E8;
+  GL_DEPTH_STENCIL = $84F9;
+  GL_UNSIGNED_INT_24_8 = $84FA;
+  GL_DEPTH24_STENCIL8 = $88F0;
+  GL_TEXTURE_STENCIL_SIZE = $88F1;
+  GL_TEXTURE_RED_TYPE = $8C10;
+  GL_TEXTURE_GREEN_TYPE = $8C11;
+  GL_TEXTURE_BLUE_TYPE = $8C12;
+  GL_TEXTURE_ALPHA_TYPE = $8C13;
+  GL_TEXTURE_DEPTH_TYPE = $8C16;
+  GL_UNSIGNED_NORMALIZED = $8C17;
+  GL_FRAMEBUFFER_BINDING = $8CA6;
+  GL_DRAW_FRAMEBUFFER_BINDING = GL_FRAMEBUFFER_BINDING;
+  GL_RENDERBUFFER_BINDING = $8CA7;
+  GL_READ_FRAMEBUFFER = $8CA8;
+  GL_DRAW_FRAMEBUFFER = $8CA9;
+  GL_READ_FRAMEBUFFER_BINDING = $8CAA;
+  GL_RENDERBUFFER_SAMPLES = $8CAB;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = $8CD0;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = $8CD1;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = $8CD2;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = $8CD3;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4;
+  GL_FRAMEBUFFER_COMPLETE = $8CD5;
+  GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6;
+  GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7;
+  GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = $8CDB;
+  GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = $8CDC;
+  GL_FRAMEBUFFER_UNSUPPORTED = $8CDD;
+  GL_MAX_COLOR_ATTACHMENTS = $8CDF;
+  GL_COLOR_ATTACHMENT0 = $8CE0;
+  GL_COLOR_ATTACHMENT1 = $8CE1;
+  GL_COLOR_ATTACHMENT2 = $8CE2;
+  GL_COLOR_ATTACHMENT3 = $8CE3;
+  GL_COLOR_ATTACHMENT4 = $8CE4;
+  GL_COLOR_ATTACHMENT5 = $8CE5;
+  GL_COLOR_ATTACHMENT6 = $8CE6;
+  GL_COLOR_ATTACHMENT7 = $8CE7;
+  GL_COLOR_ATTACHMENT8 = $8CE8;
+  GL_COLOR_ATTACHMENT9 = $8CE9;
+  GL_COLOR_ATTACHMENT10 = $8CEA;
+  GL_COLOR_ATTACHMENT11 = $8CEB;
+  GL_COLOR_ATTACHMENT12 = $8CEC;
+  GL_COLOR_ATTACHMENT13 = $8CED;
+  GL_COLOR_ATTACHMENT14 = $8CEE;
+  GL_COLOR_ATTACHMENT15 = $8CEF;
+  GL_DEPTH_ATTACHMENT = $8D00;
+  GL_STENCIL_ATTACHMENT = $8D20;
+  GL_FRAMEBUFFER = $8D40;
+  GL_RENDERBUFFER = $8D41;
+  GL_RENDERBUFFER_WIDTH = $8D42;
+  GL_RENDERBUFFER_HEIGHT = $8D43;
+  GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44;
+  GL_STENCIL_INDEX1 = $8D46;
+  GL_STENCIL_INDEX4 = $8D47;
+  GL_STENCIL_INDEX8 = $8D48;
+  GL_STENCIL_INDEX16 = $8D49;
+  GL_RENDERBUFFER_RED_SIZE = $8D50;
+  GL_RENDERBUFFER_GREEN_SIZE = $8D51;
+  GL_RENDERBUFFER_BLUE_SIZE = $8D52;
+  GL_RENDERBUFFER_ALPHA_SIZE = $8D53;
+  GL_RENDERBUFFER_DEPTH_SIZE = $8D54;
+  GL_RENDERBUFFER_STENCIL_SIZE = $8D55;
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = $8D56;
+  GL_MAX_SAMPLES = $8D57;
+{$ifdef DGL_DEPRECATED}
+  GL_INDEX = $8222;
+  GL_TEXTURE_LUMINANCE_TYPE = $8C14;
+  GL_TEXTURE_INTENSITY_TYPE = $8C15;
+{$endif}
+
+  // GL_ARB_framebuffer_sRGB
+  GL_FRAMEBUFFER_SRGB = $8DB9;
+
+  // GL_ARB_geometry_shader4
+  GL_LINES_ADJACENCY_ARB = $000A;
+  GL_LINE_STRIP_ADJACENCY_ARB = $000B;
+  GL_TRIANGLES_ADJACENCY_ARB = $000C;
+  GL_TRIANGLE_STRIP_ADJACENCY_ARB = $000D;
+  GL_PROGRAM_POINT_SIZE_ARB = $8642;
+  GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = $8C29;
+  GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = $8DA7;
+  GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = $8DA8;
+  GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = $8DA9;
+  GL_GEOMETRY_SHADER_ARB = $8DD9;
+  GL_GEOMETRY_VERTICES_OUT_ARB = $8DDA;
+  GL_GEOMETRY_INPUT_TYPE_ARB = $8DDB;
+  GL_GEOMETRY_OUTPUT_TYPE_ARB = $8DDC;
+  GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = $8DDD;
+  GL_MAX_VERTEX_VARYING_COMPONENTS_ARB = $8DDE;
+  GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = $8DDF;
+  GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = $8DE0;
+  GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = $8DE1;
+  { reuse GL_MAX_VARYING_COMPONENTS }
+  { reuse GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER }
+
+  // GL_ARB_half_float_vertex
+  GL_HALF_FLOAT = $140B;
+
+  // GL_ARB_instanced_arrays
+  GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = $88FE;
+
+  // GL_ARB_map_buffer_range
+  GL_MAP_READ_BIT = $0001;
+  GL_MAP_WRITE_BIT = $0002;
+  GL_MAP_INVALIDATE_RANGE_BIT = $0004;
+  GL_MAP_INVALIDATE_BUFFER_BIT = $0008;
+  GL_MAP_FLUSH_EXPLICIT_BIT = $0010;
+  GL_MAP_UNSYNCHRONIZED_BIT = $0020;
+
+  // GL_ARB_texture_buffer_object
+  GL_TEXTURE_BUFFER_ARB = $8C2A;
+  GL_MAX_TEXTURE_BUFFER_SIZE_ARB = $8C2B;
+  GL_TEXTURE_BINDING_BUFFER_ARB = $8C2C;
+  GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = $8C2D;
+  GL_TEXTURE_BUFFER_FORMAT_ARB = $8C2E;
+
+  // GL_ARB_texture_compression_rgtc
+  GL_COMPRESSED_RED_RGTC1 = $8DBB;
+  GL_COMPRESSED_SIGNED_RED_RGTC1 = $8DBC;
+  GL_COMPRESSED_RG_RGTC2 = $8DBD;
+  GL_COMPRESSED_SIGNED_RG_RGTC2 = $8DBE;
+
+  // GL_ARB_texture_rg
+  GL_RG = $8227;
+  GL_RG_INTEGER = $8228;
+  GL_R8 = $8229;
+  GL_R16 = $822A;
+  GL_RG8 = $822B;
+  GL_RG16 = $822C;
+  GL_R16F = $822D;
+  GL_R32F = $822E;
+  GL_RG16F = $822F;
+  GL_RG32F = $8230;
+  GL_R8I = $8231;
+  GL_R8UI = $8232;
+  GL_R16I = $8233;
+  GL_R16UI = $8234;
+  GL_R32I = $8235;
+  GL_R32UI = $8236;
+  GL_RG8I = $8237;
+  GL_RG8UI = $8238;
+  GL_RG16I = $8239;
+  GL_RG16UI = $823A;
+  GL_RG32I = $823B;
+  GL_RG32UI = $823C;
+
+  // GL_ARB_vertex_array_object
+  GL_VERTEX_ARRAY_BINDING = $85B5;
+
+  // GL_ARB_uniform_buffer_object
+  GL_UNIFORM_BUFFER = $8A11;
+  GL_UNIFORM_BUFFER_BINDING = $8A28;
+  GL_UNIFORM_BUFFER_START = $8A29;
+  GL_UNIFORM_BUFFER_SIZE = $8A2A;
+  GL_MAX_VERTEX_UNIFORM_BLOCKS = $8A2B;
+  GL_MAX_GEOMETRY_UNIFORM_BLOCKS = $8A2C;
+  GL_MAX_FRAGMENT_UNIFORM_BLOCKS = $8A2D;
+  GL_MAX_COMBINED_UNIFORM_BLOCKS = $8A2E;
+  GL_MAX_UNIFORM_BUFFER_BINDINGS = $8A2F;
+  GL_MAX_UNIFORM_BLOCK_SIZE = $8A30;
+  GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = $8A31;
+  GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = $8A32;
+  GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = $8A33;
+  GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = $8A34;
+  GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = $8A35;
+  GL_ACTIVE_UNIFORM_BLOCKS = $8A36;
+  GL_UNIFORM_TYPE = $8A37;
+  GL_UNIFORM_SIZE = $8A38;
+  GL_UNIFORM_NAME_LENGTH = $8A39;
+  GL_UNIFORM_BLOCK_INDEX = $8A3A;
+  GL_UNIFORM_OFFSET = $8A3B;
+  GL_UNIFORM_ARRAY_STRIDE = $8A3C;
+  GL_UNIFORM_MATRIX_STRIDE = $8A3D;
+  GL_UNIFORM_IS_ROW_MAJOR = $8A3E;
+  GL_UNIFORM_BLOCK_BINDING = $8A3F;
+  GL_UNIFORM_BLOCK_DATA_SIZE = $8A40;
+  GL_UNIFORM_BLOCK_NAME_LENGTH = $8A41;
+  GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = $8A42;
+  GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = $8A43;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = $8A44;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = $8A45;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46;
+  GL_INVALID_INDEX = $FFFFFFFF;
+
+  // GL_ARB_compatibility
+  { ARB_compatibility just defines tokens from core 3.0 }
+
+  // GL_ARB_copy_buffer
+  GL_COPY_READ_BUFFER_BINDING = $8F36;
+  GL_COPY_READ_BUFFER = GL_COPY_READ_BUFFER_BINDING;
+  GL_COPY_WRITE_BUFFER_BINDING = $8F37;
+  GL_COPY_WRITE_BUFFER = GL_COPY_WRITE_BUFFER_BINDING;
+
+  // GL_ARB_depth_clamp
+  GL_DEPTH_CLAMP = $864F;
+
+  // GL_ARB_provoking_vertex
+  GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = $8E4C;
+  GL_FIRST_VERTEX_CONVENTION = $8E4D;
+  GL_LAST_VERTEX_CONVENTION = $8E4E;
+  GL_PROVOKING_VERTEX = $8E4F;
+
+  // GL_ARB_seamless_cube_map
+  GL_TEXTURE_CUBE_MAP_SEAMLESS = $884F;
+
+  // GL_ARB_sync
+  GL_MAX_SERVER_WAIT_TIMEOUT = $9111;
+  GL_OBJECT_TYPE = $9112;
+  GL_SYNC_CONDITION = $9113;
+  GL_SYNC_STATUS = $9114;
+  GL_SYNC_FLAGS = $9115;
+  GL_SYNC_FENCE = $9116;
+  GL_SYNC_GPU_COMMANDS_COMPLETE = $9117;
+  GL_UNSIGNALED = $9118;
+  GL_SIGNALED = $9119;
+  GL_ALREADY_SIGNALED = $911A;
+  GL_TIMEOUT_EXPIRED = $911B;
+  GL_CONDITION_SATISFIED = $911C;
+  GL_WAIT_FAILED = $911D;
+  GL_SYNC_FLUSH_COMMANDS_BIT = $00000001;
+  GL_TIMEOUT_IGNORED = $FFFFFFFFFFFFFFFF;
+
+  // GL_ARB_texture_multisample
+  GL_SAMPLE_POSITION = $8E50;
+  GL_SAMPLE_MASK = $8E51;
+  GL_SAMPLE_MASK_VALUE = $8E52;
+  GL_MAX_SAMPLE_MASK_WORDS = $8E59;
+  GL_TEXTURE_2D_MULTISAMPLE = $9100;
+  GL_PROXY_TEXTURE_2D_MULTISAMPLE = $9101;
+  GL_TEXTURE_2D_MULTISAMPLE_ARRAY = $9102;
+  GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = $9103;
+  GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104;
+  GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = $9105;
+  GL_TEXTURE_SAMPLES = $9106;
+  GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107;
+  GL_SAMPLER_2D_MULTISAMPLE = $9108;
+  GL_INT_SAMPLER_2D_MULTISAMPLE = $9109;
+  GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A;
+  GL_SAMPLER_2D_MULTISAMPLE_ARRAY = $910B;
+  GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910C;
+  GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = $910D;
+  GL_MAX_COLOR_TEXTURE_SAMPLES = $910E;
+  GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F;
+  GL_MAX_INTEGER_SAMPLES = $9110;
+
+  // GL_ARB_vertex_array_bgra
+  { reuse GL_BGRA }
+
+  // GL_ARB_sample_shading
+  GL_SAMPLE_SHADING_ARB = $8C36;
+  GL_MIN_SAMPLE_SHADING_VALUE_ARB = $8C37;
+
+  // GL_ARB_texture_cube_map_array
+  GL_TEXTURE_CUBE_MAP_ARRAY_ARB = $9009;
+  GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = $900A;
+  GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = $900B;
+  GL_SAMPLER_CUBE_MAP_ARRAY_ARB = $900C;
+  GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = $900D;
+  GL_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900E;
+  GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = $900F;
+
+  // GL_ARB_texture_gather
+  GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5E;
+  GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = $8E5F;
+
+  // GL_ARB_shading_language_include
+  GL_SHADER_INCLUDE_ARB = $8DAE;
+  GL_NAMED_STRING_LENGTH_ARB = $8DE9;
+  GL_NAMED_STRING_TYPE_ARB = $8DEA;
+
+  // GL_ARB_texture_compression_bptc
+  GL_COMPRESSED_RGBA_BPTC_UNORM_ARB = $8E8C;
+  GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = $8E8D;
+  GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = $8E8E;
+  GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = $8E8F;
+
+  // GL_ARB_blend_func_extended
+  GL_SRC1_COLOR = $88F9;
+  { reuse GL_SRC1_ALPHA }
+  GL_ONE_MINUS_SRC1_COLOR = $88FA;
+  GL_ONE_MINUS_SRC1_ALPHA = $88FB;
+  GL_MAX_DUAL_SOURCE_DRAW_BUFFERS = $88FC;
+
+  // GL_ARB_occlusion_query2
+  GL_ANY_SAMPLES_PASSED = $8C2F;
+
+  // GL_ARB_sampler_objects
+  GL_SAMPLER_BINDING = $8919;
+
+  // GL_ARB_texture_rgb10_a2ui
+  GL_RGB10_A2UI = $906F;
+
+  // GL_ARB_texture_swizzle
+  GL_TEXTURE_SWIZZLE_R = $8E42;
+  GL_TEXTURE_SWIZZLE_G = $8E43;
+  GL_TEXTURE_SWIZZLE_B = $8E44;
+  GL_TEXTURE_SWIZZLE_A = $8E45;
+  GL_TEXTURE_SWIZZLE_RGBA = $8E46;
+
+  // GL_ARB_timer_query
+  GL_TIME_ELAPSED = $88BF;
+  GL_TIMESTAMP = $8E28;
+
+  // GL_ARB_vertex_type_2_10_10_10_rev
+  { reuse GL_UNSIGNED_INT_2_10_10_10_REV }
+  GL_INT_2_10_10_10_REV = $8D9F;
+
+  // GL_ARB_draw_indirect
+  GL_DRAW_INDIRECT_BUFFER = $8F3F;
+  GL_DRAW_INDIRECT_BUFFER_BINDING = $8F43;
+
+  // GL_ARB_gpu_shader5
+  GL_GEOMETRY_SHADER_INVOCATIONS = $887F;
+  GL_MAX_GEOMETRY_SHADER_INVOCATIONS = $8E5A;
+  GL_MIN_FRAGMENT_INTERPOLATION_OFFSET = $8E5B;
+  GL_MAX_FRAGMENT_INTERPOLATION_OFFSET = $8E5C;
+  GL_FRAGMENT_INTERPOLATION_OFFSET_BITS = $8E5D;
+  { reuse GL_MAX_VERTEX_STREAMS }
+
+  // GL_ARB_gpu_shader_fp64
+  { reuse GL_DOUBLE }
+  GL_DOUBLE_VEC2 = $8FFC;
+  GL_DOUBLE_VEC3 = $8FFD;
+  GL_DOUBLE_VEC4 = $8FFE;
+  GL_DOUBLE_MAT2 = $8F46;
+  GL_DOUBLE_MAT3 = $8F47;
+  GL_DOUBLE_MAT4 = $8F48;
+  GL_DOUBLE_MAT2x3 = $8F49;
+  GL_DOUBLE_MAT2x4 = $8F4A;
+  GL_DOUBLE_MAT3x2 = $8F4B;
+  GL_DOUBLE_MAT3x4 = $8F4C;
+  GL_DOUBLE_MAT4x2 = $8F4D;
+  GL_DOUBLE_MAT4x3 = $8F4E;
+
+  // GL_ARB_shader_subroutine
+  GL_ACTIVE_SUBROUTINES = $8DE5;
+  GL_ACTIVE_SUBROUTINE_UNIFORMS = $8DE6;
+  GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = $8E47;
+  GL_ACTIVE_SUBROUTINE_MAX_LENGTH = $8E48;
+  GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = $8E49;
+  GL_MAX_SUBROUTINES = $8DE7;
+  GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS = $8DE8;
+  GL_NUM_COMPATIBLE_SUBROUTINES = $8E4A;
+  GL_COMPATIBLE_SUBROUTINES = $8E4B;
+  { reuse GL_UNIFORM_SIZE }
+  { reuse GL_UNIFORM_NAME_LENGTH }
+
+  // GL_ARB_tessellation_shader
+  GL_PATCHES = $000E;
+  GL_PATCH_VERTICES = $8E72;
+  GL_PATCH_DEFAULT_INNER_LEVEL = $8E73;
+  GL_PATCH_DEFAULT_OUTER_LEVEL = $8E74;
+  GL_TESS_CONTROL_OUTPUT_VERTICES = $8E75;
+  GL_TESS_GEN_MODE = $8E76;
+  GL_TESS_GEN_SPACING = $8E77;
+  GL_TESS_GEN_VERTEX_ORDER = $8E78;
+  GL_TESS_GEN_POINT_MODE = $8E79;
+  { reuse GL_TRIANGLES }
+  { reuse GL_QUADS }
+  GL_ISOLINES = $8E7A;
+  { reuse GL_EQUAL }
+  GL_FRACTIONAL_ODD = $8E7B;
+  GL_FRACTIONAL_EVEN = $8E7C;
+  { reuse GL_CCW }
+  { reuse GL_CW }
+  GL_MAX_PATCH_VERTICES = $8E7D;
+  GL_MAX_TESS_GEN_LEVEL = $8E7E;
+  GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = $8E7F;
+  GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E80;
+  GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = $8E81;
+  GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = $8E82;
+  GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = $8E83;
+  GL_MAX_TESS_PATCH_COMPONENTS = $8E84;
+  GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = $8E85;
+  GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = $8E86;
+  GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS = $8E89;
+  GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = $8E8A;
+  GL_MAX_TESS_CONTROL_INPUT_COMPONENTS = $886C;
+  GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS = $886D;
+  GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = $8E1E;
+  GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = $8E1F;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = $84F0;
+  GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = $84F1;
+  GL_TESS_EVALUATION_SHADER = $8E87;
+  GL_TESS_CONTROL_SHADER = $8E88;
+
+  // GL_ARB_texture_buffer_object_rgb32
+  { reuse GL_RGB32F }
+  { reuse GL_RGB32UI }
+  { reuse GL_RGB32I }
+
+  // GL_ARB_transform_feedback2
+  GL_TRANSFORM_FEEDBACK = $8E22;
+  GL_TRANSFORM_FEEDBACK_PAUSED = $8E23;
+  GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED = GL_TRANSFORM_FEEDBACK_PAUSED;
+  GL_TRANSFORM_FEEDBACK_ACTIVE = $8E24;
+  GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = GL_TRANSFORM_FEEDBACK_ACTIVE;
+  GL_TRANSFORM_FEEDBACK_BINDING = $8E25;
+
+  // GL_ARB_transform_feedback3
+  GL_MAX_TRANSFORM_FEEDBACK_BUFFERS = $8E70;
+  GL_MAX_VERTEX_STREAMS = $8E71;
+
+  // GL_ARB_ES2_compatibility
+  GL_FIXED = $140C;
+  GL_IMPLEMENTATION_COLOR_READ_TYPE = $8B9A;
+  GL_IMPLEMENTATION_COLOR_READ_FORMAT = $8B9B;
+  GL_LOW_FLOAT = $8DF0;
+  GL_MEDIUM_FLOAT = $8DF1;
+  GL_HIGH_FLOAT = $8DF2;
+  GL_LOW_INT = $8DF3;
+  GL_MEDIUM_INT = $8DF4;
+  GL_HIGH_INT = $8DF5;
+  GL_SHADER_COMPILER = $8DFA;
+  GL_NUM_SHADER_BINARY_FORMATS = $8DF9;
+  GL_MAX_VERTEX_UNIFORM_VECTORS = $8DFB;
+  GL_MAX_VARYING_VECTORS = $8DFC;
+  GL_MAX_FRAGMENT_UNIFORM_VECTORS = $8DFD;
+  GL_RGB565 = $8D62;
+
+  // GL_ARB_get_program_binary
+  GL_PROGRAM_BINARY_RETRIEVABLE_HINT = $8257;
+  GL_PROGRAM_BINARY_LENGTH = $8741;
+  GL_NUM_PROGRAM_BINARY_FORMATS = $87FE;
+  GL_PROGRAM_BINARY_FORMATS = $87FF;
+
+  // GL_ARB_separate_shader_objects
+  GL_VERTEX_SHADER_BIT = $00000001;
+  GL_FRAGMENT_SHADER_BIT = $00000002;
+  GL_GEOMETRY_SHADER_BIT = $00000004;
+  GL_TESS_CONTROL_SHADER_BIT = $00000008;
+  GL_TESS_EVALUATION_SHADER_BIT = $00000010;
+  GL_ALL_SHADER_BITS = $FFFFFFFF;
+  GL_PROGRAM_SEPARABLE = $8258;
+  GL_ACTIVE_PROGRAM = $8259;
+  GL_PROGRAM_PIPELINE_BINDING = $825A;
+
+  // GL_ARB_vertex_attrib_64bit
+  { reuse GL_RGB32I }
+  { reuse GL_DOUBLE_VEC2 }
+  { reuse GL_DOUBLE_VEC3 }
+  { reuse GL_DOUBLE_VEC4 }
+  { reuse GL_DOUBLE_MAT2 }
+  { reuse GL_DOUBLE_MAT3 }
+  { reuse GL_DOUBLE_MAT4 }
+  { reuse GL_DOUBLE_MAT2x3 }
+  { reuse GL_DOUBLE_MAT2x4 }
+  { reuse GL_DOUBLE_MAT3x2 }
+  { reuse GL_DOUBLE_MAT3x4 }
+  { reuse GL_DOUBLE_MAT4x2 }
+  { reuse GL_DOUBLE_MAT4x3 }
+
+  // GL_ARB_viewport_array
+  { reuse GL_SCISSOR_BOX }
+  { reuse GL_VIEWPORT }
+  { reuse GL_DEPTH_RANGE }
+  { reuse GL_SCISSOR_TEST }
+  GL_MAX_VIEWPORTS = $825B;
+  GL_VIEWPORT_SUBPIXEL_BITS = $825C;
+  GL_VIEWPORT_BOUNDS_RANGE = $825D;
+  GL_LAYER_PROVOKING_VERTEX = $825E;
+  GL_VIEWPORT_INDEX_PROVOKING_VERTEX = $825F;
+  GL_UNDEFINED_VERTEX = $8260;
+  { reuse GL_FIRST_VERTEX_CONVENTION }
+  { reuse GL_LAST_VERTEX_CONVENTION }
+  { reuse GL_PROVOKING_VERTEX }
+
+  // GL_ARB_cl_event
+  GL_SYNC_CL_EVENT_ARB = $8240;
+  GL_SYNC_CL_EVENT_COMPLETE_ARB = $8241;
+
+  // GL_ARB_debug_output
+  GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB = $8242;
+  GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = $8243;
+  GL_DEBUG_CALLBACK_FUNCTION_ARB = $8244;
+  GL_DEBUG_CALLBACK_USER_PARAM_ARB = $8245;
+  GL_DEBUG_SOURCE_API_ARB = $8246;
+  GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = $8247;
+  GL_DEBUG_SOURCE_SHADER_COMPILER_ARB = $8248;
+  GL_DEBUG_SOURCE_THIRD_PARTY_ARB = $8249;
+  GL_DEBUG_SOURCE_APPLICATION_ARB = $824A;
+  GL_DEBUG_SOURCE_OTHER_ARB = $824B;
+  GL_DEBUG_TYPE_ERROR_ARB = $824C;
+  GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = $824D;
+  GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = $824E;
+  GL_DEBUG_TYPE_PORTABILITY_ARB = $824F;
+  GL_DEBUG_TYPE_PERFORMANCE_ARB = $8250;
+  GL_DEBUG_TYPE_OTHER_ARB = $8251;
+  GL_MAX_DEBUG_MESSAGE_LENGTH_ARB = $9143;
+  GL_MAX_DEBUG_LOGGED_MESSAGES_ARB = $9144;
+  GL_DEBUG_LOGGED_MESSAGES_ARB = $9145;
+  GL_DEBUG_SEVERITY_HIGH_ARB = $9146;
+  GL_DEBUG_SEVERITY_MEDIUM_ARB = $9147;
+  GL_DEBUG_SEVERITY_LOW_ARB = $9148;
+
+  // GL_ARB_robustness
+  { reuse GL_NO_ERROR }
+  GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = $00000004;
+  GL_LOSE_CONTEXT_ON_RESET_ARB = $8252;
+  GL_GUILTY_CONTEXT_RESET_ARB = $8253;
+  GL_INNOCENT_CONTEXT_RESET_ARB = $8254;
+  GL_UNKNOWN_CONTEXT_RESET_ARB = $8255;
+  GL_RESET_NOTIFICATION_STRATEGY_ARB = $8256;
+  GL_NO_RESET_NOTIFICATION_ARB = $8261;
+
+  //  GL_ARB_compressed_texture_pixel_storage
+  GL_UNPACK_COMPRESSED_BLOCK_WIDTH  = $09127;
+  GL_UNPACK_COMPRESSED_BLOCK_HEIGHT = $09128;
+  GL_UNPACK_COMPRESSED_BLOCK_DEPTH  = $09129;
+  GL_UNPACK_COMPRESSED_BLOCK_SIZE   = $0912A;
+  GL_PACK_COMPRESSED_BLOCK_WIDTH    = $0912B;
+  GL_PACK_COMPRESSED_BLOCK_HEIGHT   = $0912C;
+  GL_PACK_COMPRESSED_BLOCK_DEPTH    = $0912D;
+  GL_PACK_COMPRESSED_BLOCK_SIZE     = $0912E;
+
+  // GL_ARB_internalformat_query
+  GL_NUM_SAMPLE_COUNTS              = $09380;
+
+  // GL_ARB_map_buffer_alignment
+  GL_MIN_MAP_BUFFER_ALIGNMENT       = $090BC;
+
+  // GL_ARB_shader_atomic_counters
+  GL_ATOMIC_COUNTER_BUFFER          = $92C0;
+  GL_ATOMIC_COUNTER_BUFFER_BINDING  = $92C1;
+  GL_ATOMIC_COUNTER_BUFFER_START    = $92C2;
+  GL_ATOMIC_COUNTER_BUFFER_SIZE     = $92C3;
+  GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE = $92C4;
+  GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = $92C5;
+  GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = $92C6;
+  GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = $92C7;
+  GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = $92C8;
+  GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = $92C9;
+  GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = $92CA;
+  GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = $92CB;
+  GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = $92CC;
+  GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = $92CD;
+  GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = $92CE;
+  GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = $92CF;
+  GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = $92D0;
+  GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = $92D1;
+  GL_MAX_VERTEX_ATOMIC_COUNTERS     = $92D2;
+  GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS = $92D3;
+  GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = $92D4;
+  GL_MAX_GEOMETRY_ATOMIC_COUNTERS   = $92D5;
+  GL_MAX_FRAGMENT_ATOMIC_COUNTERS   = $92D6;
+  GL_MAX_COMBINED_ATOMIC_COUNTERS   = $92D7;
+  GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = $92D8;
+  GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = $92DC;
+  GL_ACTIVE_ATOMIC_COUNTER_BUFFERS  = $92D9;
+  GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = $92DA;
+  GL_UNSIGNED_INT_ATOMIC_COUNTER    = $92DB;
+
+  // GL_ARB_shader_image_load_store
+  GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = $00000001;
+  GL_ELEMENT_ARRAY_BARRIER_BIT      = $00000002;
+  GL_UNIFORM_BARRIER_BIT            = $00000004;
+  GL_TEXTURE_FETCH_BARRIER_BIT      = $00000008;
+  GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = $00000020;
+  GL_COMMAND_BARRIER_BIT            = $00000040;
+  GL_PIXEL_BUFFER_BARRIER_BIT       = $00000080;
+  GL_TEXTURE_UPDATE_BARRIER_BIT     = $00000100;
+  GL_BUFFER_UPDATE_BARRIER_BIT      = $00000200;
+  GL_FRAMEBUFFER_BARRIER_BIT        = $00000400;
+  GL_TRANSFORM_FEEDBACK_BARRIER_BIT = $00000800;
+  GL_ATOMIC_COUNTER_BARRIER_BIT     = $00001000;
+  GL_ALL_BARRIER_BITS               = $FFFFFFFF;
+  GL_MAX_IMAGE_UNITS                = $8F38;
+  GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = $8F39;
+  GL_IMAGE_BINDING_NAME             = $8F3A;
+  GL_IMAGE_BINDING_LEVEL            = $8F3B;
+  GL_IMAGE_BINDING_LAYERED          = $8F3C;
+  GL_IMAGE_BINDING_LAYER            = $8F3D;
+  GL_IMAGE_BINDING_ACCESS           = $8F3E;
+  GL_IMAGE_1D                       = $904C;
+  GL_IMAGE_2D                       = $904D;
+  GL_IMAGE_3D                       = $904E;
+  GL_IMAGE_2D_RECT                  = $904F;
+  GL_IMAGE_CUBE                     = $9050;
+  GL_IMAGE_BUFFER                   = $9051;
+  GL_IMAGE_1D_ARRAY                 = $9052;
+  GL_IMAGE_2D_ARRAY                 = $9053;
+  GL_IMAGE_CUBE_MAP_ARRAY           = $9054;
+  GL_IMAGE_2D_MULTISAMPLE           = $9055;
+  GL_IMAGE_2D_MULTISAMPLE_ARRAY     = $9056;
+  GL_INT_IMAGE_1D                   = $9057;
+  GL_INT_IMAGE_2D                   = $9058;
+  GL_INT_IMAGE_3D                   = $9059;
+  GL_INT_IMAGE_2D_RECT              = $905A;
+  GL_INT_IMAGE_CUBE                 = $905B;
+  GL_INT_IMAGE_BUFFER               = $905C;
+  GL_INT_IMAGE_1D_ARRAY             = $905D;
+  GL_INT_IMAGE_2D_ARRAY             = $905E;
+  GL_INT_IMAGE_CUBE_MAP_ARRAY       = $905F;
+  GL_INT_IMAGE_2D_MULTISAMPLE       = $9060;
+  GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $9061;
+  GL_UNSIGNED_INT_IMAGE_1D          = $9062;
+  GL_UNSIGNED_INT_IMAGE_2D          = $9063;
+  GL_UNSIGNED_INT_IMAGE_3D          = $9064;
+  GL_UNSIGNED_INT_IMAGE_2D_RECT     = $9065;
+  GL_UNSIGNED_INT_IMAGE_CUBE        = $9066;
+  GL_UNSIGNED_INT_IMAGE_BUFFER      = $9067;
+  GL_UNSIGNED_INT_IMAGE_1D_ARRAY    = $9068;
+  GL_UNSIGNED_INT_IMAGE_2D_ARRAY    = $9069;
+  GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = $906A;
+  GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = $906B;
+  GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = $906C;
+  GL_MAX_IMAGE_SAMPLES              = $906D;
+  GL_IMAGE_BINDING_FORMAT           = $906E;
+  GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = $90C7;
+  GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = $90C8;
+  GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = $90C9;
+  GL_MAX_VERTEX_IMAGE_UNIFORMS      = $90CA;
+  GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS = $90CB;
+  GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = $90CC;
+  GL_MAX_GEOMETRY_IMAGE_UNIFORMS    = $90CD;
+  GL_MAX_FRAGMENT_IMAGE_UNIFORMS    = $90CE;
+  GL_MAX_COMBINED_IMAGE_UNIFORMS    = $90CF;
+
+  // GL_ARB_texture_storage
+  GL_TEXTURE_IMMUTABLE_FORMAT       = $912F;
+
+  // 4.3
+    GL_COMPRESSED_RGBA_ASTC_4x4_KHR = $93B0;
+    GL_COMPRESSED_RGBA_ASTC_5x4_KHR = $93B1;
+    GL_COMPRESSED_RGBA_ASTC_5x5_KHR = $93B2;
+    GL_COMPRESSED_RGBA_ASTC_6x5_KHR = $93B3;
+    GL_COMPRESSED_RGBA_ASTC_6x6_KHR = $93B4;
+    GL_COMPRESSED_RGBA_ASTC_8x5_KHR = $93B5;
+    GL_COMPRESSED_RGBA_ASTC_8x6_KHR = $93B6;
+    GL_COMPRESSED_RGBA_ASTC_8x8_KHR = $93B7;
+    GL_COMPRESSED_RGBA_ASTC_105_KHR = $93B8;
+    GL_COMPRESSED_RGBA_ASTC_106_KHR = $93B9;
+    GL_COMPRESSED_RGBA_ASTC_108_KHR = $93BA;
+    GL_COMPRESSED_RGBA_ASTC_110_KHR = $93BB;
+    GL_COMPRESSED_RGBA_ASTC_12x10_KHR = $93BC;
+    GL_COMPRESSED_RGBA_ASTC_12x12_KHR = $93BD;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = $93D0;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = $93D1;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = $93D2;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = $93D3;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = $93D4;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = $93D5;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = $93D6;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = $93D7;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = $93D8;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = $93D9;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = $93DA;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = $93DB;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = $93DC;
+    GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = $93DD;
+    // (4.3) GL_KHR_debug
+    GL_DEBUG_OUTPUT_SYNCHRONOUS       = $8242;
+    GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = $8243;
+    GL_DEBUG_CALLBACK_FUNCTION        = $8244;
+    GL_DEBUG_CALLBACK_USER_PARAM      = $8245;
+    GL_DEBUG_SOURCE_API               = $8246;
+    GL_DEBUG_SOURCE_WINDOW_SYSTEM     = $8247;
+    GL_DEBUG_SOURCE_SHADER_COMPILER   = $8248;
+    GL_DEBUG_SOURCE_THIRD_PARTY       = $8249;
+    GL_DEBUG_SOURCE_APPLICATION       = $824A;
+    GL_DEBUG_SOURCE_OTHER             = $824B;
+    GL_DEBUG_TYPE_ERROR               = $824C;
+    GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = $824D;
+    GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR  = $824E;
+    GL_DEBUG_TYPE_PORTABILITY         = $824F;
+    GL_DEBUG_TYPE_PERFORMANCE         = $8250;
+    GL_DEBUG_TYPE_OTHER               = $8251;
+    GL_DEBUG_TYPE_MARKER              = $8268;
+    GL_DEBUG_TYPE_PUSH_GROUP          = $8269;
+    GL_DEBUG_TYPE_POP_GROUP           = $826A;
+    GL_DEBUG_SEVERITY_NOTIFICATION    = $826B;
+    GL_MAX_DEBUG_GROUP_STACK_DEPTH    = $826C;
+    GL_DEBUG_GROUP_STACK_DEPTH        = $826D;
+    GL_BUFFER                         = $82E0;
+    GL_SHADER                         = $82E1;
+    GL_PROGRAM                        = $82E2;
+    GL_QUERY                          = $82E3;
+    GL_PROGRAM_PIPELINE               = $82E4;
+    GL_SAMPLER                        = $82E6;
+    GL_DISPLAY_LIST                   = $82E7;
+    GL_MAX_LABEL_LENGTH               = $82E8;
+    GL_MAX_DEBUG_MESSAGE_LENGTH       = $9143;
+    GL_MAX_DEBUG_LOGGED_MESSAGES      = $9144;
+    GL_DEBUG_LOGGED_MESSAGES          = $9145;
+    GL_DEBUG_SEVERITY_HIGH            = $9146;
+    GL_DEBUG_SEVERITY_MEDIUM          = $9147;
+    GL_DEBUG_SEVERITY_LOW             = $9148;
+    GL_DEBUG_OUTPUT                   = $92E0;
+    GL_CONTEXT_FLAG_DEBUG_BIT         = $00000002;
+    GL_COMPUTE_SHADER                 = $91B9;
+    GL_MAX_COMPUTE_UNIFORM_BLOCKS     = $91BB;
+    GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = $91BC;
+    GL_MAX_COMPUTE_IMAGE_UNIFORMS     = $91BD;
+    GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = $8262;
+    GL_MAX_COMPUTE_UNIFORM_COMPONENTS = $8263;
+    GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = $8264;
+    GL_MAX_COMPUTE_ATOMIC_COUNTERS    = $8265;
+    GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = $8266;
+    GL_MAX_COMPUTE_LOCAL_INVOCATIONS  = $90EB;
+    GL_MAX_COMPUTE_WORK_GROUP_COUNT   = $91BE;
+    GL_MAX_COMPUTE_WORK_GROUP_SIZE    = $91BF;
+    GL_COMPUTE_LOCAL_WORK_SIZE        = $8267;
+    GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = $90EC;
+    GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = $90ED;
+    GL_DISPATCH_INDIRECT_BUFFER       = $90EE;
+    GL_DISPATCH_INDIRECT_BUFFER_BINDING = $90EF;
+    GL_COMPUTE_SHADER_BIT             = $00000020;
+    GL_COMPRESSED_RGB8_ETC2           = $9274;
+    GL_COMPRESSED_SRGB8_ETC2          = $9275;
+    GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9276;
+    GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9277;
+    GL_COMPRESSED_RGBA8_ETC2_EAC      = $9278;
+    GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = $9279;
+    GL_COMPRESSED_R11_EAC             = $9270;
+    GL_COMPRESSED_SIGNED_R11_EAC      = $9271;
+    GL_COMPRESSED_RG11_EAC            = $9272;
+    GL_COMPRESSED_SIGNED_RG11_EAC     = $9273;
+    GL_PRIMITIVE_RESTART_FIXED_INDEX  = $8D69;
+    GL_ANY_SAMPLES_PASSED_CONSERVATIVE = $8D6A;
+    GL_MAX_ELEMENT_INDEX              = $8D6B;
+       GL_MAX_UNIFORM_LOCATIONS          = $826E;
+    GL_FRAMEBUFFER_DEFAULT_WIDTH      = $9310;
+    GL_FRAMEBUFFER_DEFAULT_HEIGHT     = $9311;
+    GL_FRAMEBUFFER_DEFAULT_LAYERS     = $9312;
+    GL_FRAMEBUFFER_DEFAULT_SAMPLES    = $9313;
+    GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = $9314;
+    GL_MAX_FRAMEBUFFER_WIDTH          = $9315;
+    GL_MAX_FRAMEBUFFER_HEIGHT         = $9316;
+    GL_MAX_FRAMEBUFFER_LAYERS         = $9317;
+    GL_MAX_FRAMEBUFFER_SAMPLES        = $9318;
+         GL_INTERNALFORMAT_SUPPORTED       = $826F;
+    GL_INTERNALFORMAT_PREFERRED       = $8270;
+    GL_INTERNALFORMAT_RED_SIZE        = $8271;
+    GL_INTERNALFORMAT_GREEN_SIZE      = $8272;
+    GL_INTERNALFORMAT_BLUE_SIZE       = $8273;
+    GL_INTERNALFORMAT_ALPHA_SIZE      = $8274;
+    GL_INTERNALFORMAT_DEPTH_SIZE      = $8275;
+    GL_INTERNALFORMAT_STENCIL_SIZE    = $8276;
+    GL_INTERNALFORMAT_SHARED_SIZE     = $8277;
+    GL_INTERNALFORMAT_RED_TYPE        = $8278;
+    GL_INTERNALFORMAT_GREEN_TYPE      = $8279;
+    GL_INTERNALFORMAT_BLUE_TYPE       = $827A;
+    GL_INTERNALFORMAT_ALPHA_TYPE      = $827B;
+    GL_INTERNALFORMAT_DEPTH_TYPE      = $827C;
+    GL_INTERNALFORMAT_STENCIL_TYPE    = $827D;
+    GL_MAX_WIDTH                      = $827E;
+    GL_MAX_HEIGHT                     = $827F;
+    GL_MAX_DEPTH                      = $8280;
+    GL_MAX_LAYERS                     = $8281;
+    GL_MAX_COMBINED_DIMENSIONS        = $8282;
+    GL_COLOR_COMPONENTS               = $8283;
+    GL_DEPTH_COMPONENTS               = $8284;
+    GL_STENCIL_COMPONENTS             = $8285;
+    GL_COLOR_RENDERABLE               = $8286;
+    GL_DEPTH_RENDERABLE               = $8287;
+    GL_STENCIL_RENDERABLE             = $8288;
+    GL_FRAMEBUFFER_RENDERABLE         = $8289;
+    GL_FRAMEBUFFER_RENDERABLE_LAYERED = $828A;
+    GL_FRAMEBUFFER_BLEND              = $828B;
+    GL_READ_PIXELS                    = $828C;
+    GL_READ_PIXELS_FORMAT             = $828D;
+    GL_READ_PIXELS_TYPE               = $828E;
+    GL_TEXTURE_IMAGE_FORMAT           = $828F;
+    GL_TEXTURE_IMAGE_TYPE             = $8290;
+    GL_GET_TEXTURE_IMAGE_FORMAT       = $8291;
+    GL_GET_TEXTURE_IMAGE_TYPE         = $8292;
+    GL_MIPMAP                         = $8293;
+    GL_MANUAL_GENERATE_MIPMAP         = $8294;
+    GL_AUTO_GENERATE_MIPMAP           = $8295;
+    GL_COLOR_ENCODING                 = $8296;
+    GL_SRGB_READ                      = $8297;
+    GL_SRGB_WRITE                     = $8298;
+    GL_SRGB_DECODE_ARB                = $8299;
+    GL_FILTER                         = $829A;
+    GL_VERTEX_TEXTURE                 = $829B;
+    GL_TESS_CONTROL_TEXTURE           = $829C;
+    GL_TESS_EVALUATION_TEXTURE        = $829D;
+    GL_GEOMETRY_TEXTURE               = $829E;
+    GL_FRAGMENT_TEXTURE               = $829F;
+    GL_COMPUTE_TEXTURE                = $82A0;
+    GL_TEXTURE_SHADOW                 = $82A1;
+    GL_TEXTURE_GATHER                 = $82A2;
+    GL_TEXTURE_GATHER_SHADOW          = $82A3;
+    GL_SHADER_IMAGE_LOAD              = $82A4;
+    GL_SHADER_IMAGE_STORE             = $82A5;
+    GL_SHADER_IMAGE_ATOMIC            = $82A6;
+    GL_IMAGE_TEXEL_SIZE               = $82A7;
+    GL_IMAGE_COMPATIBILITY_CLASS      = $82A8;
+    GL_IMAGE_PIXEL_FORMAT             = $82A9;
+    GL_IMAGE_PIXEL_TYPE               = $82AA;
+    GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = $82AC;
+    GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = $82AD;
+    GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = $82AE;
+    GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = $82AF;
+    GL_TEXTURE_COMPRESSED_BLOCK_WIDTH = $82B1;
+    GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT = $82B2;
+    GL_TEXTURE_COMPRESSED_BLOCK_SIZE  = $82B3;
+    GL_CLEAR_BUFFER                   = $82B4;
+    GL_TEXTURE_VIEW                   = $82B5;
+    GL_VIEW_COMPATIBILITY_CLASS       = $82B6;
+    GL_FULL_SUPPORT                   = $82B7;
+    GL_CAVEAT_SUPPORT                 = $82B8;
+    GL_IMAGE_CLASS_4_X_32             = $82B9;
+    GL_IMAGE_CLASS_2_X_32             = $82BA;
+    GL_IMAGE_CLASS_1_X_32             = $82BB;
+    GL_IMAGE_CLASS_4_X_16             = $82BC;
+    GL_IMAGE_CLASS_2_X_16             = $82BD;
+    GL_IMAGE_CLASS_1_X_16             = $82BE;
+    GL_IMAGE_CLASS_4_X_8              = $82BF;
+    GL_IMAGE_CLASS_2_X_8              = $82C0;
+    GL_IMAGE_CLASS_1_X_8              = $82C1;
+    GL_IMAGE_CLASS_11_11_10           = $82C2;
+    GL_IMAGE_CLASS_10_10_10_2         = $82C3;
+    GL_VIEW_CLASS_128_BITS            = $82C4;
+    GL_VIEW_CLASS_96_BITS             = $82C5;
+    GL_VIEW_CLASS_64_BITS             = $82C6;
+    GL_VIEW_CLASS_48_BITS             = $82C7;
+    GL_VIEW_CLASS_32_BITS             = $82C8;
+    GL_VIEW_CLASS_24_BITS             = $82C9;
+    GL_VIEW_CLASS_16_BITS             = $82CA;
+    GL_VIEW_CLASS_8_BITS              = $82CB;
+    GL_VIEW_CLASS_S3TC_DXT1_RGB       = $82CC;
+    GL_VIEW_CLASS_S3TC_DXT1_RGBA      = $82CD;
+    GL_VIEW_CLASS_S3TC_DXT3_RGBA      = $82CE;
+    GL_VIEW_CLASS_S3TC_DXT5_RGBA      = $82CF;
+    GL_VIEW_CLASS_RGTC1_RED           = $82D0;
+    GL_VIEW_CLASS_RGTC2_RG            = $82D1;
+    GL_VIEW_CLASS_BPTC_UNORM          = $82D2;
+    GL_VIEW_CLASS_BPTC_FLOAT          = $82D3;
+    GL_UNIFORM                        = $92E1;
+    GL_UNIFORM_BLOCK                  = $92E2;
+    GL_PROGRAM_INPUT                  = $92E3;
+    GL_PROGRAM_OUTPUT                 = $92E4;
+    GL_BUFFER_VARIABLE                = $92E5;
+    GL_SHADER_STORAGE_BLOCK           = $92E6;
+    GL_VERTEX_SUBROUTINE              = $92E8;
+    GL_TESS_CONTROL_SUBROUTINE        = $92E9;
+    GL_TESS_EVALUATION_SUBROUTINE     = $92EA;
+    GL_GEOMETRY_SUBROUTINE            = $92EB;
+    GL_FRAGMENT_SUBROUTINE            = $92EC;
+    GL_COMPUTE_SUBROUTINE             = $92ED;
+    GL_VERTEX_SUBROUTINE_UNIFORM      = $92EE;
+    GL_TESS_CONTROL_SUBROUTINE_UNIFORM = $92EF;
+    GL_TESS_EVALUATION_SUBROUTINE_UNIFORM = $92F0;
+    GL_GEOMETRY_SUBROUTINE_UNIFORM    = $92F1;
+    GL_FRAGMENT_SUBROUTINE_UNIFORM    = $92F2;
+    GL_COMPUTE_SUBROUTINE_UNIFORM     = $92F3;
+    GL_TRANSFORM_FEEDBACK_VARYING     = $92F4;
+    GL_ACTIVE_RESOURCES               = $92F5;
+    GL_MAX_NAME_LENGTH                = $92F6;
+    GL_MAX_NUM_ACTIVE_VARIABLES       = $92F7;
+    GL_MAX_NUM_COMPATIBLE_SUBROUTINES = $92F8;
+    GL_NAME_LENGTH                    = $92F9;
+    GL_TYPE                           = $92FA;
+    GL_ARRAY_SIZE                     = $92FB;
+    GL_OFFSET                         = $92FC;
+    GL_BLOCK_INDEX                    = $92FD;
+    GL_ARRAY_STRIDE                   = $92FE;
+    GL_MATRIX_STRIDE                  = $92FF;
+    GL_IS_ROW_MAJOR                   = $9300;
+    GL_ATOMIC_COUNTER_BUFFER_INDEX    = $9301;
+    GL_BUFFER_BINDING                 = $9302;
+    GL_BUFFER_DATA_SIZE               = $9303;
+    GL_NUM_ACTIVE_VARIABLES           = $9304;
+    GL_ACTIVE_VARIABLES               = $9305;
+    GL_REFERENCED_BY_VERTEX_SHADER    = $9306;
+    GL_REFERENCED_BY_TESS_CONTROL_SHADER = $9307;
+    GL_REFERENCED_BY_TESS_EVALUATION_SHADER = $9308;
+    GL_REFERENCED_BY_GEOMETRY_SHADER  = $9309;
+    GL_REFERENCED_BY_FRAGMENT_SHADER  = $930A;
+    GL_REFERENCED_BY_COMPUTE_SHADER   = $930B;
+    GL_TOP_LEVEL_ARRAY_SIZE           = $930C;
+    GL_TOP_LEVEL_ARRAY_STRIDE         = $930D;
+    GL_LOCATION                       = $930E;
+    GL_LOCATION_INDEX                 = $930F;
+    GL_IS_PER_PATCH                   = $92E7;
+    GL_SHADER_STORAGE_BUFFER          = $90D2;
+    GL_SHADER_STORAGE_BUFFER_BINDING  = $90D3;
+    GL_SHADER_STORAGE_BUFFER_START    = $90D4;
+    GL_SHADER_STORAGE_BUFFER_SIZE     = $90D5;
+    GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = $90D6;
+    GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = $90D7;
+    GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = $90D8;
+    GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = $90D9;
+    GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = $90DA;
+    GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = $90DB;
+    GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = $90DC;
+    GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = $90DD;
+    GL_MAX_SHADER_STORAGE_BLOCK_SIZE  = $90DE;
+    GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = $90DF;
+    GL_SHADER_STORAGE_BARRIER_BIT     = $2000;
+    GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS;
+    GL_DEPTH_STENCIL_TEXTURE_MODE     = $90EA;
+    GL_TEXTURE_BUFFER_OFFSET          = $919D;
+    GL_TEXTURE_BUFFER_SIZE            = $919E;
+    GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT = $919F;
+    GL_TEXTURE_VIEW_MIN_LEVEL         = $82DB;
+    GL_TEXTURE_VIEW_NUM_LEVELS        = $82DC;
+    GL_TEXTURE_VIEW_MIN_LAYER         = $82DD;
+    GL_TEXTURE_VIEW_NUM_LAYERS        = $82DE;
+    GL_TEXTURE_IMMUTABLE_LEVELS       = $82DF;
+    GL_VERTEX_ATTRIB_BINDING          = $82D4;
+    GL_VERTEX_ATTRIB_RELATIVE_OFFSET  = $82D5;
+    GL_VERTEX_BINDING_DIVISOR         = $82D6;
+    GL_VERTEX_BINDING_OFFSET          = $82D7;
+    GL_VERTEX_BINDING_STRIDE          = $82D8;
+    GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D9;
+    GL_MAX_VERTEX_ATTRIB_BINDINGS     = $82DA;
+       // END 4.3
+
+  // GL 4.4
+    GL_MAX_VERTEX_ATTRIB_STRIDE         = $82E5;
+    GL_MAP_PERSISTENT_BIT               = $0040;
+    GL_MAP_COHERENT_BIT                 = $0080;
+    GL_DYNAMIC_STORAGE_BIT              = $0100;
+    GL_CLIENT_STORAGE_BIT               = $0200;
+    GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT = $00004000;
+    GL_BUFFER_IMMUTABLE_STORAGE        = $821F;
+    GL_BUFFER_STORAGE_FLAGS            = $8220;
+    GL_CLEAR_TEXTURE                   = $9365;
+    GL_LOCATION_COMPONENT              = $934A;
+    GL_TRANSFORM_FEEDBACK_BUFFER_INDEX         = $934B;
+    GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE = $934C;
+    GL_QUERY_BUFFER                    = $9192;
+    GL_QUERY_BUFFER_BARRIER_BIT        = $00008000;
+    GL_QUERY_BUFFER_BINDING            = $9193;
+    GL_QUERY_RESULT_NO_WAIT            = $9194;
+    GL_MIRROR_CLAMP_TO_EDGE            = $8743;
+  // END GL 4.4
+
+  // GL_ATI_draw_buffers
+  GL_MAX_DRAW_BUFFERS_ATI = $8824;
+  GL_DRAW_BUFFER0_ATI = $8825;
+  GL_DRAW_BUFFER1_ATI = $8826;
+  GL_DRAW_BUFFER2_ATI = $8827;
+  GL_DRAW_BUFFER3_ATI = $8828;
+  GL_DRAW_BUFFER4_ATI = $8829;
+  GL_DRAW_BUFFER5_ATI = $882A;
+  GL_DRAW_BUFFER6_ATI = $882B;
+  GL_DRAW_BUFFER7_ATI = $882C;
+  GL_DRAW_BUFFER8_ATI = $882D;
+  GL_DRAW_BUFFER9_ATI = $882E;
+  GL_DRAW_BUFFER10_ATI = $882F;
+  GL_DRAW_BUFFER11_ATI = $8830;
+  GL_DRAW_BUFFER12_ATI = $8831;
+  GL_DRAW_BUFFER13_ATI = $8832;
+  GL_DRAW_BUFFER14_ATI = $8833;
+  GL_DRAW_BUFFER15_ATI = $8834;
+
+  // GL_ATI_element_array
+  GL_ELEMENT_ARRAY_ATI = $8768;
+  GL_ELEMENT_ARRAY_TYPE_ATI = $8769;
+  GL_ELEMENT_ARRAY_POINTER_ATI = $876A;
+
+  // GL_ATI_envmap_bumpmap
+  GL_BUMP_ROT_MATRIX_ATI = $8775;
+  GL_BUMP_ROT_MATRIX_SIZE_ATI = $8776;
+  GL_BUMP_NUM_TEX_UNITS_ATI = $8777;
+  GL_BUMP_TEX_UNITS_ATI = $8778;
+  GL_DUDV_ATI = $8779;
+  GL_DU8DV8_ATI = $877A;
+  GL_BUMP_ENVMAP_ATI = $877B;
+  GL_BUMP_TARGET_ATI = $877C;
+
+  // GL_ATI_fragment_shader
+  GL_FRAGMENT_SHADER_ATI = $8920;
+  GL_REG_0_ATI = $8921;
+  GL_REG_1_ATI = $8922;
+  GL_REG_2_ATI = $8923;
+  GL_REG_3_ATI = $8924;
+  GL_REG_4_ATI = $8925;
+  GL_REG_5_ATI = $8926;
+  GL_REG_6_ATI = $8927;
+  GL_REG_7_ATI = $8928;
+  GL_REG_8_ATI = $8929;
+  GL_REG_9_ATI = $892A;
+  GL_REG_10_ATI = $892B;
+  GL_REG_11_ATI = $892C;
+  GL_REG_12_ATI = $892D;
+  GL_REG_13_ATI = $892E;
+  GL_REG_14_ATI = $892F;
+  GL_REG_15_ATI = $8930;
+  GL_REG_16_ATI = $8931;
+  GL_REG_17_ATI = $8932;
+  GL_REG_18_ATI = $8933;
+  GL_REG_19_ATI = $8934;
+  GL_REG_20_ATI = $8935;
+  GL_REG_21_ATI = $8936;
+  GL_REG_22_ATI = $8937;
+  GL_REG_23_ATI = $8938;
+  GL_REG_24_ATI = $8939;
+  GL_REG_25_ATI = $893A;
+  GL_REG_26_ATI = $893B;
+  GL_REG_27_ATI = $893C;
+  GL_REG_28_ATI = $893D;
+  GL_REG_29_ATI = $893E;
+  GL_REG_30_ATI = $893F;
+  GL_REG_31_ATI = $8940;
+  GL_CON_0_ATI = $8941;
+  GL_CON_1_ATI = $8942;
+  GL_CON_2_ATI = $8943;
+  GL_CON_3_ATI = $8944;
+  GL_CON_4_ATI = $8945;
+  GL_CON_5_ATI = $8946;
+  GL_CON_6_ATI = $8947;
+  GL_CON_7_ATI = $8948;
+  GL_CON_8_ATI = $8949;
+  GL_CON_9_ATI = $894A;
+  GL_CON_10_ATI = $894B;
+  GL_CON_11_ATI = $894C;
+  GL_CON_12_ATI = $894D;
+  GL_CON_13_ATI = $894E;
+  GL_CON_14_ATI = $894F;
+  GL_CON_15_ATI = $8950;
+  GL_CON_16_ATI = $8951;
+  GL_CON_17_ATI = $8952;
+  GL_CON_18_ATI = $8953;
+  GL_CON_19_ATI = $8954;
+  GL_CON_20_ATI = $8955;
+  GL_CON_21_ATI = $8956;
+  GL_CON_22_ATI = $8957;
+  GL_CON_23_ATI = $8958;
+  GL_CON_24_ATI = $8959;
+  GL_CON_25_ATI = $895A;
+  GL_CON_26_ATI = $895B;
+  GL_CON_27_ATI = $895C;
+  GL_CON_28_ATI = $895D;
+  GL_CON_29_ATI = $895E;
+  GL_CON_30_ATI = $895F;
+  GL_CON_31_ATI = $8960;
+  GL_MOV_ATI = $8961;
+  GL_ADD_ATI = $8963;
+  GL_MUL_ATI = $8964;
+  GL_SUB_ATI = $8965;
+  GL_DOT3_ATI = $8966;
+  GL_DOT4_ATI = $8967;
+  GL_MAD_ATI = $8968;
+  GL_LERP_ATI = $8969;
+  GL_CND_ATI = $896A;
+  GL_CND0_ATI = $896B;
+  GL_DOT2_ADD_ATI = $896C;
+  GL_SECONDARY_INTERPOLATOR_ATI = $896D;
+  GL_NUM_FRAGMENT_REGISTERS_ATI = $896E;
+  GL_NUM_FRAGMENT_CONSTANTS_ATI = $896F;
+  GL_NUM_PASSES_ATI = $8970;
+  GL_NUM_INSTRUCTIONS_PER_PASS_ATI = $8971;
+  GL_NUM_INSTRUCTIONS_TOTAL_ATI = $8972;
+  GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = $8973;
+  GL_NUM_LOOPBACK_COMPONENTS_ATI = $8974;
+  GL_COLOR_ALPHA_PAIRING_ATI = $8975;
+  GL_SWIZZLE_STR_ATI = $8976;
+  GL_SWIZZLE_STQ_ATI = $8977;
+  GL_SWIZZLE_STR_DR_ATI = $8978;
+  GL_SWIZZLE_STQ_DQ_ATI = $8979;
+  GL_SWIZZLE_STRQ_ATI = $897A;
+  GL_SWIZZLE_STRQ_DQ_ATI = $897B;
+  GL_RED_BIT_ATI = $00000001;
+  GL_GREEN_BIT_ATI = $00000002;
+  GL_BLUE_BIT_ATI = $00000004;
+  GL_2X_BIT_ATI = $00000001;
+  GL_4X_BIT_ATI = $00000002;
+  GL_8X_BIT_ATI = $00000004;
+  GL_HALF_BIT_ATI = $00000008;
+  GL_QUARTER_BIT_ATI = $00000010;
+  GL_EIGHTH_BIT_ATI = $00000020;
+  GL_SATURATE_BIT_ATI = $00000040;
+  GL_COMP_BIT_ATI = $00000002;
+  GL_NEGATE_BIT_ATI = $00000004;
+  GL_BIAS_BIT_ATI = $00000008;
+
+  // GL_ATI_pn_triangles
+  GL_PN_TRIANGLES_ATI = $87F0;
+  GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F1;
+  GL_PN_TRIANGLES_POINT_MODE_ATI = $87F2;
+  GL_PN_TRIANGLES_NORMAL_MODE_ATI = $87F3;
+  GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI = $87F4;
+  GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = $87F5;
+  GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = $87F6;
+  GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = $87F7;
+  GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = $87F8;
+
+  // GL_ATI_separate_stencil
+  GL_STENCIL_BACK_FUNC_ATI = $8800;
+  GL_STENCIL_BACK_FAIL_ATI = $8801;
+  GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = $8802;
+  GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI = $8803;
+
+  // GL_ATI_text_fragment_shader
+  GL_TEXT_FRAGMENT_SHADER_ATI = $8200;
+
+  // GL_ATI_texture_env_combine3
+  GL_MODULATE_ADD_ATI = $8744;
+  GL_MODULATE_SIGNED_ADD_ATI = $8745;
+  GL_MODULATE_SUBTRACT_ATI = $8746;
+
+  // GL_ATI_texture_float
+  GL_RGBA_FLOAT32_ATI = $8814;
+  GL_RGB_FLOAT32_ATI = $8815;
+  GL_ALPHA_FLOAT32_ATI = $8816;
+  GL_INTENSITY_FLOAT32_ATI = $8817;
+  GL_LUMINANCE_FLOAT32_ATI = $8818;
+  GL_LUMINANCE_ALPHA_FLOAT32_ATI = $8819;
+  GL_RGBA_FLOAT16_ATI = $881A;
+  GL_RGB_FLOAT16_ATI = $881B;
+  GL_ALPHA_FLOAT16_ATI = $881C;
+  GL_INTENSITY_FLOAT16_ATI = $881D;
+  GL_LUMINANCE_FLOAT16_ATI = $881E;
+  GL_LUMINANCE_ALPHA_FLOAT16_ATI = $881F;
+
+  // GL_ATI_texture_mirror_once
+  GL_MIRROR_CLAMP_ATI = $8742;
+  GL_MIRROR_CLAMP_TO_EDGE_ATI = $8743;
+
+  // GL_ATI_vertex_array_object
+  GL_STATIC_ATI = $8760;
+  GL_DYNAMIC_ATI = $8761;
+  GL_PRESERVE_ATI = $8762;
+  GL_DISCARD_ATI = $8763;
+  GL_OBJECT_BUFFER_SIZE_ATI = $8764;
+  GL_OBJECT_BUFFER_USAGE_ATI = $8765;
+  GL_ARRAY_OBJECT_BUFFER_ATI = $8766;
+  GL_ARRAY_OBJECT_OFFSET_ATI = $8767;
+
+  // GL_ATI_vertex_streams
+  GL_MAX_VERTEX_STREAMS_ATI = $876B;
+  GL_VERTEX_STREAM0_ATI = $876C;
+  GL_VERTEX_STREAM1_ATI = $876D;
+  GL_VERTEX_STREAM2_ATI = $876E;
+  GL_VERTEX_STREAM3_ATI = $876F;
+  GL_VERTEX_STREAM4_ATI = $8770;
+  GL_VERTEX_STREAM5_ATI = $8771;
+  GL_VERTEX_STREAM6_ATI = $8772;
+  GL_VERTEX_STREAM7_ATI = $8773;
+  GL_VERTEX_SOURCE_ATI = $8774;
+
+  // GL_ATI_meminfo
+  GL_VBO_FREE_MEMORY_ATI = $87FB;
+  GL_TEXTURE_FREE_MEMORY_ATI = $87FC;
+  GL_RENDERBUFFER_FREE_MEMORY_ATI = $87FD;
+
+  // GL_AMD_performance_monitor
+  GL_COUNTER_TYPE_AMD = $8BC0;
+  GL_COUNTER_RANGE_AMD = $8BC1;
+  GL_UNSIGNED_INT64_AMD = $8BC2;
+  GL_PERCENTAGE_AMD = $8BC3;
+  GL_PERFMON_RESULT_AVAILABLE_AMD = $8BC4;
+  GL_PERFMON_RESULT_SIZE_AMD = $8BC5;
+  GL_PERFMON_RESULT_AMD = $8BC6;
+  
+  // GL_AMD_vertex_shader_tesselator
+  GL_SAMPLER_BUFFER_AMD = $9001;
+  GL_INT_SAMPLER_BUFFER_AMD = $9002;
+  GL_UNSIGNED_INT_SAMPLER_BUFFER_AMD = $9003;
+  GL_TESSELLATION_MODE_AMD = $9004;
+  GL_TESSELLATION_FACTOR_AMD = $9005;
+  GL_DISCRETE_AMD = $9006;
+  GL_CONTINUOUS_AMD = $9007;
+
+  // GL_AMD_seamless_cubemap_per_texture
+  { reuse GL_TEXTURE_CUBE_MAP_SEAMLESS }
+
+  // GL_AMD_name_gen_delete
+  GL_DATA_BUFFER_AMD = $9151;
+  GL_PERFORMANCE_MONITOR_AMD = $9152;
+  GL_QUERY_OBJECT_AMD = $9153;
+  GL_VERTEX_ARRAY_OBJECT_AMD = $9154;
+  GL_SAMPLER_OBJECT_AMD = $9155;
+
+  // GL_AMD_debug_output
+  GL_MAX_DEBUG_LOGGED_MESSAGES_AMD = $9144;
+  GL_DEBUG_LOGGED_MESSAGES_AMD = $9145;
+  GL_DEBUG_SEVERITY_HIGH_AMD = $9146;
+  GL_DEBUG_SEVERITY_MEDIUM_AMD = $9147;
+  GL_DEBUG_SEVERITY_LOW_AMD = $9148;
+  GL_DEBUG_CATEGORY_API_ERROR_AMD = $9149;
+  GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = $914A;
+  GL_DEBUG_CATEGORY_DEPRECATION_AMD = $914B;
+  GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = $914C;
+  GL_DEBUG_CATEGORY_PERFORMANCE_AMD = $914D;
+  GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD = $914E;
+  GL_DEBUG_CATEGORY_APPLICATION_AMD = $914F;
+  GL_DEBUG_CATEGORY_OTHER_AMD = $9150;
+
+  // GL_AMD_depth_clamp_separate
+  GL_DEPTH_CLAMP_NEAR_AMD = $901E;
+  GL_DEPTH_CLAMP_FAR_AMD = $901F;
+
+  // GL_EXT_422_pixels
+  GL_422_EXT = $80CC;
+  GL_422_REV_EXT = $80CD;
+  GL_422_AVERAGE_EXT = $80CE;
+  GL_422_REV_AVERAGE_EXT = $80CF;
+
+  // GL_EXT_abgr
+  GL_ABGR_EXT = $8000;
+
+  // GL_EXT_bgra
+  GL_BGR_EXT = $80E0;
+  GL_BGRA_EXT = $80E1;
+
+  // GL_EXT_blend_color
+  GL_CONSTANT_COLOR_EXT = $8001;
+  GL_ONE_MINUS_CONSTANT_COLOR_EXT = $8002;
+  GL_CONSTANT_ALPHA_EXT = $8003;
+  GL_ONE_MINUS_CONSTANT_ALPHA_EXT = $8004;
+  GL_BLEND_COLOR_EXT = $8005;
+
+  // GL_EXT_blend_func_separate
+  GL_BLEND_DST_RGB_EXT = $80C8;
+  GL_BLEND_SRC_RGB_EXT = $80C9;
+  GL_BLEND_DST_ALPHA_EXT = $80CA;
+  GL_BLEND_SRC_ALPHA_EXT = $80CB;
+
+  // GL_EXT_blend_minmax
+  GL_FUNC_ADD_EXT = $8006;
+  GL_MIN_EXT = $8007;
+  GL_MAX_EXT = $8008;
+  GL_BLEND_EQUATION_EXT = $8009;
+
+  // GL_EXT_blend_subtract
+  GL_FUNC_SUBTRACT_EXT = $800A;
+  GL_FUNC_REVERSE_SUBTRACT_EXT = $800B;
+
+  // GL_EXT_clip_volume_hint
+  GL_CLIP_VOLUME_CLIPPING_HINT_EXT = $80F0;
+
+  // GL_EXT_cmyka
+  GL_CMYK_EXT = $800C;
+  GL_CMYKA_EXT = $800D;
+  GL_PACK_CMYK_HINT_EXT = $800E;
+  GL_UNPACK_CMYK_HINT_EXT = $800F;
+
+  // GL_EXT_compiled_vertex_array
+  GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = $81A8;
+  GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = $81A9;
+
+  // GL_EXT_convolution
+  GL_CONVOLUTION_1D_EXT = $8010;
+  GL_CONVOLUTION_2D_EXT = $8011;
+  GL_SEPARABLE_2D_EXT = $8012;
+  GL_CONVOLUTION_BORDER_MODE_EXT = $8013;
+  GL_CONVOLUTION_FILTER_SCALE_EXT = $8014;
+  GL_CONVOLUTION_FILTER_BIAS_EXT = $8015;
+  GL_REDUCE_EXT = $8016;
+  GL_CONVOLUTION_FORMAT_EXT = $8017;
+  GL_CONVOLUTION_WIDTH_EXT = $8018;
+  GL_CONVOLUTION_HEIGHT_EXT = $8019;
+  GL_MAX_CONVOLUTION_WIDTH_EXT = $801A;
+  GL_MAX_CONVOLUTION_HEIGHT_EXT = $801B;
+  GL_POST_CONVOLUTION_RED_SCALE_EXT = $801C;
+  GL_POST_CONVOLUTION_GREEN_SCALE_EXT = $801D;
+  GL_POST_CONVOLUTION_BLUE_SCALE_EXT = $801E;
+  GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = $801F;
+  GL_POST_CONVOLUTION_RED_BIAS_EXT = $8020;
+  GL_POST_CONVOLUTION_GREEN_BIAS_EXT = $8021;
+  GL_POST_CONVOLUTION_BLUE_BIAS_EXT = $8022;
+  GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = $8023;
+
+  // GL_EXT_coordinate_frame
+  GL_TANGENT_ARRAY_EXT = $8439;
+  GL_BINORMAL_ARRAY_EXT = $843A;
+  GL_CURRENT_TANGENT_EXT = $843B;
+  GL_CURRENT_BINORMAL_EXT = $843C;
+  GL_TANGENT_ARRAY_TYPE_EXT = $843E;
+  GL_TANGENT_ARRAY_STRIDE_EXT = $843F;
+  GL_BINORMAL_ARRAY_TYPE_EXT = $8440;
+  GL_BINORMAL_ARRAY_STRIDE_EXT = $8441;
+  GL_TANGENT_ARRAY_POINTER_EXT = $8442;
+  GL_BINORMAL_ARRAY_POINTER_EXT = $8443;
+  GL_MAP1_TANGENT_EXT = $8444;
+  GL_MAP2_TANGENT_EXT = $8445;
+  GL_MAP1_BINORMAL_EXT = $8446;
+  GL_MAP2_BINORMAL_EXT = $8447;
+
+  // GL_EXT_cull_vertex
+  GL_CULL_VERTEX_EXT = $81AA;
+  GL_CULL_VERTEX_EYE_POSITION_EXT = $81AB;
+  GL_CULL_VERTEX_OBJECT_POSITION_EXT = $81AC;
+
+  // GL_EXT_draw_range_elements
+  GL_MAX_ELEMENTS_VERTICES_EXT = $80E8;
+  GL_MAX_ELEMENTS_INDICES_EXT = $80E9;
+
+  // GL_EXT_fog_coord
+  GL_FOG_COORDINATE_SOURCE_EXT = $8450;
+  GL_FOG_COORDINATE_EXT = $8451;
+  GL_FRAGMENT_DEPTH_EXT = $8452;
+  GL_CURRENT_FOG_COORDINATE_EXT = $8453;
+  GL_FOG_COORDINATE_ARRAY_TYPE_EXT = $8454;
+  GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = $8455;
+  GL_FOG_COORDINATE_ARRAY_POINTER_EXT = $8456;
+  GL_FOG_COORDINATE_ARRAY_EXT = $8457;
+
+  // GL_EXT_framebuffer_object
+  GL_FRAMEBUFFER_EXT = $8D40;
+  GL_RENDERBUFFER_EXT = $8D41;
+  GL_STENCIL_INDEX_EXT = $8D45;
+  GL_STENCIL_INDEX1_EXT = $8D46;
+  GL_STENCIL_INDEX4_EXT = $8D47;
+  GL_STENCIL_INDEX8_EXT = $8D48;
+  GL_STENCIL_INDEX16_EXT = $8D49;
+  GL_RENDERBUFFER_WIDTH_EXT = $8D42;
+  GL_RENDERBUFFER_HEIGHT_EXT = $8D43;
+  GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = $8D44;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = $8CD0;
+  GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = $8CD1;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = $8CD2;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = $8CD3;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = $8CD4;
+  GL_COLOR_ATTACHMENT0_EXT = $8CE0;
+  GL_COLOR_ATTACHMENT1_EXT = $8CE1;
+  GL_COLOR_ATTACHMENT2_EXT = $8CE2;
+  GL_COLOR_ATTACHMENT3_EXT = $8CE3;
+  GL_COLOR_ATTACHMENT4_EXT = $8CE4;
+  GL_COLOR_ATTACHMENT5_EXT = $8CE5;
+  GL_COLOR_ATTACHMENT6_EXT = $8CE6;
+  GL_COLOR_ATTACHMENT7_EXT = $8CE7;
+  GL_COLOR_ATTACHMENT8_EXT = $8CE8;
+  GL_COLOR_ATTACHMENT9_EXT = $8CE9;
+  GL_COLOR_ATTACHMENT10_EXT = $8CEA;
+  GL_COLOR_ATTACHMENT11_EXT = $8CEB;
+  GL_COLOR_ATTACHMENT12_EXT = $8CEC;
+  GL_COLOR_ATTACHMENT13_EXT = $8CED;
+  GL_COLOR_ATTACHMENT14_EXT = $8CEE;
+  GL_COLOR_ATTACHMENT15_EXT = $8CEF;
+  GL_DEPTH_ATTACHMENT_EXT = $8D00;
+  GL_STENCIL_ATTACHMENT_EXT = $8D20;
+  GL_FRAMEBUFFER_COMPLETE_EXT = $8CD5;
+  GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = $8CD6;
+  GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = $8CD7;
+  GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT = $8CD8;
+  GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = $8CD9;
+  GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = $8CDA;
+  GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = $8CDB;
+  GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = $8CDC;
+  GL_FRAMEBUFFER_UNSUPPORTED_EXT = $8CDD;
+  GL_FRAMEBUFFER_STATUS_ERROR_EXT = $8CDE;
+  GL_FRAMEBUFFER_BINDING_EXT = $8CA6;
+  GL_RENDERBUFFER_BINDING_EXT = $8CA7;
+  GL_MAX_COLOR_ATTACHMENTS_EXT = $8CDF;
+  GL_MAX_RENDERBUFFER_SIZE_EXT = $84E8;
+  GL_INVALID_FRAMEBUFFER_OPERATION_EXT = $0506;
+
+  // GL_EXT_histogram
+  GL_HISTOGRAM_EXT = $8024;
+  GL_PROXY_HISTOGRAM_EXT = $8025;
+  GL_HISTOGRAM_WIDTH_EXT = $8026;
+  GL_HISTOGRAM_FORMAT_EXT = $8027;
+  GL_HISTOGRAM_RED_SIZE_EXT = $8028;
+  GL_HISTOGRAM_GREEN_SIZE_EXT = $8029;
+  GL_HISTOGRAM_BLUE_SIZE_EXT = $802A;
+  GL_HISTOGRAM_ALPHA_SIZE_EXT = $802B;
+  GL_HISTOGRAM_LUMINANCE_SIZE_EXT = $802C;
+  GL_HISTOGRAM_SINK_EXT = $802D;
+  GL_MINMAX_EXT = $802E;
+  GL_MINMAX_FORMAT_EXT = $802F;
+  GL_MINMAX_SINK_EXT = $8030;
+  GL_TABLE_TOO_LARGE_EXT = $8031;
+
+  // GL_EXT_index_array_formats
+  GL_IUI_V2F_EXT = $81AD;
+  GL_IUI_V3F_EXT = $81AE;
+  GL_IUI_N3F_V2F_EXT = $81AF;
+  GL_IUI_N3F_V3F_EXT = $81B0;
+  GL_T2F_IUI_V2F_EXT = $81B1;
+  GL_T2F_IUI_V3F_EXT = $81B2;
+  GL_T2F_IUI_N3F_V2F_EXT = $81B3;
+  GL_T2F_IUI_N3F_V3F_EXT = $81B4;
+
+  // GL_EXT_index_func
+  GL_INDEX_TEST_EXT = $81B5;
+  GL_INDEX_TEST_FUNC_EXT = $81B6;
+  GL_INDEX_TEST_REF_EXT = $81B7;
+
+  // GL_EXT_index_material
+  GL_INDEX_MATERIAL_EXT = $81B8;
+  GL_INDEX_MATERIAL_PARAMETER_EXT = $81B9;
+  GL_INDEX_MATERIAL_FACE_EXT = $81BA;
+
+  // GL_EXT_light_texture
+  GL_FRAGMENT_MATERIAL_EXT = $8349;
+  GL_FRAGMENT_NORMAL_EXT = $834A;
+  GL_FRAGMENT_COLOR_EXT = $834C;
+  GL_ATTENUATION_EXT = $834D;
+  GL_SHADOW_ATTENUATION_EXT = $834E;
+  GL_TEXTURE_APPLICATION_MODE_EXT = $834F;
+  GL_TEXTURE_LIGHT_EXT = $8350;
+  GL_TEXTURE_MATERIAL_FACE_EXT = $8351;
+  GL_TEXTURE_MATERIAL_PARAMETER_EXT = $8352;
+
+  // GL_EXT_multisample
+  GL_MULTISAMPLE_EXT = $809D;
+  GL_SAMPLE_ALPHA_TO_MASK_EXT = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE_EXT = $809F;
+  GL_SAMPLE_MASK_EXT = $80A0;
+  GL_1PASS_EXT = $80A1;
+  GL_2PASS_0_EXT = $80A2;
+  GL_2PASS_1_EXT = $80A3;
+  GL_4PASS_0_EXT = $80A4;
+  GL_4PASS_1_EXT = $80A5;
+  GL_4PASS_2_EXT = $80A6;
+  GL_4PASS_3_EXT = $80A7;
+  GL_SAMPLE_BUFFERS_EXT = $80A8;
+  GL_SAMPLES_EXT = $80A9;
+  GL_SAMPLE_MASK_VALUE_EXT = $80AA;
+  GL_SAMPLE_MASK_INVERT_EXT = $80AB;
+  GL_SAMPLE_PATTERN_EXT = $80AC;
+  GL_MULTISAMPLE_BIT_EXT = $20000000;
+
+  // GL_EXT_packed_pixels
+  GL_UNSIGNED_BYTE_3_3_2_EXT = $8032;
+  GL_UNSIGNED_SHORT_4_4_4_4_EXT = $8033;
+  GL_UNSIGNED_SHORT_5_5_5_1_EXT = $8034;
+  GL_UNSIGNED_INT_8_8_8_8_EXT = $8035;
+  GL_UNSIGNED_INT_10_10_10_2_EXT = $8036;
+
+  // GL_EXT_paletted_texture
+  GL_COLOR_INDEX1_EXT = $80E2;
+  GL_COLOR_INDEX2_EXT = $80E3;
+  GL_COLOR_INDEX4_EXT = $80E4;
+  GL_COLOR_INDEX8_EXT = $80E5;
+  GL_COLOR_INDEX12_EXT = $80E6;
+  GL_COLOR_INDEX16_EXT = $80E7;
+  GL_TEXTURE_INDEX_SIZE_EXT = $80ED;
+
+  // GL_EXT_pixel_transform
+  GL_PIXEL_TRANSFORM_2D_EXT = $8330;
+  GL_PIXEL_MAG_FILTER_EXT = $8331;
+  GL_PIXEL_MIN_FILTER_EXT = $8332;
+  GL_PIXEL_CUBIC_WEIGHT_EXT = $8333;
+  GL_CUBIC_EXT = $8334;
+  GL_AVERAGE_EXT = $8335;
+  GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8336;
+  GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = $8337;
+  GL_PIXEL_TRANSFORM_2D_MATRIX_EXT = $8338;
+
+  // GL_EXT_point_parameters
+  GL_POINT_SIZE_MIN_EXT = $8126;
+  GL_POINT_SIZE_MAX_EXT = $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE_EXT = $8128;
+  GL_DISTANCE_ATTENUATION_EXT = $8129;
+
+  // GL_EXT_polygon_offset
+  GL_POLYGON_OFFSET_EXT = $8037;
+  GL_POLYGON_OFFSET_FACTOR_EXT = $8038;
+  GL_POLYGON_OFFSET_BIAS_EXT = $8039;
+
+  // GL_EXT_rescale_normal
+  GL_RESCALE_NORMAL_EXT = $803A;
+
+  // GL_EXT_secondary_color
+  GL_COLOR_SUM_EXT = $8458;
+  GL_CURRENT_SECONDARY_COLOR_EXT = $8459;
+  GL_SECONDARY_COLOR_ARRAY_SIZE_EXT = $845A;
+  GL_SECONDARY_COLOR_ARRAY_TYPE_EXT = $845B;
+  GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT = $845C;
+  GL_SECONDARY_COLOR_ARRAY_POINTER_EXT = $845D;
+  GL_SECONDARY_COLOR_ARRAY_EXT = $845E;
+
+  // GL_EXT_separate_specular_color
+  GL_LIGHT_MODEL_COLOR_CONTROL_EXT = $81F8;
+  GL_SINGLE_COLOR_EXT = $81F9;
+  GL_SEPARATE_SPECULAR_COLOR_EXT = $81FA;
+
+  // GL_EXT_shared_texture_palette
+  GL_SHARED_TEXTURE_PALETTE_EXT = $81FB;
+
+  // GL_EXT_stencil_two_side
+  GL_STENCIL_TEST_TWO_SIDE_EXT = $8910;
+  GL_ACTIVE_STENCIL_FACE_EXT = $8911;
+
+  // GL_EXT_stencil_wrap
+  GL_INCR_WRAP_EXT = $8507;
+  GL_DECR_WRAP_EXT = $8508;
+
+  // GL_EXT_texture
+  GL_ALPHA4_EXT = $803B;
+  GL_ALPHA8_EXT = $803C;
+  GL_ALPHA12_EXT = $803D;
+  GL_ALPHA16_EXT = $803E;
+  GL_LUMINANCE4_EXT = $803F;
+  GL_LUMINANCE8_EXT = $8040;
+  GL_LUMINANCE12_EXT = $8041;
+  GL_LUMINANCE16_EXT = $8042;
+  GL_LUMINANCE4_ALPHA4_EXT = $8043;
+  GL_LUMINANCE6_ALPHA2_EXT = $8044;
+  GL_LUMINANCE8_ALPHA8_EXT = $8045;
+  GL_LUMINANCE12_ALPHA4_EXT = $8046;
+  GL_LUMINANCE12_ALPHA12_EXT = $8047;
+  GL_LUMINANCE16_ALPHA16_EXT = $8048;
+  GL_INTENSITY_EXT = $8049;
+  GL_INTENSITY4_EXT = $804A;
+  GL_INTENSITY8_EXT = $804B;
+  GL_INTENSITY12_EXT = $804C;
+  GL_INTENSITY16_EXT = $804D;
+  GL_RGB2_EXT = $804E;
+  GL_RGB4_EXT = $804F;
+  GL_RGB5_EXT = $8050;
+  GL_RGB8_EXT = $8051;
+  GL_RGB10_EXT = $8052;
+  GL_RGB12_EXT = $8053;
+  GL_RGB16_EXT = $8054;
+  GL_RGBA2_EXT = $8055;
+  GL_RGBA4_EXT = $8056;
+  GL_RGB5_A1_EXT = $8057;
+  GL_RGBA8_EXT = $8058;
+  GL_RGB10_A2_EXT = $8059;
+  GL_RGBA12_EXT = $805A;
+  GL_RGBA16_EXT = $805B;
+  GL_TEXTURE_RED_SIZE_EXT = $805C;
+  GL_TEXTURE_GREEN_SIZE_EXT = $805D;
+  GL_TEXTURE_BLUE_SIZE_EXT = $805E;
+  GL_TEXTURE_ALPHA_SIZE_EXT = $805F;
+  GL_TEXTURE_LUMINANCE_SIZE_EXT = $8060;
+  GL_TEXTURE_INTENSITY_SIZE_EXT = $8061;
+  GL_REPLACE_EXT = $8062;
+  GL_PROXY_TEXTURE_1D_EXT = $8063;
+  GL_PROXY_TEXTURE_2D_EXT = $8064;
+  GL_TEXTURE_TOO_LARGE_EXT = $8065;
+
+  // GL_EXT_texture3D
+  GL_PACK_SKIP_IMAGES_EXT = $806B;
+  GL_PACK_IMAGE_HEIGHT_EXT = $806C;
+  GL_UNPACK_SKIP_IMAGES_EXT = $806D;
+  GL_UNPACK_IMAGE_HEIGHT_EXT = $806E;
+  GL_TEXTURE_3D_EXT = $806F;
+  GL_PROXY_TEXTURE_3D_EXT = $8070;
+  GL_TEXTURE_DEPTH_EXT = $8071;
+  GL_TEXTURE_WRAP_R_EXT = $8072;
+  GL_MAX_3D_TEXTURE_SIZE_EXT = $8073;
+
+  // GL_EXT_texture_compression_s3tc
+  GL_COMPRESSED_RGB_S3TC_DXT1_EXT = $83F0;
+  GL_COMPRESSED_RGBA_S3TC_DXT1_EXT = $83F1;
+  GL_COMPRESSED_RGBA_S3TC_DXT3_EXT = $83F2;
+  GL_COMPRESSED_RGBA_S3TC_DXT5_EXT = $83F3;
+
+  // GL_EXT_texture_cube_map
+  GL_NORMAL_MAP_EXT = $8511;
+  GL_REFLECTION_MAP_EXT = $8512;
+  GL_TEXTURE_CUBE_MAP_EXT = $8513;
+  GL_TEXTURE_BINDING_CUBE_MAP_EXT = $8514;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = $8515;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = $8516;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = $8517;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = $8518;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = $8519;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = $851A;
+  GL_PROXY_TEXTURE_CUBE_MAP_EXT = $851B;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = $851C;
+
+  // GL_EXT_texture_edge_clamp
+  GL_CLAMP_TO_EDGE_EXT = $812F;
+
+  // GL_EXT_texture_env_combine
+  GL_COMBINE_EXT = $8570;
+  GL_COMBINE_RGB_EXT = $8571;
+  GL_COMBINE_ALPHA_EXT = $8572;
+  GL_RGB_SCALE_EXT = $8573;
+  GL_ADD_SIGNED_EXT = $8574;
+  GL_INTERPOLATE_EXT = $8575;
+  GL_CONSTANT_EXT = $8576;
+  GL_PRIMARY_COLOR_EXT = $8577;
+  GL_PREVIOUS_EXT = $8578;
+  GL_SOURCE0_RGB_EXT = $8580;
+  GL_SOURCE1_RGB_EXT = $8581;
+  GL_SOURCE2_RGB_EXT = $8582;
+  GL_SOURCE0_ALPHA_EXT = $8588;
+  GL_SOURCE1_ALPHA_EXT = $8589;
+  GL_SOURCE2_ALPHA_EXT = $858A;
+  GL_OPERAND0_RGB_EXT = $8590;
+  GL_OPERAND1_RGB_EXT = $8591;
+  GL_OPERAND2_RGB_EXT = $8592;
+  GL_OPERAND0_ALPHA_EXT = $8598;
+  GL_OPERAND1_ALPHA_EXT = $8599;
+  GL_OPERAND2_ALPHA_EXT = $859A;
+
+  // GL_EXT_texture_env_dot3
+  GL_DOT3_RGB_EXT = $8740;
+  GL_DOT3_RGBA_EXT = $8741;
+
+  // GL_EXT_texture_filter_anisotropic
+  GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
+  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
+
+  // GL_EXT_texture_lod_bias
+  GL_MAX_TEXTURE_LOD_BIAS_EXT = $84FD;
+  GL_TEXTURE_FILTER_CONTROL_EXT = $8500;
+  GL_TEXTURE_LOD_BIAS_EXT = $8501;
+
+  // GL_EXT_texture_object
+  GL_TEXTURE_PRIORITY_EXT = $8066;
+  GL_TEXTURE_RESIDENT_EXT = $8067;
+  GL_TEXTURE_1D_BINDING_EXT = $8068;
+  GL_TEXTURE_2D_BINDING_EXT = $8069;
+  GL_TEXTURE_3D_BINDING_EXT = $806A;
+
+  // GL_EXT_texture_perturb_normal
+  GL_PERTURB_EXT = $85AE;
+  GL_TEXTURE_NORMAL_EXT = $85AF;
+
+  // GL_EXT_texture_rectangle
+  GL_TEXTURE_RECTANGLE_EXT = $84F5;
+  GL_TEXTURE_BINDING_RECTANGLE_EXT = $84F6;
+  GL_PROXY_TEXTURE_RECTANGLE_EXT = $84F7;
+  GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT = $84F8;
+
+  // GL_EXT_vertex_array
+  GL_VERTEX_ARRAY_EXT = $8074;
+  GL_NORMAL_ARRAY_EXT = $8075;
+  GL_COLOR_ARRAY_EXT = $8076;
+  GL_INDEX_ARRAY_EXT = $8077;
+  GL_TEXTURE_COORD_ARRAY_EXT = $8078;
+  GL_EDGE_FLAG_ARRAY_EXT = $8079;
+  GL_VERTEX_ARRAY_SIZE_EXT = $807A;
+  GL_VERTEX_ARRAY_TYPE_EXT = $807B;
+  GL_VERTEX_ARRAY_STRIDE_EXT = $807C;
+  GL_VERTEX_ARRAY_COUNT_EXT = $807D;
+  GL_NORMAL_ARRAY_TYPE_EXT = $807E;
+  GL_NORMAL_ARRAY_STRIDE_EXT = $807F;
+  GL_NORMAL_ARRAY_COUNT_EXT = $8080;
+  GL_COLOR_ARRAY_SIZE_EXT = $8081;
+  GL_COLOR_ARRAY_TYPE_EXT = $8082;
+  GL_COLOR_ARRAY_STRIDE_EXT = $8083;
+  GL_COLOR_ARRAY_COUNT_EXT = $8084;
+  GL_INDEX_ARRAY_TYPE_EXT = $8085;
+  GL_INDEX_ARRAY_STRIDE_EXT = $8086;
+  GL_INDEX_ARRAY_COUNT_EXT = $8087;
+  GL_TEXTURE_COORD_ARRAY_SIZE_EXT = $8088;
+  GL_TEXTURE_COORD_ARRAY_TYPE_EXT = $8089;
+  GL_TEXTURE_COORD_ARRAY_STRIDE_EXT = $808A;
+  GL_TEXTURE_COORD_ARRAY_COUNT_EXT = $808B;
+  GL_EDGE_FLAG_ARRAY_STRIDE_EXT = $808C;
+  GL_EDGE_FLAG_ARRAY_COUNT_EXT = $808D;
+  GL_VERTEX_ARRAY_POINTER_EXT = $808E;
+  GL_NORMAL_ARRAY_POINTER_EXT = $808F;
+  GL_COLOR_ARRAY_POINTER_EXT = $8090;
+  GL_INDEX_ARRAY_POINTER_EXT = $8091;
+  GL_TEXTURE_COORD_ARRAY_POINTER_EXT = $8092;
+  GL_EDGE_FLAG_ARRAY_POINTER_EXT = $8093;
+
+  // GL_EXT_vertex_shader
+  GL_VERTEX_SHADER_EXT = $8780;
+  GL_VERTEX_SHADER_BINDING_EXT = $8781;
+  GL_OP_INDEX_EXT = $8782;
+  GL_OP_NEGATE_EXT = $8783;
+  GL_OP_DOT3_EXT = $8784;
+  GL_OP_DOT4_EXT = $8785;
+  GL_OP_MUL_EXT = $8786;
+  GL_OP_ADD_EXT = $8787;
+  GL_OP_MADD_EXT = $8788;
+  GL_OP_FRAC_EXT = $8789;
+  GL_OP_MAX_EXT = $878A;
+  GL_OP_MIN_EXT = $878B;
+  GL_OP_SET_GE_EXT = $878C;
+  GL_OP_SET_LT_EXT = $878D;
+  GL_OP_CLAMP_EXT = $878E;
+  GL_OP_FLOOR_EXT = $878F;
+  GL_OP_ROUND_EXT = $8790;
+  GL_OP_EXP_BASE_2_EXT = $8791;
+  GL_OP_LOG_BASE_2_EXT = $8792;
+  GL_OP_POWER_EXT = $8793;
+  GL_OP_RECIP_EXT = $8794;
+  GL_OP_RECIP_SQRT_EXT = $8795;
+  GL_OP_SUB_EXT = $8796;
+  GL_OP_CROSS_PRODUCT_EXT = $8797;
+  GL_OP_MULTIPLY_MATRIX_EXT = $8798;
+  GL_OP_MOV_EXT = $8799;
+  GL_OUTPUT_VERTEX_EXT = $879A;
+  GL_OUTPUT_COLOR0_EXT = $879B;
+  GL_OUTPUT_COLOR1_EXT = $879C;
+  GL_OUTPUT_TEXTURE_COORD0_EXT = $879D;
+  GL_OUTPUT_TEXTURE_COORD1_EXT = $879E;
+  GL_OUTPUT_TEXTURE_COORD2_EXT = $879F;
+  GL_OUTPUT_TEXTURE_COORD3_EXT = $87A0;
+  GL_OUTPUT_TEXTURE_COORD4_EXT = $87A1;
+  GL_OUTPUT_TEXTURE_COORD5_EXT = $87A2;
+  GL_OUTPUT_TEXTURE_COORD6_EXT = $87A3;
+  GL_OUTPUT_TEXTURE_COORD7_EXT = $87A4;
+  GL_OUTPUT_TEXTURE_COORD8_EXT = $87A5;
+  GL_OUTPUT_TEXTURE_COORD9_EXT = $87A6;
+  GL_OUTPUT_TEXTURE_COORD10_EXT = $87A7;
+  GL_OUTPUT_TEXTURE_COORD11_EXT = $87A8;
+  GL_OUTPUT_TEXTURE_COORD12_EXT = $87A9;
+  GL_OUTPUT_TEXTURE_COORD13_EXT = $87AA;
+  GL_OUTPUT_TEXTURE_COORD14_EXT = $87AB;
+  GL_OUTPUT_TEXTURE_COORD15_EXT = $87AC;
+  GL_OUTPUT_TEXTURE_COORD16_EXT = $87AD;
+  GL_OUTPUT_TEXTURE_COORD17_EXT = $87AE;
+  GL_OUTPUT_TEXTURE_COORD18_EXT = $87AF;
+  GL_OUTPUT_TEXTURE_COORD19_EXT = $87B0;
+  GL_OUTPUT_TEXTURE_COORD20_EXT = $87B1;
+  GL_OUTPUT_TEXTURE_COORD21_EXT = $87B2;
+  GL_OUTPUT_TEXTURE_COORD22_EXT = $87B3;
+  GL_OUTPUT_TEXTURE_COORD23_EXT = $87B4;
+  GL_OUTPUT_TEXTURE_COORD24_EXT = $87B5;
+  GL_OUTPUT_TEXTURE_COORD25_EXT = $87B6;
+  GL_OUTPUT_TEXTURE_COORD26_EXT = $87B7;
+  GL_OUTPUT_TEXTURE_COORD27_EXT = $87B8;
+  GL_OUTPUT_TEXTURE_COORD28_EXT = $87B9;
+  GL_OUTPUT_TEXTURE_COORD29_EXT = $87BA;
+  GL_OUTPUT_TEXTURE_COORD30_EXT = $87BB;
+  GL_OUTPUT_TEXTURE_COORD31_EXT = $87BC;
+  GL_OUTPUT_FOG_EXT = $87BD;
+  GL_SCALAR_EXT = $87BE;
+  GL_VECTOR_EXT = $87BF;
+  GL_MATRIX_EXT = $87C0;
+  GL_VARIANT_EXT = $87C1;
+  GL_INVARIANT_EXT = $87C2;
+  GL_LOCAL_CONSTANT_EXT = $87C3;
+  GL_LOCAL_EXT = $87C4;
+  GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = $87C5;
+  GL_MAX_VERTEX_SHADER_VARIANTS_EXT = $87C6;
+  GL_MAX_VERTEX_SHADER_INVARIANTS_EXT = $87C7;
+  GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87C8;
+  GL_MAX_VERTEX_SHADER_LOCALS_EXT = $87C9;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CA;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = $87CB;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87CC;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = $87CD;
+  GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = $87CE;
+  GL_VERTEX_SHADER_INSTRUCTIONS_EXT = $87CF;
+  GL_VERTEX_SHADER_VARIANTS_EXT = $87D0;
+  GL_VERTEX_SHADER_INVARIANTS_EXT = $87D1;
+  GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = $87D2;
+  GL_VERTEX_SHADER_LOCALS_EXT = $87D3;
+  GL_VERTEX_SHADER_OPTIMIZED_EXT = $87D4;
+  GL_X_EXT = $87D5;
+  GL_Y_EXT = $87D6;
+  GL_Z_EXT = $87D7;
+  GL_W_EXT = $87D8;
+  GL_NEGATIVE_X_EXT = $87D9;
+  GL_NEGATIVE_Y_EXT = $87DA;
+  GL_NEGATIVE_Z_EXT = $87DB;
+  GL_NEGATIVE_W_EXT = $87DC;
+  GL_ZERO_EXT = $87DD;
+  GL_ONE_EXT = $87DE;
+  GL_NEGATIVE_ONE_EXT = $87DF;
+  GL_NORMALIZED_RANGE_EXT = $87E0;
+  GL_FULL_RANGE_EXT = $87E1;
+  GL_CURRENT_VERTEX_EXT = $87E2;
+  GL_MVP_MATRIX_EXT = $87E3;
+  GL_VARIANT_VALUE_EXT = $87E4;
+  GL_VARIANT_DATATYPE_EXT = $87E5;
+  GL_VARIANT_ARRAY_STRIDE_EXT = $87E6;
+  GL_VARIANT_ARRAY_TYPE_EXT = $87E7;
+  GL_VARIANT_ARRAY_EXT = $87E8;
+  GL_VARIANT_ARRAY_POINTER_EXT = $87E9;
+  GL_INVARIANT_VALUE_EXT = $87EA;
+  GL_INVARIANT_DATATYPE_EXT = $87EB;
+  GL_LOCAL_CONSTANT_VALUE_EXT = $87EC;
+  GL_LOCAL_CONSTANT_DATATYPE_EXT = $87ED;
+
+  // GL_EXT_vertex_weighting
+  GL_MODELVIEW0_STACK_DEPTH_EXT = $0BA3;
+  GL_MODELVIEW1_STACK_DEPTH_EXT = $8502;
+  GL_MODELVIEW0_MATRIX_EXT = $0BA6;
+  GL_MODELVIEW1_MATRIX_EXT = $8506;
+  GL_VERTEX_WEIGHTING_EXT = $8509;
+  GL_MODELVIEW0_EXT = $1700;
+  GL_MODELVIEW1_EXT = $850A;
+  GL_CURRENT_VERTEX_WEIGHT_EXT = $850B;
+  GL_VERTEX_WEIGHT_ARRAY_EXT = $850C;
+  GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT = $850D;
+  GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT = $850E;
+  GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = $850F;
+  GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT = $8510;
+
+  // GL_EXT_depth_bounds_test
+  GL_DEPTH_BOUNDS_TEST_EXT = $8890;
+  GL_DEPTH_BOUNDS_EXT = $8891;
+
+  // GL_EXT_texture_mirror_clamp
+  GL_MIRROR_CLAMP_EXT = $8742;
+  GL_MIRROR_CLAMP_TO_EDGE_EXT = $8743;
+  GL_MIRROR_CLAMP_TO_BORDER_EXT = $8912;
+
+  // GL_EXT_blend_equation_separate
+  GL_BLEND_EQUATION_RGB_EXT = $8009; 
+  GL_BLEND_EQUATION_ALPHA_EXT = $883D;
+
+  // GL_EXT_pixel_buffer_object
+  GL_PIXEL_PACK_BUFFER_EXT = $88EB;
+  GL_PIXEL_UNPACK_BUFFER_EXT = $88EC;
+  GL_PIXEL_PACK_BUFFER_BINDING_EXT = $88ED;
+  GL_PIXEL_UNPACK_BUFFER_BINDING_EXT = $88EF;
+
+  // GL_EXT_stencil_clear_tag
+  GL_STENCIL_TAG_BITS_EXT = $88F2;
+  GL_STENCIL_CLEAR_TAG_VALUE_EXT = $88F3;
+
+  // GL_EXT_packed_depth_stencil
+  GL_DEPTH_STENCIL_EXT = $84F9;
+  GL_UNSIGNED_INT_24_8_EXT = $84FA;
+  GL_DEPTH24_STENCIL8_EXT = $88F0;
+  GL_TEXTURE_STENCIL_SIZE_EXT = $88F1;
+
+  // GL_EXT_texture_sRGB
+  GL_SRGB_EXT = $8C40;
+  GL_SRGB8_EXT = $8C41;
+  GL_SRGB_ALPHA_EXT = $8C42;
+  GL_SRGB8_ALPHA8_EXT = $8C43;
+  GL_SLUMINANCE_ALPHA_EXT = $8C44;
+  GL_SLUMINANCE8_ALPHA8_EXT = $8C45;
+  GL_SLUMINANCE_EXT = $8C46;
+  GL_SLUMINANCE8_EXT = $8C47;
+  GL_COMPRESSED_SRGB_EXT = $8C48;
+  GL_COMPRESSED_SRGB_ALPHA_EXT = $8C49;
+  GL_COMPRESSED_SLUMINANCE_EXT = $8C4A;
+  GL_COMPRESSED_SLUMINANCE_ALPHA_EXT = $8C4B;
+  GL_COMPRESSED_SRGB_S3TC_DXT1_EXT = $8C4C;
+  GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = $8C4D;
+  GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = $8C4E;
+  GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = $8C4F;
+
+  // GL_EXT_framebuffer_blit
+  GL_READ_FRAMEBUFFER_EXT = $8CA8;
+  GL_DRAW_FRAMEBUFFER_EXT = $8CA9;
+  GL_READ_FRAMEBUFFER_BINDING_EXT = GL_FRAMEBUFFER_BINDING_EXT;
+  GL_DRAW_FRAMEBUFFER_BINDING_EXT = $8CAA;
+
+  // GL_EXT_framebuffer_multisample
+  GL_RENDERBUFFER_SAMPLES_EXT = $8CAB;
+  GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = $8D56;
+  GL_MAX_SAMPLES_EXT = $8D57;
+
+  // GL_EXT_timer_query
+  GL_TIME_ELAPSED_EXT = $88BF;
+
+  // GL_EXT_bindable_uniform
+  GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = $8DE2;
+  GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = $8DE3;
+  GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = $8DE4;
+  GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = $8DED;
+  GL_UNIFORM_BUFFER_EXT = $8DEE;
+  GL_UNIFORM_BUFFER_BINDING_EXT = $8DEF;
+
+  // GL_EXT_framebuffer_sRGB
+  GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2;
+  WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20A9;
+  GL_FRAMEBUFFER_SRGB_EXT = $8DB9;
+  GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = $8DBA;
+
+  // GL_EXT_geometry_shader4
+  GL_GEOMETRY_SHADER_EXT = $8DD9;
+  GL_GEOMETRY_VERTICES_OUT_EXT = $8DDA;
+  GL_GEOMETRY_INPUT_TYPE_EXT = $8DDB;
+  GL_GEOMETRY_OUTPUT_TYPE_EXT = $8DDC;
+  GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = $8C29;
+  GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = $8DDD;
+  GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = $8DDE;
+  GL_MAX_VARYING_COMPONENTS_EXT = $8B4B;
+  GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = $8DDF;
+  GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = $8DE0;
+  GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = $8DE1;
+  GL_LINES_ADJACENCY_EXT = $A;
+  GL_LINE_STRIP_ADJACENCY_EXT = $B;
+  GL_TRIANGLES_ADJACENCY_EXT = $C;
+  GL_TRIANGLE_STRIP_ADJACENCY_EXT = $D;
+  GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = $8DA8;
+  GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = $8DA9;
+  GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = $8DA7;
+  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = $8CD4;
+  GL_PROGRAM_POINT_SIZE_EXT = $8642;
+
+  // GL_EXT_gpu_shader4
+  GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = $88FD;
+  GL_SAMPLER_1D_ARRAY_EXT = $8DC0;
+  GL_SAMPLER_2D_ARRAY_EXT = $8DC1;
+  GL_SAMPLER_BUFFER_EXT = $8DC2;
+  GL_SAMPLER_1D_ARRAY_SHADOW_EXT = $8DC3;
+  GL_SAMPLER_2D_ARRAY_SHADOW_EXT = $8DC4;
+  GL_SAMPLER_CUBE_SHADOW_EXT = $8DC5;
+  GL_UNSIGNED_INT_VEC2_EXT = $8DC6;
+  GL_UNSIGNED_INT_VEC3_EXT = $8DC7;
+  GL_UNSIGNED_INT_VEC4_EXT = $8DC8;
+  GL_INT_SAMPLER_1D_EXT = $8DC9;
+  GL_INT_SAMPLER_2D_EXT = $8DCA;
+  GL_INT_SAMPLER_3D_EXT = $8DCB;
+  GL_INT_SAMPLER_CUBE_EXT = $8DCC;
+  GL_INT_SAMPLER_2D_RECT_EXT = $8DCD;
+  GL_INT_SAMPLER_1D_ARRAY_EXT = $8DCE;
+  GL_INT_SAMPLER_2D_ARRAY_EXT = $8DCF;
+  GL_INT_SAMPLER_BUFFER_EXT = $8DD0;
+  GL_UNSIGNED_INT_SAMPLER_1D_EXT = $8DD1;
+  GL_UNSIGNED_INT_SAMPLER_2D_EXT = $8DD2;
+  GL_UNSIGNED_INT_SAMPLER_3D_EXT = $8DD3;
+  GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = $8DD4;
+  GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = $8DD5;
+  GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = $8DD6;
+  GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = $8DD7;
+  GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = $8DD8;
+  GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = $8904;
+  GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = $8905;
+
+  // GL_EXT_packed_float
+  GL_R11F_G11F_B10F_EXT = $8C3A;
+  GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = $8C3B;
+  RGBA_SIGNED_COMPONENTS_EXT = $8C3C;
+  WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = $20A8;
+  GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1;
+  GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008;
+
+  // GL_EXT_texture_array
+  GL_TEXTURE_1D_ARRAY_EXT = $8C18;
+  GL_TEXTURE_2D_ARRAY_EXT = $8C1A;
+  GL_PROXY_TEXTURE_2D_ARRAY_EXT = $8C1B;
+  GL_PROXY_TEXTURE_1D_ARRAY_EXT = $8C19;
+  GL_TEXTURE_BINDING_1D_ARRAY_EXT = $8C1C;
+  GL_TEXTURE_BINDING_2D_ARRAY_EXT = $8C1D;
+  GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = $88FF;
+  GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = $884E;
+
+  // GL_EXT_texture_buffer_object
+  GL_TEXTURE_BUFFER_EXT = $8C2A;
+  GL_MAX_TEXTURE_BUFFER_SIZE_EXT = $8C2B;
+  GL_TEXTURE_BINDING_BUFFER_EXT = $8C2C;
+  GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = $8C2D;
+  GL_TEXTURE_BUFFER_FORMAT_EXT = $8C2E;
+
+  // GL_EXT_texture_compression_latc
+  GL_COMPRESSED_LUMINANCE_LATC1_EXT = $8C70;
+  GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = $8C71;
+  GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = $8C72;
+  GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = $8C73;
+
+  // GL_EXT_texture_compression_rgtc
+  GL_COMPRESSED_RED_RGTC1_EXT = $8DBB;
+  GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = $8DBC;
+  GL_COMPRESSED_RED_GREEN_RGTC2_EXT = $8DBD;
+  GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = $8DBE;
+
+  // GL_EXT_texture_integer
+  GL_RGBA_INTEGER_MODE_EXT = $8D9E;
+  GL_RGBA32UI_EXT = $8D70;
+  GL_RGB32UI_EXT = $8D71;
+  GL_ALPHA32UI_EXT = $8D72;
+  GL_INTENSITY32UI_EXT = $8D73;
+  GL_LUMINANCE32UI_EXT = $8D74;
+  GL_LUMINANCE_ALPHA32UI_EXT = $8D75;
+  GL_RGBA16UI_EXT = $8D76;
+  GL_RGB16UI_EXT = $8D77;
+  GL_ALPHA16UI_EXT = $8D78;
+  GL_INTENSITY16UI_EXT = $8D79;
+  GL_LUMINANCE16UI_EXT = $8D7A;
+  GL_LUMINANCE_ALPHA16UI_EXT = $8D7B;
+  GL_RGBA8UI_EXT = $8D7C;
+  GL_RGB8UI_EXT = $8D7D;
+  GL_ALPHA8UI_EXT = $8D7E;
+  GL_INTENSITY8UI_EXT = $8D7F;
+  GL_LUMINANCE8UI_EXT = $8D80;
+  GL_LUMINANCE_ALPHA8UI_EXT = $8D81;
+  GL_RGBA32I_EXT = $8D82;
+  GL_RGB32I_EXT = $8D83;
+  GL_ALPHA32I_EXT = $8D84;
+  GL_INTENSITY32I_EXT = $8D85;
+  GL_LUMINANCE32I_EXT = $8D86;
+  GL_LUMINANCE_ALPHA32I_EXT = $8D87;
+  GL_RGBA16I_EXT = $8D88;
+  GL_RGB16I_EXT = $8D89;
+  GL_ALPHA16I_EXT = $8D8A;
+  GL_INTENSITY16I_EXT = $8D8B;
+  GL_LUMINANCE16I_EXT = $8D8C;
+  GL_LUMINANCE_ALPHA16I_EXT = $8D8D;
+  GL_RGBA8I_EXT = $8D8E;
+  GL_RGB8I_EXT = $8D8F;
+  GL_ALPHA8I_EXT = $8D90;
+  GL_INTENSITY8I_EXT = $8D91;
+  GL_LUMINANCE8I_EXT = $8D92;
+  GL_LUMINANCE_ALPHA8I_EXT = $8D93;
+  GL_RED_INTEGER_EXT = $8D94;
+  GL_GREEN_INTEGER_EXT = $8D95;
+  GL_BLUE_INTEGER_EXT = $8D96;
+  GL_ALPHA_INTEGER_EXT = $8D97;
+  GL_RGB_INTEGER_EXT = $8D98;
+  GL_RGBA_INTEGER_EXT = $8D99;
+  GL_BGR_INTEGER_EXT = $8D9A;
+  GL_BGRA_INTEGER_EXT = $8D9B;
+  GL_LUMINANCE_INTEGER_EXT = $8D9C;
+  GL_LUMINANCE_ALPHA_INTEGER_EXT = $8D9D;
+
+  // GL_EXT_texture_shared_exponent
+  GL_RGB9_E5_EXT = $8C3D;
+  GL_UNSIGNED_INT_5_9_9_9_REV_EXT = $8C3E;
+  GL_TEXTURE_SHARED_SIZE_EXT = $8C3F;
+
+  // GL_EXT_transform_feedback
+  GL_TRANSFORM_FEEDBACK_BUFFER_EXT = $8C8E;
+  GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT = $8C84;
+  GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = $8C85;
+  GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = $8C8F;
+  GL_INTERLEAVED_ATTRIBS_EXT = $8C8C;
+  GL_SEPARATE_ATTRIBS_EXT = $8C8D;
+  GL_PRIMITIVES_GENERATED_EXT = $8C87;
+  GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = $8C88;
+  GL_RASTERIZER_DISCARD_EXT = $8C89;
+  GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = $8C8A;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = $8C8B;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = $8C80;
+  GL_TRANSFORM_FEEDBACK_VARYINGS_EXT = $8C83;
+  GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = $8C7F;
+  GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = $8C76;
+
+  // GL_EXT_direct_state_access
+  GL_PROGRAM_MATRIX_EXT = $8E2D;
+  GL_TRANSPOSE_PROGRAM_MATRIX_EXT = $8E2E;
+  GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = $8E2F;
+
+  // GL_EXT_texture_swizzle
+  GL_TEXTURE_SWIZZLE_R_EXT = $8E42;
+  GL_TEXTURE_SWIZZLE_G_EXT = $8E43;
+  GL_TEXTURE_SWIZZLE_B_EXT = $8E44;
+  GL_TEXTURE_SWIZZLE_A_EXT = $8E45;
+  GL_TEXTURE_SWIZZLE_RGBA_EXT = $8E46;
+
+  // GL_EXT_provoking_vertex
+  GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = $8E4C;
+  GL_FIRST_VERTEX_CONVENTION_EXT = $8E4D;
+  GL_LAST_VERTEX_CONVENTION_EXT = $8E4E;
+  GL_PROVOKING_VERTEX_EXT = $8E4F;
+  
+  // GL_EXT_texture_snorm
+  GL_ALPHA_SNORM = $9010;
+  GL_LUMINANCE_SNORM = $9011;
+  GL_LUMINANCE_ALPHA_SNORM = $9012;
+  GL_INTENSITY_SNORM = $9013;
+  GL_ALPHA8_SNORM = $9014;
+  GL_LUMINANCE8_SNORM = $9015;
+  GL_LUMINANCE8_ALPHA8_SNORM = $9016;
+  GL_INTENSITY8_SNORM = $9017;
+  GL_ALPHA16_SNORM = $9018;
+  GL_LUMINANCE16_SNORM = $9019;
+  GL_LUMINANCE16_ALPHA16_SNORM = $901A;
+  GL_INTENSITY16_SNORM = $901B;
+  { reuse GL_RED_SNORM }
+  { reuse GL_RG_SNORM }
+  { reuse GL_RGB_SNORM }
+  { reuse GL_RGBA_SNORM }
+  { reuse GL_R8_SNORM }
+  { reuse GL_RG8_SNORM }
+  { reuse GL_RGB8_SNORM }
+  { reuse GL_RGBA8_SNORM }
+  { reuse GL_R16_SNORM }
+  { reuse GL_RG16_SNORM }
+  { reuse GL_RGB16_SNORM }
+  { reuse GL_RGBA16_SNORM }
+  { reuse GL_SIGNED_NORMALIZED }
+  
+  // GL_EXT_separate_shader_objects
+  GL_ACTIVE_PROGRAM_EXT = $8B8D;
+  
+  // GL_EXT_shader_image_load_store
+  GL_MAX_IMAGE_UNITS_EXT = $8F38;
+  GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = $8F39;
+  GL_IMAGE_BINDING_NAME_EXT = $8F3A;
+  GL_IMAGE_BINDING_LEVEL_EXT = $8F3B;
+  GL_IMAGE_BINDING_LAYERED_EXT = $8F3C;
+  GL_IMAGE_BINDING_LAYER_EXT = $8F3D;
+  GL_IMAGE_BINDING_ACCESS_EXT = $8F3E;
+  GL_IMAGE_1D_EXT = $904C;
+  GL_IMAGE_2D_EXT = $904D;
+  GL_IMAGE_3D_EXT = $904E;
+  GL_IMAGE_2D_RECT_EXT = $904F;
+  GL_IMAGE_CUBE_EXT = $9050;
+  GL_IMAGE_BUFFER_EXT = $9051;
+  GL_IMAGE_1D_ARRAY_EXT = $9052;
+  GL_IMAGE_2D_ARRAY_EXT = $9053;
+  GL_IMAGE_CUBE_MAP_ARRAY_EXT = $9054;
+  GL_IMAGE_2D_MULTISAMPLE_EXT = $9055;
+  GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9056;
+  GL_INT_IMAGE_1D_EXT = $9057;
+  GL_INT_IMAGE_2D_EXT = $9058;
+  GL_INT_IMAGE_3D_EXT = $9059;
+  GL_INT_IMAGE_2D_RECT_EXT = $905A;
+  GL_INT_IMAGE_CUBE_EXT = $905B;
+  GL_INT_IMAGE_BUFFER_EXT = $905C;
+  GL_INT_IMAGE_1D_ARRAY_EXT = $905D;
+  GL_INT_IMAGE_2D_ARRAY_EXT = $905E;
+  GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $905F;
+  GL_INT_IMAGE_2D_MULTISAMPLE_EXT = $9060;
+  GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $9061;
+  GL_UNSIGNED_INT_IMAGE_1D_EXT = $9062;
+  GL_UNSIGNED_INT_IMAGE_2D_EXT = $9063;
+  GL_UNSIGNED_INT_IMAGE_3D_EXT = $9064;
+  GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT = $9065;
+  GL_UNSIGNED_INT_IMAGE_CUBE_EXT = $9066;
+  GL_UNSIGNED_INT_IMAGE_BUFFER_EXT = $9067;
+  GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = $9068;
+  GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = $9069;
+  GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = $906A;
+  GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = $906B;
+  GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = $906C;
+  GL_MAX_IMAGE_SAMPLES_EXT = $906D;
+  GL_IMAGE_BINDING_FORMAT_EXT = $906E;
+  GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = $00000001;
+  GL_ELEMENT_ARRAY_BARRIER_BIT_EXT = $00000002;
+  GL_UNIFORM_BARRIER_BIT_EXT = $00000004;
+  GL_TEXTURE_FETCH_BARRIER_BIT_EXT = $00000008;
+  GL_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = $00000020;
+  GL_COMMAND_BARRIER_BIT_EXT = $00000040;
+  GL_PIXEL_BUFFER_BARRIER_BIT_EXT = $00000080;
+  GL_TEXTURE_UPDATE_BARRIER_BIT_EXT = $00000100;
+  GL_BUFFER_UPDATE_BARRIER_BIT_EXT = $00000200;
+  GL_FRAMEBUFFER_BARRIER_BIT_EXT = $00000400;
+  GL_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = $00000800;
+  GL_ATOMIC_COUNTER_BARRIER_BIT_EXT = $00001000;
+  GL_ALL_BARRIER_BITS_EXT = $FFFFFFFF;
+  
+  // GL_EXT_vertex_attrib_64bit
+  { reuse GL_DOUBLE }
+  GL_DOUBLE_VEC2_EXT = $8FFC;
+  GL_DOUBLE_VEC3_EXT = $8FFD;
+  GL_DOUBLE_VEC4_EXT = $8FFE;
+  GL_DOUBLE_MAT2_EXT = $8F46;
+  GL_DOUBLE_MAT3_EXT = $8F47;
+  GL_DOUBLE_MAT4_EXT = $8F48;
+  GL_DOUBLE_MAT2x3_EXT = $8F49;
+  GL_DOUBLE_MAT2x4_EXT = $8F4A;
+  GL_DOUBLE_MAT3x2_EXT = $8F4B;
+  GL_DOUBLE_MAT3x4_EXT = $8F4C;
+  GL_DOUBLE_MAT4x2_EXT = $8F4D;
+  GL_DOUBLE_MAT4x3_EXT = $8F4E;
+
+  // GL_EXT_texture_sRGB_decode
+  GL_TEXTURE_SRGB_DECODE_EXT = $8A48;
+  GL_DECODE_EXT = $8A49;
+  GL_SKIP_DECODE_EXT = $8A4A;
+
+  // GL_NV_texture_multisample 
+  GL_TEXTURE_COVERAGE_SAMPLES_NV    = $9045;
+  GL_TEXTURE_COLOR_SAMPLES_NV       = $9046;
+
+  // GL_AMD_blend_minmax_factor
+  GL_FACTOR_MIN_AMD                 = $901C;
+  GL_FACTOR_MAX_AMD                 = $901D;
+
+  // GL_AMD_sample_positions
+  GL_SUBSAMPLE_DISTANCE_AMD         = $883F;
+
+  // GL_EXT_x11_sync_object
+  GL_SYNC_X11_FENCE_EXT             = $90E1;
+
+  // GL_EXT_framebuffer_multisample_blit_scaled
+  GL_SCALED_RESOLVE_FASTEST_EXT     = $90BA;
+  GL_SCALED_RESOLVE_NICEST_EXT      = $90BB;
+
+  // (4.3) GL_NV_path_rendering
+       GL_PATH_FORMAT_SVG_NV            = $9070;
+       GL_PATH_FORMAT_PS_NV             = $9071;
+       GL_STANDARD_FONT_NAME_NV         = $9072;
+       GL_SYSTEM_FONT_NAME_NV           = $9073;
+       GL_FILE_NAME_NV                  = $9074;
+       GL_PATH_STROKE_WIDTH_NV          = $9075;
+       GL_PATH_END_CAPS_NV              = $9076;
+       GL_PATH_INITIAL_END_CAP_NV       = $9077;
+       GL_PATH_TERMINAL_END_CAP_NV      = $9078;
+       GL_PATH_JOIN_STYLE_NV            = $9079;
+       GL_PATH_MITER_LIMIT_NV           = $907A;
+       GL_PATH_DASH_CAPS_NV             = $907B;
+       GL_PATH_INITIAL_DASH_CAP_NV      = $907C;
+       GL_PATH_TERMINAL_DASH_CAP_NV     = $907D;
+       GL_PATH_DASH_OFFSET_NV           = $907E;
+       GL_PATH_CLIENT_LENGTH_NV         = $907F;
+       GL_PATH_FILL_MODE_NV             = $9080;
+       GL_PATH_FILL_MASK_NV             = $9081;
+       GL_PATH_FILL_COVER_MODE_NV       = $9082;
+       GL_PATH_STROKE_COVER_MODE_NV     = $9083;
+       GL_PATH_STROKE_MASK_NV           = $9084;
+       GL_PATH_SAMPLE_QUALITY_NV        = $9085;
+       GL_PATH_STROKE_BOUND_NV          = $9086;
+       GL_PATH_STROKE_OVERSAMPLE_COUNT_NV= $9087;
+       GL_COUNT_UP_NV                   = $9088;
+       GL_COUNT_DOWN_NV                 = $9089;
+       GL_PATH_OBJECT_BOUNDING_BOX_NV   = $908A;
+       GL_CONVEX_HULL_NV                = $908B;
+       GL_MULTI_HULLS_NV                = $908C;
+       GL_BOUNDING_BOX_NV               = $908D;
+       GL_TRANSLATE_X_NV                = $908E;
+       GL_TRANSLATE_Y_NV                = $908F;
+       GL_TRANSLATE_2D_NV               = $9090;
+       GL_TRANSLATE_3D_NV               = $9091;
+       GL_AFFINE_2D_NV                  = $9092;
+       GL_PROJECTIVE_2D_NV              = $9093;
+       GL_AFFINE_3D_NV                  = $9094;
+       GL_PROJECTIVE_3D_NV              = $9095;
+       GL_TRANSPOSE_AFFINE_2D_NV        = $9096;
+       GL_TRANSPOSE_PROJECTIVE_2D_NV    = $9097;
+       GL_TRANSPOSE_AFFINE_3D_NV        = $9098;
+       GL_TRANSPOSE_PROJECTIVE_3D_NV    = $9099;
+       GL_UTF8_NV                       = $909A;
+       GL_UTF16_NV                      = $909B;
+       GL_BOUNDING_BOX_OF_BOUNDING_BOXES_NV= $909C;
+       GL_PATH_COMMAND_COUNT_NV         = $909D;
+       GL_PATH_COORD_COUNT_NV           = $909E;
+  GL_PATH_DASH_ARRAY_COUNT_NV      = $909F;
+  GL_PATH_COMPUTED_LENGTH_NV       = $90A0;
+  GL_PATH_FILL_BOUNDING_BOX_NV     = $90A1;
+  GL_PATH_STROKE_BOUNDING_BOX_NV   = $90A2;
+  GL_SQUARE_NV                     = $90A3;
+  GL_ROUND_NV                      = $90A4;
+  GL_TRIANGULAR_NV                 = $90A5;
+  GL_BEVEL_NV                      = $90A6;
+  GL_MITER_REVERT_NV               = $90A7;
+  GL_MITER_TRUNCATE_NV             = $90A8;
+  GL_SKIP_MISSING_GLYPH_NV         = $90A9;
+  GL_USE_MISSING_GLYPH_NV          = $90AA;
+  GL_PATH_ERROR_POSITION_NV        = $90AB;
+  GL_PATH_FOG_GEN_MODE_NV          = $90AC;
+  GL_ACCUM_ADJACENT_PAIRS_NV       = $90AD;
+  GL_ADJACENT_PAIRS_NV             = $90AE;
+  GL_FIRST_TO_REST_NV              = $90AF;
+  GL_PATH_GEN_MODE_NV              = $90B0;
+  GL_PATH_GEN_COEFF_NV             = $90B1;
+  GL_PATH_GEN_COLOR_FORMAT_NV      = $90B2;
+  GL_PATH_GEN_COMPONENTS_NV        = $90B3;
+  GL_PATH_STENCIL_FUNC_NV          = $90B7;
+  GL_PATH_STENCIL_REF_NV           = $90B8;
+  GL_PATH_STENCIL_VALUE_MASK_NV    = $90B9;
+  GL_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV= $90BD;
+  GL_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV= $90BE;
+  GL_PATH_COVER_DEPTH_FUNC_NV      = $90BF;
+  GL_PATH_DASH_OFFSET_RESET_NV     = $90B4;
+  GL_MOVE_TO_RESETS_NV             = $90B5;
+  GL_MOVE_TO_CONTINUES_NV          = $90B6;
+  GL_CLOSE_PATH_NV                 = $00;
+  GL_MOVE_TO_NV                    = $02;
+  GL_RELATIVE_MOVE_TO_NV           = $03;
+  GL_LINE_TO_NV                    = $04;
+  GL_RELATIVE_LINE_TO_NV           = $05;
+  GL_HORIZONTAL_LINE_TO_NV         = $06;
+  GL_RELATIVE_HORIZONTAL_LINE_TO_NV= $07;
+  GL_VERTICAL_LINE_TO_NV           = $08;
+  GL_RELATIVE_VERTICAL_LINE_TO_NV  = $09;
+  GL_QUADRATIC_CURVE_TO_NV         = $0A;
+  GL_RELATIVE_QUADRATIC_CURVE_TO_NV= $0B;
+  GL_CUBIC_CURVE_TO_NV             = $0C;
+  GL_RELATIVE_CUBIC_CURVE_TO_NV    = $0D;
+  GL_SMOOTH_QUADRATIC_CURVE_TO_NV  = $0E;
+  GL_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV= $0F;
+  GL_SMOOTH_CUBIC_CURVE_TO_NV      = $10;
+  GL_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV= $11;
+  GL_SMALL_CCW_ARC_TO_NV           = $12;
+  GL_RELATIVE_SMALL_CCW_ARC_TO_NV  = $13;
+  GL_SMALL_CW_ARC_TO_NV            = $14;
+  GL_RELATIVE_SMALL_CW_ARC_TO_NV   = $15;
+  GL_LARGE_CCW_ARC_TO_NV           = $16;
+  GL_RELATIVE_LARGE_CCW_ARC_TO_NV  = $17;
+  GL_LARGE_CW_ARC_TO_NV            = $18;
+  GL_RELATIVE_LARGE_CW_ARC_TO_NV   = $19;
+  GL_RESTART_PATH_NV               = $F0;
+  GL_DUP_FIRST_CUBIC_CURVE_TO_NV   = $F2;
+  GL_DUP_LAST_CUBIC_CURVE_TO_NV    = $F4;
+  GL_RECT_NV                       = $F6;
+  GL_CIRCULAR_CCW_ARC_TO_NV        = $F8;
+  GL_CIRCULAR_CW_ARC_TO_NV         = $FA;
+  GL_CIRCULAR_TANGENT_ARC_TO_NV    = $FC;
+  GL_ARC_TO_NV                     = $FE;
+  GL_RELATIVE_ARC_TO_NV            = $FF;
+  GL_BOLD_BIT_NV                   = $01;
+  GL_ITALIC_BIT_NV                 = $02;
+  GL_GLYPH_WIDTH_BIT_NV            = $01;
+  GL_GLYPH_HEIGHT_BIT_NV           = $02;
+  GL_GLYPH_HORIZONTAL_BEARING_X_BIT_NV= $04;
+  GL_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV= $08;
+  GL_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV= $10;
+  GL_GLYPH_VERTICAL_BEARING_X_BIT_NV= $20;
+  GL_GLYPH_VERTICAL_BEARING_Y_BIT_NV= $40;
+  GL_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV= $80;
+  GL_GLYPH_HAS_KERNING_NV          = $100;
+  GL_FONT_X_MIN_BOUNDS_NV          = $00010000;
+  GL_FONT_Y_MIN_BOUNDS_NV          = $00020000;
+  GL_FONT_X_MAX_BOUNDS_NV          = $00040000;
+  GL_FONT_Y_MAX_BOUNDS_NV          = $00080000;
+  GL_FONT_UNITS_PER_EM_NV          = $00100000;
+  GL_FONT_ASCENDER_NV              = $00200000;
+  GL_FONT_DESCENDER_NV             = $00400000;
+  GL_FONT_HEIGHT_NV                = $00800000;
+  GL_FONT_MAX_ADVANCE_WIDTH_NV     = $01000000;
+  GL_FONT_MAX_ADVANCE_HEIGHT_NV    = $02000000;
+  GL_FONT_UNDERLINE_POSITION_NV    = $04000000;
+  GL_FONT_UNDERLINE_THICKNESS_NV   = $08000000;
+  GL_FONT_HAS_KERNING_NV           = $10000000;
+
+  // (4.3) GL_AMD_pinned_memory
+  GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD= $9160;
+
+  // (4.3) GL_AMD_stencil_operation_extended
+  GL_SET_AMD                       = $874A;
+  GL_REPLACE_VALUE_AMD             = $874B;
+  GL_STENCIL_OP_VALUE_AMD          = $874C;
+  GL_STENCIL_BACK_OP_VALUE_AMD     = $874D;
+
+  // (4.3) GL_AMD_vertex_shader_viewport_index
+
+  // (4.3) GL_AMD_vertex_shader_layer
+
+  // (4.3) GL_NV_bindless_texture
+
+  // (4.3) GL_NV_shader_atomic_float
+
+  // (4.3) GL_AMD_query_buffer_object
+  GL_QUERY_BUFFER_AMD              = $9192;
+  GL_QUERY_BUFFER_BINDING_AMD      = $9193;
+  GL_QUERY_RESULT_NO_WAIT_AMD      = $9194;
+
+  // GL_FfdMaskSGIX
+  GL_TEXTURE_DEFORMATION_BIT_SGIX = $00000001;
+  GL_GEOMETRY_DEFORMATION_BIT_SGIX = $00000002;
+
+  // GL_HP_convolution_border_modes
+  GL_IGNORE_BORDER_HP = $8150;
+  GL_CONSTANT_BORDER_HP = $8151;
+  GL_REPLICATE_BORDER_HP = $8153;
+  GL_CONVOLUTION_BORDER_COLOR_HP = $8154;
+
+  // GL_HP_image_transform
+  GL_IMAGE_SCALE_X_HP = $8155;
+  GL_IMAGE_SCALE_Y_HP = $8156;
+  GL_IMAGE_TRANSLATE_X_HP = $8157;
+  GL_IMAGE_TRANSLATE_Y_HP = $8158;
+  GL_IMAGE_ROTATE_ANGLE_HP = $8159;
+  GL_IMAGE_ROTATE_ORIGIN_X_HP = $815A;
+  GL_IMAGE_ROTATE_ORIGIN_Y_HP = $815B;
+  GL_IMAGE_MAG_FILTER_HP = $815C;
+  GL_IMAGE_MIN_FILTER_HP = $815D;
+  GL_IMAGE_CUBIC_WEIGHT_HP = $815E;
+  GL_CUBIC_HP = $815F;
+  GL_AVERAGE_HP = $8160;
+  GL_IMAGE_TRANSFORM_2D_HP = $8161;
+  GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8162;
+  GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = $8163;
+
+  // GL_HP_occlusion_test
+  GL_OCCLUSION_TEST_HP = $8165;
+  GL_OCCLUSION_TEST_RESULT_HP = $8166;
+
+  // GL_HP_texture_lighting
+  GL_TEXTURE_LIGHTING_MODE_HP = $8167;
+  GL_TEXTURE_POST_SPECULAR_HP = $8168;
+  GL_TEXTURE_PRE_SPECULAR_HP = $8169;
+
+  // GL_IBM_cull_vertex
+  GL_CULL_VERTEX_IBM = 103050;
+
+  // GL_IBM_rasterpos_clip
+  GL_RASTER_POSITION_UNCLIPPED_IBM = $19262;
+
+  // GL_IBM_texture_mirrored_repeat
+  GL_MIRRORED_REPEAT_IBM = $8370;
+
+  // GL_IBM_vertex_array_lists
+  GL_VERTEX_ARRAY_LIST_IBM = 103070;
+  GL_NORMAL_ARRAY_LIST_IBM = 103071;
+  GL_COLOR_ARRAY_LIST_IBM = 103072;
+  GL_INDEX_ARRAY_LIST_IBM = 103073;
+  GL_TEXTURE_COORD_ARRAY_LIST_IBM = 103074;
+  GL_EDGE_FLAG_ARRAY_LIST_IBM = 103075;
+  GL_FOG_COORDINATE_ARRAY_LIST_IBM = 103076;
+  GL_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077;
+  GL_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080;
+  GL_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081;
+  GL_COLOR_ARRAY_LIST_STRIDE_IBM = 103082;
+  GL_INDEX_ARRAY_LIST_STRIDE_IBM = 103083;
+  GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084;
+  GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085;
+  GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086;
+  GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087;
+
+  // GL_INGR_color_clamp
+  GL_RED_MIN_CLAMP_INGR = $8560;
+  GL_GREEN_MIN_CLAMP_INGR = $8561;
+  GL_BLUE_MIN_CLAMP_INGR = $8562;
+  GL_ALPHA_MIN_CLAMP_INGR = $8563;
+  GL_RED_MAX_CLAMP_INGR = $8564;
+  GL_GREEN_MAX_CLAMP_INGR = $8565;
+  GL_BLUE_MAX_CLAMP_INGR = $8566;
+  GL_ALPHA_MAX_CLAMP_INGR = $8567;
+
+  // GL_INGR_interlace_read
+  GL_INTERLACE_READ_INGR = $8568;
+
+  // GL_INTEL_parallel_arrays
+  GL_PARALLEL_ARRAYS_INTEL = $83F4;
+  GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = $83F5;
+  GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = $83F6;
+  GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = $83F7;
+  GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = $83F8;
+
+  // GL_NV_copy_depth_to_color
+  GL_DEPTH_STENCIL_TO_RGBA_NV = $886E;
+  GL_DEPTH_STENCIL_TO_BGRA_NV = $886F;
+
+  // GL_NV_depth_clamp
+  GL_DEPTH_CLAMP_NV = $864F;
+
+  // GL_NV_evaluators
+  GL_EVAL_2D_NV = $86C0;
+  GL_EVAL_TRIANGULAR_2D_NV = $86C1;
+  GL_MAP_TESSELLATION_NV = $86C2;
+  GL_MAP_ATTRIB_U_ORDER_NV = $86C3;
+  GL_MAP_ATTRIB_V_ORDER_NV = $86C4;
+  GL_EVAL_FRACTIONAL_TESSELLATION_NV = $86C5;
+  GL_EVAL_VERTEX_ATTRIB0_NV = $86C6;
+  GL_EVAL_VERTEX_ATTRIB1_NV = $86C7;
+  GL_EVAL_VERTEX_ATTRIB2_NV = $86C8;
+  GL_EVAL_VERTEX_ATTRIB3_NV = $86C9;
+  GL_EVAL_VERTEX_ATTRIB4_NV = $86CA;
+  GL_EVAL_VERTEX_ATTRIB5_NV = $86CB;
+  GL_EVAL_VERTEX_ATTRIB6_NV = $86CC;
+  GL_EVAL_VERTEX_ATTRIB7_NV = $86CD;
+  GL_EVAL_VERTEX_ATTRIB8_NV = $86CE;
+  GL_EVAL_VERTEX_ATTRIB9_NV = $86CF;
+  GL_EVAL_VERTEX_ATTRIB10_NV = $86D0;
+  GL_EVAL_VERTEX_ATTRIB11_NV = $86D1;
+  GL_EVAL_VERTEX_ATTRIB12_NV = $86D2;
+  GL_EVAL_VERTEX_ATTRIB13_NV = $86D3;
+  GL_EVAL_VERTEX_ATTRIB14_NV = $86D4;
+  GL_EVAL_VERTEX_ATTRIB15_NV = $86D5;
+  GL_MAX_MAP_TESSELLATION_NV = $86D6;
+  GL_MAX_RATIONAL_EVAL_ORDER_NV = $86D7;
+
+  // GL_NV_fence
+  GL_ALL_COMPLETED_NV = $84F2;
+  GL_FENCE_STATUS_NV = $84F3;
+  GL_FENCE_CONDITION_NV = $84F4;
+
+  // GL_NV_float_buffer
+  GL_FLOAT_R_NV = $8880;
+  GL_FLOAT_RG_NV = $8881;
+  GL_FLOAT_RGB_NV = $8882;
+  GL_FLOAT_RGBA_NV = $8883;
+  GL_FLOAT_R16_NV = $8884;
+  GL_FLOAT_R32_NV = $8885;
+  GL_FLOAT_RG16_NV = $8886;
+  GL_FLOAT_RG32_NV = $8887;
+  GL_FLOAT_RGB16_NV = $8888;
+  GL_FLOAT_RGB32_NV = $8889;
+  GL_FLOAT_RGBA16_NV = $888A;
+  GL_FLOAT_RGBA32_NV = $888B;
+  GL_TEXTURE_FLOAT_COMPONENTS_NV = $888C;
+  GL_FLOAT_CLEAR_COLOR_VALUE_NV = $888D;
+  GL_FLOAT_RGBA_MODE_NV = $888E;
+
+  // GL_NV_fog_distance
+  GL_FOG_DISTANCE_MODE_NV = $855A;
+  GL_EYE_RADIAL_NV = $855B;
+  GL_EYE_PLANE_ABSOLUTE_NV = $855C;
+
+  // GL_NV_fragment_program
+  GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = $8868;
+  GL_FRAGMENT_PROGRAM_NV = $8870;
+  GL_MAX_TEXTURE_COORDS_NV = $8871;
+  GL_MAX_TEXTURE_IMAGE_UNITS_NV = $8872;
+  GL_FRAGMENT_PROGRAM_BINDING_NV = $8873;
+  GL_PROGRAM_ERROR_STRING_NV = $8874;
+
+  // GL_NV_half_float
+  GL_HALF_FLOAT_NV = $140B;
+
+  // GL_NV_light_max_exponent
+  GL_MAX_SHININESS_NV = $8504;
+  GL_MAX_SPOT_EXPONENT_NV = $8505;
+
+  // GL_NV_multisample_filter_hint
+  GL_MULTISAMPLE_FILTER_HINT_NV = $8534;
+
+  // GL_NV_occlusion_query
+  GL_PIXEL_COUNTER_BITS_NV = $8864;
+  GL_CURRENT_OCCLUSION_QUERY_ID_NV = $8865;
+  GL_PIXEL_COUNT_NV = $8866;
+  GL_PIXEL_COUNT_AVAILABLE_NV = $8867;
+
+  // GL_NV_packed_depth_stencil
+  GL_DEPTH_STENCIL_NV = $84F9;
+  GL_UNSIGNED_INT_24_8_NV = $84FA;
+
+  // GL_NV_pixel_data_range
+  GL_WRITE_PIXEL_DATA_RANGE_NV = $8878;
+  GL_READ_PIXEL_DATA_RANGE_NV = $8879;
+  GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = $887A;
+  GL_READ_PIXEL_DATA_RANGE_LENGTH_NV = $887B;
+  GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV = $887C;
+  GL_READ_PIXEL_DATA_RANGE_POINTER_NV = $887D;
+
+  // GL_NV_point_sprite
+  GL_POINT_SPRITE_NV = $8861;
+  GL_COORD_REPLACE_NV = $8862;
+  GL_POINT_SPRITE_R_MODE_NV = $8863;
+
+  // GL_NV_primitive_restart
+  GL_PRIMITIVE_RESTART_NV = $8558;
+  GL_PRIMITIVE_RESTART_INDEX_NV = $8559;
+
+  // GL_NV_register_combiners
+  GL_REGISTER_COMBINERS_NV = $8522;
+  GL_VARIABLE_A_NV = $8523;
+  GL_VARIABLE_B_NV = $8524;
+  GL_VARIABLE_C_NV = $8525;
+  GL_VARIABLE_D_NV = $8526;
+  GL_VARIABLE_E_NV = $8527;
+  GL_VARIABLE_F_NV = $8528;
+  GL_VARIABLE_G_NV = $8529;
+  GL_CONSTANT_COLOR0_NV = $852A;
+  GL_CONSTANT_COLOR1_NV = $852B;
+  GL_PRIMARY_COLOR_NV = $852C;
+  GL_SECONDARY_COLOR_NV = $852D;
+  GL_SPARE0_NV = $852E;
+  GL_SPARE1_NV = $852F;
+  GL_DISCARD_NV = $8530;
+  GL_E_TIMES_F_NV = $8531;
+  GL_SPARE0_PLUS_SECONDARY_COLOR_NV = $8532;
+  GL_UNSIGNED_IDENTITY_NV = $8536;
+  GL_UNSIGNED_INVERT_NV = $8537;
+  GL_EXPAND_NORMAL_NV = $8538;
+  GL_EXPAND_NEGATE_NV = $8539;
+  GL_HALF_BIAS_NORMAL_NV = $853A;
+  GL_HALF_BIAS_NEGATE_NV = $853B;
+  GL_SIGNED_IDENTITY_NV = $853C;
+  GL_SIGNED_NEGATE_NV = $853D;
+  GL_SCALE_BY_TWO_NV = $853E;
+  GL_SCALE_BY_FOUR_NV = $853F;
+  GL_SCALE_BY_ONE_HALF_NV = $8540;
+  GL_BIAS_BY_NEGATIVE_ONE_HALF_NV = $8541;
+  GL_COMBINER_INPUT_NV = $8542;
+  GL_COMBINER_MAPPING_NV = $8543;
+  GL_COMBINER_COMPONENT_USAGE_NV = $8544;
+  GL_COMBINER_AB_DOT_PRODUCT_NV = $8545;
+  GL_COMBINER_CD_DOT_PRODUCT_NV = $8546;
+  GL_COMBINER_MUX_SUM_NV = $8547;
+  GL_COMBINER_SCALE_NV = $8548;
+  GL_COMBINER_BIAS_NV = $8549;
+  GL_COMBINER_AB_OUTPUT_NV = $854A;
+  GL_COMBINER_CD_OUTPUT_NV = $854B;
+  GL_COMBINER_SUM_OUTPUT_NV = $854C;
+  GL_MAX_GENERAL_COMBINERS_NV = $854D;
+  GL_NUM_GENERAL_COMBINERS_NV = $854E;
+  GL_COLOR_SUM_CLAMP_NV = $854F;
+  GL_COMBINER0_NV = $8550;
+  GL_COMBINER1_NV = $8551;
+  GL_COMBINER2_NV = $8552;
+  GL_COMBINER3_NV = $8553;
+  GL_COMBINER4_NV = $8554;
+  GL_COMBINER5_NV = $8555;
+  GL_COMBINER6_NV = $8556;
+  GL_COMBINER7_NV = $8557;
+
+  // GL_NV_register_combiners2
+  GL_PER_STAGE_CONSTANTS_NV = $8535;
+
+  // GL_NV_texgen_emboss
+  GL_EMBOSS_LIGHT_NV = $855D;
+  GL_EMBOSS_CONSTANT_NV = $855E;
+  GL_EMBOSS_MAP_NV = $855F;
+
+  // GL_NV_texgen_reflection
+  GL_NORMAL_MAP_NV = $8511;
+  GL_REFLECTION_MAP_NV = $8512;
+
+  // GL_NV_texture_env_combine4
+  GL_COMBINE4_NV = $8503;
+  GL_SOURCE3_RGB_NV = $8583;
+  GL_SOURCE3_ALPHA_NV = $858B;
+  GL_OPERAND3_RGB_NV = $8593;
+  GL_OPERAND3_ALPHA_NV = $859B;
+
+  // GL_NV_texture_expand_normal
+  GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = $888F;
+
+  // GL_NV_texture_rectangle
+  GL_TEXTURE_RECTANGLE_NV = $84F5;
+  GL_TEXTURE_BINDING_RECTANGLE_NV = $84F6;
+  GL_PROXY_TEXTURE_RECTANGLE_NV = $84F7;
+  GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = $84F8;
+
+  // GL_NV_texture_shader
+  GL_OFFSET_TEXTURE_RECTANGLE_NV = $864C;
+  GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = $864D;
+  GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = $864E;
+  GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = $86D9;
+  GL_UNSIGNED_INT_S8_S8_8_8_NV = $86DA;
+  GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = $86DB;
+  GL_DSDT_MAG_INTENSITY_NV = $86DC;
+  GL_SHADER_CONSISTENT_NV = $86DD;
+  GL_TEXTURE_SHADER_NV = $86DE;
+  GL_SHADER_OPERATION_NV = $86DF;
+  GL_CULL_MODES_NV = $86E0;
+  GL_OFFSET_TEXTURE_MATRIX_NV = $86E1;
+  GL_OFFSET_TEXTURE_SCALE_NV = $86E2;
+  GL_OFFSET_TEXTURE_BIAS_NV = $86E3;
+  GL_OFFSET_TEXTURE_2D_MATRIX_NV = GL_OFFSET_TEXTURE_MATRIX_NV;
+  GL_OFFSET_TEXTURE_2D_SCALE_NV = GL_OFFSET_TEXTURE_SCALE_NV;
+  GL_OFFSET_TEXTURE_2D_BIAS_NV = GL_OFFSET_TEXTURE_BIAS_NV;
+  GL_PREVIOUS_TEXTURE_INPUT_NV = $86E4;
+  GL_CONST_EYE_NV = $86E5;
+  GL_PASS_THROUGH_NV = $86E6;
+  GL_CULL_FRAGMENT_NV = $86E7;
+  GL_OFFSET_TEXTURE_2D_NV = $86E8;
+  GL_DEPENDENT_AR_TEXTURE_2D_NV = $86E9;
+  GL_DEPENDENT_GB_TEXTURE_2D_NV = $86EA;
+  GL_DOT_PRODUCT_NV = $86EC;
+  GL_DOT_PRODUCT_DEPTH_REPLACE_NV = $86ED;
+  GL_DOT_PRODUCT_TEXTURE_2D_NV = $86EE;
+  GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = $86F0;
+  GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = $86F1;
+  GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = $86F2;
+  GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = $86F3;
+  GL_HILO_NV = $86F4;
+  GL_DSDT_NV = $86F5;
+  GL_DSDT_MAG_NV = $86F6;
+  GL_DSDT_MAG_VIB_NV = $86F7;
+  GL_HILO16_NV = $86F8;
+  GL_SIGNED_HILO_NV = $86F9;
+  GL_SIGNED_HILO16_NV = $86FA;
+  GL_SIGNED_RGBA_NV = $86FB;
+  GL_SIGNED_RGBA8_NV = $86FC;
+  GL_SIGNED_RGB_NV = $86FE;
+  GL_SIGNED_RGB8_NV = $86FF;
+  GL_SIGNED_LUMINANCE_NV = $8701;
+  GL_SIGNED_LUMINANCE8_NV = $8702;
+  GL_SIGNED_LUMINANCE_ALPHA_NV = $8703;
+  GL_SIGNED_LUMINANCE8_ALPHA8_NV = $8704;
+  GL_SIGNED_ALPHA_NV = $8705;
+  GL_SIGNED_ALPHA8_NV = $8706;
+  GL_SIGNED_INTENSITY_NV = $8707;
+  GL_SIGNED_INTENSITY8_NV = $8708;
+  GL_DSDT8_NV = $8709;
+  GL_DSDT8_MAG8_NV = $870A;
+  GL_DSDT8_MAG8_INTENSITY8_NV = $870B;
+  GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = $870C;
+  GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = $870D;
+  GL_HI_SCALE_NV = $870E;
+  GL_LO_SCALE_NV = $870F;
+  GL_DS_SCALE_NV = $8710;
+  GL_DT_SCALE_NV = $8711;
+  GL_MAGNITUDE_SCALE_NV = $8712;
+  GL_VIBRANCE_SCALE_NV = $8713;
+  GL_HI_BIAS_NV = $8714;
+  GL_LO_BIAS_NV = $8715;
+  GL_DS_BIAS_NV = $8716;
+  GL_DT_BIAS_NV = $8717;
+  GL_MAGNITUDE_BIAS_NV = $8718;
+  GL_VIBRANCE_BIAS_NV = $8719;
+  GL_TEXTURE_BORDER_VALUES_NV = $871A;
+  GL_TEXTURE_HI_SIZE_NV = $871B;
+  GL_TEXTURE_LO_SIZE_NV = $871C;
+  GL_TEXTURE_DS_SIZE_NV = $871D;
+  GL_TEXTURE_DT_SIZE_NV = $871E;
+  GL_TEXTURE_MAG_SIZE_NV = $871F;
+
+  // GL_NV_texture_shader2
+  GL_DOT_PRODUCT_TEXTURE_3D_NV = $86EF;
+
+  // GL_NV_texture_shader3
+  GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = $8850;
+  GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = $8851;
+  GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8852;
+  GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = $8853;
+  GL_OFFSET_HILO_TEXTURE_2D_NV = $8854;
+  GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = $8855;
+  GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = $8856;
+  GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = $8857;
+  GL_DEPENDENT_HILO_TEXTURE_2D_NV = $8858;
+  GL_DEPENDENT_RGB_TEXTURE_3D_NV = $8859;
+  GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = $885A;
+  GL_DOT_PRODUCT_PASS_THROUGH_NV = $885B;
+  GL_DOT_PRODUCT_TEXTURE_1D_NV = $885C;
+  GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = $885D;
+  GL_HILO8_NV = $885E;
+  GL_SIGNED_HILO8_NV = $885F;
+  GL_FORCE_BLUE_TO_ONE_NV = $8860;
+
+  // GL_NV_vertex_array_range
+  GL_VERTEX_ARRAY_RANGE_NV = $851D;
+  GL_VERTEX_ARRAY_RANGE_LENGTH_NV = $851E;
+  GL_VERTEX_ARRAY_RANGE_VALID_NV = $851F;
+  GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = $8520;
+  GL_VERTEX_ARRAY_RANGE_POINTER_NV = $8521;
+
+  // GL_NV_vertex_array_range2
+  GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = $8533;
+
+  // GL_NV_vertex_program
+  GL_VERTEX_PROGRAM_NV = $8620;
+  GL_VERTEX_STATE_PROGRAM_NV = $8621;
+  GL_ATTRIB_ARRAY_SIZE_NV = $8623;
+  GL_ATTRIB_ARRAY_STRIDE_NV = $8624;
+  GL_ATTRIB_ARRAY_TYPE_NV = $8625;
+  GL_CURRENT_ATTRIB_NV = $8626;
+  GL_PROGRAM_LENGTH_NV = $8627;
+  GL_PROGRAM_STRING_NV = $8628;
+  GL_MODELVIEW_PROJECTION_NV = $8629;
+  GL_IDENTITY_NV = $862A;
+  GL_INVERSE_NV = $862B;
+  GL_TRANSPOSE_NV = $862C;
+  GL_INVERSE_TRANSPOSE_NV = $862D;
+  GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = $862E;
+  GL_MAX_TRACK_MATRICES_NV = $862F;
+  GL_MATRIX0_NV = $8630;
+  GL_MATRIX1_NV = $8631;
+  GL_MATRIX2_NV = $8632;
+  GL_MATRIX3_NV = $8633;
+  GL_MATRIX4_NV = $8634;
+  GL_MATRIX5_NV = $8635;
+  GL_MATRIX6_NV = $8636;
+  GL_MATRIX7_NV = $8637;
+  GL_CURRENT_MATRIX_STACK_DEPTH_NV = $8640;
+  GL_CURRENT_MATRIX_NV = $8641;
+  GL_VERTEX_PROGRAM_POINT_SIZE_NV = $8642;
+  GL_VERTEX_PROGRAM_TWO_SIDE_NV = $8643;
+  GL_PROGRAM_PARAMETER_NV = $8644;
+  GL_ATTRIB_ARRAY_POINTER_NV = $8645;
+  GL_PROGRAM_TARGET_NV = $8646;
+  GL_PROGRAM_RESIDENT_NV = $8647;
+  GL_TRACK_MATRIX_NV = $8648;
+  GL_TRACK_MATRIX_TRANSFORM_NV = $8649;
+  GL_VERTEX_PROGRAM_BINDING_NV = $864A;
+  GL_PROGRAM_ERROR_POSITION_NV = $864B;
+  GL_VERTEX_ATTRIB_ARRAY0_NV = $8650;
+  GL_VERTEX_ATTRIB_ARRAY1_NV = $8651;
+  GL_VERTEX_ATTRIB_ARRAY2_NV = $8652;
+  GL_VERTEX_ATTRIB_ARRAY3_NV = $8653;
+  GL_VERTEX_ATTRIB_ARRAY4_NV = $8654;
+  GL_VERTEX_ATTRIB_ARRAY5_NV = $8655;
+  GL_VERTEX_ATTRIB_ARRAY6_NV = $8656;
+  GL_VERTEX_ATTRIB_ARRAY7_NV = $8657;
+  GL_VERTEX_ATTRIB_ARRAY8_NV = $8658;
+  GL_VERTEX_ATTRIB_ARRAY9_NV = $8659;
+  GL_VERTEX_ATTRIB_ARRAY10_NV = $865A;
+  GL_VERTEX_ATTRIB_ARRAY11_NV = $865B;
+  GL_VERTEX_ATTRIB_ARRAY12_NV = $865C;
+  GL_VERTEX_ATTRIB_ARRAY13_NV = $865D;
+  GL_VERTEX_ATTRIB_ARRAY14_NV = $865E;
+  GL_VERTEX_ATTRIB_ARRAY15_NV = $865F;
+  GL_MAP1_VERTEX_ATTRIB0_4_NV = $8660;
+  GL_MAP1_VERTEX_ATTRIB1_4_NV = $8661;
+  GL_MAP1_VERTEX_ATTRIB2_4_NV = $8662;
+  GL_MAP1_VERTEX_ATTRIB3_4_NV = $8663;
+  GL_MAP1_VERTEX_ATTRIB4_4_NV = $8664;
+  GL_MAP1_VERTEX_ATTRIB5_4_NV = $8665;
+  GL_MAP1_VERTEX_ATTRIB6_4_NV = $8666;
+  GL_MAP1_VERTEX_ATTRIB7_4_NV = $8667;
+  GL_MAP1_VERTEX_ATTRIB8_4_NV = $8668;
+  GL_MAP1_VERTEX_ATTRIB9_4_NV = $8669;
+  GL_MAP1_VERTEX_ATTRIB10_4_NV = $866A;
+  GL_MAP1_VERTEX_ATTRIB11_4_NV = $866B;
+  GL_MAP1_VERTEX_ATTRIB12_4_NV = $866C;
+  GL_MAP1_VERTEX_ATTRIB13_4_NV = $866D;
+  GL_MAP1_VERTEX_ATTRIB14_4_NV = $866E;
+  GL_MAP1_VERTEX_ATTRIB15_4_NV = $866F;
+  GL_MAP2_VERTEX_ATTRIB0_4_NV = $8670;
+  GL_MAP2_VERTEX_ATTRIB1_4_NV = $8671;
+  GL_MAP2_VERTEX_ATTRIB2_4_NV = $8672;
+  GL_MAP2_VERTEX_ATTRIB3_4_NV = $8673;
+  GL_MAP2_VERTEX_ATTRIB4_4_NV = $8674;
+  GL_MAP2_VERTEX_ATTRIB5_4_NV = $8675;
+  GL_MAP2_VERTEX_ATTRIB6_4_NV = $8676;
+  GL_MAP2_VERTEX_ATTRIB7_4_NV = $8677;
+  GL_MAP2_VERTEX_ATTRIB8_4_NV = $8678;
+  GL_MAP2_VERTEX_ATTRIB9_4_NV = $8679;
+  GL_MAP2_VERTEX_ATTRIB10_4_NV = $867A;
+  GL_MAP2_VERTEX_ATTRIB11_4_NV = $867B;
+  GL_MAP2_VERTEX_ATTRIB12_4_NV = $867C;
+  GL_MAP2_VERTEX_ATTRIB13_4_NV = $867D;
+  GL_MAP2_VERTEX_ATTRIB14_4_NV = $867E;
+  GL_MAP2_VERTEX_ATTRIB15_4_NV = $867F;
+
+  // GL_NV_fragment_program2 and GL_NV_vertex_program2_option
+  GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = $88F4;
+  GL_MAX_PROGRAM_CALL_DEPTH_NV = $88F5;
+
+  // GL_NV_fragment_program2
+  GL_MAX_PROGRAM_IF_DEPTH_NV = $88F6;
+  GL_MAX_PROGRAM_LOOP_DEPTH_NV = $88F7;
+  GL_MAX_PROGRAM_LOOP_COUNT_NV = $88F8;
+
+  // GL_NV_vertex_program3
+  MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
+
+  // GL_NV_depth_buffer_float
+  GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = $8DAD;
+  GL_DEPTH_BUFFER_FLOAT_MODE_NV = $8DAF;
+
+  // GL_NV_framebuffer_multisample_coverage
+  GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = $8CAB;
+  GL_RENDERBUFFER_COLOR_SAMPLES_NV = $8E10;
+
+  // GL_NV_geometry_program4
+  GL_GEOMETRY_PROGRAM_NV = $8C26;
+  GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = $8C27;
+  GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = $8C28;
+
+  // GL_NV_gpu_program4
+  GL_PROGRAM_ATTRIB_COMPONENTS_NV = $8906;
+  GL_PROGRAM_RESULT_COMPONENTS_NV = $8907;
+  GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = $8908;
+  GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = $8909;
+  GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = $8DA5;
+  GL_MAX_PROGRAM_GENERIC_RESULTS_NV = $8DA6;
+
+  // GL_NV_parameter_buffer_object
+  GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = $8DA0;
+  GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = $8DA1;
+  GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = $8DA2;
+  GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = $8DA3;
+  GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = $8DA4;
+
+  // GL_NV_transform_feedback
+  GL_TRANSFORM_FEEDBACK_BUFFER_NV = $8C8E;
+  GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = $8C84;
+  GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = $8C85;
+  GL_TRANSFORM_FEEDBACK_RECORD_NV = $8C86;
+  GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = $8C8F;
+  GL_INTERLEAVED_ATTRIBS_NV = $8C8C;
+  GL_SEPARATE_ATTRIBS_NV = $8C8D;
+  GL_PRIMITIVES_GENERATED_NV = $8C87;
+  GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = $8C88;
+  GL_RASTERIZER_DISCARD_NV = $8C89;
+  GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = $8C8A;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = $8C8B;
+  GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = $8C80;
+  GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = $8C7E;
+  GL_ACTIVE_VARYINGS_NV = $8C81;
+  GL_ACTIVE_VARYING_MAX_LENGTH_NV = $8C82;
+  GL_TRANSFORM_FEEDBACK_VARYINGS_NV = $8C83;
+  GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = $8C7F;
+  GL_BACK_PRIMARY_COLOR_NV = $8C77;
+  GL_BACK_SECONDARY_COLOR_NV = $8C78;
+  GL_TEXTURE_COORD_NV = $8C79;
+  GL_CLIP_DISTANCE_NV = $8C7A;
+  GL_VERTEX_ID_NV = $8C7B;
+  GL_PRIMITIVE_ID_NV = $8C7C;
+  GL_GENERIC_ATTRIB_NV = $8C7D;
+  GL_LAYER_NV = $8DAA;
+  GL_NEXT_BUFFER_NV = -2;
+  GL_SKIP_COMPONENTS4_NV = -3;
+  GL_SKIP_COMPONENTS3_NV = -4;
+  GL_SKIP_COMPONENTS2_NV = -5;
+  GL_SKIP_COMPONENTS1_NV = -6;
+
+  // GL_NV_conditional_render
+  GL_QUERY_WAIT_NV = $8E13;
+  GL_QUERY_NO_WAIT_NV = $8E14;
+  GL_QUERY_BY_REGION_WAIT_NV = $8E15;
+  GL_QUERY_BY_REGION_NO_WAIT_NV = $8E16;
+
+  // GL_NV_present_video
+  GL_FRAME_NV = $8E26;
+  GL_FIELDS_NV = $8E27;
+  GL_CURRENT_TIME_NV = $8E28;
+  GL_NUM_FILL_STREAMS_NV = $8E29;
+  GL_PRESENT_TIME_NV = $8E2A;
+  GL_PRESENT_DURATION_NV = $8E2B;
+
+  // GL_NV_explicit_multisample
+  GL_SAMPLE_POSITION_NV = $8E50;
+  GL_SAMPLE_MASK_NV = $8E51;
+  GL_SAMPLE_MASK_VALUE_NV = $8E52;
+  GL_TEXTURE_BINDING_RENDERBUFFER_NV = $8E53;
+  GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = $8E54;
+  GL_TEXTURE_RENDERBUFFER_NV = $8E55;
+  GL_SAMPLER_RENDERBUFFER_NV = $8E56;
+  GL_INT_SAMPLER_RENDERBUFFER_NV = $8E57;
+  GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = $8E58;
+  GL_MAX_SAMPLE_MASK_WORDS_NV = $8E59;
+
+  // GL_NV_transform_feedback2
+  GL_TRANSFORM_FEEDBACK_NV = $8E22;
+  GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = $8E23;
+  GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = $8E24;
+  GL_TRANSFORM_FEEDBACK_BINDING_NV = $8E25;
+  
+  // GL_NV_video_capture
+  GL_VIDEO_BUFFER_NV = $9020;
+  GL_VIDEO_BUFFER_BINDING_NV = $9021;
+  GL_FIELD_UPPER_NV = $9022;
+  GL_FIELD_LOWER_NV = $9023;
+  GL_NUM_VIDEO_CAPTURE_STREAMS_NV = $9024;
+  GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = $9025;
+  GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = $9026;
+  GL_LAST_VIDEO_CAPTURE_STATUS_NV = $9027;
+  GL_VIDEO_BUFFER_PITCH_NV = $9028;
+  GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = $9029;
+  GL_VIDEO_COLOR_CONVERSION_MAX_NV = $902A;
+  GL_VIDEO_COLOR_CONVERSION_MIN_NV = $902B;
+  GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = $902C;
+  GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = $902D;
+  GL_PARTIAL_SUCCESS_NV = $902E;
+  GL_SUCCESS_NV = $902F;
+  GL_FAILURE_NV = $9030;
+  GL_YCBYCR8_422_NV = $9031;
+  GL_YCBAYCR8A_4224_NV = $9032;
+  GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = $9033;
+  GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = $9034;
+  GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = $9035;
+  GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = $9036;
+  GL_Z4Y12Z4CB12Z4CR12_444_NV = $9037;
+  GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = $9038;
+  GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = $9039;
+  GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = $903A;
+  GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = $903B;
+  GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = $903C;
+  
+  // GL_NV_shader_buffer_load
+  GL_BUFFER_GPU_ADDRESS_NV = $8F1D;
+  GL_GPU_ADDRESS_NV = $8F34;
+  GL_MAX_SHADER_BUFFER_ADDRESS_NV = $8F35;
+
+  // GL_NV_vertex_buffer_unified_memory
+  GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = $8F1E;
+  GL_ELEMENT_ARRAY_UNIFIED_NV = $8F1F;
+  GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = $8F20;
+  GL_VERTEX_ARRAY_ADDRESS_NV = $8F21;
+  GL_NORMAL_ARRAY_ADDRESS_NV = $8F22;
+  GL_COLOR_ARRAY_ADDRESS_NV = $8F23;
+  GL_INDEX_ARRAY_ADDRESS_NV = $8F24;
+  GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = $8F25;
+  GL_EDGE_FLAG_ARRAY_ADDRESS_NV = $8F26;
+  GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = $8F27;
+  GL_FOG_COORD_ARRAY_ADDRESS_NV = $8F28;
+  GL_ELEMENT_ARRAY_ADDRESS_NV = $8F29;
+  GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = $8F2A;
+  GL_VERTEX_ARRAY_LENGTH_NV = $8F2B;
+  GL_NORMAL_ARRAY_LENGTH_NV = $8F2C;
+  GL_COLOR_ARRAY_LENGTH_NV = $8F2D;
+  GL_INDEX_ARRAY_LENGTH_NV = $8F2E;
+  GL_TEXTURE_COORD_ARRAY_LENGTH_NV = $8F2F;
+  GL_EDGE_FLAG_ARRAY_LENGTH_NV = $8F30;
+  GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = $8F31;
+  GL_FOG_COORD_ARRAY_LENGTH_NV = $8F32;
+  GL_ELEMENT_ARRAY_LENGTH_NV = $8F33;
+  GL_DRAW_INDIRECT_UNIFIED_NV = $8F40;
+  GL_DRAW_INDIRECT_ADDRESS_NV = $8F41;
+  GL_DRAW_INDIRECT_LENGTH_NV = $8F42;
+
+  // GL_NV_gpu_program5
+  GL_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = $8E5A;
+  GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5B;
+  GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = $8E5C;
+  GL_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = $8E5D;
+  GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5E;
+  GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = $8E5F;
+  GL_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = $8F44;
+  GL_MAX_PROGRAM_SUBROUTINE_NUM_NV = $8F45;
+
+  // GL_NV_gpu_shader5
+  GL_INT64_NV = $140E;
+  GL_UNSIGNED_INT64_NV = $140F;
+  GL_INT8_NV = $8FE0;
+  GL_INT8_VEC2_NV = $8FE1;
+  GL_INT8_VEC3_NV = $8FE2;
+  GL_INT8_VEC4_NV = $8FE3;
+  GL_INT16_NV = $8FE4;
+  GL_INT16_VEC2_NV = $8FE5;
+  GL_INT16_VEC3_NV = $8FE6;
+  GL_INT16_VEC4_NV = $8FE7;
+  GL_INT64_VEC2_NV = $8FE9;
+  GL_INT64_VEC3_NV = $8FEA;
+  GL_INT64_VEC4_NV = $8FEB;
+  GL_UNSIGNED_INT8_NV = $8FEC;
+  GL_UNSIGNED_INT8_VEC2_NV = $8FED;
+  GL_UNSIGNED_INT8_VEC3_NV = $8FEE;
+  GL_UNSIGNED_INT8_VEC4_NV = $8FEF;
+  GL_UNSIGNED_INT16_NV = $8FF0;
+  GL_UNSIGNED_INT16_VEC2_NV = $8FF1;
+  GL_UNSIGNED_INT16_VEC3_NV = $8FF2;
+  GL_UNSIGNED_INT16_VEC4_NV = $8FF3;
+  GL_UNSIGNED_INT64_VEC2_NV = $8FF5;
+  GL_UNSIGNED_INT64_VEC3_NV = $8FF6;
+  GL_UNSIGNED_INT64_VEC4_NV = $8FF7;
+  GL_FLOAT16_NV = $8FF8;
+  GL_FLOAT16_VEC2_NV = $8FF9;
+  GL_FLOAT16_VEC3_NV = $8FFA;
+  GL_FLOAT16_VEC4_NV = $8FFB;
+  { reuse GL_PATCHES }
+
+  // GL_NV_shader_buffer_store
+  GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = $00000010;
+  { reuse GL_READ_WRITE }
+  { reuse GL_WRITE_ONLY }
+
+  // GL_NV_tessellation_program5
+  GL_MAX_PROGRAM_PATCH_ATTRIBS_NV = $86D8;
+  GL_TESS_CONTROL_PROGRAM_NV = $891E;
+  GL_TESS_EVALUATION_PROGRAM_NV = $891F;
+  GL_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = $8C74;
+  GL_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = $8C75;
+
+  // GL_NV_vertex_attrib_integer_64bit
+  { reuse GL_INT64_NV }
+  { reuse GL_UNSIGNED_INT64_NV }
+
+  // GL_NV_multisample_coverage
+  GL_COVERAGE_SAMPLES_NV = $80A9;
+  GL_COLOR_SAMPLES_NV = $8E20;
+
+  // GL_NV_vdpau_interop
+  GL_SURFACE_STATE_NV = $86EB;
+  GL_SURFACE_REGISTERED_NV = $86FD;
+  GL_SURFACE_MAPPED_NV = $8700;
+  GL_WRITE_DISCARD_NV = $88BE;
+
+  // GL_OML_interlace
+  GL_INTERLACE_OML = $8980;
+  GL_INTERLACE_READ_OML = $8981;
+
+  // GL_OML_resample
+  GL_PACK_RESAMPLE_OML = $8984;
+  GL_UNPACK_RESAMPLE_OML = $8985;
+  GL_RESAMPLE_REPLICATE_OML = $8986;
+  GL_RESAMPLE_ZERO_FILL_OML = $8987;
+  GL_RESAMPLE_AVERAGE_OML = $8988;
+  GL_RESAMPLE_DECIMATE_OML = $8989;
+
+  // GL_OML_subsample
+  GL_FORMAT_SUBSAMPLE_24_24_OML = $8982;
+  GL_FORMAT_SUBSAMPLE_244_244_OML = $8983;
+
+  // GL_PGI_misc_hints
+  GL_PREFER_DOUBLEBUFFER_HINT_PGI = $1A1F8;
+  GL_CONSERVE_MEMORY_HINT_PGI = $1A1FD;
+  GL_RECLAIM_MEMORY_HINT_PGI = $1A1FE;
+  GL_NATIVE_GRAPHICS_HANDLE_PGI = $1A202;
+  GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI = $1A203;
+  GL_NATIVE_GRAPHICS_END_HINT_PGI = $1A204;
+  GL_ALWAYS_FAST_HINT_PGI = $1A20C;
+  GL_ALWAYS_SOFT_HINT_PGI = $1A20D;
+  GL_ALLOW_DRAW_OBJ_HINT_PGI = $1A20E;
+  GL_ALLOW_DRAW_WIN_HINT_PGI = $1A20F;
+  GL_ALLOW_DRAW_FRG_HINT_PGI = $1A210;
+  GL_ALLOW_DRAW_MEM_HINT_PGI = $1A211;
+  GL_STRICT_DEPTHFUNC_HINT_PGI = $1A216;
+  GL_STRICT_LIGHTING_HINT_PGI = $1A217;
+  GL_STRICT_SCISSOR_HINT_PGI = $1A218;
+  GL_FULL_STIPPLE_HINT_PGI = $1A219;
+  GL_CLIP_NEAR_HINT_PGI = $1A220;
+  GL_CLIP_FAR_HINT_PGI = $1A221;
+  GL_WIDE_LINE_HINT_PGI = $1A222;
+  GL_BACK_NORMALS_HINT_PGI = $1A223;
+
+  // GL_PGI_vertex_hints
+  GL_VERTEX_DATA_HINT_PGI = $1A22A;
+  GL_VERTEX_CONSISTENT_HINT_PGI = $1A22B;
+  GL_MATERIAL_SIDE_HINT_PGI = $1A22C;
+  GL_MAX_VERTEX_HINT_PGI = $1A22D;
+  GL_COLOR3_BIT_PGI = $00010000;
+  GL_COLOR4_BIT_PGI = $00020000;
+  GL_EDGEFLAG_BIT_PGI = $00040000;
+  GL_INDEX_BIT_PGI = $00080000;
+  GL_MAT_AMBIENT_BIT_PGI = $00100000;
+  GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = $00200000;
+  GL_MAT_DIFFUSE_BIT_PGI = $00400000;
+  GL_MAT_EMISSION_BIT_PGI = $00800000;
+  GL_MAT_COLOR_INDEXES_BIT_PGI = $01000000;
+  GL_MAT_SHININESS_BIT_PGI = $02000000;
+  GL_MAT_SPECULAR_BIT_PGI = $04000000;
+  GL_NORMAL_BIT_PGI = $08000000;
+  GL_TEXCOORD1_BIT_PGI = $10000000;
+  GL_TEXCOORD2_BIT_PGI = $20000000;
+  GL_TEXCOORD3_BIT_PGI = $40000000;
+  GL_TEXCOORD4_BIT_PGI = $80000000;
+  GL_VERTEX23_BIT_PGI = $00000004;
+  GL_VERTEX4_BIT_PGI = $00000008;
+
+  // GL_REND_screen_coordinates
+  GL_SCREEN_COORDINATES_REND = $8490;
+  GL_INVERTED_SCREEN_W_REND = $8491;
+
+  // GL_S3_s3tc
+  GL_RGB_S3TC = $83A0;
+  GL_RGB4_S3TC = $83A1;
+  GL_RGBA_S3TC = $83A2;
+  GL_RGBA4_S3TC = $83A3;
+
+  // GL_SGIS_detail_texture
+  GL_DETAIL_TEXTURE_2D_SGIS = $8095;
+  GL_DETAIL_TEXTURE_2D_BINDING_SGIS = $8096;
+  GL_LINEAR_DETAIL_SGIS = $8097;
+  GL_LINEAR_DETAIL_ALPHA_SGIS = $8098;
+  GL_LINEAR_DETAIL_COLOR_SGIS = $8099;
+  GL_DETAIL_TEXTURE_LEVEL_SGIS = $809A;
+  GL_DETAIL_TEXTURE_MODE_SGIS = $809B;
+  GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS = $809C;
+
+  // GL_SGIS_fog_function
+  GL_FOG_FUNC_SGIS = $812A;
+  GL_FOG_FUNC_POINTS_SGIS = $812B;
+  GL_MAX_FOG_FUNC_POINTS_SGIS = $812C;
+
+  // GL_SGIS_generate_mipmap
+  GL_GENERATE_MIPMAP_SGIS = $8191;
+  GL_GENERATE_MIPMAP_HINT_SGIS = $8192;
+
+  // GL_SGIS_multisample
+  GL_MULTISAMPLE_SGIS = $809D;
+  GL_SAMPLE_ALPHA_TO_MASK_SGIS = $809E;
+  GL_SAMPLE_ALPHA_TO_ONE_SGIS = $809F;
+  GL_SAMPLE_MASK_SGIS = $80A0;
+  GL_1PASS_SGIS = $80A1;
+  GL_2PASS_0_SGIS = $80A2;
+  GL_2PASS_1_SGIS = $80A3;
+  GL_4PASS_0_SGIS = $80A4;
+  GL_4PASS_1_SGIS = $80A5;
+  GL_4PASS_2_SGIS = $80A6;
+  GL_4PASS_3_SGIS = $80A7;
+  GL_SAMPLE_BUFFERS_SGIS = $80A8;
+  GL_SAMPLES_SGIS = $80A9;
+  GL_SAMPLE_MASK_VALUE_SGIS = $80AA;
+  GL_SAMPLE_MASK_INVERT_SGIS = $80AB;
+  GL_SAMPLE_PATTERN_SGIS = $80AC;
+
+  // GL_SGIS_pixel_texture
+  GL_PIXEL_TEXTURE_SGIS = $8353;
+  GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = $8354;
+  GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = $8355;
+  GL_PIXEL_GROUP_COLOR_SGIS = $8356;
+
+  // GL_SGIS_point_line_texgen
+  GL_EYE_DISTANCE_TO_POINT_SGIS = $81F0;
+  GL_OBJECT_DISTANCE_TO_POINT_SGIS = $81F1;
+  GL_EYE_DISTANCE_TO_LINE_SGIS = $81F2;
+  GL_OBJECT_DISTANCE_TO_LINE_SGIS = $81F3;
+  GL_EYE_POINT_SGIS = $81F4;
+  GL_OBJECT_POINT_SGIS = $81F5;
+  GL_EYE_LINE_SGIS = $81F6;
+  GL_OBJECT_LINE_SGIS = $81F7;
+
+  // GL_SGIS_point_parameters
+  GL_POINT_SIZE_MIN_SGIS = $8126;
+  GL_POINT_SIZE_MAX_SGIS = $8127;
+  GL_POINT_FADE_THRESHOLD_SIZE_SGIS = $8128;
+  GL_DISTANCE_ATTENUATION_SGIS = $8129;
+
+  // GL_SGIS_sharpen_texture
+  GL_LINEAR_SHARPEN_SGIS = $80AD;
+  GL_LINEAR_SHARPEN_ALPHA_SGIS = $80AE;
+  GL_LINEAR_SHARPEN_COLOR_SGIS = $80AF;
+  GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = $80B0;
+
+  // GL_SGIS_texture4D
+  GL_PACK_SKIP_VOLUMES_SGIS = $8130;
+  GL_PACK_IMAGE_DEPTH_SGIS = $8131;
+  GL_UNPACK_SKIP_VOLUMES_SGIS = $8132;
+  GL_UNPACK_IMAGE_DEPTH_SGIS = $8133;
+  GL_TEXTURE_4D_SGIS = $8134;
+  GL_PROXY_TEXTURE_4D_SGIS = $8135;
+  GL_TEXTURE_4DSIZE_SGIS = $8136;
+  GL_TEXTURE_WRAP_Q_SGIS = $8137;
+  GL_MAX_4D_TEXTURE_SIZE_SGIS = $8138;
+  GL_TEXTURE_4D_BINDING_SGIS = $814F;
+
+  // GL_SGIS_texture_color_mask
+  GL_TEXTURE_COLOR_WRITEMASK_SGIS = $81EF;
+
+  // GL_SGIS_texture_edge_clamp
+  GL_CLAMP_TO_EDGE_SGIS = $812F;
+
+  // GL_SGIS_texture_filter4
+  GL_FILTER4_SGIS = $8146;
+  GL_TEXTURE_FILTER4_SIZE_SGIS = $8147;
+
+  // GL_SGIS_texture_lod
+  GL_TEXTURE_MIN_LOD_SGIS = $813A;
+  GL_TEXTURE_MAX_LOD_SGIS = $813B;
+  GL_TEXTURE_BASE_LEVEL_SGIS = $813C;
+  GL_TEXTURE_MAX_LEVEL_SGIS = $813D;
+
+  // GL_SGIS_texture_select
+  GL_DUAL_ALPHA4_SGIS = $8110;
+  GL_DUAL_ALPHA8_SGIS = $8111;
+  GL_DUAL_ALPHA12_SGIS = $8112;
+  GL_DUAL_ALPHA16_SGIS = $8113;
+  GL_DUAL_LUMINANCE4_SGIS = $8114;
+  GL_DUAL_LUMINANCE8_SGIS = $8115;
+  GL_DUAL_LUMINANCE12_SGIS = $8116;
+  GL_DUAL_LUMINANCE16_SGIS = $8117;
+  GL_DUAL_INTENSITY4_SGIS = $8118;
+  GL_DUAL_INTENSITY8_SGIS = $8119;
+  GL_DUAL_INTENSITY12_SGIS = $811A;
+  GL_DUAL_INTENSITY16_SGIS = $811B;
+  GL_DUAL_LUMINANCE_ALPHA4_SGIS = $811C;
+  GL_DUAL_LUMINANCE_ALPHA8_SGIS = $811D;
+  GL_QUAD_ALPHA4_SGIS = $811E;
+  GL_QUAD_ALPHA8_SGIS = $811F;
+  GL_QUAD_LUMINANCE4_SGIS = $8120;
+  GL_QUAD_LUMINANCE8_SGIS = $8121;
+  GL_QUAD_INTENSITY4_SGIS = $8122;
+  GL_QUAD_INTENSITY8_SGIS = $8123;
+  GL_DUAL_TEXTURE_SELECT_SGIS = $8124;
+  GL_QUAD_TEXTURE_SELECT_SGIS = $8125;
+
+  // GL_SGIX_async
+  GL_ASYNC_MARKER_SGIX = $8329;
+
+  // GL_SGIX_async_histogram
+  GL_ASYNC_HISTOGRAM_SGIX = $832C;
+  GL_MAX_ASYNC_HISTOGRAM_SGIX = $832D;
+
+  // GL_SGIX_async_pixel
+  GL_ASYNC_TEX_IMAGE_SGIX = $835C;
+  GL_ASYNC_DRAW_PIXELS_SGIX = $835D;
+  GL_ASYNC_READ_PIXELS_SGIX = $835E;
+  GL_MAX_ASYNC_TEX_IMAGE_SGIX = $835F;
+  GL_MAX_ASYNC_DRAW_PIXELS_SGIX = $8360;
+  GL_MAX_ASYNC_READ_PIXELS_SGIX = $8361;
+
+  // GL_SGIX_blend_alpha_minmax
+  GL_ALPHA_MIN_SGIX = $8320;
+  GL_ALPHA_MAX_SGIX = $8321;
+
+  // GL_SGIX_calligraphic_fragment
+  GL_CALLIGRAPHIC_FRAGMENT_SGIX = $8183;
+
+  // GL_SGIX_clipmap
+  GL_LINEAR_CLIPMAP_LINEAR_SGIX = $8170;
+  GL_TEXTURE_CLIPMAP_CENTER_SGIX = $8171;
+  GL_TEXTURE_CLIPMAP_FRAME_SGIX = $8172;
+  GL_TEXTURE_CLIPMAP_OFFSET_SGIX = $8173;
+  GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8174;
+  GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = $8175;
+  GL_TEXTURE_CLIPMAP_DEPTH_SGIX = $8176;
+  GL_MAX_CLIPMAP_DEPTH_SGIX = $8177;
+  GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = $8178;
+  GL_NEAREST_CLIPMAP_NEAREST_SGIX = $844D;
+  GL_NEAREST_CLIPMAP_LINEAR_SGIX = $844E;
+  GL_LINEAR_CLIPMAP_NEAREST_SGIX = $844F;
+
+  // GL_SGIX_convolution_accuracy
+  GL_CONVOLUTION_HINT_SGIX = $8316;
+
+  // GL_SGIX_depth_texture
+  GL_DEPTH_COMPONENT16_SGIX = $81A5;
+  GL_DEPTH_COMPONENT24_SGIX = $81A6;
+  GL_DEPTH_COMPONENT32_SGIX = $81A7;
+
+  // GL_SGIX_fog_offset
+  GL_FOG_OFFSET_SGIX = $8198;
+  GL_FOG_OFFSET_VALUE_SGIX = $8199;
+
+  // GL_SGIX_fog_scale
+  GL_FOG_SCALE_SGIX = $81FC;
+  GL_FOG_SCALE_VALUE_SGIX = $81FD;
+
+  // GL_SGIX_fragment_lighting
+  GL_FRAGMENT_LIGHTING_SGIX = $8400;
+  GL_FRAGMENT_COLOR_MATERIAL_SGIX = $8401;
+  GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = $8402;
+  GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = $8403;
+  GL_MAX_FRAGMENT_LIGHTS_SGIX = $8404;
+  GL_MAX_ACTIVE_LIGHTS_SGIX = $8405;
+  GL_CURRENT_RASTER_NORMAL_SGIX = $8406;
+  GL_LIGHT_ENV_MODE_SGIX = $8407;
+  GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = $8408;
+  GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = $8409;
+  GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = $840A;
+  GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = $840B;
+  GL_FRAGMENT_LIGHT0_SGIX = $840C;
+  GL_FRAGMENT_LIGHT1_SGIX = $840D;
+  GL_FRAGMENT_LIGHT2_SGIX = $840E;
+  GL_FRAGMENT_LIGHT3_SGIX = $840F;
+  GL_FRAGMENT_LIGHT4_SGIX = $8410;
+  GL_FRAGMENT_LIGHT5_SGIX = $8411;
+  GL_FRAGMENT_LIGHT6_SGIX = $8412;
+  GL_FRAGMENT_LIGHT7_SGIX = $8413;
+
+  // GL_SGIX_framezoom
+  GL_FRAMEZOOM_SGIX = $818B;
+  GL_FRAMEZOOM_FACTOR_SGIX = $818C;
+  GL_MAX_FRAMEZOOM_FACTOR_SGIX = $818D;
+
+  // GL_SGIX_impact_pixel_texture
+  GL_PIXEL_TEX_GEN_Q_CEILING_SGIX = $8184;
+  GL_PIXEL_TEX_GEN_Q_ROUND_SGIX = $8185;
+  GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX = $8186;
+  GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = $8187;
+  GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = $8188;
+  GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX = $8189;
+  GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX = $818A;
+
+  // GL_SGIX_instruments
+  GL_INSTRUMENT_BUFFER_POINTER_SGIX = $8180;
+  GL_INSTRUMENT_MEASUREMENTS_SGIX = $8181;
+
+  // GL_SGIX_interlace
+  GL_INTERLACE_SGIX = $8094;
+
+  // GL_SGIX_ir_instrument1
+  GL_IR_INSTRUMENT1_SGIX = $817F;
+
+  // GL_SGIX_list_priority
+  GL_LIST_PRIORITY_SGIX = $8182;
+
+  // GL_SGIX_pixel_texture
+  GL_PIXEL_TEX_GEN_SGIX = $8139;
+  GL_PIXEL_TEX_GEN_MODE_SGIX = $832B;
+
+  // GL_SGIX_pixel_tiles
+  GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX = $813E;
+  GL_PIXEL_TILE_CACHE_INCREMENT_SGIX = $813F;
+  GL_PIXEL_TILE_WIDTH_SGIX = $8140;
+  GL_PIXEL_TILE_HEIGHT_SGIX = $8141;
+  GL_PIXEL_TILE_GRID_WIDTH_SGIX = $8142;
+  GL_PIXEL_TILE_GRID_HEIGHT_SGIX = $8143;
+  GL_PIXEL_TILE_GRID_DEPTH_SGIX = $8144;
+  GL_PIXEL_TILE_CACHE_SIZE_SGIX = $8145;
+
+  // GL_SGIX_polynomial_ffd
+  GL_GEOMETRY_DEFORMATION_SGIX = $8194;
+  GL_TEXTURE_DEFORMATION_SGIX = $8195;
+  GL_DEFORMATIONS_MASK_SGIX = $8196;
+  GL_MAX_DEFORMATION_ORDER_SGIX = $8197;
+
+  // GL_SGIX_reference_plane
+  GL_REFERENCE_PLANE_SGIX = $817D;
+  GL_REFERENCE_PLANE_EQUATION_SGIX = $817E;
+
+  // GL_SGIX_resample
+  GL_PACK_RESAMPLE_SGIX = $842C;
+  GL_UNPACK_RESAMPLE_SGIX = $842D;
+  GL_RESAMPLE_REPLICATE_SGIX = $842E;
+  GL_RESAMPLE_ZERO_FILL_SGIX = $842F;
+  GL_RESAMPLE_DECIMATE_SGIX = $8430;
+
+  // GL_SGIX_scalebias_hint
+  GL_SCALEBIAS_HINT_SGIX = $8322;
+
+  // GL_SGIX_shadow
+  GL_TEXTURE_COMPARE_SGIX = $819A;
+  GL_TEXTURE_COMPARE_OPERATOR_SGIX = $819B;
+  GL_TEXTURE_LEQUAL_R_SGIX = $819C;
+  GL_TEXTURE_GEQUAL_R_SGIX = $819D;
+
+  // GL_SGIX_shadow_ambient
+  GL_SHADOW_AMBIENT_SGIX = $80BF;
+
+  // GL_SGIX_sprite
+  GL_SPRITE_SGIX = $8148;
+  GL_SPRITE_MODE_SGIX = $8149;
+  GL_SPRITE_AXIS_SGIX = $814A;
+  GL_SPRITE_TRANSLATION_SGIX = $814B;
+  GL_SPRITE_AXIAL_SGIX = $814C;
+  GL_SPRITE_OBJECT_ALIGNED_SGIX = $814D;
+  GL_SPRITE_EYE_ALIGNED_SGIX = $814E;
+
+  // GL_SGIX_subsample
+  GL_PACK_SUBSAMPLE_RATE_SGIX = $85A0;
+  GL_UNPACK_SUBSAMPLE_RATE_SGIX = $85A1;
+  GL_PIXEL_SUBSAMPLE_4444_SGIX = $85A2;
+  GL_PIXEL_SUBSAMPLE_2424_SGIX = $85A3;
+  GL_PIXEL_SUBSAMPLE_4242_SGIX = $85A4;
+
+  // GL_SGIX_texture_add_env
+  GL_TEXTURE_ENV_BIAS_SGIX = $80BE;
+
+  // GL_SGIX_texture_coordinate_clamp
+  GL_TEXTURE_MAX_CLAMP_S_SGIX = $8369;
+  GL_TEXTURE_MAX_CLAMP_T_SGIX = $836A;
+  GL_TEXTURE_MAX_CLAMP_R_SGIX = $836B;
+
+  // GL_SGIX_texture_lod_bias
+  GL_TEXTURE_LOD_BIAS_S_SGIX = $818E;
+  GL_TEXTURE_LOD_BIAS_T_SGIX = $818F;
+  GL_TEXTURE_LOD_BIAS_R_SGIX = $8190;
+
+  // GL_SGIX_texture_multi_buffer
+  GL_TEXTURE_MULTI_BUFFER_HINT_SGIX = $812E;
+
+  // GL_SGIX_texture_scale_bias
+  GL_POST_TEXTURE_FILTER_BIAS_SGIX = $8179;
+  GL_POST_TEXTURE_FILTER_SCALE_SGIX = $817A;
+  GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = $817B;
+  GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = $817C;
+
+  // GL_SGIX_vertex_preclip
+  GL_VERTEX_PRECLIP_SGIX = $83EE;
+  GL_VERTEX_PRECLIP_HINT_SGIX = $83EF;
+
+  // GL_SGIX_ycrcb
+  GL_YCRCB_422_SGIX = $81BB;
+  GL_YCRCB_444_SGIX = $81BC;
+
+  // GL_SGIX_ycrcba
+  GL_YCRCB_SGIX = $8318;
+  GL_YCRCBA_SGIX = $8319;
+
+  // GL_SGI_color_matrix
+  GL_COLOR_MATRIX_SGI = $80B1;
+  GL_COLOR_MATRIX_STACK_DEPTH_SGI = $80B2;
+  GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = $80B3;
+  GL_POST_COLOR_MATRIX_RED_SCALE_SGI = $80B4;
+  GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI = $80B5;
+  GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI = $80B6;
+  GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = $80B7;
+  GL_POST_COLOR_MATRIX_RED_BIAS_SGI = $80B8;
+  GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI = $80B9;
+  GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI = $80BA;
+  GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = $80BB;
+
+  // GL_SGI_color_table
+  GL_COLOR_TABLE_SGI = $80D0;
+  GL_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D1;
+  GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D2;
+  GL_PROXY_COLOR_TABLE_SGI = $80D3;
+  GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = $80D4;
+  GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = $80D5;
+  GL_COLOR_TABLE_SCALE_SGI = $80D6;
+  GL_COLOR_TABLE_BIAS_SGI = $80D7;
+  GL_COLOR_TABLE_FORMAT_SGI = $80D8;
+  GL_COLOR_TABLE_WIDTH_SGI = $80D9;
+  GL_COLOR_TABLE_RED_SIZE_SGI = $80DA;
+  GL_COLOR_TABLE_GREEN_SIZE_SGI = $80DB;
+  GL_COLOR_TABLE_BLUE_SIZE_SGI = $80DC;
+  GL_COLOR_TABLE_ALPHA_SIZE_SGI = $80DD;
+  GL_COLOR_TABLE_LUMINANCE_SIZE_SGI = $80DE;
+  GL_COLOR_TABLE_INTENSITY_SIZE_SGI = $80DF;
+
+  // GL_SGI_depth_pass_instrument
+  GL_DEPTH_PASS_INSTRUMENT_SGIX = $8310;
+  GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = $8311;
+  GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX = $8312;
+
+  // GL_SGI_texture_color_table
+  GL_TEXTURE_COLOR_TABLE_SGI = $80BC;
+  GL_PROXY_TEXTURE_COLOR_TABLE_SGI = $80BD;
+
+  // GL_SUNX_constant_data
+  GL_UNPACK_CONSTANT_DATA_SUNX = $81D5;
+  GL_TEXTURE_CONSTANT_DATA_SUNX = $81D6;
+
+  // GL_SUN_convolution_border_modes
+  GL_WRAP_BORDER_SUN = $81D4;
+
+  // GL_SUN_global_alpha
+  GL_GLOBAL_ALPHA_SUN = $81D9;
+  GL_GLOBAL_ALPHA_FACTOR_SUN = $81DA;
+
+  // GL_SUN_mesh_array
+  GL_QUAD_MESH_SUN = $8614;
+  GL_TRIANGLE_MESH_SUN = $8615;
+
+  // GL_SUN_slice_accum
+  GL_SLICE_ACCUM_SUN = $85CC;
+
+  // GL_SUN_triangle_list
+  GL_RESTART_SUN = $0001;
+  GL_REPLACE_MIDDLE_SUN = $0002;
+  GL_REPLACE_OLDEST_SUN = $0003;
+  GL_TRIANGLE_LIST_SUN = $81D7;
+  GL_REPLACEMENT_CODE_SUN = $81D8;
+  GL_REPLACEMENT_CODE_ARRAY_SUN = $85C0;
+  GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN = $85C1;
+  GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = $85C2;
+  GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN = $85C3;
+  GL_R1UI_V3F_SUN = $85C4;
+  GL_R1UI_C4UB_V3F_SUN = $85C5;
+  GL_R1UI_C3F_V3F_SUN = $85C6;
+  GL_R1UI_N3F_V3F_SUN = $85C7;
+  GL_R1UI_C4F_N3F_V3F_SUN = $85C8;
+  GL_R1UI_T2F_V3F_SUN = $85C9;
+  GL_R1UI_T2F_N3F_V3F_SUN = $85CA;
+  GL_R1UI_T2F_C4F_N3F_V3F_SUN = $85CB;
+
+  // GL_WIN_phong_shading
+  GL_PHONG_WIN = $80EA;
+  GL_PHONG_HINT_WIN = $80EB;
+
+  // GL_WIN_specular_fog
+  GL_FOG_SPECULAR_TEXTURE_WIN = $80EC;
+
+   // GL_ARB_vertex_shader
+  GL_VERTEX_SHADER_ARB = $8B31;
+  GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = $8B4A;
+  GL_MAX_VARYING_FLOATS_ARB = $8B4B;
+  GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = $8B4C;
+  GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = $8B4D;
+  GL_OBJECT_ACTIVE_ATTRIBUTES_ARB = $8B89;
+  GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = $8B8A;
+
+  // GL_ARB_fragment_shader
+  GL_FRAGMENT_SHADER_ARB = $8B30;
+  GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = $8B49; // 1.4
+  GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = $8B8B; // 1.4
+
+  // GL_ARB_occlusion_query
+  GL_SAMPLES_PASSED_ARB = $8914;
+  GL_QUERY_COUNTER_BITS_ARB = $8864;
+  GL_CURRENT_QUERY_ARB = $8865;
+  GL_QUERY_RESULT_ARB = $8866;
+  GL_QUERY_RESULT_AVAILABLE_ARB = $8867;
+
+  // GL_ARB_point_sprite
+  GL_POINT_SPRITE_ARB = $8861;
+  GL_COORD_REPLACE_ARB = $8862;
+
+  // GL_ARB_shading_language_100
+  GL_SHADING_LANGUAGE_VERSION_ARB = $8B8C; // 1.4
+
+  // GL_ARB_shader_objects
+  GL_PROGRAM_OBJECT_ARB = $8B40;
+
+  GL_OBJECT_TYPE_ARB = $8B4E;
+  GL_OBJECT_SUBTYPE_ARB = $8B4F;
+  GL_OBJECT_DELETE_STATUS_ARB = $8B80;
+  GL_OBJECT_COMPILE_STATUS_ARB = $8B81;
+  GL_OBJECT_LINK_STATUS_ARB = $8B82;
+  GL_OBJECT_VALIDATE_STATUS_ARB = $8B83;
+  GL_OBJECT_INFO_LOG_LENGTH_ARB = $8B84;
+  GL_OBJECT_ATTACHED_OBJECTS_ARB = $8B85;
+  GL_OBJECT_ACTIVE_UNIFORMS_ARB = $8B86;
+  GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = $8B87;
+  GL_OBJECT_SHADER_SOURCE_LENGTH_ARB = $8B88;
+
+  GL_SHADER_OBJECT_ARB = $8B48;
+
+  GL_FLOAT_VEC2_ARB = $8B50;
+  GL_FLOAT_VEC3_ARB = $8B51;
+  GL_FLOAT_VEC4_ARB = $8B52;
+  GL_INT_VEC2_ARB = $8B53;
+  GL_INT_VEC3_ARB = $8B54;
+  GL_INT_VEC4_ARB = $8B55;
+  GL_BOOL_ARB = $8B56;
+  GL_BOOL_VEC2_ARB = $8B57;
+  GL_BOOL_VEC3_ARB = $8B58;
+  GL_BOOL_VEC4_ARB = $8B59;
+  GL_FLOAT_MAT2_ARB = $8B5A;
+  GL_FLOAT_MAT3_ARB = $8B5B;
+  GL_FLOAT_MAT4_ARB = $8B5C;
+  GL_SAMPLER_1D_ARB = $8B5D;
+  GL_SAMPLER_2D_ARB = $8B5E;
+  GL_SAMPLER_3D_ARB = $8B5F;
+  GL_SAMPLER_CUBE_ARB = $8B60;
+  GL_SAMPLER_1D_SHADOW_ARB = $8B61;
+  GL_SAMPLER_2D_SHADOW_ARB = $8B62;
+  GL_SAMPLER_2D_RECT_ARB = $8B63;
+  GL_SAMPLER_2D_RECT_SHADOW_ARB = $8B64;
+
+  // WGL_3DFX_multisample
+  WGL_SAMPLE_BUFFERS_3DFX = $2060;
+  WGL_SAMPLES_3DFX = $2061;
+
+  // WGL_ARB_buffer_region
+  WGL_FRONT_COLOR_BUFFER_BIT_ARB = $00000001;
+  WGL_BACK_COLOR_BUFFER_BIT_ARB = $00000002;
+  WGL_DEPTH_BUFFER_BIT_ARB = $00000004;
+  WGL_STENCIL_BUFFER_BIT_ARB = $00000008;
+
+  // WGL_ARB_make_current_read
+  ERROR_INVALID_PIXEL_TYPE_ARB = $2043;
+  ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB = $2054;
+
+  // WGL_ARB_multisample
+  WGL_SAMPLE_BUFFERS_ARB = $2041;
+  WGL_SAMPLES_ARB = $2042;
+
+  // WGL_ARB_pbuffer
+  WGL_DRAW_TO_PBUFFER_ARB = $202D;
+  WGL_MAX_PBUFFER_PIXELS_ARB = $202E;
+  WGL_MAX_PBUFFER_WIDTH_ARB = $202F;
+  WGL_MAX_PBUFFER_HEIGHT_ARB = $2030;
+  WGL_PBUFFER_LARGEST_ARB = $2033;
+  WGL_PBUFFER_WIDTH_ARB = $2034;
+  WGL_PBUFFER_HEIGHT_ARB = $2035;
+  WGL_PBUFFER_LOST_ARB = $2036;
+
+  // WGL_ARB_pixel_format
+  WGL_NUMBER_PIXEL_FORMATS_ARB = $2000;
+  WGL_DRAW_TO_WINDOW_ARB = $2001;
+  WGL_DRAW_TO_BITMAP_ARB = $2002;
+  WGL_ACCELERATION_ARB = $2003;
+  WGL_NEED_PALETTE_ARB = $2004;
+  WGL_NEED_SYSTEM_PALETTE_ARB = $2005;
+  WGL_SWAP_LAYER_BUFFERS_ARB = $2006;
+  WGL_SWAP_METHOD_ARB = $2007;
+  WGL_NUMBER_OVERLAYS_ARB = $2008;
+  WGL_NUMBER_UNDERLAYS_ARB = $2009;
+  WGL_TRANSPARENT_ARB = $200A;
+  WGL_TRANSPARENT_RED_VALUE_ARB = $2037;
+  WGL_TRANSPARENT_GREEN_VALUE_ARB = $2038;
+  WGL_TRANSPARENT_BLUE_VALUE_ARB = $2039;
+  WGL_TRANSPARENT_ALPHA_VALUE_ARB = $203A;
+  WGL_TRANSPARENT_INDEX_VALUE_ARB = $203B;
+  WGL_SHARE_DEPTH_ARB = $200C;
+  WGL_SHARE_STENCIL_ARB = $200D;
+  WGL_SHARE_ACCUM_ARB = $200E;
+  WGL_SUPPORT_GDI_ARB = $200F;
+  WGL_SUPPORT_OPENGL_ARB = $2010;
+  WGL_DOUBLE_BUFFER_ARB = $2011;
+  WGL_STEREO_ARB = $2012;
+  WGL_PIXEL_TYPE_ARB = $2013;
+  WGL_COLOR_BITS_ARB = $2014;
+  WGL_RED_BITS_ARB = $2015;
+  WGL_RED_SHIFT_ARB = $2016;
+  WGL_GREEN_BITS_ARB = $2017;
+  WGL_GREEN_SHIFT_ARB = $2018;
+  WGL_BLUE_BITS_ARB = $2019;
+  WGL_BLUE_SHIFT_ARB = $201A;
+  WGL_ALPHA_BITS_ARB = $201B;
+  WGL_ALPHA_SHIFT_ARB = $201C;
+  WGL_ACCUM_BITS_ARB = $201D;
+  WGL_ACCUM_RED_BITS_ARB = $201E;
+  WGL_ACCUM_GREEN_BITS_ARB = $201F;
+  WGL_ACCUM_BLUE_BITS_ARB = $2020;
+  WGL_ACCUM_ALPHA_BITS_ARB = $2021;
+  WGL_DEPTH_BITS_ARB = $2022;
+  WGL_STENCIL_BITS_ARB = $2023;
+  WGL_AUX_BUFFERS_ARB = $2024;
+  WGL_NO_ACCELERATION_ARB = $2025;
+  WGL_GENERIC_ACCELERATION_ARB = $2026;
+  WGL_FULL_ACCELERATION_ARB = $2027;
+  WGL_SWAP_EXCHANGE_ARB = $2028;
+  WGL_SWAP_COPY_ARB = $2029;
+  WGL_SWAP_UNDEFINED_ARB = $202A;
+  WGL_TYPE_RGBA_ARB = $202B;
+  WGL_TYPE_COLORINDEX_ARB = $202C;
+
+  // WGL_ARB_pixel_format_float
+  WGL_RGBA_FLOAT_MODE_ARB = $8820;
+  WGL_CLAMP_VERTEX_COLOR_ARB = $891A;
+  WGL_CLAMP_FRAGMENT_COLOR_ARB = $891B;
+  WGL_CLAMP_READ_COLOR_ARB = $891C;
+  WGL_FIXED_ONLY_ARB = $891D;
+
+  // WGL_ARB_render_texture
+  WGL_BIND_TO_TEXTURE_RGB_ARB = $2070;
+  WGL_BIND_TO_TEXTURE_RGBA_ARB = $2071;
+  WGL_TEXTURE_FORMAT_ARB = $2072;
+  WGL_TEXTURE_TARGET_ARB = $2073;
+  WGL_MIPMAP_TEXTURE_ARB = $2074;
+  WGL_TEXTURE_RGB_ARB = $2075;
+  WGL_TEXTURE_RGBA_ARB = $2076;
+  WGL_NO_TEXTURE_ARB = $2077;
+  WGL_TEXTURE_CUBE_MAP_ARB = $2078;
+  WGL_TEXTURE_1D_ARB = $2079;
+  WGL_TEXTURE_2D_ARB = $207A;
+  WGL_MIPMAP_LEVEL_ARB = $207B;
+  WGL_CUBE_MAP_FACE_ARB = $207C;
+  WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = $207D;
+  WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = $207E;
+  WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = $207F;
+  WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = $2080;
+  WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = $2081;
+  WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = $2082;
+  WGL_FRONT_LEFT_ARB = $2083;
+  WGL_FRONT_RIGHT_ARB = $2084;
+  WGL_BACK_LEFT_ARB = $2085;
+  WGL_BACK_RIGHT_ARB = $2086;
+  WGL_AUX0_ARB = $2087;
+  WGL_AUX1_ARB = $2088;
+  WGL_AUX2_ARB = $2089;
+  WGL_AUX3_ARB = $208A;
+  WGL_AUX4_ARB = $208B;
+  WGL_AUX5_ARB = $208C;
+  WGL_AUX6_ARB = $208D;
+  WGL_AUX7_ARB = $208E;
+  WGL_AUX8_ARB = $208F;
+  WGL_AUX9_ARB = $2090;
+
+  // WGL_ARB_create_context
+  WGL_CONTEXT_DEBUG_BIT_ARB = $00000001;
+  WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002;
+  WGL_CONTEXT_MAJOR_VERSION_ARB = $2091;
+  WGL_CONTEXT_MINOR_VERSION_ARB = $2092;
+  WGL_CONTEXT_LAYER_PLANE_ARB = $2093;
+  WGL_CONTEXT_FLAGS_ARB = $2094;
+  ERROR_INVALID_VERSION_ARB = $2095;
+
+  // WGL_ARB_create_context_profile
+  WGL_CONTEXT_PROFILE_MASK_ARB = $9126;
+  WGL_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001;
+  WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002;
+  ERROR_INVALID_PROFILE_ARB = $2096;
+
+  // WGL_ARB_framebuffer_sRGB
+  WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20A9;
+
+  // WGL_ARB_create_context_robustness
+  WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004;
+  WGL_LOSE_CONTEXT_ON_RESET_ARB = $8252;
+  WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256;
+  WGL_NO_RESET_NOTIFICATION_ARB = $8261;
+
+  // WGL_ATI_pixel_format_float
+  WGL_TYPE_RGBA_FLOAT_ATI = $21A0;
+  GL_TYPE_RGBA_FLOAT_ATI = $8820;
+  GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = $8835;
+
+  // WGL_AMD_gpu_association
+  WGL_GPU_VENDOR_AMD = $1F00;
+  WGL_GPU_RENDERER_STRING_AMD = $1F01;
+  WGL_GPU_OPENGL_VERSION_STRING_AMD = $1F02;
+  WGL_GPU_FASTEST_TARGET_GPUS_AMD = $21A2;
+  WGL_GPU_RAM_AMD = $21A3;
+  WGL_GPU_CLOCK_AMD = $21A4;
+  WGL_GPU_NUM_PIPES_AMD = $21A5;
+  WGL_GPU_NUM_SIMD_AMD = $21A6;
+  WGL_GPU_NUM_RB_AMD = $21A7;
+  WGL_GPU_NUM_SPI_AMD = $21A8;
+
+  // WGL_EXT_depth_float
+  WGL_DEPTH_FLOAT_EXT = $2040;
+
+  // WGL_EXT_make_current_read
+  ERROR_INVALID_PIXEL_TYPE_EXT = $2043;
+
+  // WGL_EXT_multisample
+  WGL_SAMPLE_BUFFERS_EXT = $2041;
+  WGL_SAMPLES_EXT = $2042;
+
+  // WGL_EXT_pbuffer
+  WGL_DRAW_TO_PBUFFER_EXT = $202D;
+  WGL_MAX_PBUFFER_PIXELS_EXT = $202E;
+  WGL_MAX_PBUFFER_WIDTH_EXT = $202F;
+  WGL_MAX_PBUFFER_HEIGHT_EXT = $2030;
+  WGL_OPTIMAL_PBUFFER_WIDTH_EXT = $2031;
+  WGL_OPTIMAL_PBUFFER_HEIGHT_EXT = $2032;
+  WGL_PBUFFER_LARGEST_EXT = $2033;
+  WGL_PBUFFER_WIDTH_EXT = $2034;
+  WGL_PBUFFER_HEIGHT_EXT = $2035;
+
+  // WGL_EXT_pixel_format
+  WGL_NUMBER_PIXEL_FORMATS_EXT = $2000;
+  WGL_DRAW_TO_WINDOW_EXT = $2001;
+  WGL_DRAW_TO_BITMAP_EXT = $2002;
+  WGL_ACCELERATION_EXT = $2003;
+  WGL_NEED_PALETTE_EXT = $2004;
+  WGL_NEED_SYSTEM_PALETTE_EXT = $2005;
+  WGL_SWAP_LAYER_BUFFERS_EXT = $2006;
+  WGL_SWAP_METHOD_EXT = $2007;
+  WGL_NUMBER_OVERLAYS_EXT = $2008;
+  WGL_NUMBER_UNDERLAYS_EXT = $2009;
+  WGL_TRANSPARENT_EXT = $200A;
+  WGL_TRANSPARENT_VALUE_EXT = $200B;
+  WGL_SHARE_DEPTH_EXT = $200C;
+  WGL_SHARE_STENCIL_EXT = $200D;
+  WGL_SHARE_ACCUM_EXT = $200E;
+  WGL_SUPPORT_GDI_EXT = $200F;
+  WGL_SUPPORT_OPENGL_EXT = $2010;
+  WGL_DOUBLE_BUFFER_EXT = $2011;
+  WGL_STEREO_EXT = $2012;
+  WGL_PIXEL_TYPE_EXT = $2013;
+  WGL_COLOR_BITS_EXT = $2014;
+  WGL_RED_BITS_EXT = $2015;
+  WGL_RED_SHIFT_EXT = $2016;
+  WGL_GREEN_BITS_EXT = $2017;
+  WGL_GREEN_SHIFT_EXT = $2018;
+  WGL_BLUE_BITS_EXT = $2019;
+  WGL_BLUE_SHIFT_EXT = $201A;
+  WGL_ALPHA_BITS_EXT = $201B;
+  WGL_ALPHA_SHIFT_EXT = $201C;
+  WGL_ACCUM_BITS_EXT = $201D;
+  WGL_ACCUM_RED_BITS_EXT = $201E;
+  WGL_ACCUM_GREEN_BITS_EXT = $201F;
+  WGL_ACCUM_BLUE_BITS_EXT = $2020;
+  WGL_ACCUM_ALPHA_BITS_EXT = $2021;
+  WGL_DEPTH_BITS_EXT = $2022;
+  WGL_STENCIL_BITS_EXT = $2023;
+  WGL_AUX_BUFFERS_EXT = $2024;
+  WGL_NO_ACCELERATION_EXT = $2025;
+  WGL_GENERIC_ACCELERATION_EXT = $2026;
+  WGL_FULL_ACCELERATION_EXT = $2027;
+  WGL_SWAP_EXCHANGE_EXT = $2028;
+  WGL_SWAP_COPY_EXT = $2029;
+  WGL_SWAP_UNDEFINED_EXT = $202A;
+  WGL_TYPE_RGBA_EXT = $202B;
+  WGL_TYPE_COLORINDEX_EXT = $202C;
+
+  // WGL_I3D_digital_video_control
+  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D = $2050;
+  WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D = $2051;
+  WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D = $2052;
+  WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D = $2053;
+
+  // WGL_I3D_gamma
+  WGL_GAMMA_TABLE_SIZE_I3D = $204E;
+  WGL_GAMMA_EXCLUDE_DESKTOP_I3D = $204F;
+
+  // WGL_I3D_genlock
+  WGL_GENLOCK_SOURCE_MULTIVIEW_I3D = $2044;
+  WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D = $2045;
+  WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D = $2046;
+  WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D = $2047;
+  WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D = $2048;
+  WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D = $2049;
+  WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D = $204A;
+  WGL_GENLOCK_SOURCE_EDGE_RISING_I3D = $204B;
+  WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D = $204C;
+
+  // WGL_I3D_image_buffer
+  WGL_IMAGE_BUFFER_MIN_ACCESS_I3D = $00000001;
+  WGL_IMAGE_BUFFER_LOCK_I3D = $00000002;
+
+  // WGL_NV_float_buffer
+  WGL_FLOAT_COMPONENTS_NV = $20B0;
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV = $20B1;
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV = $20B2;
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV = $20B3;
+  WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV = $20B4;
+  WGL_TEXTURE_FLOAT_R_NV = $20B5;
+  WGL_TEXTURE_FLOAT_RG_NV = $20B6;
+  WGL_TEXTURE_FLOAT_RGB_NV = $20B7;
+  WGL_TEXTURE_FLOAT_RGBA_NV = $20B8;
+
+  // WGL_NV_render_depth_texture
+  WGL_BIND_TO_TEXTURE_DEPTH_NV = $20A3;
+  WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV = $20A4;
+  WGL_DEPTH_TEXTURE_FORMAT_NV = $20A5;
+  WGL_TEXTURE_DEPTH_COMPONENT_NV = $20A6;
+  WGL_DEPTH_COMPONENT_NV = $20A7;
+
+  // WGL_NV_render_texture_rectangle
+  WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV = $20A0;
+  WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV = $20A1;
+  WGL_TEXTURE_RECTANGLE_NV = $20A2;
+
+  // WGL_NV_present_video
+  WGL_NUM_VIDEO_SLOTS_NV = $20F0;
+  
+  // WGL_NV_video_output
+  WGL_BIND_TO_VIDEO_RGB_NV = $20C0;
+  WGL_BIND_TO_VIDEO_RGBA_NV = $20C1;
+  WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV = $20C2;
+  WGL_VIDEO_OUT_COLOR_NV = $20C3;
+  WGL_VIDEO_OUT_ALPHA_NV = $20C4;
+  WGL_VIDEO_OUT_DEPTH_NV = $20C5;
+  WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV = $20C6;
+  WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV = $20C7;
+  WGL_VIDEO_OUT_FRAME = $20C8;
+  WGL_VIDEO_OUT_FIELD_1 = $20C9;
+  WGL_VIDEO_OUT_FIELD_2 = $20CA;
+  WGL_VIDEO_OUT_STACKED_FIELDS_1_2 = $20CB;
+  WGL_VIDEO_OUT_STACKED_FIELDS_2_1 = $20CC;
+
+  // WGL_NV_gpu_affinity
+  WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV = $20D0;
+  WGL_ERROR_MISSING_AFFINITY_MASK_NV = $20D1;
+
+  // WGL_NV_video_capture
+  WGL_UNIQUE_ID_NV = $20CE;
+  WGL_NUM_VIDEO_CAPTURE_SLOTS_NV = $20CF;
+  
+  // WGL_NV_multisample_coverage
+  WGL_COVERAGE_SAMPLES_NV = $2042;
+  WGL_COLOR_SAMPLES_NV = $20B9;
+
+  // WGL_EXT_create_context_es2_profile
+  WGL_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004;
+
+  // WGL_NV_DX_interop
+  WGL_ACCESS_READ_ONLY_NV        = $00000000;
+  WGL_ACCESS_READ_WRITE_NV       = $00000001;
+  WGL_ACCESS_WRITE_DISCARD_NV    = $00000002;
+
+  // WIN_draw_range_elements
+  GL_MAX_ELEMENTS_VERTICES_WIN = $80E8;
+  GL_MAX_ELEMENTS_INDICES_WIN = $80E9;
+
+  // GLX 1.1 and later:
+  GLX_VENDOR = 1;
+  GLX_VERSION = 2;
+  GLX_EXTENSIONS = 3;
+
+  GLX_USE_GL = 1;
+  GLX_BUFFER_SIZE = 2;
+  GLX_LEVEL = 3;
+  GLX_RGBA = 4;
+  GLX_DOUBLEBUFFER = 5;
+  GLX_STEREO = 6;
+  GLX_AUX_BUFFERS = 7;
+  GLX_RED_SIZE = 8;
+  GLX_GREEN_SIZE = 9;
+  GLX_BLUE_SIZE = 10;
+  GLX_ALPHA_SIZE = 11;
+  GLX_DEPTH_SIZE = 12;
+  GLX_STENCIL_SIZE = 13;
+  GLX_ACCUM_RED_SIZE = 14;
+  GLX_ACCUM_GREEN_SIZE = 15;
+  GLX_ACCUM_BLUE_SIZE = 16;
+  GLX_ACCUM_ALPHA_SIZE = 17;
+
+  // GLX_VERSION_1_3
+  GLX_WINDOW_BIT = $00000001;
+  GLX_PIXMAP_BIT = $00000002;
+  GLX_PBUFFER_BIT = $00000004;
+  GLX_RGBA_BIT = $00000001;
+  GLX_COLOR_INDEX_BIT = $00000002;
+  GLX_PBUFFER_CLOBBER_MASK = $08000000;
+  GLX_FRONT_LEFT_BUFFER_BIT = $00000001;
+  GLX_FRONT_RIGHT_BUFFER_BIT = $00000002;
+  GLX_BACK_LEFT_BUFFER_BIT = $00000004;
+  GLX_BACK_RIGHT_BUFFER_BIT = $00000008;
+  GLX_AUX_BUFFERS_BIT = $00000010;
+  GLX_DEPTH_BUFFER_BIT = $00000020;
+  GLX_STENCIL_BUFFER_BIT = $00000040;
+  GLX_ACCUM_BUFFER_BIT = $00000080;
+  GLX_CONFIG_CAVEAT = $20;
+  GLX_X_VISUAL_TYPE = $22;
+  GLX_TRANSPARENT_TYPE = $23;
+  GLX_TRANSPARENT_INDEX_VALUE = $24;
+  GLX_TRANSPARENT_RED_VALUE = $25;
+  GLX_TRANSPARENT_GREEN_VALUE = $26;
+  GLX_TRANSPARENT_BLUE_VALUE = $27;
+  GLX_TRANSPARENT_ALPHA_VALUE = $28;
+  GLX_DONT_CARE = $FFFFFFFF;
+  GLX_NONE = $8000;
+  GLX_SLOW_CONFIG = $8001;
+  GLX_TRUE_COLOR = $8002;
+  GLX_DIRECT_COLOR = $8003;
+  GLX_PSEUDO_COLOR = $8004;
+  GLX_STATIC_COLOR = $8005;
+  GLX_GRAY_SCALE = $8006;
+  GLX_STATIC_GRAY = $8007;
+  GLX_TRANSPARENT_RGB = $8008;
+  GLX_TRANSPARENT_INDEX = $8009;
+  GLX_VISUAL_ID = $800B;
+  GLX_SCREEN = $800C;
+  GLX_NON_CONFORMANT_CONFIG = $800D;
+  GLX_DRAWABLE_TYPE = $8010;
+  GLX_RENDER_TYPE = $8011;
+  GLX_X_RENDERABLE = $8012;
+  GLX_FBCONFIG_ID = $8013;
+  GLX_RGBA_TYPE = $8014;
+  GLX_COLOR_INDEX_TYPE = $8015;
+  GLX_MAX_PBUFFER_WIDTH = $8016;
+  GLX_MAX_PBUFFER_HEIGHT = $8017;
+  GLX_MAX_PBUFFER_PIXELS = $8018;
+  GLX_PRESERVED_CONTENTS = $801B;
+  GLX_LARGEST_PBUFFER = $801C;
+  GLX_WIDTH = $801D;
+  GLX_HEIGHT = $801E;
+  GLX_EVENT_MASK = $801F;
+  GLX_DAMAGED = $8020;
+  GLX_SAVED = $8021;
+  GLX_WINDOW = $8022;
+  GLX_PBUFFER = $8023;
+  GLX_PBUFFER_HEIGHT = $8040;
+  GLX_PBUFFER_WIDTH = $8041;
+
+  // GLX_VERSION_1_4
+  GLX_SAMPLE_BUFFERS = 100000;
+  GLX_SAMPLES = 100001;
+
+  // GLX_ARB_multisample
+  GLX_SAMPLE_BUFFERS_ARB = 100000;
+  GLX_SAMPLES_ARB = 100001;
+
+  // GLX_ARB_fbconfig_float
+  GLX_RGBA_FLOAT_TYPE_ARB = $20B9;
+  GLX_RGBA_FLOAT_BIT_ARB = $00000004;
+
+  // GLX_ARB_create_context
+  GLX_CONTEXT_DEBUG_BIT_ARB = $00000001;
+  GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = $00000002;
+  GLX_CONTEXT_MAJOR_VERSION_ARB = $2091;
+  GLX_CONTEXT_MINOR_VERSION_ARB = $2092;
+  GLX_CONTEXT_FLAGS_ARB = $2094;
+
+  // GLX_ARB_create_context_profile
+  GLX_CONTEXT_CORE_PROFILE_BIT_ARB = $00000001;
+  GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = $00000002;
+  GLX_CONTEXT_PROFILE_MASK_ARB = $9126;
+
+  // GLX_ARB_vertex_buffer_object
+  GLX_CONTEXT_ALLOW_BUFFER_BYTE_ORDER_MISMATCH_ARB = $2095;
+
+  // GLX_ARB_framebuffer_sRGB
+  GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB = $20B2;
+
+  // GLX_ARB_create_context_robustness
+  GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB = $00000004;
+  GLX_LOSE_CONTEXT_ON_RESET_ARB = $8252;
+  GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB = $8256;
+  GLX_NO_RESET_NOTIFICATION_ARB = $8261;
+
+  // GLX_EXT_visual_info
+  GLX_X_VISUAL_TYPE_EXT = $22;
+  GLX_TRANSPARENT_TYPE_EXT = $23;
+  GLX_TRANSPARENT_INDEX_VALUE_EXT = $24;
+  GLX_TRANSPARENT_RED_VALUE_EXT = $25;
+  GLX_TRANSPARENT_GREEN_VALUE_EXT = $26;
+  GLX_TRANSPARENT_BLUE_VALUE_EXT = $27;
+  GLX_TRANSPARENT_ALPHA_VALUE_EXT = $28;
+  GLX_NONE_EXT = $8000;
+  GLX_TRUE_COLOR_EXT = $8002;
+  GLX_DIRECT_COLOR_EXT = $8003;
+  GLX_PSEUDO_COLOR_EXT = $8004;
+  GLX_STATIC_COLOR_EXT = $8005;
+  GLX_GRAY_SCALE_EXT = $8006;
+  GLX_STATIC_GRAY_EXT = $8007;
+  GLX_TRANSPARENT_RGB_EXT = $8008;
+  GLX_TRANSPARENT_INDEX_EXT = $8009;
+  
+  // GLX_EXT_visual_rating
+  GLX_VISUAL_CAVEAT_EXT = $20;
+  GLX_SLOW_VISUAL_EXT = $8001;
+  GLX_NON_CONFORMANT_VISUAL_EXT = $800D;
+  (* reuse GLX_NONE_EXT *)
+  
+  // GLX_EXT_import_context
+  GLX_SHARE_CONTEXT_EXT = $800A;
+  GLX_VISUAL_ID_EXT = $800B;
+  GLX_SCREEN_EXT = $800C;
+
+  // GLX_EXT_fbconfig_packed_float
+//  GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = $20B1;
+//  GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = $00000008;
+
+  // GLX_EXT_framebuffer_sRGB
+//  GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = $20B2;
+
+  // GLX_EXT_texture_from_pixmap
+  GLX_TEXTURE_1D_BIT_EXT = $00000001;
+  GLX_TEXTURE_2D_BIT_EXT = $00000002;
+  GLX_TEXTURE_RECTANGLE_BIT_EXT = $00000004;
+  GLX_BIND_TO_TEXTURE_RGB_EXT = $20D0;
+  GLX_BIND_TO_TEXTURE_RGBA_EXT = $20D1;
+  GLX_BIND_TO_MIPMAP_TEXTURE_EXT = $20D2;
+  GLX_BIND_TO_TEXTURE_TARGETS_EXT = $20D3;
+  GLX_Y_INVERTED_EXT = $20D4;
+  GLX_TEXTURE_FORMAT_EXT = $20D5;
+  GLX_TEXTURE_TARGET_EXT = $20D6;
+  GLX_MIPMAP_TEXTURE_EXT = $20D7;
+  GLX_TEXTURE_FORMAT_NONE_EXT = $20D8;
+  GLX_TEXTURE_FORMAT_RGB_EXT = $20D9;
+  GLX_TEXTURE_FORMAT_RGBA_EXT = $20DA;
+  GLX_TEXTURE_1D_EXT = $20DB;
+  GLX_TEXTURE_2D_EXT = $20DC;
+  GLX_TEXTURE_RECTANGLE_EXT = $20DD;
+  GLX_FRONT_LEFT_EXT = $20DE;
+  GLX_FRONT_RIGHT_EXT = $20DF;
+  GLX_BACK_LEFT_EXT = $20E0;
+  GLX_BACK_RIGHT_EXT = $20E1;
+  GLX_FRONT_EXT = GLX_FRONT_LEFT_EXT;
+  GLX_BACK_EXT = GLX_BACK_LEFT_EXT;
+  GLX_AUX0_EXT = $20E2;
+  GLX_AUX1_EXT = $20E3;
+  GLX_AUX2_EXT = $20E4;
+  GLX_AUX3_EXT = $20E5;
+  GLX_AUX4_EXT = $20E6;
+  GLX_AUX5_EXT = $20E7;
+  GLX_AUX6_EXT = $20E8;
+  GLX_AUX7_EXT = $20E9;
+  GLX_AUX8_EXT = $20EA;
+  GLX_AUX9_EXT = $20EB;
+
+  // GLX_EXT_swap_control
+  GLX_SWAP_INTERVAL_EXT = $20F1;
+  GLX_MAX_SWAP_INTERVAL_EXT = $20F2;
+
+  // GLX_EXT_create_context_es2_profile
+  GLX_CONTEXT_ES2_PROFILE_BIT_EXT = $00000004;
+
+  // GL_EXT_Late_Swaps
+  GLX_LATE_SWAPS_TEAR_EXT         = $20F3;
+
+  // GLU
+  GLU_INVALID_ENUM = 100900;
+  GLU_INVALID_VALUE = 100901;
+  GLU_OUT_OF_MEMORY = 100902;
+  GLU_INCOMPATIBLE_GL_VERSION = 100903;
+  GLU_VERSION = 100800;
+  GLU_EXTENSIONS = 100801;
+  GLU_TRUE = GL_TRUE;
+  GLU_FALSE = GL_FALSE;
+  GLU_SMOOTH = 100000;
+  GLU_FLAT = 100001;
+  GLU_NONE = 100002;
+  GLU_POINT = 100010;
+  GLU_LINE = 100011;
+  GLU_FILL = 100012;
+  GLU_SILHOUETTE = 100013;
+  GLU_OUTSIDE = 100020;
+  GLU_INSIDE = 100021;
+  GLU_TESS_MAX_COORD = 1.0E150;
+  GLU_TESS_WINDING_RULE = 100140;
+  GLU_TESS_BOUNDARY_ONLY = 100141;
+  GLU_TESS_TOLERANCE = 100142;
+  GLU_TESS_WINDING_ODD = 100130;
+  GLU_TESS_WINDING_NONZERO = 100131;
+  GLU_TESS_WINDING_POSITIVE = 100132;
+  GLU_TESS_WINDING_NEGATIVE = 100133;
+  GLU_TESS_WINDING_ABS_GEQ_TWO = 100134;
+  GLU_TESS_BEGIN = 100100; // TGLUTessBeginProc
+  GLU_TESS_VERTEX = 100101; // TGLUTessVertexProc
+  GLU_TESS_END = 100102; // TGLUTessEndProc
+  GLU_TESS_ERROR = 100103; // TGLUTessErrorProc
+  GLU_TESS_EDGE_FLAG = 100104; // TGLUTessEdgeFlagProc
+  GLU_TESS_COMBINE = 100105; // TGLUTessCombineProc
+  GLU_TESS_BEGIN_DATA = 100106; // TGLUTessBeginDataProc
+  GLU_TESS_VERTEX_DATA = 100107; // TGLUTessVertexDataProc
+  GLU_TESS_END_DATA = 100108; // TGLUTessEndDataProc
+  GLU_TESS_ERROR_DATA = 100109; // TGLUTessErrorDataProc
+  GLU_TESS_EDGE_FLAG_DATA = 100110; // TGLUTessEdgeFlagDataProc
+  GLU_TESS_COMBINE_DATA = 100111; // TGLUTessCombineDataProc
+  GLU_TESS_ERROR1 = 100151;
+  GLU_TESS_ERROR2 = 100152;
+  GLU_TESS_ERROR3 = 100153;
+  GLU_TESS_ERROR4 = 100154;
+  GLU_TESS_ERROR5 = 100155;
+  GLU_TESS_ERROR6 = 100156;
+  GLU_TESS_ERROR7 = 100157;
+  GLU_TESS_ERROR8 = 100158;
+  GLU_TESS_MISSING_BEGIN_POLYGON = GLU_TESS_ERROR1;
+  GLU_TESS_MISSING_BEGIN_CONTOUR = GLU_TESS_ERROR2;
+  GLU_TESS_MISSING_END_POLYGON = GLU_TESS_ERROR3;
+  GLU_TESS_MISSING_END_CONTOUR = GLU_TESS_ERROR4;
+  GLU_TESS_COORD_TOO_LARGE = GLU_TESS_ERROR5;
+  GLU_TESS_NEED_COMBINE_CALLBACK = GLU_TESS_ERROR6;
+  GLU_AUTO_LOAD_MATRIX = 100200;
+  GLU_CULLING = 100201;
+  GLU_SAMPLING_TOLERANCE = 100203;
+  GLU_DISPLAY_MODE = 100204;
+  GLU_PARAMETRIC_TOLERANCE = 100202;
+  GLU_SAMPLING_METHOD = 100205;
+  GLU_U_STEP = 100206;
+  GLU_V_STEP = 100207;
+  GLU_PATH_LENGTH = 100215;
+  GLU_PARAMETRIC_ERROR = 100216;
+  GLU_DOMAIN_DISTANCE = 100217;
+  GLU_MAP1_TRIM_2 = 100210;
+  GLU_MAP1_TRIM_3 = 100211;
+  GLU_OUTLINE_POLYGON = 100240;
+  GLU_OUTLINE_PATCH = 100241;
+  GLU_NURBS_ERROR1 = 100251;
+  GLU_NURBS_ERROR2 = 100252;
+  GLU_NURBS_ERROR3 = 100253;
+  GLU_NURBS_ERROR4 = 100254;
+  GLU_NURBS_ERROR5 = 100255;
+  GLU_NURBS_ERROR6 = 100256;
+  GLU_NURBS_ERROR7 = 100257;
+  GLU_NURBS_ERROR8 = 100258;
+  GLU_NURBS_ERROR9 = 100259;
+  GLU_NURBS_ERROR10 = 100260;
+  GLU_NURBS_ERROR11 = 100261;
+  GLU_NURBS_ERROR12 = 100262;
+  GLU_NURBS_ERROR13 = 100263;
+  GLU_NURBS_ERROR14 = 100264;
+  GLU_NURBS_ERROR15 = 100265;
+  GLU_NURBS_ERROR16 = 100266;
+  GLU_NURBS_ERROR17 = 100267;
+  GLU_NURBS_ERROR18 = 100268;
+  GLU_NURBS_ERROR19 = 100269;
+  GLU_NURBS_ERROR20 = 100270;
+  GLU_NURBS_ERROR21 = 100271;
+  GLU_NURBS_ERROR22 = 100272;
+  GLU_NURBS_ERROR23 = 100273;
+  GLU_NURBS_ERROR24 = 100274;
+  GLU_NURBS_ERROR25 = 100275;
+  GLU_NURBS_ERROR26 = 100276;
+  GLU_NURBS_ERROR27 = 100277;
+  GLU_NURBS_ERROR28 = 100278;
+  GLU_NURBS_ERROR29 = 100279;
+  GLU_NURBS_ERROR30 = 100280;
+  GLU_NURBS_ERROR31 = 100281;
+  GLU_NURBS_ERROR32 = 100282;
+  GLU_NURBS_ERROR33 = 100283;
+  GLU_NURBS_ERROR34 = 100284;
+  GLU_NURBS_ERROR35 = 100285;
+  GLU_NURBS_ERROR36 = 100286;
+  GLU_NURBS_ERROR37 = 100287;
+  GLU_CW = 100120;
+  GLU_CCW = 100121;
+  GLU_INTERIOR = 100122;
+  GLU_EXTERIOR = 100123;
+  GLU_UNKNOWN = 100124;
+  GLU_BEGIN = GLU_TESS_BEGIN;
+  GLU_VERTEX = GLU_TESS_VERTEX;
+  GLU_END = GLU_TESS_END;
+  GLU_ERROR = GLU_TESS_ERROR;
+  GLU_EDGE_FLAG = GLU_TESS_EDGE_FLAG;
+
+type
+  // GL_VERSION_1_0
+  TglCullFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFrontFace = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglHint = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLineWidth = procedure(width: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointSize = procedure(size: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPolygonMode = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglScissor = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameterf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameteri = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClear = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearStencil = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearDepth = procedure(depth: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorMask = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDepthMask = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnable = procedure(cap: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFinish = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFlush = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendFunc = procedure(sfactor: GLenum; dfactor: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLogicOp = procedure(opcode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilFunc = procedure(func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilOp = procedure(fail: GLenum; zfail: GLenum; zpass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDepthFunc = procedure(func: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelStoref = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelStorei = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReadBuffer = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReadPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBooleanv = procedure(pname: GLenum; params: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetDoublev = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetError = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFloatv = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetString = function(name: GLenum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsEnabled = function(cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDepthRange = procedure(zNear: GLclampd; zFar: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglViewport = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_1_1
+  TglDrawArrays = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElements = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPointerv = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPolygonOffset = procedure(factor: GLfloat; units: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexImage1D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexImage2D = procedure(target: GLenum; level: GLint; internalFormat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindTexture = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenTextures = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  
+{$ifdef DGL_DEPRECATED}
+  TglAccum = procedure(op: GLenum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglAlphaFunc = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglArrayElement = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBegin = procedure(mode: GLenum); {$IFNDEF CLR}{$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}{$ENDIF}
+  TglBitmap = procedure(width: GLsizei; height: GLsizei; xorig: GLfloat; yorig: GLfloat; xmove: GLfloat; ymove: GLfloat; const bitmap: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCallList = procedure(list: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCallLists = procedure(n: GLsizei; _type: GLenum; const lists: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearAccum = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearIndex = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClipPlane = procedure(plane: GLenum; const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte; alpha: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble; alpha: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat; alpha: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4i = procedure(red: GLint; green: GLint; blue: GLint; alpha: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4s = procedure(red: GLshort; green: GLshort; blue: GLshort; alpha: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte; alpha: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4ui = procedure(red: GLuint; green: GLuint; blue: GLuint; alpha: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4us = procedure(red: GLushort; green: GLushort; blue: GLushort; alpha: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorMaterial = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyPixels = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; _type: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteLists = procedure(list: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawPixels = procedure(width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEdgeFlag = procedure(flag: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEdgeFlagPointer = procedure(stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEdgeFlagv = procedure(const flag: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableClientState = procedure(_array: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnd = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndList = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord1d = procedure(u: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord1dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord1f = procedure(u: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord1fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord2d = procedure(u: GLdouble; v: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord2dv = procedure(const u: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord2f = procedure(u: GLfloat; v: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalCoord2fv = procedure(const u: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalMesh1 = procedure(mode: GLenum; i1: GLint; i2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalMesh2 = procedure(mode: GLenum; i1: GLint; i2: GLint; j1: GLint; j2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalPoint1 = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalPoint2 = procedure(i: GLint; j: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFeedbackBuffer = procedure(size: GLsizei; _type: GLenum; buffer: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogiv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFrustum = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenLists = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetClipPlane = procedure(plane: GLenum; equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetLightfv = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetLightiv = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapdv = procedure(target: GLenum; query: GLenum; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapfv = procedure(target: GLenum; query: GLenum; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapiv = procedure(target: GLenum; query: GLenum; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMaterialfv = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMaterialiv = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPixelMapfv = procedure(map: GLenum; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPixelMapuiv = procedure(map: GLenum; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPixelMapusv = procedure(map: GLenum; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPolygonStipple = procedure(mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexEnvfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexEnviv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexGendv = procedure(coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexGenfv = procedure(coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexGeniv = procedure(coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexMask = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexd = procedure(c: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexdv = procedure(const c: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexf = procedure(c: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexfv = procedure(const c: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexi = procedure(c: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexiv = procedure(const c: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexs = procedure(c: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexsv = procedure(const c: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexub = procedure(c: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexubv = procedure(const c: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInitNames = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInterleavedArrays = procedure(format: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsList = function(list: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsTexture = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightModelf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightModelfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightModeli = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightModeliv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightf = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightfv = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLighti = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightiv = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLineStipple = procedure(factor: GLint; pattern: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglListBase = procedure(base: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadIdentity = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMap1d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMap1f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMap2d = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMap2f = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapGrid1d = procedure(un: GLint; u1: GLdouble; u2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapGrid1f = procedure(un: GLint; u1: GLfloat; u2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapGrid2d = procedure(un: GLint; u1: GLdouble; u2: GLdouble; vn: GLint; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapGrid2f = procedure(un: GLint; u1: GLfloat; u2: GLfloat; vn: GLint; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMaterialf = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMaterialfv = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMateriali = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMaterialiv = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixMode = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNewList = procedure(list: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3b = procedure(nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3d = procedure(nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3f = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3i = procedure(nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3s = procedure(nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglOrtho = procedure(left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPassThrough = procedure(token: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelMapfv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelMapuiv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelMapusv = procedure(map: GLenum; mapsize: GLsizei; const values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTransferf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTransferi = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelZoom = procedure(xfactor: GLfloat; yfactor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPolygonStipple = procedure(const mask: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPopAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPopClientAttrib = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPopMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPopName = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPrioritizeTextures = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPushAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPushClientAttrib = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPushMatrix = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPushName = procedure(name: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRasterPos4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRectd = procedure(x1: GLdouble; y1: GLdouble; x2: GLdouble; y2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRectdv = procedure(const v1: PGLdouble; const v2: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRectf = procedure(x1: GLfloat; y1: GLfloat; x2: GLfloat; y2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRectfv = procedure(const v1: PGLfloat; const v2: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRecti = procedure(x1: GLint; y1: GLint; x2: GLint; y2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRectiv = procedure(const v1: PGLint; const v2: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRects = procedure(x1: GLshort; y1: GLshort; x2: GLshort; y2: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRectsv = procedure(const v1: PGLshort; const v2: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRenderMode = function(mode: GLenum): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRotated = procedure(angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRotatef = procedure(angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglScaled = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglScalef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSelectBuffer = procedure(size: GLsizei; buffer: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglShadeModel = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1d = procedure(s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1f = procedure(s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1i = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1s = procedure(s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2d = procedure(s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2f = procedure(s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2i = procedure(s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2s = procedure(s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3d = procedure(s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3f = procedure(s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3i = procedure(s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3s = procedure(s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4d = procedure(s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4f = procedure(s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4i = procedure(s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4s = procedure(s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexEnvf = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexEnvfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexEnvi = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexEnviv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexGend = procedure(coord: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexGendv = procedure(coord: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexGenf = procedure(coord: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexGenfv = procedure(coord: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexGeni = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexGeniv = procedure(coord: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+
+  TglTranslated = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTranslatef = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4d = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4f = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4i = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4s = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$endif}
+
+  // GL_VERSION_1_2
+  TglBlendColor = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendEquation = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawRangeElements = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$ifdef DGL_DEPRECATED}
+  TglColorTable = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorTableParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorTableParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyColorTable = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTable = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorSubTable = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyColorSubTable = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameterf = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameteri = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyConvolutionFilter1D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyConvolutionFilter2D = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetConvolutionFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetConvolutionParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetConvolutionParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSeparableFilter = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSeparableFilter2D = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetHistogram = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetHistogramParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetHistogramParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMinmax = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMinmaxParameterfv = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMinmaxParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglHistogram = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMinmax = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglResetHistogram = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglResetMinmax = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$endif}
+
+  // GL_VERSION_1_3
+  TglActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSampleCoverage = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexImage3D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexImage1D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexSubImage3D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexSubImage2D = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexSubImage1D = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$ifdef DGL_DEPRECATED}
+  TglClientActiveTexture = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1d = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1f = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1i = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1s = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2d = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2f = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2i = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2s = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4d = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4dv = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4f = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4fv = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4i = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4iv = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4s = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4sv = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultTransposeMatrixf = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultTransposeMatrixd = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$endif}
+
+  // GL_VERSION_1_4
+  TglBlendFuncSeparate = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiDrawArrays = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiDrawElements = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameterf = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameterfv = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameteri = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameteriv = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$ifdef DGL_DEPRECATED}
+  TglFogCoordf = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordfv = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordd = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoorddv = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordPointer = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3b = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3bv = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3d = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3f = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3i = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3s = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3ub = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3ubv = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3ui = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3uiv = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3us = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3usv = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColorPointer = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2d = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2f = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2i = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2s = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3d = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3dv = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3f = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3fv = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3i = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3iv = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3s = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3sv = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$endif}
+
+  // GL_VERSION_1_5
+  TglGenQueries = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteQueries = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsQuery = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginQuery = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndQuery = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryiv = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryObjectiv = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryObjectuiv = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBuffer = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteBuffers = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenBuffers = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsBuffer = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBufferData = procedure(target: GLenum; size: GLsizeiptr; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferSubData = procedure(target: GLenum; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapBuffer = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUnmapBuffer = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferPointerv = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_2_0
+  TglBlendEquationSeparate = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawBuffers = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilOpSeparate = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilFuncSeparate = procedure(face: GLenum; func: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilMaskSeparate = procedure(face: GLenum; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglAttachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindAttribLocation = procedure(programObj: GLhandle; index: GLuint; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompileShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateProgram = function: GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateShader = function(shaderType: GLenum): GLhandle; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteShader = procedure(shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDetachShader = procedure(programObj, shaderObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableVertexAttribArray = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveAttrib = procedure(programObj: GLhandle; index: GLuint; maxlength: GLsizei; var length: GLint; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveUniform = procedure(programObj: GLhandle; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetAttachedShaders = procedure(programObj: GLhandle; MaxCount: GLsizei; var Count: GLint; shaders: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetAttribLocation = function(programObj: GLhandle; char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramiv = procedure(programObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramInfoLog = procedure(programObj: GLHandle; maxLength: glsizei; var length: PGLsizei; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetShaderiv = procedure(shaderObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetShaderInfoLog = procedure(shaderObj: GLHandle; maxLength: glsizei; var length: glint; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetShaderSource = procedure(shaderObj: GLhandle; maxlength: GLsizei; var length: GLsizei; source: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformLocation = function(programObj: GLhandle; const char: PGLChar): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformfv = procedure(programObj: GLhandle; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformiv = procedure(programObj: GLhandle; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribfv = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribiv = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribPointerv = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsProgram = function(programObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsShader = function(shaderObj: GLhandle) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLinkProgram = procedure(programObj: GLHandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglShaderSource = procedure(shaderObj: GLHandle; count: glsizei; const _string: PPGLChar; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUseProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1f = procedure(location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2f = procedure(location: GLint; v0, v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3f = procedure(location: GLint; v0, v1, v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4f = procedure(location: GLint; v0, v1, v2, v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1i = procedure(location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2i = procedure(location: GLint; v0, v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3i = procedure(location: GLint; v0, v1, v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4i = procedure(location: GLint; v0, v1, v2, v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4fv = procedure(location: GLint; count: GLsizei; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4iv = procedure(location: GLint; count: GLsizei; value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglValidateProgram = procedure(programObj: GLhandle); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1f = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1s = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2f = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2s = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4Nbv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4Niv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4Nsv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4Nub = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4Nubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4Nuiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4Nusv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4bv = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4f = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4fv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4iv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4s = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4sv = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4ubv = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4uiv = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4usv = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribPointer = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_2_1
+  TglUniformMatrix2x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix3x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix2x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix4x2fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix3x4fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix4x3fv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_3_0
+  { OpenGL 3.0 also reuses entry points from these extensions: }
+  { ARB_framebuffer_object }
+  { ARB_map_buffer_range }
+  { ARB_vertex_array_object }
+  TglColorMaski = procedure(index_: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBooleani_v = procedure(target: GLenum; index_: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetIntegeri_v = procedure(target: GLenum; index_: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisablei = procedure(target: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsEnabledi = function(target: GLenum; index_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginTransformFeedback = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferRange = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferBase = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformFeedbackVaryings = procedure(program_: GLuint; count: GLsizei; const varyings: PPGLchar; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTransformFeedbackVarying = procedure(program_: GLuint; index_: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; type_: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClampColor = procedure(targe: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginConditionalRender = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndConditionalRender = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribIPointer = procedure(index_: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribIiv = procedure(index_: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribIuiv = procedure(index_: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI1i = procedure(index_: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2i = procedure(index_: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4i = procedure(index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI1ui = procedure(index_: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2ui = procedure(index_: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4ui = procedure(index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI1iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4iv = procedure(index_: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI1uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4uiv = procedure(index_: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4bv = procedure(index_: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4sv = procedure(index_: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4ubv = procedure(index_: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4usv = procedure(index_: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformuiv = procedure(program_: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindFragDataLocation = procedure(program_: GLuint; color: GLuint; const name: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFragDataLocation = function(program_: GLuint; const name: PGLChar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1ui = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2ui = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4ui = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4uiv = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameterIiv = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameterIuiv = procedure(target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameterIiv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameterIuiv = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearBufferiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearBufferuiv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearBufferfv = procedure(buffer: GLenum; drawbuffer: GLint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearBufferfi = procedure(buffer: GLenum; drawbuffer: GLint; depth: GLfloat; stencil: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetStringi = function(name: GLenum; index: GLuint): PGLubyte; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_2_1
+  TglEnableVertexArrayEXT = procedure(vaobj: GLuint; array_: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableVertexArrayAttribEXT = procedure(vaobj: GLuint; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexAttribOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; normalized: GLboolean; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_3_1
+  { OpenGL 3.1 also reuses entry points from these extensions: }
+  { ARB_copy_buffer }
+  { ARB_uniform_buffer_object }
+  TglDrawArraysInstanced = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementsInstanced = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexBuffer = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPrimitiveRestartIndex = procedure(index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_3_2
+  { OpenGL 3.2 also reuses entry points from these extensions: }
+  { ARB_draw_elements_base_vertex }
+  { ARB_provoking_vertex }
+  { ARB_sync }
+  { ARB_texture_multisample }
+  TglGetInteger64i_v = procedure(target: GLenum; index_: GLuint; data: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferParameteri64v = procedure(target: GLenum; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTexture = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+//  TglFramebufferTextureFace = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_3_3
+  { OpenGL 3.3 also reuses entry points from these extensions: }
+  { ARB_blend_func_extended }
+  { ARB_sampler_objects }
+  { ARB_explicit_attrib_location, but it has none }
+  { ARB_occlusion_query2 (no entry points) }
+  { ARB_shader_bit_encoding (no entry points) }
+  { ARB_texture_rgb10_a2ui (no entry points) }
+  { ARB_texture_swizzle (no entry points) }
+  { ARB_timer_query }
+  { ARB_vertex_type_2_10_10_10_rev }
+  TglVertexAttribDivisor = procedure(index: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  
+  // GL_VERSION_4_0
+  { OpenGL 4.0 also reuses entry points from these extensions: }
+  { ARB_texture_query_lod (no entry points) }
+  { ARB_draw_indirect }
+  { ARB_gpu_shader5 (no entry points) }
+  { ARB_gpu_shader_fp64 }
+  { ARB_shader_subroutine }
+  { ARB_tessellation_shader }
+  { ARB_texture_buffer_object_rgb32 (no entry points) }
+  { ARB_texture_cube_map_array (no entry points) }
+  { ARB_texture_gather (no entry points) }
+  { ARB_transform_feedback2 }
+  { ARB_transform_feedback3 }
+  TglMinSampleShading = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendEquationi = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendEquationSeparatei = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendFunci = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendFuncSeparatei = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_VERSION_4_1
+  { OpenGL 4.1 also reuses entry points from these extensions: }
+  { ARB_ES2_compatibility }
+  { ARB_get_program_binary }
+  { ARB_separate_shader_objects }
+  { ARB_shader_precision (no entry points) }
+  { ARB_vertex_attrib_64bit }
+  { ARB_viewport_array }
+
+  // GL_3DFX_tbuffer
+  TglTbufferMask3DFX = procedure(mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_APPLE_element_array
+  TglElementPointerAPPLE = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementArrayAPPLE = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiDrawElementArrayAPPLE = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiDrawRangeElementArrayAPPLE = procedure(mode: GLenum; start: GLuint; _end: GLuint; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_APPLE_fence
+  TglGenFencesAPPLE = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteFencesAPPLE = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSetFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTestFenceAPPLE = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFinishFenceAPPLE = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTestObjectAPPLE = function(_object: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFinishObjectAPPLE = procedure(_object: GLenum; name: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_APPLE_vertex_array_object
+  TglBindVertexArrayAPPLE = procedure(_array: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenVertexArraysAPPLE = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsVertexArrayAPPLE = function(_array: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_APPLE_vertex_array_range
+  TglVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFlushVertexArrayRangeAPPLE = procedure(length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayParameteriAPPLE = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_APPLE_texture_range
+  TglTextureRangeAPPLE = procedure(target: GLenum; length: GLsizei; const Pointer_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameterPointervAPPLE = procedure(target: GLenum; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_APPLE_vertex_program_evaluators
+  TglEnableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableVertexAttribAPPLE = procedure(index_: GLuint; pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsVertexAttribEnabledAPPLE = function(index_: GLuint; pname: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapVertexAttrib1dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; stride: GLint; order: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapVertexAttrib1fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; stride: GLint; order: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapVertexAttrib2dAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapVertexAttrib2fAPPLE = procedure(index_: GLuint; size: GLuint; u1: GLfloat; u2: GLfloat; ustride: GLint; order: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; const points: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_APPLE_object_purgeable
+  TglObjectPurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglObjectUnpurgeableAPPLE = function(objectType: GLenum; name: GLuint; option: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetObjectParameterivAPPLE = procedure(objectType: GLenum; name: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_matrix_palette
+  TglCurrentPaletteMatrixARB = procedure(index: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixIndexubvARB = procedure(size: GLint; const indices: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixIndexusvARB = procedure(size: GLint; const indices: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixIndexuivARB = procedure(size: GLint; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixIndexPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_multisample
+  TglSampleCoverageARB = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_multitexture
+  TglActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClientActiveTextureARB = procedure(texture: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1dARB = procedure(target: GLenum; s: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1fARB = procedure(target: GLenum; s: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1iARB = procedure(target: GLenum; s: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1sARB = procedure(target: GLenum; s: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2iARB = procedure(target: GLenum; s: GLint; t: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2sARB = procedure(target: GLenum; s: GLshort; t: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4dARB = procedure(target: GLenum; s: GLdouble; t: GLdouble; r: GLdouble; q: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4dvARB = procedure(target: GLenum; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4fARB = procedure(target: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4fvARB = procedure(target: GLenum; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4iARB = procedure(target: GLenum; s: GLint; t: GLint; r: GLint; q: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4ivARB = procedure(target: GLenum; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4sARB = procedure(target: GLenum; s: GLshort; t: GLshort; r: GLshort; q: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4svARB = procedure(target: GLenum; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_point_parameters
+  TglPointParameterfARB = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameterfvARB = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_texture_compression
+  TglCompressedTexImage3DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexImage2DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexImage1DARB = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexSubImage3DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexSubImage2DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTexSubImage1DARB = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCompressedTexImageARB = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_transpose_matrix
+  TglLoadTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultTransposeMatrixfARB = procedure(const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultTransposeMatrixdARB = procedure(const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_blend
+  TglWeightbvARB = procedure(size: GLint; const weights: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightsvARB = procedure(size: GLint; const weights: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightivARB = procedure(size: GLint; const weights: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightfvARB = procedure(size: GLint; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightdvARB = procedure(size: GLint; const weights: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightubvARB = procedure(size: GLint; const weights: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightusvARB = procedure(size: GLint; const weights: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightuivARB = procedure(size: GLint; const weights: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightPointerARB = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexBlendARB = procedure(count: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_buffer_object
+  TglBindBufferARB = procedure(target: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteBuffersARB = procedure(n: GLsizei; const buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenBuffersARB = procedure(n: GLsizei; buffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsBufferARB = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBufferDataARB = procedure(target: GLenum; size: GLsizeiptrARB; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferSubDataARB = procedure(target: GLenum; offset: GLintptrARB; size: GLsizeiptrARB; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapBufferARB = function(target: GLenum; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUnmapBufferARB = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferParameterivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferPointervARB = procedure(target: GLenum; pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_program
+  TglVertexAttrib1dARB = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1fARB = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1sARB = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2sARB = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4NbvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4NivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4NsvARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4NubARB = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4NubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4NuivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4NusvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4bvARB = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4dARB = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4dvARB = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4fARB = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4fvARB = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4ivARB = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4sARB = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4svARB = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4ubvARB = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4uivARB = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4usvARB = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribPointerARB = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableVertexAttribArrayARB = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramStringARB = procedure(target: GLenum; format: GLenum; len: GLsizei; const _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindProgramARB = procedure(target: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteProgramsARB = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenProgramsARB = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameter4dARB = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameter4dvARB = procedure(target: GLenum; index: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameter4fARB = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameter4fvARB = procedure(target: GLenum; index: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramEnvParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramEnvParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramLocalParameterdvARB = procedure(target: GLenum; index: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramLocalParameterfvARB = procedure(target: GLenum; index: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramivARB = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramStringARB = procedure(target: GLenum; pname: GLenum; _string: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribdvARB = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribfvARB = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribivARB = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribPointervARB = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsProgramARB = function(_program: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_window_pos
+  TglWindowPos2dARB = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2fARB = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2iARB = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2sARB = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3dARB = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3dvARB = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3fARB = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3fvARB = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3iARB = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3ivARB = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3sARB = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3svARB = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_draw_buffers
+  TglDrawBuffersARB = procedure(n: GLsizei; bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_color_buffer_float
+  TglClampColorARB = procedure(target: GLenum; clamp: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_shader
+  TglGetActiveAttribARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetAttribLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindAttribLocationARB = procedure(programObj: GLhandleARB; index: GLuint; const name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_shader_objects
+  TglDeleteObjectARB = procedure(Obj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetHandleARB = function(pname: GlEnum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDetachObjectARB = procedure(container, attached: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateShaderObjectARB = function(shaderType: glenum): GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglShaderSourceARB = procedure(shaderObj: GLHandleARB; count: glsizei; const _string: PPGLCharARB; lengths: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompileShaderARB = procedure(shaderObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateProgramObjectARB = function: GLHandleARB; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglAttachObjectARB = procedure(programObj, shaderObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLinkProgramARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUseProgramObjectARB = procedure(programObj: GLHandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglValidateProgramARB = procedure(programObj: GLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1fARB = procedure(location: glint; v0: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2fARB = procedure(location: glint; v0, v1: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3fARB = procedure(location: glint; v0, v1, v2: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4fARB = procedure(location: glint; v0, v1, v2, v3: glfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1iARB = procedure(location: glint; v0: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2iARB = procedure(location: glint; v0, v1: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3iARB = procedure(location: glint; v0, v1, v2: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4iARB = procedure(location: glint; v0, v1, v2, v3: glint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4fvARB = procedure(location: glint; count: GLsizei; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4ivARB = procedure(location: glint; count: GLsizei; value: pglint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix2fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix3fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix4fvARB = procedure(location: glint; count: glsizei; transpose: glboolean; value: pglfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetObjectParameterfvARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetObjectParameterivARB = procedure(Obj: GLHandleARB; pname: GLEnum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetInfoLogARB = procedure(shaderObj: GLHandleARB; maxLength: glsizei; var length: glint; infoLog: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetAttachedObjectsARB = procedure(programobj: GLhandleARB; maxCount: GLsizei; var count: GLsizei; objects: PGLhandleARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformLocationARB = function(programObj: GLhandleARB; const char: PGLcharARB): glint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveUniformARB = procedure(programobj: GLhandleARB; index: GLuint; maxLength: GLsizei; var length: GLsizei; var size: GLint; var _type: GLenum; name: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformfvARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformivARB = procedure(programObj: GLhandleARB; location: GLint; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetShaderSourceARB = procedure(shader: GLhandleARB; maxLength: GLsizei; var length: GLsizei; source: PGLcharARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_Occlusion_Query
+  TglGenQueriesARB = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteQueriesARB = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsQueryARB = function(id: GLuint): boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginQueryARB = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndQueryARB = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryivARB = procedure(target, pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryObjectivARB = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryObjectuivARB = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_draw_instanced
+  TglDrawArraysInstancedARB = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementsInstancedARB = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_framebuffer_object
+  TglIsRenderbuffer = function(renderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindRenderbuffer = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteRenderbuffers = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenRenderbuffers = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRenderbufferStorage = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetRenderbufferParameteriv = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsFramebuffer = function(framebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindFramebuffer = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteFramebuffers = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenFramebuffers = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCheckFramebufferStatus = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTexture1D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTexture2D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTexture3D = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferRenderbuffer = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFramebufferAttachmentParameteriv = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenerateMipmap = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlitFramebuffer = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRenderbufferStorageMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTextureLayer = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_geometry_shader4
+  TglProgramParameteriARB = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTextureARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTextureLayerARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTextureFaceARB = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_instanced_arrays
+  TglVertexAttribDivisorARB = procedure(index_: GLuint; divisor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_map_buffer_range
+  TglMapBufferRange = function(target: GLenum; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFlushMappedBufferRange = procedure(target: GLenum; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_texture_buffer_object
+  TglTexBufferARB = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_array_object
+  TglBindVertexArray = procedure(array_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteVertexArrays = procedure(n: GLsizei; const arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenVertexArrays = procedure(n: GLsizei; arrays: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsVertexArray = function(array_: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_uniform_buffer_object
+  TglGetUniformIndices = procedure(program_: GLuint; uniformCount: GLsizei; const uniformNames: PPGLchar; uniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveUniformsiv = procedure(program_: GLuint; uniformCount: GLsizei; const uniformIndices: PGLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveUniformName = procedure(program_: GLuint; uniformIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformBlockIndex = function(program_: GLuint; const uniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveUniformBlockiv = procedure(program_: GLuint; uniformBlockIndex: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveUniformBlockName = procedure(program_: GLuint; uniformBlockIndex: GLuint; bufSize: GLsizei; length: PGLsizei; uniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformBlockBinding = procedure(program_: GLuint; uniformBlockIndex: GLuint; uniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_copy_buffer
+  TglCopyBufferSubData = procedure(readTarget: GLenum; writeTarget: GLenum; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_draw_elements_base_vertex
+  TglDrawElementsBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawRangeElementsBaseVertex = procedure(mode: GLenum; start: GLuint; end_: GLuint; count: GLsizei; type_: GLenum; const indices: PGLvoid; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementsInstancedBaseVertex = procedure(mode: GLenum; count: GLsizei; type_: GLenum; const indices: PGLvoid; primcount: GLsizei; basevertex: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiDrawElementsBaseVertex = procedure(mode: GLenum; const count: PGLsizei; type_: GLenum; const indices: PPGLvoid; primcount: GLsizei; const basevertex: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_provoking_vertex
+  TglProvokingVertex = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_sync
+  TglFenceSync = function(condition: GLenum; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsSync = function(sync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteSync = procedure(sync: GLsync); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClientWaitSync = function(sync: GLsync; flags: GLbitfield; timeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWaitSync = procedure(sync: GLsync; flags: GLbitfield; timeout: GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetInteger64v = procedure(pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSynciv = procedure(sync: GLsync; pname: GLenum; butSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_texture_multisample
+  TglTexImage2DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexImage3DMultisample = procedure(target: GLenum; samples: GLsizei; internalformat: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; fixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultisamplefv = procedure(pname: GLenum; index_: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSampleMaski = procedure(index_: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_draw_buffers_blend
+  TglBlendEquationiARB = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendEquationSeparateiARB = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendFunciARB = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendFuncSeparateiARB = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_sample_shading
+  TglMinSampleShadingARB = procedure(value: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_shading_language_include
+  TglNamedStringARB = procedure(type_: GLenum; namelen: GLint; const name: PGLchar; stringlen: GLint; const string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteNamedStringARB = procedure(namelen: GLint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompileShaderIncludeARB = procedure (shader: GLuint; count: GLsizei; const path: PPGLchar; const length: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsNamedStringARB = function(namelen: GLint; const name: PGLchar): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedStringARB = procedure(namelen: GLint; const name: PGLchar; bufSize: GLsizei; stringlen: GLint; string_: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedStringivARB = procedure(namelen: GLint; const name: PGLchar; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_blend_func_extended
+  TglBindFragDataLocationIndexed = procedure(program_: GLuint; colorNumber: GLuint; index: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFragDataIndex = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_sampler_objects
+  TglGenSamplers = procedure(count: GLsizei; samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteSamplers = procedure(count: GLsizei; const samplers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsSampler = function(sampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindSampler = procedure(unit_: GLuint; sampler: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplerParameteri = procedure(sampler: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplerParameterf = procedure(sampler: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; const param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSamplerParameteriv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSamplerParameterIiv = procedure(sampler: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSamplerParameterfv = procedure(sampler: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSamplerParameterIuiv = procedure(sampler: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_timer_query
+  TglQueryCounter = procedure(id: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryObjecti64v = procedure(id: GLuint; pname: GLenum; params: PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryObjectui64v = procedure(id: GLuint; pname: GLenum; params: PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_type_2_10_10_10_rev
+  TglVertexP2ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexP2uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexP3ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexP3uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexP4ui = procedure(type_: GLenum; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexP4uiv = procedure(type_: GLenum; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP1ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP1uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP2ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP2uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP4ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordP4uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP1ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP1uiv = procedure(texture: GLenum; type_: GLenum; const coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP2ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP2uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP3ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP3uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP4ui = procedure(texture: GLenum; type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordP4uiv = procedure(texture: GLenum; type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalP3ui = procedure(type_: GLenum; coords: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalP3uiv = procedure(type_: GLenum; const coords: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorP4ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorP4uiv = procedure(type_: GLenum; const color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColorP3ui = procedure(type_: GLenum; color: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColorP3uiv = procedure(type_: GLenum; const color: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP1ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP1uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP2ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP2uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP3ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP3uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP4ui = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; value: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribP4uiv = procedure(index: GLuint; type_: GLenum; normalized: GLboolean; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_draw_indirect
+  TglDrawArraysIndirect = procedure(mode: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementsIndirect = procedure(mode: GLenum; type_: GLenum; const indirect: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_gpu_shader_fp64
+  TglUniform1d = procedure(location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2d = procedure(location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4d = procedure(location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4dv = procedure(location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix2x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix2x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix3x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix3x4dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix4x2dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformMatrix4x3dv = procedure(location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformdv = procedure(program_: GLuint; location: GLint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_shader_subroutine
+  TglGetSubroutineUniformLocation = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSubroutineIndex = function(program_: GLuint; shadertype: GLenum; const name: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveSubroutineUniformiv = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveSubroutineUniformName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveSubroutineName = procedure(program_: GLuint; shadertype: GLenum; index: GLuint; bufsize: GLsizei; length: PGLsizei; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformSubroutinesuiv = procedure(shadertype: GLenum; count: GLsizei; const indices: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformSubroutineuiv = procedure(shadertype: GLenum; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramStageiv = procedure(program_: GLuint; shadertype: GLenum; pname: GLenum; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_tessellation_shader
+  TglPatchParameteri = procedure(pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPatchParameterfv = procedure(pname: GLenum; const values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_transform_feedback2
+  TglBindTransformFeedback = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteTransformFeedbacks = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenTransformFeedbacks = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsTransformFeedback = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPauseTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglResumeTransformFeedback = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawTransformFeedback = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_transform_feedback3
+  TglDrawTransformFeedbackStream = procedure(mode: GLenum; id: GLuint; stream: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginQueryIndexed = procedure(target: GLenum; index: GLuint; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndQueryIndexed = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryIndexediv = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_ES2_compatibility
+  TglReleaseShaderCompiler = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglShaderBinary = procedure(count: GLsizei; const shaders: PGLuint; binaryformat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetShaderPrecisionFormat = procedure(shadertype: GLenum; precisiontype: GLenum; range: PGLint; precision: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDepthRangef = procedure(n: GLclampf; f: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearDepthf = procedure(d: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_get_program_binary
+  TglGetProgramBinary = procedure(program_: GLuint; bufSize: GLsizei; length: PGLsizei; binaryFormat: PGLenum; binary: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramBinary = procedure(program_: GLuint; binaryFormat: GLenum; const binary: PGLvoid; length: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramParameteri = procedure(program_: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  
+  // GL_ARB_separate_shader_objects
+  TglUseProgramStages = procedure(pipeline: GLuint; stages: GLbitfield; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglActiveShaderProgram = procedure(pipeline: GLuint; program_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateShaderProgramv = function(type_: GLenum; count: GLsizei; const strings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteProgramPipelines = procedure(n: GLsizei; const pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenProgramPipelines = procedure(n: GLsizei; pipelines: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsProgramPipeline = function(pipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramPipelineiv = procedure(pipeline: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1i = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1f = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1d = procedure(program_: GLuint; location: GLint; v0: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1ui = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4i = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4iv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4f = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4d = procedure(program_: GLuint; location: GLint; v0: GLdouble; v1: GLdouble; v2: GLdouble; v3: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4ui = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4uiv = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x2fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x4fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x3fv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x2dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x4dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x3dv = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglValidateProgramPipeline = procedure(pipeline: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramPipelineInfoLog = procedure(pipeline: GLuint; bufSize: GLsizei; length: PGLsizei; infoLog: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_attrib_64bit
+  TglVertexAttribL1d = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2d = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4d = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL1dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4dv = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribLPointer = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribLdv = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_viewport_array
+  TglViewportArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglViewportIndexedf = procedure(index: GLuint; x: GLfloat; y: GLfloat; w: GLfloat; h: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglViewportIndexedfv = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglScissorArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglScissorIndexed = procedure(index: GLuint; left: GLint; bottom: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglScissorIndexedv = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDepthRangeArrayv = procedure(first: GLuint; count: GLsizei; const v: PGLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDepthRangeIndexed = procedure(index: GLuint; n: GLclampd; f: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFloati_v = procedure(target: GLenum; index: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetDoublei_v = procedure(target: GLenum; index: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL 4.2
+
+  // GL_ARB_base_instance
+  TglDrawArraysInstancedBaseInstance = procedure(mode : GLenum; first : GLint; count :GLsizei; primcount : GLsizei; baseinstance : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementsInstancedBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount : GLsizei; baseinstance : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementsInstancedBaseVertexBaseInstance = procedure(mode : GLEnum; count : GLsizei; _type : GLenum; const indices : PGLVoid; primcount :GLsizei; basevertex : GLint; baseinstance : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_transform_feedback_instanced
+  TglDrawTransformFeedbackInstanced = procedure(mode : GLenum; id : GLuint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawTransformFeedbackStreamInstanced = procedure(mode : GLenum; id : GLUInt; stream : GLUint; primcount : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_internalformat_query
+  TglGetInternalformativ = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_shader_atomic_counters
+  TglGetActiveAtomicCounterBufferiv = procedure(_program : GLuint; bufferIndex : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  /// GL_ARB_shader_image_load_store
+  TglBindImageTexture = procedure(_unit : GLuint; texture : GLuint; level :GLint; layered : GLboolean; layer : GLint; access : GLenum; format : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMemoryBarrier = procedure(barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_texture_storage
+  TglTexStorage1D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexStorage2D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexStorage3D = procedure(target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage1DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage2DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage3DEXT = procedure(texture : GLuint; target : GLenum; levels :GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+
+  // GL 4.3
+
+  // GL_KHR_debug
+  TglDebugMessageControl = procedure(source : GLenum; type_ : GLenum; severity : TGLenum; count : GLsizei; const ids : PGLUInt; enabled : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDebugMessageInsert = procedure(source : GLenum;  type_ : GLenum; id : GLuint; sverity : GLenum; length : GLsizei; const buf : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDebugMessageCallback = procedure(callback : TGLDEBUGPROC; const userParam : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetDebugMessageLog = function(count : GLuint; bufsize : GLsizei; sources : PGLenum; types : PGLenum; ids : PGLuint; sverities : PGLenum; lengths : PGLSizei; messagelog : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPushDebugGroup = procedure(source : GLenum; id : GLuint; length : GLsizei; const message_ : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPopDebugGroup = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglObjectLabel = procedure(identifier : GLenum; name : GLuint; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetObjectLabel = procedure(identifier : GLenum; name : GLuint; bufsize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglObjectPtrLabel = procedure(const ptr : Pointer; length : GLsizei; const label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetObjectPtrLabel = procedure(const ptr : Pointer; bufSize : GLsizei; length : PGLsizei; label_ : PGLCHar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_clear_buffer_object
+  TglClearBufferData = procedure(target : GLenum; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearBufferSubData = procedure(target : GLenum; internalformat : GLenum; offset : GLintptr; size : GLsizeiptr; format : GLenum; type_ : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedBufferDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLEnum; type_ : GLEnum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedBufferSubDataEXT = procedure(buffer : GLuint; internalformat : GLenum; format : GLenum; type_ : GLenum; offset : GLsizeiptr; size : GLsizeiptr; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_compute_shader 1
+  TglDispatchCompute = procedure(num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDispatchComputeIndirect = procedure(indirect : GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_copy_image
+  TglCopyImageSubData = procedure(srcName : GLUInt; srcTarget : GLenum; srcLevel : GLint; srcX : GLint; srcY : GLint; srcZ : GLint; dstName : GLUInt; dstTarget : GLEnum; dstLevel : GLInt; dstX : GLInt; dstY : GLint; dstZ : GLint; srcWidth : GLsizei; srcHeight : GLsizei; srcDepth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_debug_group
+  // ARB_debug_group reuses entry points from KHR_debug
+
+  // GL_ARB_debug_label
+  // ARB_debug_label reuses entry points from KHR_debug
+
+  // GL_ARB_debug_output2
+
+  // GL_ARB_ES3_compatibility
+
+  // GL_ARB_explicit_uniform_location
+
+  // GL_ARB_fragment_layer_viewport
+
+  // GL_ARB_framebuffer_no_attachments
+  TglFramebufferParameteri = procedure(target : GLenum; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFramebufferParameteriv = procedure(target : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferParameteriEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedFramebufferParameterivEXT = procedure(framebuffer : GLUInt; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_internalformat_query2
+  TglGetInternalformati64v = procedure(target : GLenum; internalformat : GLenum; pname : GLenum; bufSize : GLsizei; params : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_invalidate_subdata
+  TglInvalidateTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInvalidateTexImage = procedure(texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInvalidateBufferSubData = procedure(buffer : GLuint; offset : GLintptr; length : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInvalidateBufferData = procedure(buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInvalidateFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInvalidateSubFramebuffer = procedure(target : GLenum; numAttachments : GLsizei; const attachments : PGLenum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_multi_draw_indirect
+  TglMultiDrawArraysIndirect = procedure(mode : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiDrawElementsIndirect = procedure(mode : GLenum; type_ : GLenum; const indirect : Pointer; drawcount : GLsizei; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_program_interface_query
+  TglGetProgramInterfaceiv = procedure(program_ : GLUInt;programInterface : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramResourceIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLUInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramResourceName = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; bufSize : GLsizei; length : PGLsizei; name : PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramResourceiv = procedure(program_ : GLUInt;programInterface : GLenum; index : GLuint; propCount : GLsizei; const props : PGLenum; bufSize : GLsizei; length : PGLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramResourceLocation = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramResourceLocationIndex = function(program_ : GLUInt;programInterface : GLenum; const name : PGLchar) : GLInt; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_robust_buffer_access_behavior
+
+  // GL_ARB_shader_image_size
+
+  // GL_ARB_shader_storage_buffer_object
+  TglShaderStorageBlockBinding = procedure(program_ : GLuint; storageBlockIndex : GLuint; storageBlockBinding : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_stencil_texturing
+
+  // GL_ARB_texture_buffer_range
+  TglTexBufferRange = procedure(target : GLenum; internalformat : GLenum; buffer : GLuint; offset :GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureBufferRangeEXT = procedure(texture : GLuint; target : GLenum; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_texture_query_levels
+
+  // GL_ARB_texture_storage_multisample
+  TglTexStorage2DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexStorage3DMultisample = procedure(target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage2DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage3DMultisampleEXT = procedure(texture : GLuint; target : GLenum; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL 4.4
+
+  TglBufferStorage = procedure(target : GLenum; size : GLsizeiptr; const data : pointer; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglClearTexImage = procedure(texture : GLuint; level : GLint; format : GLenum; _type : GLenum; const data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglClearTexSubImage = procedure(texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; const Data : Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglBindBuffersBase = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglBindBuffersRange = procedure(target : GLenum; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : GLintptr; const sizes : GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglBindTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglBindSamplers = procedure(first : GLuint; count : GLsizei; const samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglBindImageTextures = procedure(first : GLuint; count : GLsizei; const textures : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+       TglBindVertexBuffers = procedure(first : GLuint; count : GLsizei; const buffers : GLuint; const offsets : GLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // END GL 4.4
+
+
+  // GL_ARB_texture_view
+  TglTextureView = procedure(texture : GLuint; target : GLenum; origtexture : GLuint; internalformat : GLenum; minlevel : GLuint; numlevels : GLuint; minlayer : GLuint; numlayers : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_vertex_attrib_binding
+  TglBindVertexBuffer = procedure(bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribIFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribLFormat = procedure(attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribBinding = procedure(attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexBindingDivisor = procedure(bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayBindVertexBufferEXT = procedure(vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexAttribFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; normalized : GLboolean; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexAttribIFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexAttribLFormatEXT = procedure(vaobj : GLuint; attribindex : GLuint; size : GLInt; type_ : GLEnum; relativeoffset : GLUint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexAttribBindingEXT = procedure(vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexBindingDivisorEXT = procedure(vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_robustness_isolation
+
+  //
+
+  // GL_ARB_cl_event
+  TglCreateSyncFromCLeventARB = function(context: p_cl_context; event: p_cl_event; flags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_debug_output
+  TglDebugMessageControlARB = procedure(source: GLenum; type_: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDebugMessageInsertARB = procedure(source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDebugMessageCallbackARB = procedure(callback: TglDebugProcARB; const userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetDebugMessageLogARB = function(count: GLuint; bufsize: GLsizei; sources: PGLenum; types: PGLenum; ids: PGLuint; severities: PGLenum; lengths: PGLsizei; messageLog: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_robustness
+  TglGetGraphicsResetStatusARB = function(): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMapdvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMapfvARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMapivARB = procedure(target: GLenum; query: GLenum; bufSize: GLsizei; v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPixelMapfvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPixelMapuivARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPixelMapusvARB = procedure(map: GLenum; bufSize: GLsizei; values: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPolygonStippleARB = procedure(bufSize: GLsizei; pattern: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnColorTableARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnConvolutionFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; bufSize: GLsizei; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnSeparableFilterARB = procedure(target: GLenum; format: GLenum; type_: GLenum; rowBufSize: GLsizei; row: PGLvoid; columnBufSize: GLsizei; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnHistogramARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMinmaxARB = procedure(target: GLenum; reset: GLboolean; format: GLenum; type_: GLenum; bufSize: GLsizei; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnTexImageARB = procedure(target: GLenum; level: GLint; format: GLenum; type_: GLenum; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReadnPixelsARB = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; bufSize: GLsizei; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnCompressedTexImageARB = procedure(target: GLenum; lod: GLint; bufSize: GLsizei; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformfvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformuivARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformdvARB = procedure(program_: GLuint; location: GLint; bufSize: GLsizei; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_draw_buffers
+  TglDrawBuffersATI = procedure(n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_element_array
+  TglElementPointerATI = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementArrayATI = procedure(mode: GLenum; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawRangeElementArrayATI = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_envmap_bumpmap
+  TglTexBumpParameterivATI = procedure(pname: GLenum; const param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexBumpParameterfvATI = procedure(pname: GLenum; const param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexBumpParameterivATI = procedure(pname: GLenum; param: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexBumpParameterfvATI = procedure(pname: GLenum; param: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_fragment_shader
+  TglGenFragmentShadersATI = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteFragmentShaderATI = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndFragmentShaderATI = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPassTexCoordATI = procedure(dst: GLuint; coord: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSampleMapATI = procedure(dst: GLuint; interp: GLuint; swizzle: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMask: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglAlphaFragmentOp1ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglAlphaFragmentOp2ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglAlphaFragmentOp3ATI = procedure(op: GLenum; dst: GLuint; dstMod: GLuint; arg1: GLuint; arg1Rep: GLuint; arg1Mod: GLuint; arg2: GLuint; arg2Rep: GLuint; arg2Mod: GLuint; arg3: GLuint; arg3Rep: GLuint; arg3Mod: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSetFragmentShaderConstantATI = procedure(dst: GLuint; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_map_object_buffer
+  TglMapObjectBufferATI = function(buffer: GLuint): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUnmapObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_pn_triangles
+  TglPNTrianglesiATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPNTrianglesfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_separate_stencil
+  TglStencilOpSeparateATI = procedure(face: GLenum; sfail: GLenum; dpfail: GLenum; dppass: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilFuncSeparateATI = procedure(frontfunc: GLenum; backfunc: GLenum; ref: GLint; mask: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_vertex_array_object
+  TglNewObjectBufferATI = function(size: GLsizei; const _pointer: PGLvoid; usage: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsObjectBufferATI = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUpdateObjectBufferATI = procedure(buffer: GLuint; offset: GLuint; size: GLsizei; const _pointer: PGLvoid; preserve: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetObjectBufferfvATI = procedure(buffer: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetObjectBufferivATI = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFreeObjectBufferATI = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglArrayObjectATI = procedure(_array: GLenum; size: GLint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetArrayObjectfvATI = procedure(_array: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetArrayObjectivATI = procedure(_array: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantArrayObjectATI = procedure(id: GLuint; _type: GLenum; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVariantArrayObjectfvATI = procedure(id: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVariantArrayObjectivATI = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_vertex_attrib_array_object
+  TglVertexAttribArrayObjectATI = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei; buffer: GLuint; offset: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribArrayObjectfvATI = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribArrayObjectivATI = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ATI_vertex_streams
+  TglVertexStream1sATI = procedure(stream: GLenum; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream1svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream1iATI = procedure(stream: GLenum; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream1ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream1fATI = procedure(stream: GLenum; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream1fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream1dATI = procedure(stream: GLenum; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream1dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2sATI = procedure(stream: GLenum; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2iATI = procedure(stream: GLenum; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream2dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4sATI = procedure(stream: GLenum; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4iATI = procedure(stream: GLenum; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4fATI = procedure(stream: GLenum; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4dATI = procedure(stream: GLenum; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexStream4dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3bATI = procedure(stream: GLenum; nx: GLbyte; ny: GLbyte; nz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3bvATI = procedure(stream: GLenum; const coords: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3sATI = procedure(stream: GLenum; nx: GLshort; ny: GLshort; nz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3svATI = procedure(stream: GLenum; const coords: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3iATI = procedure(stream: GLenum; nx: GLint; ny: GLint; nz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3ivATI = procedure(stream: GLenum; const coords: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3fATI = procedure(stream: GLenum; nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3fvATI = procedure(stream: GLenum; const coords: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3dATI = procedure(stream: GLenum; nx: GLdouble; ny: GLdouble; nz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalStream3dvATI = procedure(stream: GLenum; const coords: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClientActiveVertexStreamATI = procedure(stream: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexBlendEnviATI = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexBlendEnvfATI = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_performance_monitor
+  TglGetPerfMonitorGroupsAMD = procedure(numGroups: PGLint; groupsSize: GLsizei; groups: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPerfMonitorCountersAMD = procedure(group: GLuint; numCounters: PGLint; maxActiveCouters: PGLint; counterSize: GLsizei; counters: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPerfMonitorGroupStringAMD = procedure(group: GLuint; bufSize: GLsizei; length: PGLsizei; groupString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPerfMonitorCounterStringAMD = procedure(group: GLuint; counter: GLuint; bufSize: GLsizei; length: PGLsizei; counterString: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPerfMonitorCounterInfoAMD = procedure(group: GLuint; counter: GLuint; pname: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenPerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeletePerfMonitorsAMD = procedure(n: GLsizei; monitors: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSelectPerfMonitorCountersAMD = procedure(monitor: GLuint; enable: GLboolean; group: GLuint; numCounters: GLint; counterList: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndPerfMonitorAMD = procedure(monitor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPerfMonitorCounterDataAMD = procedure(monitor: GLuint; pname: GLenum; dataSize: GLsizei; data: PGLuint; bytesWritten: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_vertex_shader_tesselator
+  TglTessellationFactorAMD = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTessellationModeAMD = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_draw_buffers_blend
+  TglBlendFuncIndexedAMD = procedure(buf: GLuint; src: GLenum; dst: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendFuncSeparateIndexedAMD = procedure(buf: GLuint; srcRGB: GLenum; dstRGB: GLenum; srcAlpha: GLenum; dstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendEquationIndexedAMD = procedure(buf: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlendEquationSeparateIndexedAMD = procedure(buf: GLuint; modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_name_gen_delete
+  TglGenNamesAMD = procedure(identifier: GLenum; num: GLuint; names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteNamesAMD = procedure(identifier: GLenum; num: GLuint; const names: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsNameAMD = function(identifier: GLenum; name: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_debug_output
+  TglDebugMessageEnableAMD = procedure(category: GLenum; severity: GLenum; count: GLsizei; const ids: PGLuint; enabled: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDebugMessageInsertAMD = procedure(category: GLenum; severity: GLenum; id: GLuint; length: GLsizei; const buf: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDebugMessageCallbackAMD = procedure(callback: TGLDebugProcAMD; userParam: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetDebugMessageLogAMD = function(count: GLuint; bufsize: GLsizei; categories: PGLenum; severities: PGLuint; ids: PGLuint; lengths: PGLsizei; message: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_blend_color
+  TglBlendColorEXT = procedure(red: GLclampf; green: GLclampf; blue: GLclampf; alpha: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_blend_func_separate
+  TglBlendFuncSeparateEXT = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_blend_minmax
+  TglBlendEquationEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_color_subtable
+  TglColorSubTableEXT = procedure(target: GLenum; start: GLsizei; count: GLsizei; format: GLenum; _type: GLenum; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyColorSubTableEXT = procedure(target: GLenum; start: GLsizei; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_compiled_vertex_array
+  TglLockArraysEXT = procedure(first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUnlockArraysEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_convolution
+  TglConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameterfEXT = procedure(target: GLenum; pname: GLenum; params: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameteriEXT = procedure(target: GLenum; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyConvolutionFilter1DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyConvolutionFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetConvolutionFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; image: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetConvolutionParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetConvolutionParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSeparableFilterEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; row: PGLvoid; column: PGLvoid; span: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSeparableFilter2DEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const row: PGLvoid; const column: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_coordinate_frame
+  TglTangent3bEXT = procedure(tx: GLbyte; ty: GLbyte; tz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3dEXT = procedure(tx: GLdouble; ty: GLdouble; tz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3fEXT = procedure(tx: GLfloat; ty: GLfloat; tz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3iEXT = procedure(tx: GLint; ty: GLint; tz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3sEXT = procedure(tx: GLshort; ty: GLshort; tz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangent3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3bEXT = procedure(bx: GLbyte; by: GLbyte; bz: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3dEXT = procedure(bx: GLdouble; by: GLdouble; bz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3fEXT = procedure(bx: GLfloat; by: GLfloat; bz: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3iEXT = procedure(bx: GLint; by: GLint; bz: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3sEXT = procedure(bx: GLshort; by: GLshort; bz: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormal3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTangentPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBinormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_copy_texture
+  TglCopyTexImage1DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexImage2DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_cull_vertex
+  TglCullParameterdvEXT = procedure(pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCullParameterfvEXT = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_draw_range_elements
+  TglDrawRangeElementsEXT = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_fog_coord
+  TglFogCoordfEXT = procedure(coord: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordfvEXT = procedure(const coord: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoorddEXT = procedure(coord: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoorddvEXT = procedure(const coord: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordPointerEXT = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_framebuffer_object
+  TglIsRenderbufferEXT = function(renderbuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindRenderbufferEXT = procedure(target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteRenderbuffersEXT = procedure(n: GLsizei; const renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenRenderbuffersEXT = procedure(n: GLsizei; renderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRenderbufferStorageEXT = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetRenderbufferParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsFramebufferEXT = function(framebuffer: GLuint): Boolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindFramebufferEXT = procedure(target: GLenum; framebuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteFramebuffersEXT = procedure(n: GLsizei; const framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenFramebuffersEXT = procedure(n: GLsizei; framebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCheckFramebufferStatusEXT = function(target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTexture1DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTexture2DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTexture3DEXT = procedure(target: GLenum; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferRenderbufferEXT = procedure(target: GLenum; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFramebufferAttachmentParameterivEXT = procedure(target: GLenum; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenerateMipmapEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_histogram
+  TglGetHistogramEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetHistogramParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetHistogramParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMinmaxEXT = procedure(target: GLenum; reset: GLboolean; format: GLenum; _type: GLenum; values: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMinmaxParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMinmaxParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglHistogramEXT = procedure(target: GLenum; width: GLsizei; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMinmaxEXT = procedure(target: GLenum; internalformat: GLenum; sink: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglResetHistogramEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglResetMinmaxEXT = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_index_func
+  TglIndexFuncEXT = procedure(func: GLenum; ref: GLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_index_material
+  TglIndexMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_light_texture
+  TglApplyTextureEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureLightEXT = procedure(pname: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureMaterialEXT = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_multi_draw_arrays
+  TglMultiDrawArraysEXT = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiDrawElementsEXT = procedure(mode: GLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_multisample
+  TglSampleMaskEXT = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplePatternEXT = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_paletted_texture
+  TglColorTableEXT = procedure(target: GLenum; internalFormat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableEXT = procedure(target: GLenum; format: GLenum; _type: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableParameterivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableParameterfvEXT = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_pixel_transform
+  TglPixelTransformParameteriEXT = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTransformParameterfEXT = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTransformParameterivEXT = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTransformParameterfvEXT = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_point_parameters
+  TglPointParameterfEXT = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameterfvEXT = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_polygon_offset
+  TglPolygonOffsetEXT = procedure(factor: GLfloat; bias: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_secondary_color
+  TglSecondaryColor3bEXT = procedure(red: GLbyte; green: GLbyte; blue: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3bvEXT = procedure(const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3dEXT = procedure(red: GLdouble; green: GLdouble; blue: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3dvEXT = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3fEXT = procedure(red: GLfloat; green: GLfloat; blue: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3fvEXT = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3iEXT = procedure(red: GLint; green: GLint; blue: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3ivEXT = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3sEXT = procedure(red: GLshort; green: GLshort; blue: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3svEXT = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3ubEXT = procedure(red: GLubyte; green: GLubyte; blue: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3ubvEXT = procedure(const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3uiEXT = procedure(red: GLuint; green: GLuint; blue: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3uivEXT = procedure(const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3usEXT = procedure(red: GLushort; green: GLushort; blue: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3usvEXT = procedure(const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_stencil_two_side
+  TglActiveStencilFaceEXT = procedure(face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_subtexture
+  TglTexSubImage1DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexSubImage2DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_texture3D
+  TglTexImage3DEXT = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexSubImage3DEXT = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_texture_object
+  TglAreTexturesResidentEXT = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindTextureEXT = procedure(target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteTexturesEXT = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenTexturesEXT = procedure(n: GLsizei; textures: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsTextureEXT = function(texture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPrioritizeTexturesEXT = procedure(n: GLsizei; const textures: PGLuint; const priorities: PGLclampf); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_texture_perturb_normal
+  TglTextureNormalEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_vertex_array
+  TglArrayElementEXT = procedure(i: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawArraysEXT = procedure(mode: GLenum; first: GLint; count: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEdgeFlagPointerEXT = procedure(stride: GLsizei; count: GLsizei; const _pointer: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPointervEXT = procedure(pname: GLenum; params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalPointerEXT = procedure(_type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexPointerEXT = procedure(size: GLint; _type: GLenum; stride: GLsizei; count: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_vertex_shader
+  TglBeginVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndVertexShaderEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenVertexShadersEXT = function(range: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteVertexShaderEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglShaderOp1EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglShaderOp2EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglShaderOp3EXT = procedure(op: GLenum; res: GLuint; arg1: GLuint; arg2: GLuint; arg3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSwizzleEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWriteMaskEXT = procedure(res: GLuint; _in: GLuint; outX: GLenum; outY: GLenum; outZ: GLenum; outW: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInsertComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglExtractComponentEXT = procedure(res: GLuint; src: GLuint; num: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenSymbolsEXT = function(datatype: GLenum; storagetype: GLenum; range: GLenum; components: GLuint): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSetInvariantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSetLocalConstantEXT = procedure(id: GLuint; _type: GLenum; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantbvEXT = procedure(id: GLuint; const addr: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantsvEXT = procedure(id: GLuint; const addr: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantivEXT = procedure(id: GLuint; const addr: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantfvEXT = procedure(id: GLuint; const addr: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantdvEXT = procedure(id: GLuint; const addr: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantubvEXT = procedure(id: GLuint; const addr: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantusvEXT = procedure(id: GLuint; const addr: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantuivEXT = procedure(id: GLuint; const addr: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVariantPointerEXT = procedure(id: GLuint; _type: GLenum; stride: GLuint; const addr: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableVariantClientStateEXT = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindLightParameterEXT = function(light: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindMaterialParameterEXT = function(face: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindTexGenParameterEXT = function(_unit: GLenum; coord: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindTextureUnitParameterEXT = function(_unit: GLenum; value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindParameterEXT = function(value: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsVariantEnabledEXT = function(id: GLuint; cap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVariantPointervEXT = procedure(id: GLuint; value: GLenum; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetInvariantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetInvariantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetInvariantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetLocalConstantBooleanvEXT = procedure(id: GLuint; value: GLenum; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetLocalConstantIntegervEXT = procedure(id: GLuint; value: GLenum; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetLocalConstantFloatvEXT = procedure(id: GLuint; value: GLenum; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_vertex_weighting
+  TglVertexWeightfEXT = procedure(weight: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexWeightfvEXT = procedure(const weight: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexWeightPointerEXT = procedure(size: GLsizei; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_stencil_clear_tag
+  TglStencilClearTagEXT = procedure(stencilTagBits: GLsizei; stencilClearTag: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_framebuffer_blit
+  TglBlitFramebufferEXT = procedure(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_framebuffer_multisample
+  TglRenderbufferStorageMultisampleEXT = procedure(target: GLenum; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_timer_query
+  TglGetQueryObjecti64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetQueryObjectui64vEXT = procedure(id: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_gpu_program_parameters
+  TglProgramEnvParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameters4fvEXT = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_bindable_uniform
+  TglUniformBufferEXT = procedure(_program: GLuint; location: GLint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformBufferSizeEXT = function(_program: GLuint; location: GLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformOffsetEXT = function(_program: GLuint; location: GLint): GLintptr; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_draw_buffers2
+  TglColorMaskIndexedEXT = procedure(buf: GLuint; r: GLboolean; g: GLboolean; b: GLboolean; a: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBooleanIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetIntegerIndexedvEXT = procedure(value: GLenum; index: GLuint; data: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableIndexedEXT = procedure(target: GLenum; index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsEnabledIndexedEXT = function(target: GLenum; index: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_draw_instanced
+  TglDrawArraysInstancedEXT = procedure(mode: GLenum; first: GLint; count: GLsizei; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawElementsInstancedEXT = procedure(mode: GLenum; count: GLsizei; _type: GLenum; const indices: Pointer; primcount: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_geometry_shader4
+  TglProgramParameteriEXT = procedure (_program: GLuint; pname: GLenum; value: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTextureEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+//  TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferTextureFaceEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_gpu_shader4
+  TglVertexAttribI1iEXT = procedure(index: GLuint; x: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2iEXT = procedure(index: GLuint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4iEXT = procedure(index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI1uiEXT = procedure(index: GLuint; x: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4uiEXT = procedure(index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI1ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4ivEXT = procedure(index: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI1uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI2uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI3uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4uivEXT = procedure(index: GLuint; const v: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4bvEXT = procedure(index: GLuint; const v: PGLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4svEXT = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4ubvEXT = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribI4usvEXT = procedure(index: GLuint; const v: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribIPointerEXT = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei; const _pointer: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribIivEXT = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribIuivEXT = procedure(index: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1uiEXT = procedure(location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4uiEXT = procedure(location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4uivEXT = procedure(location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformuivEXT = procedure(_program: GLuint; location: GLint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindFragDataLocationEXT = procedure(_program: GLuint; colorNumber: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFragDataLocationEXT = function(_program: GLuint; const name: PGLchar): GLint;
+
+  // GL_EXT_texture_array
+  TglFramebufferTextureLayerEXT = procedure(target: GLenum; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_texture_buffer_object
+  TglTexBufferEXT = procedure(target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_texture_integer
+  TglClearColorIiEXT = procedure(r: GLint; g: GLint; b: GLint; a: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearColorIuiEXT = procedure(r: GLuint; g: GLuint; b: GLuint; a: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameterIuivEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameterIivEXT = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameterIiuvEXT = procedure(target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_HP_image_transform
+  TglImageTransformParameteriHP = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglImageTransformParameterfHP = procedure(target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetImageTransformParameterivHP = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetImageTransformParameterfvHP = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_depth_bounds_test
+  TglDepthBoundsEXT = procedure(zmin: GLclampd; zmax: GLclampd); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_blend_equation_separate
+  TglBlendEquationSeparateEXT = procedure(modeRGB: GLenum; modeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_transform_feedback
+  TglBeginTransformFeedbackEXT = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndTransformFeedbackEXT = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferRangeEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferOffsetEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferBaseEXT = procedure(target: GLenum; index_: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformFeedbackVaryingsEXT = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTransformFeedbackVaryingEXT = procedure(program_: GLuint; index_: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_direct_state_access
+  TglClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPushClientAttribDefaultEXT = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixLoadfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixLoaddEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixMultfEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixMultdEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixLoadIdentityEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixRotatefEXT = procedure(mode: GLenum; angle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixRotatedEXT = procedure(mode: GLenum; angle: GLdouble; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixScalefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixScaledEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixTranslatefEXT = procedure(mode: GLenum; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixTranslatedEXT = procedure(mode: GLenum; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixFrustumEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixOrthoEXT = procedure(mode: GLenum; left: GLdouble; right: GLdouble; bottom: GLdouble; top: GLdouble; zNear: GLdouble; zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixPopEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixPushEXT = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixLoadTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixLoadTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixMultTransposefEXT = procedure(mode: GLenum; const m: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMatrixMultTransposedEXT = procedure(mode: GLenum; const m: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterfEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameteriEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureImageEXT = procedure(texture: GLuint; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameterfvEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameterivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureLevelParameterfvEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureLevelParameterivEXT = procedure(texture: GLuint; target: GLenum; level: GLint; pname: GLenum; params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexParameterfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexParameteriEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei; height: GLsizei; border: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; format: GLenum; type_: GLenum; pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexParameterfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexParameterivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexLevelParameterfvEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexLevelParameterivEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; format: GLenum; type_: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; type_: GLenum; const pixels:PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; x: GLint; y: GLint; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindMultiTextureEXT = procedure(texunit: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableClientStateIndexedEXT = procedure(array_: GLenum; index_: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoordPointerEXT = procedure(texunit: GLenum; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexEnvfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexEnviEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexGendEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexGendvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexGenfEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexGenfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexGeniEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexGenivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexEnvfvEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexEnvivEXT = procedure(texunit: GLenum; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexGendvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexGenfvEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexGenivEXT = procedure(texunit: GLenum; coord: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFloatIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetDoubleIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPointerIndexedvEXT = procedure(target: GLenum; index_: GLuint; data: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureSubImage3DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureSubImage2DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureSubImage1DEXT = procedure(texture: GLuint; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCompressedTextureImageEXT = procedure(texture: GLuint; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedMultiTexImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedMultiTexImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedMultiTexImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedMultiTexSubImage3DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedMultiTexSubImage2DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; width: GLsizei; height: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedMultiTexSubImage1DEXT = procedure(texunit: GLenum; target: GLenum; level: GLint; xoffset: GLint; width: GLsizei; format: GLenum; imageSize: GLsizei; const bits: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCompressedMultiTexImageEXT = procedure(texunit: GLenum; target: GLenum; lod: GLint; img: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; format: GLenum; len: GLsizei; const string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameter4dEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameter4dvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameter4fEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameter4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedProgramLocalParameterdvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedProgramLocalParameterfvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedProgramivEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedProgramStringEXT = procedure(program_: GLuint; target: GLenum; pname: GLenum; string_: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameters4fvEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameterI4iEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameterI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParametersI4ivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameterI4uiEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParameterI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedProgramLocalParametersI4uivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedProgramLocalParameterIivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedProgramLocalParameterIuivEXT = procedure(program_: GLuint; target: GLenum; index_: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexParameterIivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMultiTexParameterIuivEXT = procedure(texture: GLuint; target: GLenum; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4fEXT = procedure(program_: GLuint; location: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1iEXT = procedure(program_: GLuint; location: GLint; v0: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4iEXT = procedure(program_: GLuint; location: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4ivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x2fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x4fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x3fvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4uiEXT = procedure(program_: GLuint; location: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4uivEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedBufferDataEXT = procedure(buffer: GLuint; size: GLsizei; const data: PGLvoid; usage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; const data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapNamedBufferEXT = function(buffer: GLuint; access: GLenum): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUnmapNamedBufferEXT = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapNamedBufferRangeEXT = function(buffer: GLuint; offset: GLintptr; length: GLsizeiptr; access: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFlushMappedNamedBufferRangeEXT = procedure(buffer: GLuint; offset: GLintptr; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedCopyBufferSubDataEXT = procedure(readBuffer: GLuint; writeBuffer: GLuint; readOffset: GLintptr; writeOffset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferParameterivEXT = procedure(buffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferPointervEXT = procedure(buffer: GLuint; pname: GLenum; params: PPGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferSubDataEXT = procedure(buffer: GLuint; offset: GLintptr; size: GLsizeiptr; data: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureBufferEXT = procedure(texture: GLuint; target: GLenum; internalformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexBufferEXT = procedure(texunit: GLenum; target: GLenum; interformat: GLenum; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedRenderbufferStorageEXT = procedure(renderbuffer: GLuint; interformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedRenderbufferParameterivEXT = procedure(renderbuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCheckNamedFramebufferStatusEXT = function(framebuffer: GLuint; target: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTexture1DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTexture2DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTexture3DEXT = procedure(framebuffer: GLuint; attachment: GLenum; textarget: GLenum; texture: GLuint; level: GLint; zoffset: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferRenderbufferEXT = procedure(framebuffer: GLuint; attachment: GLenum; renderbuffertarget: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedFramebufferAttachmentParameterivEXT = procedure(framebuffer: GLuint; attachment: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenerateTextureMipmapEXT = procedure(texture: GLuint; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenerateMultiTexMipmapEXT = procedure(texunit: GLenum; target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferDrawBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferDrawBuffersEXT = procedure(framebuffer: GLuint; n: GLsizei; const bufs: PGLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFramebufferReadBufferEXT = procedure(framebuffer: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFramebufferParameterivEXT = procedure(framebuffer: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedRenderbufferStorageMultisampleEXT = procedure(renderbuffer: GLuint; samples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedRenderbufferStorageMultisampleCoverageEXT = procedure(renderbuffer: GLuint; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTextureEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTextureLayerEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; layer: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTextureFaceEXT = procedure(framebuffer: GLuint; attachment: GLenum; texture: GLuint; level: GLint; face: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureRenderbufferEXT = procedure(texture: GLuint; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexRenderbufferEXT = procedure(texunit: GLenum; target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4dEXT = procedure(program_: GLuint; location: GLint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix2x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix3x4dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x2dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformMatrix4x3dvEXT = procedure(program_: GLuint; location: GLint; count: GLsizei; transpose: GLboolean; const value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_separate_shader_objects
+  TglUseShaderProgramEXT = procedure(_type: GLenum; _program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglActiveProgramEXT = procedure(_program: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateShaderProgramEXT = function(_type: GLenum; const _string: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_shader_image_load_store
+  TglBindImageTextureEXT = procedure(index: GLuint; texture: GLuint; level: GLint; layered: GLboolean; layer: GLint; access: GLenum; format: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMemoryBarrierEXT = procedure(barriers: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_EXT_vertex_attrib_64bit
+  TglVertexAttribL1dEXT = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4dEXT = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL1dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4dvEXT = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribLPointerEXT = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; const pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribLdvEXT = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexAttribLOffsetEXT = procedure(vaobj: GLuint; buffer: GLuint; index: GLuint; size: GLint; type_: GLenum; stride: GLsizei; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_IBM_multimode_draw_arrays
+  TglMultiModeDrawArraysIBM = procedure(mode: GLenum; const first: PGLint; const count: PGLsizei; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiModeDrawElementsIBM = procedure(const mode: PGLenum; const count: PGLsizei; _type: GLenum; const indices: PGLvoid; primcount: GLsizei; modestride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_IBM_vertex_array_lists
+  TglColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColorPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEdgeFlagPointerListIBM = procedure(stride: GLint; const _pointer: PGLboolean; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalPointerListIBM = procedure(_type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexPointerListIBM = procedure(size: GLint; _type: GLenum; stride: GLint; const _pointer: PGLvoid; ptrstride: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_INGR_blend_func_separate
+  TglBlendFuncSeparateINGR = procedure(sfactorRGB: GLenum; dfactorRGB: GLenum; sfactorAlpha: GLenum; dfactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_INTEL_parallel_arrays
+  TglVertexPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalPointervINTEL = procedure(_type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordPointervINTEL = procedure(size: GLint; _type: GLenum; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_MESA_resize_buffers
+  TglResizeBuffersMESA = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_MESA_window_pos
+  TglWindowPos2dMESA = procedure(x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2fMESA = procedure(x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2iMESA = procedure(x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2sMESA = procedure(x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos2svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3iMESA = procedure(x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3sMESA = procedure(x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos3svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4dMESA = procedure(x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4dvMESA = procedure(const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4fMESA = procedure(x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4fvMESA = procedure(const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4iMESA = procedure(x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4ivMESA = procedure(const v: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4sMESA = procedure(x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWindowPos4svMESA = procedure(const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_evaluators
+  TglMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; uorder: GLint; vorder: GLint; _packed: GLboolean; const points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapParameterivNV = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapParameterfvNV = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapControlPointsNV = procedure(target: GLenum; index: GLuint; _type: GLenum; ustride: GLsizei; vstride: GLsizei; _packed: GLboolean; points: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapParameterivNV = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapParameterfvNV = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapAttribParameterivNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetMapAttribParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEvalMapsNV = procedure(target: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_fence
+  TglDeleteFencesNV = procedure(n: GLsizei; const fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenFencesNV = procedure(n: GLsizei; fences: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTestFenceNV = function(fence: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFenceivNV = procedure(fence: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFinishFenceNV = procedure(fence: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSetFenceNV = procedure(fence: GLuint; condition: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_fragment_program
+  TglProgramNamedParameter4fNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramNamedParameter4dNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramNamedParameter4fvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramNamedParameter4dvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramNamedParameterfvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramNamedParameterdvNV = procedure(id: GLuint; len: GLsizei; const name: PGLubyte; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_half_float
+  TglVertex2hNV = procedure(x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4hNV = procedure(x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertex4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3hNV = procedure(nx: GLhalfNV; ny: GLhalfNV; nz: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV; alpha: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1hNV = procedure(s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord1hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2hNV = procedure(s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4hNV = procedure(s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1hNV = procedure(target: GLenum; s: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord1hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord2hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord3hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4hNV = procedure(target: GLenum; s: GLhalfNV; t: GLhalfNV; r: GLhalfNV; q: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMultiTexCoord4hvNV = procedure(target: GLenum; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordhNV = procedure(fog: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordhvNV = procedure(const fog: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3hNV = procedure(red: GLhalfNV; green: GLhalfNV; blue: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColor3hvNV = procedure(const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexWeighthNV = procedure(weight: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexWeighthvNV = procedure(const weight: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1hNV = procedure(index: GLuint; x: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4hNV = procedure(index: GLuint; x: GLhalfNV; y: GLhalfNV; z: GLhalfNV; w: GLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4hvNV = procedure(index: GLuint; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs1hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs2hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs3hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs4hvNV = procedure(index: GLuint; n: GLsizei; const v: PGLhalfNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_occlusion_query
+  TglGenOcclusionQueriesNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteOcclusionQueriesNV = procedure(n: GLsizei; const ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsOcclusionQueryNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBeginOcclusionQueryNV = procedure(id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndOcclusionQueryNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetOcclusionQueryivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetOcclusionQueryuivNV = procedure(id: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_pixel_data_range
+  TglPixelDataRangeNV = procedure(target: GLenum; length: GLsizei; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFlushPixelDataRangeNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_point_sprite
+  TglPointParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_primitive_restart
+  TglPrimitiveRestartNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPrimitiveRestartIndexNV = procedure(index: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_register_combiners
+  TglCombinerParameterfvNV = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCombinerParameterfNV = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCombinerParameterivNV = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCombinerParameteriNV = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCombinerInputNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCombinerOutputNV = procedure(stage: GLenum; portion: GLenum; abOutput: GLenum; cdOutput: GLenum; sumOutput: GLenum; scale: GLenum; bias: GLenum; abDotProduct: GLboolean; cdDotProduct: GLboolean; muxSum: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFinalCombinerInputNV = procedure(variable: GLenum; input: GLenum; mapping: GLenum; componentUsage: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCombinerInputParameterfvNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCombinerInputParameterivNV = procedure(stage: GLenum; portion: GLenum; variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCombinerOutputParameterfvNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCombinerOutputParameterivNV = procedure(stage: GLenum; portion: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFinalCombinerInputParameterfvNV = procedure(variable: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFinalCombinerInputParameterivNV = procedure(variable: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_register_combiners2
+  TglCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCombinerStageParameterfvNV = procedure(stage: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_vertex_array_range
+  TglFlushVertexArrayRangeNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayRangeNV = procedure(length: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_vertex_program
+  TglAreProgramsResidentNV = function(n: GLsizei; const programs: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindProgramNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglExecuteProgramNV = procedure(target: GLenum; id: GLuint; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenProgramsNV = procedure(n: GLsizei; programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramParameterdvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramParameterfvNV = procedure(target: GLenum; index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramivNV = procedure(id: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramStringNV = procedure(id: GLuint; pname: GLenum; _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTrackMatrixivNV = procedure(target: GLenum; address: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribdvNV = procedure(index: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribfvNV = procedure(index: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribivNV = procedure(index: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribPointervNV = procedure(index: GLuint; pname: GLenum; _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsProgramNV = function(id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadProgramNV = procedure(target: GLenum; id: GLuint; len: GLsizei; const _program: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramParameter4dNV = procedure(target: GLenum; index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramParameter4dvNV = procedure(target: GLenum; index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramParameter4fNV = procedure(target: GLenum; index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramParameter4fvNV = procedure(target: GLenum; index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramParameters4dvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramParameters4fvNV = procedure(target: GLenum; index: GLuint; count: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglRequestResidentProgramsNV = procedure(n: GLsizei; const programs: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTrackMatrixNV = procedure(target: GLenum; address: GLuint; matrix: GLenum; transform: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribPointerNV = procedure(index: GLuint; fsize: GLint; _type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1dNV = procedure(index: GLuint; x: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1fNV = procedure(index: GLuint; x: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1sNV = procedure(index: GLuint; x: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib1svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2sNV = procedure(index: GLuint; x: GLshort; y: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib2svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib3svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4dNV = procedure(index: GLuint; x: GLdouble; y: GLdouble; z: GLdouble; w: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4dvNV = procedure(index: GLuint; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4fNV = procedure(index: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4fvNV = procedure(index: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4sNV = procedure(index: GLuint; x: GLshort; y: GLshort; z: GLshort; w: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4svNV = procedure(index: GLuint; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4ubNV = procedure(index: GLuint; x: GLubyte; y: GLubyte; z: GLubyte; w: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttrib4ubvNV = procedure(index: GLuint; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs1dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs1fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs1svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs2dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs2fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs2svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs3dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs3fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs3svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs4dvNV = procedure(index: GLuint; count: GLsizei; const v: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs4fvNV = procedure(index: GLuint; count: GLsizei; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs4svNV = procedure(index: GLuint; count: GLsizei; const v: PGLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribs4ubvNV = procedure(index: GLuint; count: GLsizei; const v: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_depth_buffer_float
+  TglDepthRangedNV = procedure(n: GLdouble; f: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearDepthdNV = procedure(d: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDepthBoundsdNV = procedure(zmin: GLdouble; zmax: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_framebuffer_multisample_coverage
+  TglRenderbufferStorageMultsampleCoverageNV = procedure(target: GLenum; coverageSamples: GLsizei; colorSamples: GLsizei; internalformat: GLenum; width: GLsizei; height: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_geometry_program4
+  TglProgramVertexLimitNV = procedure(target: GLenum; limit: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_gpu_program4
+  TglProgramLocalParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramLocalParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameterI4iNV = procedure(target: GLenum; index: GLuint; x: GLint; y: GLint; z: GLint; w: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameterI4ivNV = procedure(target: GLenum; index: GLuint; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParametersI4ivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameterI4uiNV = procedure(target: GLenum; index: GLuint; x: GLuint; y: GLuint; z: GLuint; w: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParameterI4uivNV = procedure(target: GLenum; index: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramEnvParametersI4uivNV = procedure(target: GLenum; index: GLuint; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramLocalParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramLocalParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramEnvParameterIivNV = procedure(target: GLenum; index: GLuint; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramEnvParameterIuivNV = procedure(target: GLenum; index: GLuint; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_parameter_buffer_object
+  TglProgramBufferParametersfvNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramBufferParametersIivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLsizei; const params: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramBufferParametersIuivNV = procedure(target: GLenum; buffer: GLuint; index: GLuint; count: GLuint; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_transform_feedback
+  TglBeginTransformFeedbackNV = procedure(primitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformFeedbackAttribsNV = procedure(count: GLsizei; const attribs: GLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferRangeNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr; size: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferOffsetNV = procedure(target: GLenum; index: GLuint; buffer: GLuint; offset: GLintptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindBufferBaseNV = procedure(target: GLenum; index: GLuint; buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformFeedbackVaryingsNV = procedure(program_: GLuint; count: GLsizei; const locations: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglActiveVaryingNV = procedure(program_: GLuint; const name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVaryingLocationNV = function(program_: GLuint; const name: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetActiveVaryingNV = procedure(program_: GLuint; index: GLuint; bufSize: GLsizei; length: PGLsizei; size: PGLsizei; _type: PGLenum; name: PGLchar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTransformFeedbackVaryingNV = procedure(program_: GLuint; index: GLuint; location: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformFeedbackStreamAttribsNV = procedure(count: GLsizei; const attribs: PGLint; nbuffers: GLsizei; const bufstreams: PGLint; bufferMode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_conditional_render
+  TglBeginConditionalRenderNV = procedure(id: GLuint; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndConditionalRenderNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_present_video
+  TglPresentFrameKeyedNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDuratioId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; key0: GLuint; target1: GLenum; fill1: GLuint; key1: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPresentFrameDualFillNV = procedure(video_slot: GLuint; minPresentTime: GLuint64EXT; beginPresentTimeId: GLuint; presentDurationId: GLuint; type_: GLenum; target0: GLenum; fill0: GLuint; target1: GLenum; fill1: GLuint; target2: GLenum; fill2: GLuint; target3: GLenum; fill3: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideoivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideouivNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideoi64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideoui64vNV = procedure(video_slot: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+//  TglVideoParameterivNV = procedure(video_slot: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  
+  // GL_NV_explicit_multisample
+  TglGetMultisamplefvNV = procedure (pname: GLenum; index: GLuint; val: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSampleMaskIndexedNV = procedure (index: GLuint; mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexRenderbufferNV = procedure (target: GLenum; renderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_transform_feedback2
+  TglBindTransformFeedbackNV = procedure(target: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenTransformFeedbacksNV = procedure(n: GLsizei; ids: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsTransformFeedbackNV = function (id: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPauseTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglResumeTransformFeedbackNV = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDrawTransformFeedbackNV = procedure(mode: GLenum; id: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_video_capture
+  TglBeginVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindVideoCaptureStreamBufferNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; offset: GLintptrARB); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindVideoCaptureStreamTextureNV = procedure(video_capture_slot: GLuint; stream: GLuint; frame_region: GLenum; target: GLenum; texture: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEndVideoCaptureNV = procedure(video_capture_slot: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideoCaptureivNV = procedure(video_capture_slot: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideoCaptureStreamivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideoCaptureStreamfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVideoCaptureStreamdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVideoCaptureNV = function(video_capture_slot: GLuint; sequence_num: PGLuint; capture_time: PGLuint64EXT): GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVideoCaptureStreamParameterivNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVideoCaptureStreamParameterfvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVideoCaptureStreamParameterdvNV = procedure(video_capture_slot: GLuint; stream: GLuint; pname: GLenum; const params: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_copy_image
+  TglCopyImageSubDataNV = procedure(srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_shader_buffer_load
+  TglMakeBufferResidentNV = procedure(target: GLenum; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeBufferNonResidentNV = procedure(target: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsBufferResidentNV = function(target: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeNamedBufferResidentNV = procedure(buffer: GLuint; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeNamedBufferNonResidentNV = procedure(buffer: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsNamedBufferResidentNV = function(buffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetBufferParameterui64vNV = procedure(target: GLenum; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferParameterui64vNV = procedure(buffer: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetIntegerui64vNV = procedure(value: GLenum; result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformui64NV = procedure(location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformui64vNV = procedure(_program: GLuint; location: GLint; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformui64NV = procedure(_program: GLuint; location: GLint; value: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformui64vNV = procedure(_program: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_vertex_buffer_unified_memory
+  TglBufferAddressRangeNV = procedure(pname: GLenum; index: GLuint; adress: GLuint64EXT; length: GLsizeiptr); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormalFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIndexFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoordFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEdgeFlagFormatNV = procedure(stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSecondaryColorFormatNV = procedure(size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFogCoordFormatNV = procedure(_type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; normalized: GLboolean; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribIFormatNV = procedure(index: GLuint; size: GLint; _type: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetIntegerui64i_vNV = procedure(value: GLenum; index: GLuint; Result: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_gpu_program5
+  TglProgramSubroutineParametersuivNV = procedure(target: GLenum; count: GLsizei; const params: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetProgramSubroutineParameteruivNV = procedure(target: GLenum; index: GLuint; param: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_gpu_shader5
+  TglUniform1i64NV = procedure(location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4i64NV = procedure(location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4i64vNV = procedure(location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1ui64NV = procedure(location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4ui64NV = procedure(location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform1ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform2ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform3ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniform4ui64vNV = procedure(location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetUniformi64vNV = procedure(program_: GLuint; location: GLint; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4i64NV = procedure(program_: GLuint; location: GLint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4i64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4ui64NV = procedure(program_: GLuint; location: GLint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform1ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform2ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform3ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniform4ui64vNV = procedure(program_: GLuint; location: GLint; count: GLsizei; const value: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_vertex_attrib_integer_64bit
+  TglVertexAttribL1i64NV = procedure(index: GLuint; x: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4i64NV = procedure(index: GLuint; x: GLint64EXT; y: GLint64EXT; z: GLint64EXT; w: GLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL1i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4i64vNV = procedure(index: GLuint; const v: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL1ui64NV = procedure(index: GLuint; x: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4ui64NV = procedure(index: GLuint; x: GLuint64EXT; y: GLuint64EXT; z: GLuint64EXT; w: GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL1ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL2ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL3ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL4ui64vNV = procedure(index: GLuint; const v: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribLi64vNV = procedure(index: GLuint; pname: GLenum; params: PGLint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribLui64vNV = procedure(index: GLuint; pname: GLenum; params: PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribLFormatNV = procedure(index: GLuint; size: GLint; type_: GLenum; stride: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_vdpau_interop
+  TglVDPAUInitNV = procedure(const vdpDevice: PGLvoid; const getProcAddress: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAUFiniNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAURegisterVideoSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAURegisterOutputSurfaceNV = function(vdpSurface: PGLvoid; target: GLenum; numTextureNames: GLsizei; const textureNames: PGLuint): GLvdpauSurfaceNV; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAUIsSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAUUnregisterSurfaceNV = procedure(surface: GLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAUGetSurfaceivNV = procedure(surface: GLvdpauSurfaceNV; pname: GLenum; bufSize: GLsizei; length: PGLsizei; values: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAUSurfaceAccessNV = procedure(surface: GLvdpauSurfaceNV; access: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAUMapSurfacesNV = procedure(numSurfaces: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVDPAUUnmapSurfacesNV = procedure(numSurface: GLsizei; const surfaces: PGLvdpauSurfaceNV); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_NV_texture_barrier
+  TglTextureBarrierNV = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // (4.3)
+       // GL_NV_path_rendering
+  TglGenPathsNV = function(range : GLsizei) : GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeletePathsNV = procedure(path : GLUInt; range : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsPathNV = function(path : GLUInt) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathCommandsNV = procedure(path : GLUInt; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLsizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathCoordsNV = procedure(path : GLUInt; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathSubCommandsNV = procedure(path : GLUInt; commandStart : GLsizei; commandsToDelete : GLsizei; numCommands : GLsizei; const commands : PGLubyte; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathSubCoordsNV = procedure(path : GLUInt; coordStart : GLsizei; numCoords : GLSizei; coordType : GLenum; const coords : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathStringNV = procedure(path : GLUInt; format : GLenum; length : GLsizei; const pathString : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathGlyphsNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; numGlyphs : GLsizei; type_ : GLenum; const charcodes : PGLvoid; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathGlyphRangeNV = procedure(firstPathName : GLuint; fontTarget : GLenum; const fontName : PGLvoid; fontStyle : GLbitfield; firstGlyph : GLuint; numGlyphs : GLsizei; handleMissingGlyphs : GLenum; pathParameterTemplate : GLUInt; emScale : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglWeightPathsNV = procedure(resultPath : GLUInt; numPaths : GLSizei; const paths : PGLuint; const weights : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyPathNV = procedure(resultPath : GLUInt; srcPath : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInterpolatePathsNV = procedure(resultPath : GLUInt; pathA : GLUInt; pathB : GLUInt; weight : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformPathNV = procedure(resultPath : GLUInt; srcPath : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathParameteriNV = procedure(path : GLUInt; pname : GLEnum; value : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; const value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathParameterfNV = procedure(path : GLUInt; pname : GLEnum; value : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathDashArrayNV = procedure(path : GLUInt; dashCount : GLsizei; const dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathStencilFuncNV = procedure(func : GLenum; ref : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathStencilDepthOffsetNV = procedure(factor : GLfloat; units : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilFillPathNV = procedure(path : GLUInt; fillMode : GLenum; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilStrokePathNV = procedure(path : GLUInt; reference : GLint; mask : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; fillMode : GLenum; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStencilStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; reference : GLint; mask : GLuint; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathCoverDepthFuncNV = procedure(func : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathColorGenNV = procedure(color : GLenum; genMode : GLenum; colorFormat : GLenum; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathTexGenNV = procedure(texCoordSet : GLenum; genMode : GLenum; components : GLint; const coeffs : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPathFogGenNV = procedure(genMode : GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCoverFillPathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCoverStrokePathNV = procedure(path : GLUInt; coverMode : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCoverFillPathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCoverStrokePathInstancedNV = procedure(numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; coverMode : GLenum; transformType : GLenum; const transformValues : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathParameterivNV = procedure(path : GLUInt; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathParameterfvNV = procedure(path : GLUInt; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathCommandsNV = procedure(path : GLUInt; commands : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathCoordsNV = procedure(path : GLUInt; coords : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathDashArrayNV = procedure(path : GLUInt; dashArray : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathMetricsNV = procedure(metricQueryMask : GLbitfield; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathMetricRangeNV = procedure(metricQueryMask : GLbitfield; firstPathName : GLuint; numPaths : GLSizei; stride : GLsizei; metrics : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathSpacingNV = procedure(pathListMode : GLenum; numPaths : GLSizei; pathNameType : GLenum; const paths : PGLvoid; pathBase : GLUInt; advanceScale : GLfloat; kerningScale : GLfloat; transformType : GLenum; returnedSpacing : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathColorGenivNV = procedure(color : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathColorGenfvNV = procedure(color : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathTexGenivNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathTexGenfvNV = procedure(texCoordSet : GLenum; pname : GLEnum; value : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsPointInFillPathNV = function(path : GLUInt; mask : GLuint; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsPointInStrokePathNV = function (path : GLUInt; x : GLfloat; y : GLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPathLengthNV = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei) : GLfloat; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointAlongPathNV  = function(path : GLUInt; startSegment : GLsizei; numSegments : GLsizei; distance : GLfloat; x : PGLfloat; y : PGLfloat; tangentX : PGLfloat; tangentY : PGLfloat) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_pinned_memory
+
+  // GL_AMD_stencil_operation_extended
+  TglStencilOpValueAMD = procedure(face : GLEnum; value : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_AMD_vertex_shader_viewport_index
+
+  // GL_AMD_vertex_shader_layer
+
+  // GL_NV_bindless_texture
+  TglGetTextureHandleNV = function(texture : GLuint ) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureSamplerHandleNV = function(texture : GLuint; sampler : GLuint) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeTextureHandleResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeTextureHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetImageHandleNV = function(texture : GLuint; level : GLint; layered : GLboolean; layer : GLint; format : GLenum) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeImageHandleResidentNV = procedure(handle : GLUint64; access : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeImageHandleNonResidentNV = procedure(handle : GLUint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformHandleui64NV = procedure(location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformHandleui64vNV = procedure(location : GLint; cowunt : GLsizei; const value : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformHandleui64NV = procedure(program_ : GLuint; location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformHandleui64vNV = procedure(program_ : GLuint; location : GLint; count : GLsizei; const values : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsTextureHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsImageHandleResidentNV = function(handle : GLUint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+       // GL_NV_shader_atomic_float
+
+       // GL_AMD_query_buffer_object
+
+  //
+
+  // GL_PGI_misc_hints
+  TglHintPGI = procedure(target: GLenum; mode: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_detail_texture
+  TglDetailTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetDetailTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_fog_function
+  TglFogFuncSGIS = procedure(n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFogFuncSGIS = procedure(points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_multisample
+  TglSampleMaskSGIS = procedure(value: GLclampf; invert: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSamplePatternSGIS = procedure(pattern: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_pixel_texture
+  TglPixelTexGenParameteriSGIS = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTexGenParameterivSGIS = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTexGenParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelTexGenParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPixelTexGenParameterivSGIS = procedure(pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetPixelTexGenParameterfvSGIS = procedure(pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_point_parameters
+  TglPointParameterfSGIS = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPointParameterfvSGIS = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_sharpen_texture
+  TglSharpenTexFuncSGIS = procedure(target: GLenum; n: GLsizei; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetSharpenTexFuncSGIS = procedure(target: GLenum; points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_texture4D
+  TglTexImage4DSGIS = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexSubImage4DSGIS = procedure(target: GLenum; level: GLint; xoffset: GLint; yoffset: GLint; zoffset: GLint; woffset: GLint; width: GLsizei; height: GLsizei; depth: GLsizei; size4d: GLsizei; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_texture_color_mask
+  TglTextureColorMaskSGIS = procedure(red: GLboolean; green: GLboolean; blue: GLboolean; alpha: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIS_texture_filter4
+  TglGetTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexFilterFuncSGIS = procedure(target: GLenum; filter: GLenum; n: GLsizei; const weights: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_async
+  TglAsyncMarkerSGIX = procedure(marker: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFinishAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPollAsyncSGIX = function(markerp: PGLuint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenAsyncMarkersSGIX = function(range: GLsizei): GLuint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteAsyncMarkersSGIX = procedure(marker: GLuint; range: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsAsyncMarkerSGIX = function(marker: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_flush_raster
+  TglFlushRasterSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_fragment_lighting
+  TglFragmentColorMaterialSGIX = procedure(face: GLenum; mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightfSGIX = procedure(light: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightiSGIX = procedure(light: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightModelfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightModelfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightModeliSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentLightModelivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentMaterialfSGIX = procedure(face: GLenum; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentMaterialiSGIX = procedure(face: GLenum; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFragmentLightfvSGIX = procedure(light: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFragmentLightivSGIX = procedure(light: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFragmentMaterialfvSGIX = procedure(face: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetFragmentMaterialivSGIX = procedure(face: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLightEnviSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_framezoom
+  TglFrameZoomSGIX = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_igloo_interface
+  TglIglooInterfaceSGIX = procedure(pname: GLenum; const params: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_instruments
+  TglGetInstrumentsSGIX = function(): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInstrumentsBufferSGIX = procedure(size: GLsizei; buffer: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPollInstrumentsSGIX = function(marker_p: PGLint): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReadInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStartInstrumentsSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglStopInstrumentsSGIX = procedure(marker: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_list_priority
+  TglGetListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetListParameterivSGIX = procedure(list: GLuint; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglListParameterfSGIX = procedure(list: GLuint; pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglListParameterfvSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglListParameteriSGIX = procedure(list: GLuint; pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglListParameterivSGIX = procedure(list: GLuint; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_pixel_texture
+  TglPixelTexGenSGIX = procedure(mode: GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_polynomial_ffd
+  TglDeformationMap3dSGIX = procedure(target: GLenum; u1: GLdouble; u2: GLdouble; ustride: GLint; uorder: GLint; v1: GLdouble; v2: GLdouble; vstride: GLint; vorder: GLint; w1: GLdouble; w2: GLdouble; wstride: GLint; worder: GLint; const points: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeformationMap3fSGIX = procedure(target: GLenum; u1: GLfloat; u2: GLfloat; ustride: GLint; uorder: GLint; v1: GLfloat; v2: GLfloat; vstride: GLint; vorder: GLint; w1: GLfloat; w2: GLfloat; wstride: GLint; worder: GLint; const points: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeformSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglLoadIdentityDeformationMapSGIX = procedure(mask: GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_reference_plane
+  TglReferencePlaneSGIX = procedure(const equation: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_sprite
+  TglSpriteParameterfSGIX = procedure(pname: GLenum; param: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSpriteParameterfvSGIX = procedure(pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSpriteParameteriSGIX = procedure(pname: GLenum; param: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglSpriteParameterivSGIX = procedure(pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGIX_tag_sample_buffer
+  TglTagSampleBufferSGIX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SGI_color_table
+  TglColorTableSGI = procedure(target: GLenum; internalformat: GLenum; width: GLsizei; format: GLenum; _type: GLenum; const table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyColorTableSGI = procedure(target: GLenum; internalformat: GLenum; x: GLint; y: GLint; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableSGI = procedure(target: GLenum; format: GLenum; _type: GLenum; table: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableParameterfvSGI = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetColorTableParameterivSGI = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SUNX_constant_data
+  TglFinishTextureSUNX = procedure(); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SUN_global_alpha
+  TglGlobalAlphaFactorbSUN = procedure(factor: GLbyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGlobalAlphaFactorsSUN = procedure(factor: GLshort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGlobalAlphaFactoriSUN = procedure(factor: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGlobalAlphaFactorfSUN = procedure(factor: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGlobalAlphaFactordSUN = procedure(factor: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGlobalAlphaFactorubSUN = procedure(factor: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGlobalAlphaFactorusSUN = procedure(factor: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGlobalAlphaFactoruiSUN = procedure(factor: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SUN_mesh_array
+  TglDrawMeshArraysSUN = procedure(mode: GLenum; first: GLint; count: GLsizei; width: GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SUN_triangle_list
+  TglReplacementCodeuiSUN = procedure(code: GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeusSUN = procedure(code: GLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeubSUN = procedure(code: GLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuivSUN = procedure(const code: PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeusvSUN = procedure(const code: PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeubvSUN = procedure(const code: PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodePointerSUN = procedure(_type: GLenum; stride: GLsizei; const _pointer: PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_SUN_vertex
+  TglColor4ubVertex2fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4ubVertex2fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4ubVertex3fSUN = procedure(r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4ubVertex3fvSUN = procedure(const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor3fVertex3fvSUN = procedure(const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3fVertex3fSUN = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNormal3fVertex3fvSUN = procedure(const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4fNormal3fVertex3fSUN = procedure(r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglColor4fNormal3fVertex3fvSUN = procedure(const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fVertex3fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4fVertex4fSUN = procedure(s: GLfloat; t: GLfloat; p: GLfloat; q: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat; w: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4fVertex4fvSUN = procedure(const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fColor4ubVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fColor4ubVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fColor3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fColor3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fColor4fNormal3fVertex3fSUN = procedure(s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4fColor4fNormal3fVertex4fSUN = procedure(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: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexCoord4fColor4fNormal3fVertex4fvSUN = procedure(const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiVertex3fSUN = procedure(rc: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiVertex3fvSUN = procedure(const rc: PGLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiColor4ubVertex3fSUN = procedure(rc: GLuint; r: GLubyte; g: GLubyte; b: GLubyte; a: GLubyte; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiColor4ubVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLubyte; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiColor3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiColor3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiNormal3fVertex3fSUN = procedure(rc: GLuint; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiTexCoord2fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiTexCoord2fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = procedure(rc: GLuint; s: GLfloat; t: GLfloat; r: GLfloat; g: GLfloat; b: GLfloat; a: GLfloat; nx: GLfloat; ny: GLfloat; nz: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = procedure(const rc: PGLuint; const tc: PGLfloat; const c: PGLfloat; const n: PGLfloat; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // window support functions
+{$IFDEF DGL_WIN}
+  TwglGetProcAddress = function(ProcName: PAnsiChar): Pointer; stdcall;
+  TwglCopyContext = function(p1: HGLRC; p2: HGLRC; p3: Cardinal): BOOL; stdcall;
+  TwglCreateContext = function(DC: HDC): HGLRC; stdcall;
+  TwglCreateLayerContext = function(p1: HDC; p2: Integer): HGLRC; stdcall;
+  TwglDeleteContext = function(p1: HGLRC): BOOL; stdcall;
+  TwglDescribeLayerPlane = function(p1: HDC; p2, p3: Integer; p4: Cardinal; p5: PLayerPlaneDescriptor): BOOL; stdcall;
+  TwglGetCurrentContext = function: HGLRC; stdcall;
+  TwglGetCurrentDC = function: HDC; stdcall;
+  TwglGetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
+  TwglMakeCurrent = function(DC: HDC; p2: HGLRC): BOOL; stdcall;
+  TwglRealizeLayerPalette = function(p1: HDC; p2: Integer; p3: BOOL): BOOL; stdcall;
+  TwglSetLayerPaletteEntries = function(p1: HDC; p2, p3, p4: Integer; var pcr): Integer; stdcall;
+  TwglShareLists = function(p1, p2: HGLRC): BOOL; stdcall;
+  TwglSwapLayerBuffers = function(p1: HDC; p2: Cardinal): BOOL; stdcall;
+  TwglSwapMultipleBuffers = function(p1: UINT; const p2: PWGLSWAP): DWORD; stdcall;
+  TwglUseFontBitmapsA = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
+  TwglUseFontBitmapsW = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
+  TwglUseFontBitmaps = function(DC: HDC; p2, p3, p4: DWORD): BOOL; stdcall;
+
+  TwglUseFontOutlinesA = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
+  TwglUseFontOutlinesW = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
+  TwglUseFontOutlines = function(p1: HDC; p2, p3, p4: DWORD; p5, p6: Single; p7: Integer; p8: PGlyphMetricsFloat): BOOL; stdcall;
+
+
+  // WGL_ARB_buffer_region
+  TwglCreateBufferRegionARB = function(hDC: HDC; iLayerPlane: GLint; uType: GLuint): THandle; stdcall;
+  TwglDeleteBufferRegionARB = procedure(hRegion: THandle); stdcall;
+  TwglSaveBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint): Boolean; stdcall;
+  TwglRestoreBufferRegionARB = function(hRegion: THandle; x: GLint; y: GLint; width: GLint; height: GLint; xSrc: GLint; ySrc: GLint): Boolean; stdcall;
+
+  // WGL_ARB_extensions_string
+  TwglGetExtensionsStringARB = function(hdc: HDC): PAnsiChar; stdcall;
+
+  // WGL_ARB_make_current_read
+  TwglMakeContextCurrentARB = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall;
+  TwglGetCurrentReadDCARB = function(): HDC; stdcall;
+
+  // WGL_ARB_pbuffer
+  TwglCreatePbufferARB = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFERARB; stdcall;
+  TwglGetPbufferDCARB = function(hPbuffer: HPBUFFERARB): HDC; stdcall;
+  TwglReleasePbufferDCARB = function(hPbuffer: HPBUFFERARB; hDC: HDC): GLint; stdcall;
+  TwglDestroyPbufferARB = function(hPbuffer: HPBUFFERARB): Boolean; stdcall;
+  TwglQueryPbufferARB = function(hPbuffer: HPBUFFERARB; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
+
+  // WGL_ARB_pixel_format
+  TwglGetPixelFormatAttribivARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; piValues: PGLint): Boolean; stdcall;
+  TwglGetPixelFormatAttribfvARB = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; const piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall;
+  TwglChoosePixelFormatARB = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): BOOL; stdcall;
+
+  // WGL_ARB_color_buffer_float
+  TwglClampColorARB = procedure(target: GLenum; clamp: GLenum); stdcall;
+
+  // WGL_ARB_render_texture
+  TwglBindTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall;
+  TwglReleaseTexImageARB = function(hPbuffer: HPBUFFERARB; iBuffer: GLint): Boolean; stdcall;
+  TwglSetPbufferAttribARB = function(hPbuffer: HPBUFFERARB; const piAttribList: PGLint): Boolean; stdcall;
+
+  // WGL_ARB_create_context
+  TwglCreateContextAttribsARB = function(hDC: HDC; hShareContext: HGLRC; const attribList: PGLint): HGLRC; stdcall;
+
+  // WGL_AMD_gpu_association
+  TwglGetGPUIDsAMD = function(maxCount: Cardinal; ids: PCardinal): Cardinal; stdcall;
+  TwglGetGPUInfoAMD = function(id: Cardinal; property_: Integer; dataType: GLenum; size: Cardinal; data: Pointer): Integer; stdcall;
+  TwglGetContextGPUIDAMD = function(hglrc: HGLRC): Cardinal; stdcall;
+  TwglCreateAssociatedContextAMD = function(id: Cardinal): HGLRC; stdcall;
+  TwglCreateAssociatedContextAttribsAMD = function(id: Cardinal; hShareContext: HGLRC; const attribList: PInteger): HGLRC; stdcall;
+  TwglDeleteAssociatedContextAMD = function(hglrc: HGLRC): Boolean; stdcall;
+  TwglMakeAssociatedContextCurrentAMD = function(hglrc: HGLRC): Boolean; stdcall;
+  TwglGetCurrentAssociatedContextAMD = function(): HGLRC; stdcall;
+  TwglBlitContextFramebufferAMD = procedure(dstCtx: HGLRC; srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: GLint; mask: GLbitfield; filter: GLenum); stdcall;
+
+  // WGL_EXT_display_color_table
+  TwglCreateDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall;
+  TwglLoadDisplayColorTableEXT = function(const table: PGLushort; length: GLuint): GLboolean; stdcall;
+  TwglBindDisplayColorTableEXT = function(id: GLushort): GLboolean; stdcall;
+  TwglDestroyDisplayColorTableEXT = procedure(id: GLushort); stdcall;
+
+  // WGL_EXT_extensions_string
+  TwglGetExtensionsStringEXT = function(): PAnsiChar; stdcall;
+
+  // WGL_EXT_make_current_read
+  TwglMakeContextCurrentEXT = function(hDrawDC: HDC; hReadDC: HDC; hglrc: HGLRC): Boolean; stdcall;
+  TwglGetCurrentReadDCEXT = function(): HDC; stdcall;
+
+  // WGL_EXT_pbuffer
+  TwglCreatePbufferEXT = function(hDC: HDC; iPixelFormat: GLint; iWidth: GLint; iHeight: GLint; const piAttribList: PGLint): HPBUFFEREXT; stdcall;
+  TwglGetPbufferDCEXT = function(hPbuffer: HPBUFFEREXT): HDC; stdcall;
+  TwglReleasePbufferDCEXT = function(hPbuffer: HPBUFFEREXT; hDC: HDC): GLint; stdcall;
+  TwglDestroyPbufferEXT = function(hPbuffer: HPBUFFEREXT): Boolean; stdcall;
+  TwglQueryPbufferEXT = function(hPbuffer: HPBUFFEREXT; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
+
+  // WGL_EXT_pixel_format
+  TwglGetPixelFormatAttribivEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; piValues: PGLint): Boolean; stdcall;
+  TwglGetPixelFormatAttribfvEXT = function(hdc: HDC; iPixelFormat: GLint; iLayerPlane: GLint; nAttributes: GLuint; piAttributes: PGLint; pfValues: PGLfloat): Boolean; stdcall;
+  TwglChoosePixelFormatEXT = function(hdc: HDC; const piAttribIList: PGLint; const pfAttribFList: PGLfloat; nMaxFormats: GLuint; piFormats: PGLint; nNumFormats: PGLuint): Boolean; stdcall;
+
+  // WGL_EXT_swap_control
+  TwglSwapIntervalEXT = function(interval: GLint): Boolean; stdcall;
+  TwglGetSwapIntervalEXT = function(): GLint; stdcall;
+
+  // WGL_I3D_digital_video_control
+  TwglGetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
+  TwglSetDigitalVideoParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall;
+
+  // WGL_I3D_gamma
+  TwglGetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; piValue: PGLint): Boolean; stdcall;
+  TwglSetGammaTableParametersI3D = function(hDC: HDC; iAttribute: GLint; const piValue: PGLint): Boolean; stdcall;
+  TwglGetGammaTableI3D = function(hDC: HDC; iEntries: GLint; puRed: PGLushort; puGreen: PGLushort; puBlue: PGLushort): Boolean; stdcall;
+  TwglSetGammaTableI3D = function(hDC: HDC; iEntries: GLint; const puRed: PGLushort; const puGreen: PGLushort; const puBlue: PGLushort): Boolean; stdcall;
+
+  // WGL_I3D_genlock
+  TwglEnableGenlockI3D = function(hDC: HDC): Boolean; stdcall;
+  TwglDisableGenlockI3D = function(hDC: HDC): Boolean; stdcall;
+  TwglIsEnabledGenlockI3D = function(hDC: HDC; pFlag: Boolean): Boolean; stdcall;
+  TwglGenlockSourceI3D = function(hDC: HDC; uSource: GLuint): Boolean; stdcall;
+  TwglGetGenlockSourceI3D = function(hDC: HDC; uSource: PGLuint): Boolean; stdcall;
+  TwglGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: GLuint): Boolean; stdcall;
+  TwglGetGenlockSourceEdgeI3D = function(hDC: HDC; uEdge: PGLuint): Boolean; stdcall;
+  TwglGenlockSampleRateI3D = function(hDC: HDC; uRate: GLuint): Boolean; stdcall;
+  TwglGetGenlockSampleRateI3D = function(hDC: HDC; uRate: PGLuint): Boolean; stdcall;
+  TwglGenlockSourceDelayI3D = function(hDC: HDC; uDelay: GLuint): Boolean; stdcall;
+  TwglGetGenlockSourceDelayI3D = function(hDC: HDC; uDelay: PGLuint): Boolean; stdcall;
+  TwglQueryGenlockMaxSourceDelayI3D = function(hDC: HDC; uMaxLineDelay: PGLuint; uMaxPixelDelay: PGLuint): Boolean; stdcall;
+
+  // WGL_I3D_image_buffer
+  TwglCreateImageBufferI3D = function(hDC: HDC; dwSize: GLuint; uFlags: GLuint): GLvoid; stdcall;
+  TwglDestroyImageBufferI3D = function(hDC: HDC; pAddress: GLvoid): Boolean; stdcall;
+  TwglAssociateImageBufferEventsI3D = function(hDC: HDC; const pEvent: THandle; const pAddress: PGLvoid; const pSize: PGLuint; count: GLuint): Boolean; stdcall;
+  TwglReleaseImageBufferEventsI3D = function(hDC: HDC; const pAddress: PGLvoid; count: GLuint): Boolean; stdcall;
+
+  // WGL_I3D_swap_frame_lock
+  TwglEnableFrameLockI3D = function(): Boolean; stdcall;
+  TwglDisableFrameLockI3D = function(): Boolean; stdcall;
+  TwglIsEnabledFrameLockI3D = function(pFlag: Boolean): Boolean; stdcall;
+  TwglQueryFrameLockMasterI3D = function(pFlag: Boolean): Boolean; stdcall;
+
+  // WGL_I3D_swap_frame_usage
+  TwglGetFrameUsageI3D = function(pUsage: PGLfloat): Boolean; stdcall;
+  TwglBeginFrameTrackingI3D = function(): Boolean; stdcall;
+  TwglEndFrameTrackingI3D = function(): Boolean; stdcall;
+  TwglQueryFrameTrackingI3D = function(pFrameCount: PGLuint; pMissedFrames: PGLuint; pLastMissedUsage: PGLfloat): Boolean; stdcall;
+
+  // WGL_NV_vertex_array_range
+  TwglAllocateMemoryNV = procedure(size: GLsizei; readfreq: GLfloat; writefreq: GLfloat; priority: GLfloat); stdcall;
+  TwglFreeMemoryNV = procedure(_pointer: Pointer); stdcall;
+
+  // WGL_NV_present_video
+  TwglEnumerateVideoDevicesNV = function(hdc: HDC; phDeviceList: PHVIDEOOUTPUTDEVICENV): Integer; stdcall;
+  TwglBindVideoDeviceNV = function(hd: HDC; uVideoSlot: Cardinal; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: PInteger): Boolean; stdcall;
+  TwglQueryCurrentContextNV = function(iAttribute: Integer; piValue: PInteger): Boolean; stdcall;
+
+  // WGL_NV_video_output
+  TwglGetVideoDeviceNV = function(hDC: HDC; numDevices: Integer; hVideoDevice: PHPVIDEODEV): Boolean; stdcall;
+  TwglReleaseVideoDeviceNV = function(hVideoDevice: HPVIDEODEV): Boolean; stdcall;
+  TwglBindVideoImageNV = function(hVideoDevice: HPVIDEODEV; hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall;
+  TwglReleaseVideoImageNV = function(hPbuffer: HPBUFFERARB; iVideoBuffer: Integer): Boolean; stdcall;
+  TwglSendPbufferToVideoNV = function(hPbuffer: HPBUFFERARB; iBufferType: Integer; pulCounterPbuffer: PCardinal; bBlock: Boolean): Boolean; stdcall;
+  TwglGetVideoInfoNV = function(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: PCardinal; pulCounterOutputVideo: PCardinal): Boolean; stdcall;
+
+  // WGL_NV_swap_group
+  TwglJoinSwapGroupNV = function(hDC: HDC; group: GLuint): Boolean; stdcall;
+  TwglBindSwapBarrierNV = function(group: GLuint; barrier: GLuint): Boolean; stdcall;
+  TwglQuerySwapGroupNV = function(hDC: HDC; group: PGLuint; barrier: PGLuint): Boolean; stdcall;
+  TwglQueryMaxSwapGroupsNV = function(hDC: HDC; mxGroups: PGLuint; maxBarriers: PGLuint): Boolean; stdcall;
+  TwglQueryFrameCountNV = function(hDC: HDC; count: PGLuint): Boolean; stdcall;
+  TwglResetFrameCountNV = function(hDC: HDC): Boolean; stdcall;
+
+  // WGL_NV_gpu_affinity
+  TwglEnumGpusNV = function(iGpuIndex: Cardinal; phGpu: PHGPUNV): Boolean; stdcall;
+  TwglEnumGpuDevicesNV = function(hGpu: HGPUNV; iDeviceIndex: Cardinal; lpGpuDevice: PGPU_DEVICE): Boolean; stdcall;
+  TwglCreateAffinityDCNV = function(const phGpuList: PHGPUNV): HDC; stdcall;
+  TwglEnumGpusFromAffinityDCNV = function(hAffinityDC: HDC; iGpuIndex: Cardinal; hGpu: PHGPUNV): Boolean; stdcall;
+  TwglDeleteDCNV = function(hDC: HDC): Boolean; stdcall;
+
+  // WGL_NV_video_capture
+  TwglBindVideoCaptureDeviceNV = function(uVideoSlot: Cardinal; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall;
+  TwglEnumerateVideoCaptureDevicesNV = function(hDc: HDC; phDeviceList: PHVIDEOINPUTDEVICENV): Cardinal; stdcall;
+  TwglLockVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall;
+  TwglQueryVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Integer; piValue: PInteger): Boolean; stdcall;
+  TwglReleaseVideoCaptureDeviceNV = function(hDc: HDC; hDevice: HVIDEOINPUTDEVICENV): Boolean; stdcall;
+
+  // WGL_NV_copy_image
+  TwglCopyImageSubDataNV = function(hSrcRc: HGLRC; srcName: GLuint; srcTarget: GLenum; srcLevel: GLint; srcX: GLint; srcY: GLint; srcZ: GLint; hDstRC: HGLRC; dstName: GLuint; dstTarget: GLenum; dstLevel: GLint; dstX: GLint; dstY: GLint; dstZ: GLint; width: GLsizei; height: GLsizei; depth: GLsizei): Boolean; stdcall;
+
+  // WGL_NV_DX_interop
+  TwglDXSetResourceShareHandleNV = function(dxObject : PGLVoid; hareHandle : Cardinal) : Boolean; stdcall;
+  TwglDXOpenDeviceNV = function(dxDevice : PGLVoid) : Cardinal; stdcall;
+  TwglDXCloseDeviceNV = function(hDevice : Cardinal) : Boolean; stdcall;
+  TwglDXRegisterObjectNV = function(hDevice : Cardinal; dxObject : PGLVoid; name : GLUInt; _type : TGLEnum; access : TGLenum) : Cardinal; stdcall;
+  TwglDXUnregisterObjectNV = function(hDevice : Cardinal; hObject : Cardinal) : Boolean; stdcall;
+  TwglDXObjectAccessNV = function(hObject : Cardinal; access : GLenum) : Boolean; stdcall;
+  TwglDXLockObjectsNV = function(hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall;
+  TwglDXUnlockObjectsNV = function (hDevice : Cardinal; count : GLint; hObjects : PCardinal) : Boolean; stdcall;
+
+  // WGL_OML_sync_control
+  TwglGetSyncValuesOML = function(hdc: HDC; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
+  TwglGetMscRateOML = function(hdc: HDC; numerator: PGLint; denominator: PGLint): Boolean; stdcall;
+  TwglSwapBuffersMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall;
+  TwglSwapLayerBuffersMscOML = function(hdc: HDC; fuPlanes: GLint; target_msc: GLint64; divisor: GLint64; remainder: GLint64): GLint64; stdcall;
+  TwglWaitForMscOML = function(hdc: HDC; target_msc: GLint64; divisor: GLint64; remainder: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
+  TwglWaitForSbcOML = function(hdc: HDC; target_sbc: GLint64; ust: PGLint64; msc: PGLint64; sbc: PGLint64): Boolean; stdcall;
+
+  // WGL_3DL_stereo_control
+  TwglSetStereoEmitterState3DL = function(hDC: HDC; uState: UINT): Boolean; stdcall;
+  
+  // WIN_draw_range_elements
+  TglDrawRangeElementsWIN = procedure(mode: GLenum; start: GLuint; _end: GLuint; count: GLsizei; _type: GLenum; const indices: PGLvoid); stdcall;
+
+  // WIN_swap_hint
+  TglAddSwapHintRectWIN = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei); stdcall;
+{$ENDIF}
+
+{$IFDEF DGL_LINUX}
+  TglXChooseVisual = function(dpy: PDisplay; screen: GLint; attribList: PGLint): PXVisualInfo; cdecl;
+  TglXCopyContext = procedure(dpy: PDisplay; src: GLXContext; dst: GLXContext; mask: GLuint); cdecl;
+  TglXCreateContext = function(dpy: PDisplay; vis: PXVisualInfo; shareList: GLXContext; direct: GLboolean): GLXContext; cdecl;
+  TglXCreateGLXPixmap = function(dpy: PDisplay; vis: PXVisualInfo; pixmap: Pixmap): GLXPixmap cdecl;
+  TglXDestroyContext = procedure(dpy: PDisplay; ctx: GLXContext); cdecl;
+  TglXDestroyGLXPixmap = procedure(dpy : PDisplay; pix: GLXPixmap); cdecl;
+  TglXGetConfig = function(dpy : PDisplay; vis: PXVisualInfo; attrib: GLint; value: PGLint): GLint; cdecl;
+  TglXGetCurrentContext = function: GLXContext cdecl;
+  TglXGetCurrentDrawable = function: GLXDrawable cdecl;
+  TglXIsDirect = function(dpy: PDisplay; ctx: GLXContext): glboolean; cdecl;
+  TglXMakeCurrent = function(dpy: PDisplay; drawable: GLXDrawable; ctx: GLXContext): GLboolean cdecl;
+  TglXQueryExtension = function(dpy: PDisplay; errorBase: PGLint; eventBase: PGLint): GLboolean; cdecl;
+  TglXQueryVersion = function(dpy: PDisplay; major: PGLint; minor: PGLint): GLboolean cdecl;
+  TglXSwapBuffers = procedure(dpy: PDisplay; drawable: GLXDrawable); cdecl;
+  TglXUseXFont = procedure(font: Font; first: GLint; count: GLint; listBase: GLint); cdecl;
+  TglXWaitGL = procedure; cdecl; 
+  TglXWaitX = procedure; cdecl;
+
+  TglXGetClientString = function(dpy: PDisplay; name: GLint): PGLchar; cdecl;
+  TglXQueryServerString = function(dpy: PDisplay; screen: GLint; name: GLint): PGLchar; cdecl;
+  TglXQueryExtensionsString = function(dpy: PDisplay; screen: GLint): PGLchar; cdecl;
+
+  // GLX_VERSION_1_3
+  TglXGetFBConfigs = function(dpy: PDisplay; screen: GLint; nelements: PGLint): GLXFBConfig; cdecl;
+  TglXChooseFBConfig = function(dpy: PDisplay; screen: GLint; attrib_list: PGLint; nelements: PGLint): GLXFBConfig; cdecl;
+  TglXGetFBConfigAttrib = function(dpy: PDisplay; config: GLXFBConfig; attribute: GLint; value: PGLint): glint; cdecl;
+  TglXGetVisualFromFBConfig = function(dpy: PDisplay; config: GLXFBConfig) : PXVisualInfo; cdecl;
+  TglXCreateWindow = function(dpy: PDisplay; config: GLXFBConfig; win: Window; attrib_list: PGLint): GLXWindow; cdecl;
+  TglXDestroyWindow = procedure(dpy: PDisplay; win: GLXWindow); cdecl;
+  TglXCreatePixmap = function(dpy: PDisplay; config: GLXFBConfig; pixmap: Pixmap; attrib_list: PGLint): GLXPixmap; cdecl;
+
+  TglXDestroyPixmap = procedure(dpy: PDisplay; pixmap: GLXPixmap); cdecl;
+  TglXCreatePbuffer = function(dpy: PDisplay; config: GLXFBConfig; attrib_list: PGLint): GLXPbuffer; cdecl;
+  TglXDestroyPbuffer = procedure(dpy: PDisplay; pbuf: GLXPbuffer); cdecl;
+  TglXQueryDrawable = procedure(dpy: PDisplay; draw: GLXDrawable; attribute: GLint; value: PGLuint); cdecl;
+  TglXCreateNewContext = function(dpy: PDisplay; config: GLXFBConfig; render_type: GLint; share_list: GLXContext; direct: GLboolean): GLXContext cdecl;
+  TglXMakeContextCurrent = function(display: PDisplay; draw: GLXDrawable; read_: GLXDrawable; ctx: GLXContext): GLboolean; cdecl;
+  TglXGetCurrentReadDrawable = function: GLXDrawable; cdecl;
+  TglXGetCurreentDisplay = function: PDisplay;
+
+  TglXQueryContext = function(dpy: PDisplay; ctx: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl;
+  TglXSelectEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: GLuint); cdecl;
+  TglXGetSelectedEvent = procedure(dpy: PDisplay; draw: GLXDrawable; event_mask: PGLuint); cdecl;
+
+  // GLX_VERSION_1_4
+  TglXGetProcAddress = function(const name: PAnsiChar): pointer; cdecl;
+
+  // GLX_ARB_get_proc_address
+  TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
+
+  // GLX_ARB_create_context
+  TglXCreateContextAttribsARB = function(dpy: PDisplay; config: GLXFBConfig; share_context: GLXContext; direct: GLboolean; const attrib_list: PGLint): GLXContext; cdecl;
+
+  // GLX_EXT_import_context
+  TglXGetCurrentDisplayEXT = function: PDisplay; cdecl;
+  TglXQueryContextInfoEXT = function(dpy: PDisplay; context: GLXContext; attribute: GLint; value: PGLint): GLint; cdecl;
+  TglXGetContextIDEXT = function(const context: GLXContext): GLXContextID; cdecl;
+  TglXImportContextEXT = function(dpy: PDisplay; contextID: GLXContextID): GLXContext; cdecl;
+  TglXFreeContextEXT = procedure(dpy: PDisplay; context: GLXContext); cdecl;
+  
+  // GLX_EXT_texture_from_pixmap
+  TglXBindTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint; const attrib_list: PGLint); cdecl;
+  TglXReleaseTexImageEXT = procedure(dpy: PDisplay; drawable: GLXDrawable; buffer: GLint); cdecl;
+{$ENDIF}
+
+  // GL utility functions and procedures
+  TgluErrorString = function(errCode: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluGetString = function(name: GLEnum): PAnsiChar; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluOrtho2D = procedure(left, right, bottom, top: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluPerspective = procedure(fovy, aspect, zNear, zFar: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluPickMatrix = procedure(x, y, width, height: GLdouble; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluLookAt = procedure(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluProject = function(objx, objy, objz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; winx, winy, winz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluUnProject = function(winx, winy, winz: GLdouble; const modelMatrix: TGLMatrixd4; const projMatrix: TGLMatrixd4; const viewport: TVector4i; objx, objy, objz: PGLdouble): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluScaleImage = function(format: GLEnum; widthin, heightin: GLint; typein: GLEnum; datain: Pointer; widthout, heightout: GLint; typeout: GLEnum; const dataout: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNewQuadric = function: PGLUquadric; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluDeleteQuadric = procedure(state: PGLUquadric); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluQuadricNormals = procedure(quadObject: PGLUquadric; normals: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluQuadricTexture = procedure(quadObject: PGLUquadric; textureCoords: GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluQuadricOrientation = procedure(quadObject: PGLUquadric; orientation: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluQuadricDrawStyle = procedure(quadObject: PGLUquadric; drawStyle: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluCylinder = procedure(quadObject: PGLUquadric; baseRadius, topRadius, height: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluPartialDisk = procedure(quadObject: PGLUquadric; innerRadius, outerRadius: GLdouble; slices, loops: GLint; startAngle, sweepAngle: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluSphere = procedure(quadObject: PGLUquadric; radius: GLdouble; slices, stacks: GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluQuadricCallback = procedure(quadObject: PGLUquadric; which: GLEnum; fn: TGLUQuadricErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNewTess = function: PGLUtesselator; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluDeleteTess = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessBeginPolygon = procedure(tess: PGLUtesselator; polygon_data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessBeginContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessVertex = procedure(tess: PGLUtesselator; const coords: TGLArrayd3; data: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessEndContour = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessNormal = procedure(tess: PGLUtesselator; x, y, z: GLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluTessCallback = procedure(tess: PGLUtesselator; which: GLEnum; fn: Pointer); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluGetTessProperty = procedure(tess: PGLUtesselator; which: GLEnum; value: PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNewNurbsRenderer = function: PGLUnurbs; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluDeleteNurbsRenderer = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluBeginSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluBeginCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluEndCurve = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluEndSurface = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluBeginTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluEndTrim = procedure(nobj: PGLUnurbs); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluPwlCurve = procedure(nobj: PGLUnurbs; count: GLint; points: PGLfloat; stride: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNurbsCurve = procedure(nobj: PGLUnurbs; nknots: GLint; knot: PGLfloat; stride: GLint; ctlarray: PGLfloat; order: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNurbsSurface = procedure(nobj: PGLUnurbs; sknot_count: GLint; sknot: PGLfloat; tknot_count: GLint; tknot: PGLfloat; s_stride, t_stride: GLint; ctlarray: PGLfloat; sorder, torder: GLint; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluLoadSamplingMatrices = procedure(nobj: PGLUnurbs; const modelMatrix, projMatrix: TGLMatrixf4; const viewport: TVector4i); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluGetNurbsProperty = procedure(nobj: PGLUnurbs; aproperty: GLEnum; value: PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNurbsCallback = procedure(nobj: PGLUnurbs; which: GLEnum; fn: TGLUNurbsErrorProc); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluBeginPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluNextContour = procedure(tess: PGLUtesselator; atype: GLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluEndPolygon = procedure(tess: PGLUtesselator); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+var
+  // GL_VERSION_1_0
+  glCullFace: TglCullFace;
+  glFrontFace: TglFrontFace;
+  glHint: TglHint;
+  glLineWidth: TglLineWidth;
+  glPointSize: TglPointSize;
+  glPolygonMode: TglPolygonMode;
+  glScissor: TglScissor;
+  glTexParameterf: TglTexParameterf;
+  glTexParameterfv: TglTexParameterfv;
+  glTexParameteri: TglTexParameteri;
+  glTexParameteriv: TglTexParameteriv;
+  glTexImage1D: TglTexImage1D;
+  glTexImage2D: TglTexImage2D;
+  glDrawBuffer: TglDrawBuffer;
+  glClear: TglClear;
+  glClearColor: TglClearColor;
+  glClearStencil: TglClearStencil;
+  glClearDepth: TglClearDepth;
+  glStencilMask: TglStencilMask;
+  glColorMask: TglColorMask;
+  glDepthMask: TglDepthMask;
+  glDisable: TglDisable;
+  glEnable: TglEnable;
+  glFinish: TglFinish;
+  glFlush: TglFlush;
+  glBlendFunc: TglBlendFunc;
+  glLogicOp: TglLogicOp;
+  glStencilFunc: TglStencilFunc;
+  glStencilOp: TglStencilOp;
+  glDepthFunc: TglDepthFunc;
+  glPixelStoref: TglPixelStoref;
+  glPixelStorei: TglPixelStorei;
+  glReadBuffer: TglReadBuffer;
+  glReadPixels: TglReadPixels;
+  glGetBooleanv: TglGetBooleanv;
+  glGetDoublev: TglGetDoublev;
+  glGetError: TglGetError;
+  glGetFloatv: TglGetFloatv;
+  glGetIntegerv: TglGetIntegerv;
+  glGetString: TglGetString;
+  glGetTexImage: TglGetTexImage;
+  glGetTexParameteriv: TglGetTexParameteriv;
+  glGetTexParameterfv: TglGetTexParameterfv;
+  glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
+  glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
+  glIsEnabled: TglIsEnabled;
+  glDepthRange: TglDepthRange;
+  glViewport: TglViewport;
+
+  // GL_VERSION_1_1
+  glDrawArrays: TglDrawArrays;
+  glDrawElements: TglDrawElements;
+  glGetPointerv: TglGetPointerv;
+  glPolygonOffset: TglPolygonOffset;
+  glCopyTexImage1D: TglCopyTexImage1D;
+  glCopyTexImage2D: TglCopyTexImage2D;
+  glCopyTexSubImage1D: TglCopyTexSubImage1D;
+  glCopyTexSubImage2D: TglCopyTexSubImage2D;
+  glTexSubImage1D: TglTexSubImage1D;
+  glTexSubImage2D: TglTexSubImage2D;
+  glBindTexture: TglBindTexture;
+  glDeleteTextures: TglDeleteTextures;
+  glGenTextures: TglGenTextures;
+{$ifdef DGL_DEPRECATED}
+  glAccum: TglAccum;
+  glAlphaFunc: TglAlphaFunc;
+  glAreTexturesResident: TglAreTexturesResident;
+  glArrayElement: TglArrayElement;
+  glBegin: TglBegin;
+  glBitmap: TglBitmap;
+  glCallList: TglCallList;
+  glCallLists: TglCallLists;
+  glClearAccum: TglClearAccum;
+  glClearIndex: TglClearIndex;
+  glClipPlane: TglClipPlane;
+  glColor3b: TglColor3b;
+  glColor3bv: TglColor3bv;
+  glColor3d: TglColor3d;
+  glColor3dv: TglColor3dv;
+  glColor3f: TglColor3f;
+  glColor3fv: TglColor3fv;
+  glColor3i: TglColor3i;
+  glColor3iv: TglColor3iv;
+  glColor3s: TglColor3s;
+  glColor3sv: TglColor3sv;
+  glColor3ub: TglColor3ub;
+  glColor3ubv: TglColor3ubv;
+  glColor3ui: TglColor3ui;
+  glColor3uiv: TglColor3uiv;
+  glColor3us: TglColor3us;
+  glColor3usv: TglColor3usv;
+  glColor4b: TglColor4b;
+  glColor4bv: TglColor4bv;
+  glColor4d: TglColor4d;
+  glColor4dv: TglColor4dv;
+  glColor4f: TglColor4f;
+  glColor4fv: TglColor4fv;
+  glColor4i: TglColor4i;
+  glColor4iv: TglColor4iv;
+  glColor4s: TglColor4s;
+  glColor4sv: TglColor4sv;
+  glColor4ub: TglColor4ub;
+  glColor4ubv: TglColor4ubv;
+  glColor4ui: TglColor4ui;
+  glColor4uiv: TglColor4uiv;
+  glColor4us: TglColor4us;
+  glColor4usv: TglColor4usv;
+  glColorMaterial: TglColorMaterial;
+  glColorPointer: TglColorPointer;
+  glCopyPixels: TglCopyPixels;
+  glDeleteLists: TglDeleteLists;
+  glDisableClientState: TglDisableClientState;
+  glDrawPixels: TglDrawPixels;
+  glEdgeFlag: TglEdgeFlag;
+  glEdgeFlagPointer: TglEdgeFlagPointer;
+  glEdgeFlagv: TglEdgeFlagv;
+  glEnableClientState: TglEnableClientState;
+  glEnd: TglEnd;
+  glEndList: TglEndList;
+  glEvalCoord1d: TglEvalCoord1d;
+  glEvalCoord1dv: TglEvalCoord1dv;
+  glEvalCoord1f: TglEvalCoord1f;
+  glEvalCoord1fv: TglEvalCoord1fv;
+  glEvalCoord2d: TglEvalCoord2d;
+  glEvalCoord2dv: TglEvalCoord2dv;
+  glEvalCoord2f: TglEvalCoord2f;
+  glEvalCoord2fv: TglEvalCoord2fv;
+  glEvalMesh1: TglEvalMesh1;
+  glEvalMesh2: TglEvalMesh2;
+  glEvalPoint1: TglEvalPoint1;
+  glEvalPoint2: TglEvalPoint2;
+  glFeedbackBuffer: TglFeedbackBuffer;
+  glFogf: TglFogf;
+  glFogfv: TglFogfv;
+  glFogi: TglFogi;
+  glFogiv: TglFogiv;
+  glFrustum: TglFrustum;
+  glGenLists: TglGenLists;
+  glGetClipPlane: TglGetClipPlane;
+  glGetLightfv: TglGetLightfv;
+  glGetLightiv: TglGetLightiv;
+  glGetMapdv: TglGetMapdv;
+  glGetMapfv: TglGetMapfv;
+  glGetMapiv: TglGetMapiv;
+  glGetMaterialfv: TglGetMaterialfv;
+  glGetMaterialiv: TglGetMaterialiv;
+  glGetPixelMapfv: TglGetPixelMapfv;
+  glGetPixelMapuiv: TglGetPixelMapuiv;
+  glGetPixelMapusv: TglGetPixelMapusv;
+  glGetPolygonStipple: TglGetPolygonStipple;
+  glGetTexEnvfv: TglGetTexEnvfv;
+  glGetTexEnviv: TglGetTexEnviv;
+  glGetTexGendv: TglGetTexGendv;
+  glGetTexGenfv: TglGetTexGenfv;
+  glGetTexGeniv: TglGetTexGeniv;
+  glIndexMask: TglIndexMask;
+  glIndexPointer: TglIndexPointer;
+  glIndexd: TglIndexd;
+  glIndexdv: TglIndexdv;
+  glIndexf: TglIndexf;
+  glIndexfv: TglIndexfv;
+  glIndexi: TglIndexi;
+  glIndexiv: TglIndexiv;
+  glIndexs: TglIndexs;
+  glIndexsv: TglIndexsv;
+  glIndexub: TglIndexub;
+  glIndexubv: TglIndexubv;
+  glInitNames: TglInitNames;
+  glInterleavedArrays: TglInterleavedArrays;
+  glIsList: TglIsList;
+  glIsTexture: TglIsTexture;
+  glLightModelf: TglLightModelf;
+  glLightModelfv: TglLightModelfv;
+  glLightModeli: TglLightModeli;
+  glLightModeliv: TglLightModeliv;
+  glLightf: TglLightf;
+  glLightfv: TglLightfv;
+  glLighti: TglLighti;
+  glLightiv: TglLightiv;
+  glLineStipple: TglLineStipple;
+  glListBase: TglListBase;
+  glLoadIdentity: TglLoadIdentity;
+  glLoadMatrixd: TglLoadMatrixd;
+  glLoadMatrixf: TglLoadMatrixf;
+  glLoadName: TglLoadName;
+  glMap1d: TglMap1d;
+  glMap1f: TglMap1f;
+  glMap2d: TglMap2d;
+  glMap2f: TglMap2f;
+  glMapGrid1d: TglMapGrid1d;
+  glMapGrid1f: TglMapGrid1f;
+  glMapGrid2d: TglMapGrid2d;
+  glMapGrid2f: TglMapGrid2f;
+  glMaterialf: TglMaterialf;
+  glMaterialfv: TglMaterialfv;
+  glMateriali: TglMateriali;
+  glMaterialiv: TglMaterialiv;
+  glMatrixMode: TglMatrixMode;
+  glMultMatrixd: TglMultMatrixd;
+  glMultMatrixf: TglMultMatrixf;
+  glNewList: TglNewList;
+  glNormal3b: TglNormal3b;
+  glNormal3bv: TglNormal3bv;
+  glNormal3d: TglNormal3d;
+  glNormal3dv: TglNormal3dv;
+  glNormal3f: TglNormal3f;
+  glNormal3fv: TglNormal3fv;
+  glNormal3i: TglNormal3i;
+  glNormal3iv: TglNormal3iv;
+  glNormal3s: TglNormal3s;
+  glNormal3sv: TglNormal3sv;
+  glNormalPointer: TglNormalPointer;
+  glOrtho: TglOrtho;
+  glPassThrough: TglPassThrough;
+  glPixelMapfv: TglPixelMapfv;
+  glPixelMapuiv: TglPixelMapuiv;
+  glPixelMapusv: TglPixelMapusv;
+  glPixelTransferf: TglPixelTransferf;
+  glPixelTransferi: TglPixelTransferi;
+  glPixelZoom: TglPixelZoom;
+  glPolygonStipple: TglPolygonStipple;
+  glPopAttrib: TglPopAttrib;
+  glPopClientAttrib: TglPopClientAttrib;
+  glPopMatrix: TglPopMatrix;
+  glPopName: TglPopName;
+  glPrioritizeTextures: TglPrioritizeTextures;
+  glPushAttrib: TglPushAttrib;
+  glPushClientAttrib: TglPushClientAttrib;
+  glPushMatrix: TglPushMatrix;
+  glPushName: TglPushName;
+  glRasterPos2d: TglRasterPos2d;
+  glRasterPos2dv: TglRasterPos2dv;
+  glRasterPos2f: TglRasterPos2f;
+  glRasterPos2fv: TglRasterPos2fv;
+  glRasterPos2i: TglRasterPos2i;
+  glRasterPos2iv: TglRasterPos2iv;
+  glRasterPos2s: TglRasterPos2s;
+  glRasterPos2sv: TglRasterPos2sv;
+  glRasterPos3d: TglRasterPos3d;
+  glRasterPos3dv: TglRasterPos3dv;
+  glRasterPos3f: TglRasterPos3f;
+  glRasterPos3fv: TglRasterPos3fv;
+  glRasterPos3i: TglRasterPos3i;
+  glRasterPos3iv: TglRasterPos3iv;
+  glRasterPos3s: TglRasterPos3s;
+  glRasterPos3sv: TglRasterPos3sv;
+  glRasterPos4d: TglRasterPos4d;
+  glRasterPos4dv: TglRasterPos4dv;
+  glRasterPos4f: TglRasterPos4f;
+  glRasterPos4fv: TglRasterPos4fv;
+  glRasterPos4i: TglRasterPos4i;
+  glRasterPos4iv: TglRasterPos4iv;
+  glRasterPos4s: TglRasterPos4s;
+  glRasterPos4sv: TglRasterPos4sv;
+  glRectd: TglRectd;
+  glRectdv: TglRectdv;
+  glRectf: TglRectf;
+  glRectfv: TglRectfv;
+  glRecti: TglRecti;
+  glRectiv: TglRectiv;
+  glRects: TglRects;
+  glRectsv: TglRectsv;
+  glRenderMode: TglRenderMode;
+  glRotated: TglRotated;
+  glRotatef: TglRotatef;
+  glScaled: TglScaled;
+  glScalef: TglScalef;
+  glSelectBuffer: TglSelectBuffer;
+  glShadeModel: TglShadeModel;
+  glTexCoord1d: TglTexCoord1d;
+  glTexCoord1dv: TglTexCoord1dv;
+  glTexCoord1f: TglTexCoord1f;
+  glTexCoord1fv: TglTexCoord1fv;
+  glTexCoord1i: TglTexCoord1i;
+  glTexCoord1iv: TglTexCoord1iv;
+  glTexCoord1s: TglTexCoord1s;
+  glTexCoord1sv: TglTexCoord1sv;
+  glTexCoord2d: TglTexCoord2d;
+  glTexCoord2dv: TglTexCoord2dv;
+  glTexCoord2f: TglTexCoord2f;
+  glTexCoord2fv: TglTexCoord2fv;
+  glTexCoord2i: TglTexCoord2i;
+  glTexCoord2iv: TglTexCoord2iv;
+  glTexCoord2s: TglTexCoord2s;
+  glTexCoord2sv: TglTexCoord2sv;
+  glTexCoord3d: TglTexCoord3d;
+  glTexCoord3dv: TglTexCoord3dv;
+  glTexCoord3f: TglTexCoord3f;
+  glTexCoord3fv: TglTexCoord3fv;
+  glTexCoord3i: TglTexCoord3i;
+  glTexCoord3iv: TglTexCoord3iv;
+  glTexCoord3s: TglTexCoord3s;
+  glTexCoord3sv: TglTexCoord3sv;
+  glTexCoord4d: TglTexCoord4d;
+  glTexCoord4dv: TglTexCoord4dv;
+  glTexCoord4f: TglTexCoord4f;
+  glTexCoord4fv: TglTexCoord4fv;
+  glTexCoord4i: TglTexCoord4i;
+  glTexCoord4iv: TglTexCoord4iv;
+  glTexCoord4s: TglTexCoord4s;
+  glTexCoord4sv: TglTexCoord4sv;
+  glTexCoordPointer: TglTexCoordPointer;
+  glTexEnvf: TglTexEnvf;
+  glTexEnvfv: TglTexEnvfv;
+  glTexEnvi: TglTexEnvi;
+  glTexEnviv: TglTexEnviv;
+  glTexGend: TglTexGend;
+  glTexGendv: TglTexGendv;
+  glTexGenf: TglTexGenf;
+  glTexGenfv: TglTexGenfv;
+  glTexGeni: TglTexGeni;
+  glTexGeniv: TglTexGeniv;
+  glTranslated: TglTranslated;
+  glTranslatef: TglTranslatef;
+  glVertex2d: TglVertex2d;
+  glVertex2dv: TglVertex2dv;
+  glVertex2f: TglVertex2f;
+  glVertex2fv: TglVertex2fv;
+  glVertex2i: TglVertex2i;
+  glVertex2iv: TglVertex2iv;
+  glVertex2s: TglVertex2s;
+  glVertex2sv: TglVertex2sv;
+  glVertex3d: TglVertex3d;
+  glVertex3dv: TglVertex3dv;
+  glVertex3f: TglVertex3f;
+  glVertex3fv: TglVertex3fv;
+  glVertex3i: TglVertex3i;
+  glVertex3iv: TglVertex3iv;
+  glVertex3s: TglVertex3s;
+  glVertex3sv: TglVertex3sv;
+  glVertex4d: TglVertex4d;
+  glVertex4dv: TglVertex4dv;
+  glVertex4f: TglVertex4f;
+  glVertex4fv: TglVertex4fv;
+  glVertex4i: TglVertex4i;
+  glVertex4iv: TglVertex4iv;
+  glVertex4s: TglVertex4s;
+  glVertex4sv: TglVertex4sv;
+  glVertexPointer: TglVertexPointer;
+{$endif}
+
+  // GL_VERSION_1_2
+  glBlendColor: TglBlendColor;
+  glBlendEquation: TglBlendEquation;
+  glDrawRangeElements: TglDrawRangeElements;
+  glTexImage3D: TglTexImage3D;
+  glTexSubImage3D: TglTexSubImage3D;
+  glCopyTexSubImage3D: TglCopyTexSubImage3D;
+{$ifdef DGL_DEPRECATED}
+  glColorTable: TglColorTable;
+  glColorTableParameterfv: TglColorTableParameterfv;
+  glColorTableParameteriv: TglColorTableParameteriv;
+  glCopyColorTable: TglCopyColorTable;
+  glGetColorTable: TglGetColorTable;
+  glGetColorTableParameterfv: TglGetColorTableParameterfv;
+  glGetColorTableParameteriv: TglGetColorTableParameteriv;
+  glColorSubTable: TglColorSubTable;
+  glCopyColorSubTable: TglCopyColorSubTable;
+  glConvolutionFilter1D: TglConvolutionFilter1D;
+  glConvolutionFilter2D: TglConvolutionFilter2D;
+  glConvolutionParameterf: TglConvolutionParameterf;
+  glConvolutionParameterfv: TglConvolutionParameterfv;
+  glConvolutionParameteri: TglConvolutionParameteri;
+  glConvolutionParameteriv: TglConvolutionParameteriv;
+  glCopyConvolutionFilter1D: TglCopyConvolutionFilter1D;
+  glCopyConvolutionFilter2D: TglCopyConvolutionFilter2D;
+  glGetConvolutionFilter: TglGetConvolutionFilter;
+  glGetConvolutionParameterfv: TglGetConvolutionParameterfv;
+  glGetConvolutionParameteriv: TglGetConvolutionParameteriv;
+  glGetSeparableFilter: TglGetSeparableFilter;
+  glSeparableFilter2D: TglSeparableFilter2D;
+  glGetHistogram: TglGetHistogram;
+  glGetHistogramParameterfv: TglGetHistogramParameterfv;
+  glGetHistogramParameteriv: TglGetHistogramParameteriv;
+  glGetMinmax: TglGetMinmax;
+  glGetMinmaxParameterfv: TglGetMinmaxParameterfv;
+  glGetMinmaxParameteriv: TglGetMinmaxParameteriv;
+  glHistogram: TglHistogram;
+  glMinmax: TglMinmax;
+  glResetHistogram: TglResetHistogram;
+  glResetMinmax: TglResetMinmax;
+{$endif}
+
+  // GL_VERSION_1_3
+  glActiveTexture: TglActiveTexture;
+  glSampleCoverage: TglSampleCoverage;
+  glCompressedTexImage3D: TglCompressedTexImage3D;
+  glCompressedTexImage2D: TglCompressedTexImage2D;
+  glCompressedTexImage1D: TglCompressedTexImage1D;
+  glCompressedTexSubImage3D: TglCompressedTexSubImage3D;
+  glCompressedTexSubImage2D: TglCompressedTexSubImage2D;
+  glCompressedTexSubImage1D: TglCompressedTexSubImage1D;
+  glGetCompressedTexImage: TglGetCompressedTexImage;
+{$ifdef DGL_DEPRECATED}
+  glClientActiveTexture: TglClientActiveTexture;
+  glMultiTexCoord1d: TglMultiTexCoord1d;
+  glMultiTexCoord1dv: TglMultiTexCoord1dv;
+  glMultiTexCoord1f: TglMultiTexCoord1f;
+  glMultiTexCoord1fv: TglMultiTexCoord1fv;
+  glMultiTexCoord1i: TglMultiTexCoord1i;
+  glMultiTexCoord1iv: TglMultiTexCoord1iv;
+  glMultiTexCoord1s: TglMultiTexCoord1s;
+  glMultiTexCoord1sv: TglMultiTexCoord1sv;
+  glMultiTexCoord2d: TglMultiTexCoord2d;
+  glMultiTexCoord2dv: TglMultiTexCoord2dv;
+  glMultiTexCoord2f: TglMultiTexCoord2f;
+  glMultiTexCoord2fv: TglMultiTexCoord2fv;
+  glMultiTexCoord2i: TglMultiTexCoord2i;
+  glMultiTexCoord2iv: TglMultiTexCoord2iv;
+  glMultiTexCoord2s: TglMultiTexCoord2s;
+  glMultiTexCoord2sv: TglMultiTexCoord2sv;
+  glMultiTexCoord3d: TglMultiTexCoord3d;
+  glMultiTexCoord3dv: TglMultiTexCoord3dv;
+  glMultiTexCoord3f: TglMultiTexCoord3f;
+  glMultiTexCoord3fv: TglMultiTexCoord3fv;
+  glMultiTexCoord3i: TglMultiTexCoord3i;
+  glMultiTexCoord3iv: TglMultiTexCoord3iv;
+  glMultiTexCoord3s: TglMultiTexCoord3s;
+  glMultiTexCoord3sv: TglMultiTexCoord3sv;
+  glMultiTexCoord4d: TglMultiTexCoord4d;
+  glMultiTexCoord4dv: TglMultiTexCoord4dv;
+  glMultiTexCoord4f: TglMultiTexCoord4f;
+  glMultiTexCoord4fv: TglMultiTexCoord4fv;
+  glMultiTexCoord4i: TglMultiTexCoord4i;
+  glMultiTexCoord4iv: TglMultiTexCoord4iv;
+  glMultiTexCoord4s: TglMultiTexCoord4s;
+  glMultiTexCoord4sv: TglMultiTexCoord4sv;
+  glLoadTransposeMatrixf: TglLoadTransposeMatrixf;
+  glLoadTransposeMatrixd: TglLoadTransposeMatrixd;
+  glMultTransposeMatrixf: TglMultTransposeMatrixf;
+  glMultTransposeMatrixd: TglMultTransposeMatrixd;
+{$endif}
+
+  // GL_VERSION_1_4
+  glBlendFuncSeparate: TglBlendFuncSeparate;
+  glMultiDrawArrays: TglMultiDrawArrays;
+  glMultiDrawElements: TglMultiDrawElements;
+  glPointParameterf: TglPointParameterf;
+  glPointParameterfv: TglPointParameterfv;
+  glPointParameteri: TglPointParameteri;
+  glPointParameteriv: TglPointParameteriv;
+{$ifdef DGL_DEPRECATED}
+  glFogCoordf: TglFogCoordf;
+  glFogCoordfv: TglFogCoordfv;
+  glFogCoordd: TglFogCoordd;
+  glFogCoorddv: TglFogCoorddv;
+  glFogCoordPointer: TglFogCoordPointer;
+  glSecondaryColor3b: TglSecondaryColor3b;
+  glSecondaryColor3bv: TglSecondaryColor3bv;
+  glSecondaryColor3d: TglSecondaryColor3d;
+  glSecondaryColor3dv: TglSecondaryColor3dv;
+  glSecondaryColor3f: TglSecondaryColor3f;
+  glSecondaryColor3fv: TglSecondaryColor3fv;
+  glSecondaryColor3i: TglSecondaryColor3i;
+  glSecondaryColor3iv: TglSecondaryColor3iv;
+  glSecondaryColor3s: TglSecondaryColor3s;
+  glSecondaryColor3sv: TglSecondaryColor3sv;
+  glSecondaryColor3ub: TglSecondaryColor3ub;
+  glSecondaryColor3ubv: TglSecondaryColor3ubv;
+  glSecondaryColor3ui: TglSecondaryColor3ui;
+  glSecondaryColor3uiv: TglSecondaryColor3uiv;
+  glSecondaryColor3us: TglSecondaryColor3us;
+  glSecondaryColor3usv: TglSecondaryColor3usv;
+  glSecondaryColorPointer: TglSecondaryColorPointer;
+  glWindowPos2d: TglWindowPos2d;
+  glWindowPos2dv: TglWindowPos2dv;
+  glWindowPos2f: TglWindowPos2f;
+  glWindowPos2fv: TglWindowPos2fv;
+  glWindowPos2i: TglWindowPos2i;
+  glWindowPos2iv: TglWindowPos2iv;
+  glWindowPos2s: TglWindowPos2s;
+  glWindowPos2sv: TglWindowPos2sv;
+  glWindowPos3d: TglWindowPos3d;
+  glWindowPos3dv: TglWindowPos3dv;
+  glWindowPos3f: TglWindowPos3f;
+  glWindowPos3fv: TglWindowPos3fv;
+  glWindowPos3i: TglWindowPos3i;
+  glWindowPos3iv: TglWindowPos3iv;
+  glWindowPos3s: TglWindowPos3s;
+  glWindowPos3sv: TglWindowPos3sv;
+{$endif}
+
+  // GL_VERSION_1_5
+  glGenQueries: TglGenQueries;
+  glDeleteQueries: TglDeleteQueries;
+  glIsQuery: TglIsQuery;
+  glBeginQuery: TglBeginQuery;
+  glEndQuery: TglEndQuery;
+  glGetQueryiv: TglGetQueryiv;
+  glGetQueryObjectiv: TglGetQueryObjectiv;
+  glGetQueryObjectuiv: TglGetQueryObjectuiv;
+  glBindBuffer: TglBindBuffer;
+  glDeleteBuffers: TglDeleteBuffers;
+  glGenBuffers: TglGenBuffers;
+  glIsBuffer: TglIsBuffer;
+  glBufferData: TglBufferData;
+  glBufferSubData: TglBufferSubData;
+  glGetBufferSubData: TglGetBufferSubData;
+  glMapBuffer: TglMapBuffer;
+  glUnmapBuffer: TglUnmapBuffer;
+  glGetBufferParameteriv: TglGetBufferParameteriv;
+  glGetBufferPointerv: TglGetBufferPointerv;
+
+  // GL_VERSION_2_0
+  glBlendEquationSeparate: TglBlendEquationSeparate;
+  glDrawBuffers: TglDrawBuffers;
+  glStencilOpSeparate: TglStencilOpSeparate;
+  glStencilFuncSeparate: TglStencilFuncSeparate;
+  glStencilMaskSeparate: TglStencilMaskSeparate;
+  glAttachShader: TglAttachShader;
+  glBindAttribLocation: TglBindAttribLocation;
+  glCompileShader: TglCompileShader;
+  glCreateProgram: TglCreateProgram;
+  glCreateShader: TglCreateShader;
+  glDeleteProgram: TglDeleteProgram;
+  glDeleteShader: TglDeleteShader;
+  glDetachShader: TglDetachShader;
+  glDisableVertexAttribArray: TglDisableVertexAttribArray;
+  glEnableVertexAttribArray: TglEnableVertexAttribArray;
+  glGetActiveAttrib: TglGetActiveAttrib;
+  glGetActiveUniform: TglGetActiveUniform;
+  glGetAttachedShaders: TglGetAttachedShaders;
+  glGetAttribLocation: TglGetAttribLocation;
+  glGetProgramiv: TglGetProgramiv;
+  glGetProgramInfoLog: TglGetProgramInfoLog;
+  glGetShaderiv: TglGetShaderiv;
+  glGetShaderInfoLog: TglGetShaderInfoLog;
+  glGetShaderSource: TglGetShaderSource;
+  glGetUniformLocation: TglGetUniformLocation;
+  glGetUniformfv: TglGetUniformfv;
+  glGetUniformiv: TglGetUniformiv;
+  glGetVertexAttribfv: TglGetVertexAttribfv;
+  glGetVertexAttribiv: TglGetVertexAttribiv;
+  glGetVertexAttribPointerv: TglGetVertexAttribPointerv;
+  glIsProgram: TglIsProgram;
+  glIsShader: TglIsShader;
+  glLinkProgram: TglLinkProgram;
+  glShaderSource: TglShaderSource;
+  glUseProgram: TglUseProgram;
+  glUniform1f: TglUniform1f;
+  glUniform2f: TglUniform2f;
+  glUniform3f: TglUniform3f;
+  glUniform4f: TglUniform4f;
+  glUniform1i: TglUniform1i;
+  glUniform2i: TglUniform2i;
+  glUniform3i: TglUniform3i;
+  glUniform4i: TglUniform4i;
+  glUniform1fv: TglUniform1fv;
+  glUniform2fv: TglUniform2fv;
+  glUniform3fv: TglUniform3fv;
+  glUniform4fv: TglUniform4fv;
+  glUniform1iv: TglUniform1iv;
+  glUniform2iv: TglUniform2iv;
+  glUniform3iv: TglUniform3iv;
+  glUniform4iv: TglUniform4iv;
+  glUniformMatrix2fv: TglUniformMatrix2fv;
+  glUniformMatrix3fv: TglUniformMatrix3fv;
+  glUniformMatrix4fv: TglUniformMatrix4fv;
+  glValidateProgram: TglValidateProgram;
+  glVertexAttrib1d: TglVertexAttrib1d;
+  glVertexAttrib1dv: TglVertexAttrib1dv;
+  glVertexAttrib1f: TglVertexAttrib1f;
+  glVertexAttrib1fv: TglVertexAttrib1fv;
+  glVertexAttrib1s: TglVertexAttrib1s;
+  glVertexAttrib1sv: TglVertexAttrib1sv;
+  glVertexAttrib2d: TglVertexAttrib2d;
+  glVertexAttrib2dv: TglVertexAttrib2dv;
+  glVertexAttrib2f: TglVertexAttrib2f;
+  glVertexAttrib2fv: TglVertexAttrib2fv;
+  glVertexAttrib2s: TglVertexAttrib2s;
+  glVertexAttrib2sv: TglVertexAttrib2sv;
+  glVertexAttrib3d: TglVertexAttrib3d;
+  glVertexAttrib3dv: TglVertexAttrib3dv;
+  glVertexAttrib3f: TglVertexAttrib3f;
+  glVertexAttrib3fv: TglVertexAttrib3fv;
+  glVertexAttrib3s: TglVertexAttrib3s;
+  glVertexAttrib3sv: TglVertexAttrib3sv;
+  glVertexAttrib4Nbv: TglVertexAttrib4Nbv;
+  glVertexAttrib4Niv: TglVertexAttrib4Niv;
+  glVertexAttrib4Nsv: TglVertexAttrib4Nsv;
+  glVertexAttrib4Nub: TglVertexAttrib4Nub;
+  glVertexAttrib4Nubv: TglVertexAttrib4Nubv;
+  glVertexAttrib4Nuiv: TglVertexAttrib4Nuiv;
+  glVertexAttrib4Nusv: TglVertexAttrib4Nusv;
+  glVertexAttrib4bv: TglVertexAttrib4bv;
+  glVertexAttrib4d: TglVertexAttrib4d;
+  glVertexAttrib4dv: TglVertexAttrib4dv;
+  glVertexAttrib4f: TglVertexAttrib4f;
+  glVertexAttrib4fv: TglVertexAttrib4fv;
+  glVertexAttrib4iv: TglVertexAttrib4iv;
+  glVertexAttrib4s: TglVertexAttrib4s;
+  glVertexAttrib4sv: TglVertexAttrib4sv;
+  glVertexAttrib4ubv: TglVertexAttrib4ubv;
+  glVertexAttrib4uiv: TglVertexAttrib4uiv;
+  glVertexAttrib4usv: TglVertexAttrib4usv;
+  glVertexAttribPointer: TglVertexAttribPointer;
+
+  // GL_VERSION_2_1
+  glUniformMatrix2x3fv: TglUniformMatrix2x3fv;
+  glUniformMatrix3x2fv: TglUniformMatrix3x2fv;
+  glUniformMatrix2x4fv: TglUniformMatrix2x4fv;
+  glUniformMatrix4x2fv: TglUniformMatrix4x2fv;
+  glUniformMatrix3x4fv: TglUniformMatrix3x4fv;
+  glUniformMatrix4x3fv: TglUniformMatrix4x3fv;
+
+  // GL_VERSION_3_0
+  glColorMaski: TglColorMaski;
+  glGetBooleani_v: TglGetBooleani_v;
+  glGetIntegeri_v: TglGetIntegeri_v;
+  glEnablei: TglEnablei;
+  glDisablei: TglDisablei;
+  glIsEnabledi: TglIsEnabledi;
+  glBeginTransformFeedback: TglBeginTransformFeedback;
+  glEndTransformFeedback: TglEndTransformFeedback;
+  glBindBufferRange: TglBindBufferRange;
+  glBindBufferBase: TglBindBufferBase;
+  glTransformFeedbackVaryings: TglTransformFeedbackVaryings;
+  glGetTransformFeedbackVarying: TglGetTransformFeedbackVarying;
+  glClampColor: TglClampColor;
+  glBeginConditionalRender: TglBeginConditionalRender;
+  glEndConditionalRender: TglEndConditionalRender;
+  glVertexAttribI1i: TglVertexAttribI1i;
+  glVertexAttribI2i: TglVertexAttribI2i;
+  glVertexAttribI3i: TglVertexAttribI3i;
+  glVertexAttribI4i: TglVertexAttribI4i;
+  glVertexAttribI1ui: TglVertexAttribI1ui;
+  glVertexAttribI2ui: TglVertexAttribI2ui;
+  glVertexAttribI3ui: TglVertexAttribI3ui;
+  glVertexAttribI4ui: TglVertexAttribI4ui;
+  glVertexAttribI1iv: TglVertexAttribI1iv;
+  glVertexAttribI2iv: TglVertexAttribI2iv;
+  glVertexAttribI3iv: TglVertexAttribI3iv;
+  glVertexAttribI4iv: TglVertexAttribI4iv;
+  glVertexAttribI1uiv: TglVertexAttribI1uiv;
+  glVertexAttribI2uiv: TglVertexAttribI2uiv;
+  glVertexAttribI3uiv: TglVertexAttribI3uiv;
+  glVertexAttribI4uiv: TglVertexAttribI4uiv;
+  glVertexAttribI4bv: TglVertexAttribI4bv;
+  glVertexAttribI4sv: TglVertexAttribI4sv;
+  glVertexAttribI4ubv: TglVertexAttribI4ubv;
+  glVertexAttribI4usv: TglVertexAttribI4usv;
+  glVertexAttribIPointer: TglVertexAttribIPointer;
+  glGetVertexAttribIiv: TglGetVertexAttribIiv;
+  glGetVertexAttribIuiv: TglGetVertexAttribIuiv;
+  glGetUniformuiv: TglGetUniformuiv;
+  glBindFragDataLocation: TglBindFragDataLocation;
+  glGetFragDataLocation: TglGetFragDataLocation;
+  glUniform1ui: TglUniform1ui;
+  glUniform2ui: TglUniform2ui;
+  glUniform3ui: TglUniform3ui;
+  glUniform4ui: TglUniform4ui;
+  glUniform1uiv: TglUniform1uiv;
+  glUniform2uiv: TglUniform2uiv;
+  glUniform3uiv: TglUniform3uiv;
+  glUniform4uiv: TglUniform4uiv;
+  glTexParameterIiv: TglTexParameterIiv;
+  glTexParameterIuiv: TglTexParameterIuiv;
+  glGetTexParameterIiv: TglGetTexParameterIiv;
+  glGetTexParameterIuiv: TglGetTexParameterIuiv;
+  glClearBufferiv: TglClearBufferiv;
+  glClearBufferuiv: TglClearBufferuiv;
+  glClearBufferfv: TglClearBufferfv;
+  glClearBufferfi: TglClearBufferfi;
+  glGetStringi: TglGetStringi;
+
+  // GL_VERSION_2_1
+  glEnableVertexArrayEXT : TglEnableVertexArrayEXT;
+  glEnableVertexArrayAttribEXT : TglEnableVertexArrayAttribEXT;
+  glVertexArrayVertexAttribOffsetEXT : TglVertexArrayVertexAttribOffsetEXT;
+
+  // GL_VERSION_3_1
+  glDrawArraysInstanced: TglDrawArraysInstanced;
+  glDrawElementsInstanced: TglDrawElementsInstanced;
+  glTexBuffer: TglTexBuffer;
+  glPrimitiveRestartIndex: TglPrimitiveRestartIndex;
+
+  // GL_VERSION_3_2
+  glGetInteger64i_v: TglGetInteger64i_v;
+  glGetBufferParameteri64v: TglGetBufferParameteri64v;
+  glFramebufferTexture: TglFramebufferTexture;
+
+  // GL_VERSION_3_3
+  glVertexAttribDivisor: TglVertexAttribDivisor;
+  
+  // GL_VERSION_4_0
+  { OpenGL 4.0 also reuses entry points from these extensions: }
+  { ARB_texture_query_lod (no entry points) }
+  { ARB_draw_indirect }
+  { ARB_gpu_shader5 (no entry points) }
+  { ARB_gpu_shader_fp64 }
+  { ARB_shader_subroutine }
+  { ARB_tessellation_shader }
+  { ARB_texture_buffer_object_rgb32 (no entry points) }
+  { ARB_texture_cube_map_array (no entry points) }
+  { ARB_texture_gather (no entry points) }
+  { ARB_transform_feedback2 }
+  { ARB_transform_feedback3 }
+  glMinSampleShading: TglMinSampleShading;
+  glBlendEquationi: TglBlendEquationi;
+  glBlendEquationSeparatei: TglBlendEquationSeparatei;
+  glBlendFunci: TglBlendFunci;
+  glBlendFuncSeparatei: TglBlendFuncSeparatei;
+
+  // GL_3DFX_tbuffer
+  glTbufferMask3DFX: TglTbufferMask3DFX;
+
+  // GL_APPLE_element_array
+  glElementPointerAPPLE: TglElementPointerAPPLE;
+  glDrawElementArrayAPPLE: TglDrawElementArrayAPPLE;
+  glDrawRangeElementArrayAPPLE: TglDrawRangeElementArrayAPPLE;
+  glMultiDrawElementArrayAPPLE: TglMultiDrawElementArrayAPPLE;
+  glMultiDrawRangeElementArrayAPPLE: TglMultiDrawRangeElementArrayAPPLE;
+
+  // GL_APPLE_fence
+  glGenFencesAPPLE: TglGenFencesAPPLE;
+  glDeleteFencesAPPLE: TglDeleteFencesAPPLE;
+  glSetFenceAPPLE: TglSetFenceAPPLE;
+  glIsFenceAPPLE: TglIsFenceAPPLE;
+  glTestFenceAPPLE: TglTestFenceAPPLE;
+  glFinishFenceAPPLE: TglFinishFenceAPPLE;
+  glTestObjectAPPLE: TglTestObjectAPPLE;
+  glFinishObjectAPPLE: TglFinishObjectAPPLE;
+
+  // GL_APPLE_vertex_array_object
+  glBindVertexArrayAPPLE: TglBindVertexArrayAPPLE;
+  glDeleteVertexArraysAPPLE: TglDeleteVertexArraysAPPLE;
+  glGenVertexArraysAPPLE: TglGenVertexArraysAPPLE;
+  glIsVertexArrayAPPLE: TglIsVertexArrayAPPLE;
+
+  // GL_APPLE_vertex_array_range
+  glVertexArrayRangeAPPLE: TglVertexArrayRangeAPPLE;
+  glFlushVertexArrayRangeAPPLE: TglFlushVertexArrayRangeAPPLE;
+  glVertexArrayParameteriAPPLE: TglVertexArrayParameteriAPPLE;
+
+  // GL_APPLE_texture_range
+  glTextureRangeAPPLE: TglTextureRangeAPPLE;
+  glGetTexParameterPointervAPPLE: TglGetTexParameterPointervAPPLE;
+
+  // GL_APPLE_vertex_program_evaluators
+  glEnableVertexAttribAPPLE: TglEnableVertexAttribAPPLE;
+  glDisableVertexAttribAPPLE: TglDisableVertexAttribAPPLE;
+  glIsVertexAttribEnabledAPPLE: TglIsVertexAttribEnabledAPPLE;
+  glMapVertexAttrib1dAPPLE: TglMapVertexAttrib1dAPPLE;
+  glMapVertexAttrib1fAPPLE: TglMapVertexAttrib1fAPPLE;
+  glMapVertexAttrib2dAPPLE: TglMapVertexAttrib2dAPPLE;
+  glMapVertexAttrib2fAPPLE: TglMapVertexAttrib2fAPPLE;
+
+  // GL_APPLE_object_purgeable
+  glObjectPurgeableAPPLE: TglObjectPurgeableAPPLE;
+  glObjectUnpurgeableAPPLE: TglObjectUnpurgeableAPPLE;
+  glGetObjectParameterivAPPLE: TglGetObjectParameterivAPPLE;
+
+  // GL_ARB_matrix_palette
+  glCurrentPaletteMatrixARB: TglCurrentPaletteMatrixARB;
+  glMatrixIndexubvARB: TglMatrixIndexubvARB;
+  glMatrixIndexusvARB: TglMatrixIndexusvARB;
+  glMatrixIndexuivARB: TglMatrixIndexuivARB;
+  glMatrixIndexPointerARB: TglMatrixIndexPointerARB;
+
+  // GL_ARB_multisample
+  glSampleCoverageARB: TglSampleCoverageARB;
+
+  // GL_ARB_multitexture
+  glActiveTextureARB: TglActiveTextureARB;
+  glClientActiveTextureARB: TglClientActiveTextureARB;
+  glMultiTexCoord1dARB: TglMultiTexCoord1dARB;
+  glMultiTexCoord1dvARB: TglMultiTexCoord1dvARB;
+  glMultiTexCoord1fARB: TglMultiTexCoord1fARB;
+  glMultiTexCoord1fvARB: TglMultiTexCoord1fvARB;
+  glMultiTexCoord1iARB: TglMultiTexCoord1iARB;
+  glMultiTexCoord1ivARB: TglMultiTexCoord1ivARB;
+  glMultiTexCoord1sARB: TglMultiTexCoord1sARB;
+  glMultiTexCoord1svARB: TglMultiTexCoord1svARB;
+  glMultiTexCoord2dARB: TglMultiTexCoord2dARB;
+  glMultiTexCoord2dvARB: TglMultiTexCoord2dvARB;
+  glMultiTexCoord2fARB: TglMultiTexCoord2fARB;
+  glMultiTexCoord2fvARB: TglMultiTexCoord2fvARB;
+  glMultiTexCoord2iARB: TglMultiTexCoord2iARB;
+  glMultiTexCoord2ivARB: TglMultiTexCoord2ivARB;
+  glMultiTexCoord2sARB: TglMultiTexCoord2sARB;
+  glMultiTexCoord2svARB: TglMultiTexCoord2svARB;
+  glMultiTexCoord3dARB: TglMultiTexCoord3dARB;
+  glMultiTexCoord3dvARB: TglMultiTexCoord3dvARB;
+  glMultiTexCoord3fARB: TglMultiTexCoord3fARB;
+  glMultiTexCoord3fvARB: TglMultiTexCoord3fvARB;
+  glMultiTexCoord3iARB: TglMultiTexCoord3iARB;
+  glMultiTexCoord3ivARB: TglMultiTexCoord3ivARB;
+  glMultiTexCoord3sARB: TglMultiTexCoord3sARB;
+  glMultiTexCoord3svARB: TglMultiTexCoord3svARB;
+  glMultiTexCoord4dARB: TglMultiTexCoord4dARB;
+  glMultiTexCoord4dvARB: TglMultiTexCoord4dvARB;
+  glMultiTexCoord4fARB: TglMultiTexCoord4fARB;
+  glMultiTexCoord4fvARB: TglMultiTexCoord4fvARB;
+  glMultiTexCoord4iARB: TglMultiTexCoord4iARB;
+  glMultiTexCoord4ivARB: TglMultiTexCoord4ivARB;
+  glMultiTexCoord4sARB: TglMultiTexCoord4sARB;
+  glMultiTexCoord4svARB: TglMultiTexCoord4svARB;
+
+  // GL_ARB_point_parameters
+  glPointParameterfARB: TglPointParameterfARB;
+  glPointParameterfvARB: TglPointParameterfvARB;
+
+  // GL_ARB_texture_compression
+  glCompressedTexImage3DARB: TglCompressedTexImage3DARB;
+  glCompressedTexImage2DARB: TglCompressedTexImage2DARB;
+  glCompressedTexImage1DARB: TglCompressedTexImage1DARB;
+  glCompressedTexSubImage3DARB: TglCompressedTexSubImage3DARB;
+  glCompressedTexSubImage2DARB: TglCompressedTexSubImage2DARB;
+  glCompressedTexSubImage1DARB: TglCompressedTexSubImage1DARB;
+  glGetCompressedTexImageARB: TglGetCompressedTexImageARB;
+
+  // GL_ARB_transpose_matrix
+  glLoadTransposeMatrixfARB: TglLoadTransposeMatrixfARB;
+  glLoadTransposeMatrixdARB: TglLoadTransposeMatrixdARB;
+  glMultTransposeMatrixfARB: TglMultTransposeMatrixfARB;
+  glMultTransposeMatrixdARB: TglMultTransposeMatrixdARB;
+
+  // GL_ARB_vertex_blend
+  glWeightbvARB: TglWeightbvARB;
+  glWeightsvARB: TglWeightsvARB;
+  glWeightivARB: TglWeightivARB;
+  glWeightfvARB: TglWeightfvARB;
+  glWeightdvARB: TglWeightdvARB;
+  glWeightubvARB: TglWeightubvARB;
+  glWeightusvARB: TglWeightusvARB;
+  glWeightuivARB: TglWeightuivARB;
+  glWeightPointerARB: TglWeightPointerARB;
+  glVertexBlendARB: TglVertexBlendARB;
+
+  // GL_ARB_vertex_buffer_object
+  glBindBufferARB: TglBindBufferARB;
+  glDeleteBuffersARB: TglDeleteBuffersARB;
+  glGenBuffersARB: TglGenBuffersARB;
+  glIsBufferARB: TglIsBufferARB;
+  glBufferDataARB: TglBufferDataARB;
+  glBufferSubDataARB: TglBufferSubData;
+  glGetBufferSubDataARB: TglGetBufferSubDataARB;
+  glMapBufferARB: TglMapBufferARB;
+  glUnmapBufferARB: TglUnmapBufferARB;
+  glGetBufferParameterivARB: TglGetBufferParameterivARB;
+  glGetBufferPointervARB: TglGetBufferPointervARB;
+
+  // GL_ARB_vertex_program
+  glVertexAttrib1dARB: TglVertexAttrib1dARB;
+  glVertexAttrib1dvARB: TglVertexAttrib1dvARB;
+  glVertexAttrib1fARB: TglVertexAttrib1fARB;
+  glVertexAttrib1fvARB: TglVertexAttrib1fvARB;
+  glVertexAttrib1sARB: TglVertexAttrib1sARB;
+  glVertexAttrib1svARB: TglVertexAttrib1svARB;
+  glVertexAttrib2dARB: TglVertexAttrib2dARB;
+  glVertexAttrib2dvARB: TglVertexAttrib2dvARB;
+  glVertexAttrib2fARB: TglVertexAttrib2fARB;
+  glVertexAttrib2fvARB: TglVertexAttrib2fvARB;
+  glVertexAttrib2sARB: TglVertexAttrib2sARB;
+  glVertexAttrib2svARB: TglVertexAttrib2svARB;
+  glVertexAttrib3dARB: TglVertexAttrib3dARB;
+  glVertexAttrib3dvARB: TglVertexAttrib3dvARB;
+  glVertexAttrib3fARB: TglVertexAttrib3fARB;
+  glVertexAttrib3fvARB: TglVertexAttrib3fvARB;
+  glVertexAttrib3sARB: TglVertexAttrib3sARB;
+  glVertexAttrib3svARB: TglVertexAttrib3svARB;
+  glVertexAttrib4NbvARB: TglVertexAttrib4NbvARB;
+  glVertexAttrib4NivARB: TglVertexAttrib4NivARB;
+  glVertexAttrib4NsvARB: TglVertexAttrib4NsvARB;
+  glVertexAttrib4NubARB: TglVertexAttrib4NubARB;
+  glVertexAttrib4NubvARB: TglVertexAttrib4NubvARB;
+  glVertexAttrib4NuivARB: TglVertexAttrib4NuivARB;
+  glVertexAttrib4NusvARB: TglVertexAttrib4NusvARB;
+  glVertexAttrib4bvARB: TglVertexAttrib4bvARB;
+  glVertexAttrib4dARB: TglVertexAttrib4dARB;
+  glVertexAttrib4dvARB: TglVertexAttrib4dvARB;
+  glVertexAttrib4fARB: TglVertexAttrib4fARB;
+  glVertexAttrib4fvARB: TglVertexAttrib4fvARB;
+  glVertexAttrib4ivARB: TglVertexAttrib4ivARB;
+  glVertexAttrib4sARB: TglVertexAttrib4sARB;
+  glVertexAttrib4svARB: TglVertexAttrib4svARB;
+  glVertexAttrib4ubvARB: TglVertexAttrib4ubvARB;
+  glVertexAttrib4uivARB: TglVertexAttrib4uivARB;
+  glVertexAttrib4usvARB: TglVertexAttrib4usvARB;
+  glVertexAttribPointerARB: TglVertexAttribPointerARB;
+  glEnableVertexAttribArrayARB: TglEnableVertexAttribArrayARB;
+  glDisableVertexAttribArrayARB: TglDisableVertexAttribArrayARB;
+  glProgramStringARB: TglProgramStringARB;
+  glBindProgramARB: TglBindProgramARB;
+  glDeleteProgramsARB: TglDeleteProgramsARB;
+  glGenProgramsARB: TglGenProgramsARB;
+
+  glProgramEnvParameter4dARB: TglProgramEnvParameter4dARB;
+  glProgramEnvParameter4dvARB: TglProgramEnvParameter4dvARB;
+  glProgramEnvParameter4fARB: TglProgramEnvParameter4fARB;
+  glProgramEnvParameter4fvARB: TglProgramEnvParameter4fvARB;
+  glProgramLocalParameter4dARB: TglProgramLocalParameter4dARB;
+  glProgramLocalParameter4dvARB: TglProgramLocalParameter4dvARB;
+  glProgramLocalParameter4fARB: TglProgramLocalParameter4fARB;
+  glProgramLocalParameter4fvARB: TglProgramLocalParameter4fvARB;
+  glGetProgramEnvParameterdvARB: TglGetProgramEnvParameterdvARB;
+  glGetProgramEnvParameterfvARB: TglGetProgramEnvParameterfvARB;
+  glGetProgramLocalParameterdvARB: TglGetProgramLocalParameterdvARB;
+  glGetProgramLocalParameterfvARB: TglGetProgramLocalParameterfvARB;
+  glGetProgramivARB: TglGetProgramivARB;
+  glGetProgramStringARB: TglGetProgramStringARB;
+  glGetVertexAttribdvARB: TglGetVertexAttribdvARB;
+  glGetVertexAttribfvARB: TglGetVertexAttribfvARB;
+  glGetVertexAttribivARB: TglGetVertexAttribivARB;
+  glGetVertexAttribPointervARB: TglGetVertexAttribPointervARB;
+  glIsProgramARB: TglIsProgramARB;
+
+  // GL_ARB_window_pos
+  glWindowPos2dARB: TglWindowPos2dARB;
+  glWindowPos2dvARB: TglWindowPos2dvARB;
+  glWindowPos2fARB: TglWindowPos2fARB;
+  glWindowPos2fvARB: TglWindowPos2fvARB;
+  glWindowPos2iARB: TglWindowPos2iARB;
+  glWindowPos2ivARB: TglWindowPos2ivARB;
+  glWindowPos2sARB: TglWindowPos2sARB;
+  glWindowPos2svARB: TglWindowPos2svARB;
+  glWindowPos3dARB: TglWindowPos3dARB;
+  glWindowPos3dvARB: TglWindowPos3dvARB;
+  glWindowPos3fARB: TglWindowPos3fARB;
+  glWindowPos3fvARB: TglWindowPos3fvARB;
+  glWindowPos3iARB: TglWindowPos3iARB;
+  glWindowPos3ivARB: TglWindowPos3ivARB;
+  glWindowPos3sARB: TglWindowPos3sARB;
+  glWindowPos3svARB: TglWindowPos3svARB;
+
+  // GL_ARB_draw_buffers
+  glDrawBuffersARB: TglDrawBuffersARB;
+
+  // GL_ARB_color_buffer_float
+  glClampColorARB: TglClampColorARB;
+
+  // GL_ARB_vertex_shader
+  glGetActiveAttribARB: TglGetActiveAttribARB;
+  glGetAttribLocationARB: TglGetAttribLocationARB;
+  glBindAttribLocationARB: TglBindAttribLocationARB;
+
+  // GL_ARB_shader_objects
+  glDeleteObjectARB: TglDeleteObjectARB;
+  glGetHandleARB: TglGetHandleARB;
+  glDetachObjectARB: TglDetachObjectARB;
+  glCreateShaderObjectARB: TglCreateShaderObjectARB;
+  glShaderSourceARB: TglShaderSourceARB;
+  glCompileShaderARB: TglCompileShaderARB;
+  glCreateProgramObjectARB: TglCreateProgramObjectARB;
+  glAttachObjectARB: TglAttachObjectARB;
+  glLinkProgramARB: TglLinkProgramARB;
+  glUseProgramObjectARB: TglUseProgramObjectARB;
+  glValidateProgramARB: TglValidateProgramARB;
+  glUniform1fARB: TglUniform1fARB;
+  glUniform2fARB: TglUniform2fARB;
+  glUniform3fARB: TglUniform3fARB;
+  glUniform4fARB: TglUniform4fARB;
+  glUniform1iARB: TglUniform1iARB;
+  glUniform2iARB: TglUniform2iARB;
+  glUniform3iARB: TglUniform3iARB;
+  glUniform4iARB: TglUniform4iARB;
+  glUniform1fvARB: TglUniform1fvARB;
+  glUniform2fvARB: TglUniform2fvARB;
+  glUniform3fvARB: TglUniform3fvARB;
+  glUniform4fvARB: TglUniform4fvARB;
+  glUniform1ivARB: TglUniform1ivARB;
+  glUniform2ivARB: TglUniform2ivARB;
+  glUniform3ivARB: TglUniform3ivARB;
+  glUniform4ivARB: TglUniform4ivARB;
+  glUniformMatrix2fvARB: TglUniformMatrix2fvARB;
+  glUniformMatrix3fvARB: TglUniformMatrix3fvARB;
+  glUniformMatrix4fvARB: TglUniformMatrix4fvARB;
+  glGetObjectParameterfvARB: TglGetObjectParameterfvARB;
+  glGetObjectParameterivARB: TglGetObjectParameterivARB;
+  glGetInfoLogARB: TglGetInfoLogARB;
+  glGetAttachedObjectsARB: TglGetAttachedObjectsARB;
+  glGetUniformLocationARB: TglGetUniformLocationARB;
+  glGetActiveUniformARB: TglGetActiveUniformARB;
+  glGetUniformfvARB: TglGetUniformfvARB;
+  glGetUniformivARB: TglGetUniformivARB;
+  glGetShaderSourceARB: TglGetShaderSourceARB;
+
+  // GL_ARB_Occlusion_Query
+  glGenQueriesARB: TglGenQueriesARB;
+  glDeleteQueriesARB: TglDeleteQueriesARB;
+  glIsQueryARB: TglIsQueryARB;
+  glBeginQueryARB: TglBeginQueryARB;
+  glEndQueryARB: TglEndQueryARB;
+  glGetQueryivARB: TglGetQueryivARB;
+  glGetQueryObjectivARB: TglGetQueryObjectivARB;
+  glGetQueryObjectuivARB: TglGetQueryObjectuivARB;
+
+  // GL_ARB_draw_instanced
+  glDrawArraysInstancedARB: TglDrawArraysInstancedARB;
+  glDrawElementsInstancedARB: TglDrawElementsInstancedARB;
+
+  // GL_ARB_framebuffer_object
+  glIsRenderbuffer: TglIsRenderbuffer;
+  glBindRenderbuffer: TglBindRenderbuffer;
+  glDeleteRenderbuffers: TglDeleteRenderbuffers;
+  glGenRenderbuffers: TglGenRenderbuffers;
+  glRenderbufferStorage: TglRenderbufferStorage;
+  glGetRenderbufferParameteriv: TglGetRenderbufferParameteriv;
+  glIsFramebuffer: TglIsFramebuffer;
+  glBindFramebuffer: TglBindFramebuffer;
+  glDeleteFramebuffers: TglDeleteFramebuffers;
+  glGenFramebuffers: TglGenFramebuffers;
+  glCheckFramebufferStatus: TglCheckFramebufferStatus;
+  glFramebufferTexture1D: TglFramebufferTexture1D;
+  glFramebufferTexture2D: TglFramebufferTexture2D;
+  glFramebufferTexture3D: TglFramebufferTexture3D;
+  glFramebufferRenderbuffer: TglFramebufferRenderbuffer;
+  glGetFramebufferAttachmentParameteriv: TglGetFramebufferAttachmentParameteriv;
+  glGenerateMipmap: TglGenerateMipmap;
+  glBlitFramebuffer: TglBlitFramebuffer;
+  glRenderbufferStorageMultisample: TglRenderbufferStorageMultisample;
+  glFramebufferTextureLayer: TglFramebufferTextureLayer;
+
+  // GL_ARB_geometry_shader4
+  glProgramParameteriARB: TglProgramParameteriARB;
+  glFramebufferTextureARB: TglFramebufferTextureARB;
+  glFramebufferTextureLayerARB: TglFramebufferTextureLayerARB;
+  glFramebufferTextureFaceARB: TglFramebufferTextureFaceARB;
+
+  // GL_ARB_instanced_arrays
+  glVertexAttribDivisorARB: TglVertexAttribDivisorARB;
+
+  // GL_ARB_map_buffer_range
+  glMapBufferRange: TglMapBufferRange;
+  glFlushMappedBufferRange: TglFlushMappedBufferRange;
+
+  // GL_ARB_texture_buffer_object
+  glTexBufferARB: TglTexBufferARB;
+
+  // GL_ARB_vertex_array_object
+  glBindVertexArray: TglBindVertexArray;
+  glDeleteVertexArrays: TglDeleteVertexArrays;
+  glGenVertexArrays: TglGenVertexArrays;
+  glIsVertexArray: TglIsVertexArray;
+
+  // GL_ARB_uniform_buffer_object
+  glGetUniformIndices: TglGetUniformIndices;
+  glGetActiveUniformsiv: TglGetActiveUniformsiv;
+  glGetActiveUniformName: TglGetActiveUniformName;
+  glGetUniformBlockIndex: TglGetUniformBlockIndex;
+  glGetActiveUniformBlockiv: TglGetActiveUniformBlockiv;
+  glGetActiveUniformBlockName: TglGetActiveUniformBlockName;
+  glUniformBlockBinding: TglUniformBlockBinding;
+
+  // GL_ARB_copy_buffer
+  glCopyBufferSubData: TglCopyBufferSubData;
+
+  // GL_ARB_draw_elements_base_vertex
+  glDrawElementsBaseVertex: TglDrawElementsBaseVertex;
+  glDrawRangeElementsBaseVertex: TglDrawRangeElementsBaseVertex;
+  glDrawElementsInstancedBaseVertex: TglDrawElementsInstancedBaseVertex;
+  glMultiDrawElementsBaseVertex: TglMultiDrawElementsBaseVertex;
+
+  // GL_ARB_provoking_vertex
+  glProvokingVertex: TglProvokingVertex;
+
+  // GL_ARB_sync
+  glFenceSync: TglFenceSync;
+  glIsSync: TglIsSync;
+  glDeleteSync: TglDeleteSync;
+  glClientWaitSync: TglClientWaitSync;
+  glWaitSync: TglWaitSync;
+  glGetInteger64v: TglGetInteger64v;
+  glGetSynciv: TglGetSynciv;
+
+  // GL_ARB_texture_multisample
+  glTexImage2DMultisample: TglTexImage2DMultisample;
+  glTexImage3DMultisample: TglTexImage3DMultisample;
+  glGetMultisamplefv: TglGetMultisamplefv;
+  glSampleMaski: TglSampleMaski;
+
+  // GL_ARB_draw_buffers_blend
+  glBlendEquationiARB: TglBlendEquationiARB;
+  glBlendEquationSeparateiARB: TglBlendEquationSeparateiARB;
+  glBlendFunciARB: TglBlendFunciARB;
+  glBlendFuncSeparateiARB: TglBlendFuncSeparateiARB;
+
+  // GL_ARB_sample_shading
+  glMinSampleShadingARB: TglMinSampleShadingARB;
+
+  // GL_ARB_shading_language_include
+  glNamedStringARB: TglNamedStringARB;
+  glDeleteNamedStringARB: TglDeleteNamedStringARB;
+  glCompileShaderIncludeARB: TglCompileShaderIncludeARB;
+  glIsNamedStringARB: TglIsNamedStringARB;
+  glGetNamedStringARB: TglGetNamedStringARB;
+  glGetNamedStringivARB: TglGetNamedStringivARB;
+
+  // GL_ARB_blend_func_extended
+  glBindFragDataLocationIndexed: TglBindFragDataLocationIndexed;
+  glGetFragDataIndex: TglGetFragDataIndex;
+
+  // GL_ARB_sampler_objects
+  glGenSamplers: TglGenSamplers;
+  glDeleteSamplers: TglDeleteSamplers;
+  glIsSampler: TglIsSampler;
+  glBindSampler: TglBindSampler;
+  glSamplerParameteri: TglSamplerParameteri;
+  glSamplerParameteriv: TglSamplerParameteriv;
+  glSamplerParameterf: TglSamplerParameterf;
+  glSamplerParameterfv: TglSamplerParameterfv;
+  glSamplerParameterIiv: TglSamplerParameterIiv;
+  glSamplerParameterIuiv: TglSamplerParameterIuiv;
+  glGetSamplerParameteriv: TglGetSamplerParameteriv;
+  glGetSamplerParameterIiv: TglGetSamplerParameterIiv;
+  glGetSamplerParameterfv: TglGetSamplerParameterfv;
+  glGetSamplerParameterIuiv: TglGetSamplerParameterIuiv;
+
+  // GL_ARB_timer_query
+  glQueryCounter: TglQueryCounter;
+  glGetQueryObjecti64v: TglGetQueryObjecti64v;
+  glGetQueryObjectui64v: TglGetQueryObjectui64v;
+
+  // GL_ARB_vertex_type_2_10_10_10_rev
+  glVertexP2ui: TglVertexP2ui;
+  glVertexP2uiv: TglVertexP2uiv;
+  glVertexP3ui: TglVertexP3ui;
+  glVertexP3uiv: TglVertexP3uiv;
+  glVertexP4ui: TglVertexP4ui;
+  glVertexP4uiv: TglVertexP4uiv;
+  glTexCoordP1ui: TglTexCoordP1ui;
+  glTexCoordP1uiv: TglTexCoordP1uiv;
+  glTexCoordP2ui: TglTexCoordP2ui;
+  glTexCoordP2uiv: TglTexCoordP2uiv;
+  glTexCoordP3ui: TglTexCoordP3ui;
+  glTexCoordP3uiv: TglTexCoordP3uiv;
+  glTexCoordP4ui: TglTexCoordP4ui;
+  glTexCoordP4uiv: TglTexCoordP4uiv;
+  glMultiTexCoordP1ui: TglMultiTexCoordP1ui;
+  glMultiTexCoordP1uiv: TglMultiTexCoordP1uiv;
+  glMultiTexCoordP2ui: TglMultiTexCoordP2ui;
+  glMultiTexCoordP2uiv: TglMultiTexCoordP2uiv;
+  glMultiTexCoordP3ui: TglMultiTexCoordP3ui;
+  glMultiTexCoordP3uiv: TglMultiTexCoordP3uiv;
+  glMultiTexCoordP4ui: TglMultiTexCoordP4ui;
+  glMultiTexCoordP4uiv: TglMultiTexCoordP4uiv;
+  glNormalP3ui: TglNormalP3ui;
+  glNormalP3uiv: TglNormalP3uiv;
+  glColorP3ui: TglColorP3ui;
+  glColorP3uiv: TglColorP3uiv;
+  glColorP4ui: TglColorP4ui;
+  glColorP4uiv: TglColorP4uiv;
+  glSecondaryColorP3ui: TglSecondaryColorP3ui;
+  glSecondaryColorP3uiv: TglSecondaryColorP3uiv;
+  glVertexAttribP1ui: TglVertexAttribP1ui;
+  glVertexAttribP1uiv: TglVertexAttribP1uiv;
+  glVertexAttribP2ui: TglVertexAttribP2ui;
+  glVertexAttribP2uiv: TglVertexAttribP2uiv;
+  glVertexAttribP3ui: TglVertexAttribP3ui;
+  glVertexAttribP3uiv: TglVertexAttribP3uiv;
+  glVertexAttribP4ui: TglVertexAttribP4ui;
+  glVertexAttribP4uiv: TglVertexAttribP4uiv;
+
+  // GL_ARB_draw_indirect
+  glDrawArraysIndirect: TglDrawArraysIndirect;
+  glDrawElementsIndirect: TglDrawElementsIndirect;
+
+  // GL_ARB_gpu_shader_fp64
+  glUniform1d: TglUniform1d;
+  glUniform2d: TglUniform2d;
+  glUniform3d: TglUniform3d;
+  glUniform4d: TglUniform4d;
+  glUniform1dv: TglUniform1dv;
+  glUniform2dv: TglUniform2dv;
+  glUniform3dv: TglUniform3dv;
+  glUniform4dv: TglUniform4dv;
+  glUniformMatrix2dv: TglUniformMatrix2dv;
+  glUniformMatrix3dv: TglUniformMatrix3dv;
+  glUniformMatrix4dv: TglUniformMatrix4dv;
+  glUniformMatrix2x3dv: TglUniformMatrix2x3dv;
+  glUniformMatrix2x4dv: TglUniformMatrix2x4dv;
+  glUniformMatrix3x2dv: TglUniformMatrix3x2dv;
+  glUniformMatrix3x4dv: TglUniformMatrix3x4dv;
+  glUniformMatrix4x2dv: TglUniformMatrix4x2dv;
+  glUniformMatrix4x3dv: TglUniformMatrix4x3dv;
+  glGetUniformdv: TglGetUniformdv;
+
+  // GL_ARB_shader_subroutine
+  glGetSubroutineUniformLocation: TglGetSubroutineUniformLocation;
+  glGetSubroutineIndex: TglGetSubroutineIndex;
+  glGetActiveSubroutineUniformiv: TglGetActiveSubroutineUniformiv;
+  glGetActiveSubroutineUniformName: TglGetActiveSubroutineUniformName;
+  glGetActiveSubroutineName: TglGetActiveSubroutineName;
+  glUniformSubroutinesuiv: TglUniformSubroutinesuiv;
+  glGetUniformSubroutineuiv: TglGetUniformSubroutineuiv;
+  glGetProgramStageiv: TglGetProgramStageiv;
+
+  // GL_ARB_tessellation_shader
+  glPatchParameteri: TglPatchParameteri;
+  glPatchParameterfv: TglPatchParameterfv;
+
+  // GL_ARB_transform_feedback2
+  glBindTransformFeedback: TglBindTransformFeedback;
+  glDeleteTransformFeedbacks: TglDeleteTransformFeedbacks;
+  glGenTransformFeedbacks: TglGenTransformFeedbacks;
+  glIsTransformFeedback: TglIsTransformFeedback;
+  glPauseTransformFeedback: TglPauseTransformFeedback;
+  glResumeTransformFeedback: TglResumeTransformFeedback;
+  glDrawTransformFeedback: TglDrawTransformFeedback;
+
+  // GL_ARB_transform_feedback3
+  glDrawTransformFeedbackStream: TglDrawTransformFeedbackStream;
+  glBeginQueryIndexed: TglBeginQueryIndexed;
+  glEndQueryIndexed: TglEndQueryIndexed;
+  glGetQueryIndexediv: TglGetQueryIndexediv;
+
+  // GL_ARB_ES2_compatibility
+  glReleaseShaderCompiler: TglReleaseShaderCompiler;
+  glShaderBinary: TglShaderBinary;
+  glGetShaderPrecisionFormat: TglGetShaderPrecisionFormat;
+  glDepthRangef: TglDepthRangef;
+  glClearDepthf: TglClearDepthf;
+
+  // GL_ARB_get_program_binary
+  glGetProgramBinary: TglGetProgramBinary;
+  glProgramBinary: TglProgramBinary;
+  glProgramParameteri: TglProgramParameteri;
+  
+  // GL_ARB_separate_shader_objects
+  glUseProgramStages: TglUseProgramStages;
+  glActiveShaderProgram: TglActiveShaderProgram;
+  glCreateShaderProgramv: TglCreateShaderProgramv;
+  glBindProgramPipeline: TglBindProgramPipeline;
+  glDeleteProgramPipelines: TglDeleteProgramPipelines;
+  glGenProgramPipelines: TglGenProgramPipelines;
+  glIsProgramPipeline: TglIsProgramPipeline;
+  glGetProgramPipelineiv: TglGetProgramPipelineiv;
+  glProgramUniform1i: TglProgramUniform1i;
+  glProgramUniform1iv: TglProgramUniform1iv;
+  glProgramUniform1f: TglProgramUniform1f;
+  glProgramUniform1fv: TglProgramUniform1fv;
+  glProgramUniform1d: TglProgramUniform1d;
+  glProgramUniform1dv: TglProgramUniform1dv;
+  glProgramUniform1ui: TglProgramUniform1ui;
+  glProgramUniform1uiv: TglProgramUniform1uiv;
+  glProgramUniform2i: TglProgramUniform2i;
+  glProgramUniform2iv: TglProgramUniform2iv;
+  glProgramUniform2f: TglProgramUniform2f;
+  glProgramUniform2fv: TglProgramUniform2fv;
+  glProgramUniform2d: TglProgramUniform2d;
+  glProgramUniform2dv: TglProgramUniform2dv;
+  glProgramUniform2ui: TglProgramUniform2ui;
+  glProgramUniform2uiv: TglProgramUniform2uiv;
+  glProgramUniform3i: TglProgramUniform3i;
+  glProgramUniform3iv: TglProgramUniform3iv;
+  glProgramUniform3f: TglProgramUniform3f;
+  glProgramUniform3fv: TglProgramUniform3fv;
+  glProgramUniform3d: TglProgramUniform3d;
+  glProgramUniform3dv: TglProgramUniform3dv;
+  glProgramUniform3ui: TglProgramUniform3ui;
+  glProgramUniform3uiv: TglProgramUniform3uiv;
+  glProgramUniform4i: TglProgramUniform4i;
+  glProgramUniform4iv: TglProgramUniform4iv;
+  glProgramUniform4f: TglProgramUniform4f;
+  glProgramUniform4fv: TglProgramUniform4fv;
+  glProgramUniform4d: TglProgramUniform4d;
+  glProgramUniform4dv: TglProgramUniform4dv;
+  glProgramUniform4ui: TglProgramUniform4ui;
+  glProgramUniform4uiv: TglProgramUniform4uiv;
+  glProgramUniformMatrix2fv: TglProgramUniformMatrix2fv;
+  glProgramUniformMatrix3fv: TglProgramUniformMatrix3fv;
+  glProgramUniformMatrix4fv: TglProgramUniformMatrix4fv;
+  glProgramUniformMatrix2dv: TglProgramUniformMatrix2dv;
+  glProgramUniformMatrix3dv: TglProgramUniformMatrix3dv;
+  glProgramUniformMatrix4dv: TglProgramUniformMatrix4dv;
+  glProgramUniformMatrix2x3fv: TglProgramUniformMatrix2x3fv;
+  glProgramUniformMatrix3x2fv: TglProgramUniformMatrix3x2fv;
+  glProgramUniformMatrix2x4fv: TglProgramUniformMatrix2x4fv;
+  glProgramUniformMatrix4x2fv: TglProgramUniformMatrix4x2fv;
+  glProgramUniformMatrix3x4fv: TglProgramUniformMatrix3x4fv;
+  glProgramUniformMatrix4x3fv: TglProgramUniformMatrix4x3fv;
+  glProgramUniformMatrix2x3dv: TglProgramUniformMatrix2x3dv;
+  glProgramUniformMatrix3x2dv: TglProgramUniformMatrix3x2dv;
+  glProgramUniformMatrix2x4dv: TglProgramUniformMatrix2x4dv;
+  glProgramUniformMatrix4x2dv: TglProgramUniformMatrix4x2dv;
+  glProgramUniformMatrix3x4dv: TglProgramUniformMatrix3x4dv;
+  glProgramUniformMatrix4x3dv: TglProgramUniformMatrix4x3dv;
+  glValidateProgramPipeline: TglValidateProgramPipeline;
+  glGetProgramPipelineInfoLog: TglGetProgramPipelineInfoLog;
+
+  // GL_ARB_vertex_attrib_64bit
+  glVertexAttribL1d: TglVertexAttribL1d;
+  glVertexAttribL2d: TglVertexAttribL2d;
+  glVertexAttribL3d: TglVertexAttribL3d;
+  glVertexAttribL4d: TglVertexAttribL4d;
+  glVertexAttribL1dv: TglVertexAttribL1dv;
+  glVertexAttribL2dv: TglVertexAttribL2dv;
+  glVertexAttribL3dv: TglVertexAttribL3dv;
+  glVertexAttribL4dv: TglVertexAttribL4dv;
+  glVertexAttribLPointer: TglVertexAttribLPointer;
+  glGetVertexAttribLdv: TglGetVertexAttribLdv;
+
+  // GL_ARB_viewport_array
+  glViewportArrayv: TglViewportArrayv;
+  glViewportIndexedf: TglViewportIndexedf;
+  glViewportIndexedfv: TglViewportIndexedfv;
+  glScissorArrayv: TglScissorArrayv;
+  glScissorIndexed: TglScissorIndexed;
+  glScissorIndexedv: TglScissorIndexedv;
+  glDepthRangeArrayv: TglDepthRangeArrayv;
+  glDepthRangeIndexed: TglDepthRangeIndexed;
+  glGetFloati_v: TglGetFloati_v;
+  glGetDoublei_v: TglGetDoublei_v;
+
+  // GL 4.2
+
+  // GL_ARB_base_instance
+  glDrawArraysInstancedBaseInstance : TglDrawArraysInstancedBaseInstance;
+  glDrawElementsInstancedBaseInstance : TglDrawElementsInstancedBaseInstance;
+  glDrawElementsInstancedBaseVertexBaseInstance : TglDrawElementsInstancedBaseVertexBaseInstance;
+
+  // GL_ARB_transform_feedback_instanced
+  glDrawTransformFeedbackInstanced : TglDrawTransformFeedbackInstanced;
+  glDrawTransformFeedbackStreamInstanced : TglDrawTransformFeedbackStreamInstanced;
+
+  // GL_ARB_internalformat_query
+  glGetInternalformativ : TglGetInternalformativ;
+
+  // GL_ARB_shader_atomic_counters
+  glGetActiveAtomicCounterBufferiv : TglGetActiveAtomicCounterBufferiv;
+
+  /// GL_ARB_shader_image_load_store
+  glBindImageTexture : TglBindImageTexture;
+  glMemoryBarrier : TglMemoryBarrier;
+
+  // GL_ARB_texture_storage
+  glTexStorage1D : TglTexStorage1D;
+  glTexStorage2D : TglTexStorage2D;
+  glTexStorage3D : TglTexStorage3D;
+  glTextureStorage1DEXT : TglTextureStorage1DEXT;
+  glTextureStorage2DEXT : TglTextureStorage2DEXT;
+  glTextureStorage3DEXT : TglTextureStorage3DEXT;
+
+
+  // GL 4.3
+    // GL_KHR_debug
+    glDebugMessageControl : TglDebugMessageControl;
+    glDebugMessageInsert : TglDebugMessageInsert;
+    glDebugMessageCallback : TglDebugMessageCallback;
+    glGetDebugMessageLog : TglGetDebugMessageLog;
+    glPushDebugGroup : TglPushDebugGroup;
+    glPopDebugGroup : TglPopDebugGroup;
+    glObjectLabel : TglObjectLabel;
+    glGetObjectLabel : TglGetObjectLabel;
+    glObjectPtrLabel : TglObjectPtrLabel;
+    glGetObjectPtrLabel : TglGetObjectPtrLabel;
+    // GL_ARB_clear_buffer_object
+    glClearBufferData : TglClearBufferData;
+    glClearBufferSubData : TglClearBufferSubData;
+    glClearNamedBufferDataEXT : TglClearNamedBufferDataEXT;
+    glClearNamedBufferSubDataEXT : TglClearNamedBufferSubDataEXT;
+    // GL_ARB_compute_shader
+    glDispatchCompute : TglDispatchCompute;
+    glDispatchComputeIndirect : TglDispatchComputeIndirect;
+    // GL_ARB_copy_image
+    glCopyImageSubData : TglCopyImageSubData;
+    // GL_ARB_framebuffer_no_attachments
+    glFramebufferParameteri : TglFramebufferParameteri;
+    glGetFramebufferParameteriv : TglGetFramebufferParameteriv;
+    glNamedFramebufferParameteriEXT : TglNamedFramebufferParameteriEXT;
+    glGetNamedFramebufferParameterivEXT : TglGetNamedFramebufferParameterivEXT;
+    // GL_ARB_internalformat_query2
+    glGetInternalformati64v : TglGetInternalformati64v;
+    // GL_ARB_invalidate_subdata
+    glInvalidateTexSubImage : TglInvalidateTexSubImage;
+    glInvalidateTexImage : TglInvalidateTexImage;
+    glInvalidateBufferSubData : TglInvalidateBufferSubData;
+    glInvalidateBufferData : TglInvalidateBufferData;
+    glInvalidateFramebuffer : TglInvalidateFramebuffer;
+    glInvalidateSubFramebuffer : TglInvalidateSubFramebuffer;
+    // GL_ARB_multi_draw_indirect
+    glMultiDrawArraysIndirect : TglMultiDrawArraysIndirect;
+    glMultiDrawElementsIndirect : TglMultiDrawElementsIndirect;
+    // GL_ARB_program_interface_query
+    glGetProgramInterfaceiv : TglGetProgramInterfaceiv;
+    glGetProgramResourceIndex : TglGetProgramResourceIndex;
+    glGetProgramResourceName : TglGetProgramResourceName;
+    glGetProgramResourceiv : TglGetProgramResourceiv;
+    glGetProgramResourceLocation : TglGetProgramResourceLocation;
+    glGetProgramResourceLocationIndex : TglGetProgramResourceLocationIndex;
+    // GL_ARB_shader_storage_buffer_object
+    glShaderStorageBlockBinding : TglShaderStorageBlockBinding;
+    // GL_ARB_texture_buffer_range
+    glTexBufferRange : TglTexBufferRange;
+    glTextureBufferRangeEXT : TglTextureBufferRangeEXT;
+    // GL_ARB_texture_storage_multisample
+    glTexStorage2DMultisample : TglTexStorage2DMultisample;
+    glTexStorage3DMultisample : TglTexStorage3DMultisample;
+    glTextureStorage2DMultisampleEXT : TglTextureStorage2DMultisampleEXT;
+    glTextureStorage3DMultisampleEXT : TglTextureStorage3DMultisampleEXT;
+    // GL_ARB_texture_view
+    glTextureView : TglTextureView;
+    // GL_ARB_vertex_attrib_binding
+    glBindVertexBuffer : TglBindVertexBuffer;
+    glVertexAttribFormat : TglVertexAttribFormat;
+    glVertexAttribIFormat : TglVertexAttribIFormat;
+    glVertexAttribLFormat : TglVertexAttribLFormat;
+    glVertexAttribBinding : TglVertexAttribBinding;
+    glVertexBindingDivisor : TglVertexBindingDivisor;
+    glVertexArrayBindVertexBufferEXT : TglVertexArrayBindVertexBufferEXT;
+    glVertexArrayVertexAttribFormatEXT : TglVertexArrayVertexAttribFormatEXT;
+    glVertexArrayVertexAttribIFormatEXT : TglVertexArrayVertexAttribIFormatEXT;
+    glVertexArrayVertexAttribLFormatEXT : TglVertexArrayVertexAttribLFormatEXT;
+    glVertexArrayVertexAttribBindingEXT : TglVertexArrayVertexAttribBindingEXT;
+    glVertexArrayVertexBindingDivisorEXT : TglVertexArrayVertexBindingDivisorEXT;
+  // END GL 4.3
+
+
+  // GL 4.4
+    glBufferStorage : TglBufferStorage;
+    glClearTexImage : TglClearTexImage;
+    glClearTexSubImage : TglClearTexSubImage;
+    glBindBuffersBase : TglBindBuffersBase;
+    glBindBuffersRange : TglBindBuffersRange;
+    glBindTextures : TglBindTextures;
+    glBindSamplers : TglBindSamplers;
+    glBindImageTextures : TglBindImageTextures;
+    glBindVertexBuffers : TglBindVertexBuffers;
+  // END GL 4.4
+
+
+  // GL_ARB_cl_event
+  glCreateSyncFromCLeventARB: TglCreateSyncFromCLeventARB;
+
+  // GL_ARB_debug_output
+  glDebugMessageControlARB: TglDebugMessageControlARB;
+  glDebugMessageInsertARB: TglDebugMessageInsertARB;
+  glDebugMessageCallbackARB: TglDebugMessageCallbackARB;
+  glGetDebugMessageLogARB: TglGetDebugMessageLogARB;
+
+  // GL_ARB_robustness
+  glGetGraphicsResetStatusARB: TglGetGraphicsResetStatusARB;
+  glGetnMapdvARB: TglGetnMapdvARB;
+  glGetnMapfvARB: TglGetnMapfvARB;
+  glGetnMapivARB: TglGetnMapivARB;
+  glGetnPixelMapfvARB: TglGetnPixelMapfvARB;
+  glGetnPixelMapuivARB: TglGetnPixelMapuivARB;
+  glGetnPixelMapusvARB: TglGetnPixelMapusvARB;
+  glGetnPolygonStippleARB: TglGetnPolygonStippleARB;
+  glGetnColorTableARB: TglGetnColorTableARB;
+  glGetnConvolutionFilterARB: TglGetnConvolutionFilterARB;
+  glGetnSeparableFilterARB: TglGetnSeparableFilterARB;
+  glGetnHistogramARB: TglGetnHistogramARB;
+  glGetnMinmaxARB: TglGetnMinmaxARB;
+  glGetnTexImageARB: TglGetnTexImageARB;
+  glReadnPixelsARB: TglReadnPixelsARB;
+  glGetnCompressedTexImageARB: TglGetnCompressedTexImageARB;
+  glGetnUniformfvARB: TglGetnUniformfvARB;
+  glGetnUniformivARB: TglGetnUniformivARB;
+  glGetnUniformuivARB: TglGetnUniformuivARB;
+  glGetnUniformdvARB: TglGetnUniformdvARB;
+
+  // GL_ATI_draw_buffers
+  glDrawBuffersATI: TglDrawBuffersATI;
+
+  // GL_ATI_element_array
+  glElementPointerATI: TglElementPointerATI;
+  glDrawElementArrayATI: TglDrawElementArrayATI;
+  glDrawRangeElementArrayATI: TglDrawRangeElementArrayATI;
+
+  // GL_ATI_envmap_bumpmap
+  glTexBumpParameterivATI: TglTexBumpParameterivATI;
+  glTexBumpParameterfvATI: TglTexBumpParameterfvATI;
+  glGetTexBumpParameterivATI: TglGetTexBumpParameterivATI;
+  glGetTexBumpParameterfvATI: TglGetTexBumpParameterfvATI;
+
+  // GL_ATI_fragment_shader
+  glGenFragmentShadersATI: TglGenFragmentShadersATI;
+  glBindFragmentShaderATI: TglBindFragmentShaderATI;
+  glDeleteFragmentShaderATI: TglDeleteFragmentShaderATI;
+  glBeginFragmentShaderATI: TglBeginFragmentShaderATI;
+  glEndFragmentShaderATI: TglEndFragmentShaderATI;
+  glPassTexCoordATI: TglPassTexCoordATI;
+  glSampleMapATI: TglSampleMapATI;
+  glColorFragmentOp1ATI: TglColorFragmentOp1ATI;
+  glColorFragmentOp2ATI: TglColorFragmentOp2ATI;
+  glColorFragmentOp3ATI: TglColorFragmentOp3ATI;
+  glAlphaFragmentOp1ATI: TglAlphaFragmentOp1ATI;
+  glAlphaFragmentOp2ATI: TglAlphaFragmentOp2ATI;
+  glAlphaFragmentOp3ATI: TglAlphaFragmentOp3ATI;
+  glSetFragmentShaderConstantATI: TglSetFragmentShaderConstantATI;
+
+  // GL_ATI_map_object_buffer
+  glMapObjectBufferATI: TglMapObjectBufferATI;
+  glUnmapObjectBufferATI: TglUnmapObjectBufferATI;
+
+  // GL_ATI_pn_triangles
+  glPNTrianglesiATI: TglPNTrianglesiATI;
+  glPNTrianglesfATI: TglPNTrianglesfATI;
+
+  // GL_ATI_separate_stencil
+  glStencilOpSeparateATI: TglStencilOpSeparateATI;
+  glStencilFuncSeparateATI: TglStencilFuncSeparateATI;
+
+  // GL_ATI_vertex_array_object
+  glNewObjectBufferATI: TglNewObjectBufferATI;
+  glIsObjectBufferATI: TglIsObjectBufferATI;
+  glUpdateObjectBufferATI: TglUpdateObjectBufferATI;
+  glGetObjectBufferfvATI: TglGetObjectBufferfvATI;
+  glGetObjectBufferivATI: TglGetObjectBufferivATI;
+  glFreeObjectBufferATI: TglFreeObjectBufferATI;
+  glArrayObjectATI: TglArrayObjectATI;
+  glGetArrayObjectfvATI: TglGetArrayObjectfvATI;
+  glGetArrayObjectivATI: TglGetArrayObjectivATI;
+  glVariantArrayObjectATI: TglVariantArrayObjectATI;
+  glGetVariantArrayObjectfvATI: TglGetVariantArrayObjectfvATI;
+  glGetVariantArrayObjectivATI: TglGetVariantArrayObjectivATI;
+  glVertexAttribArrayObjectATI: TglVertexAttribArrayObjectATI;
+  glGetVertexAttribArrayObjectfvATI: TglGetVertexAttribArrayObjectfvATI;
+  glGetVertexAttribArrayObjectivATI: TglGetVertexAttribArrayObjectivATI;
+
+  // GL_ATI_vertex_streams
+  glVertexStream1sATI: TglVertexStream1sATI;
+  glVertexStream1svATI: TglVertexStream1svATI;
+  glVertexStream1iATI: TglVertexStream1iATI;
+  glVertexStream1ivATI: TglVertexStream1ivATI;
+  glVertexStream1fATI: TglVertexStream1fATI;
+  glVertexStream1fvATI: TglVertexStream1fvATI;
+  glVertexStream1dATI: TglVertexStream1dATI;
+  glVertexStream1dvATI: TglVertexStream1dvATI;
+  glVertexStream2sATI: TglVertexStream2sATI;
+  glVertexStream2svATI: TglVertexStream2svATI;
+  glVertexStream2iATI: TglVertexStream2iATI;
+  glVertexStream2ivATI: TglVertexStream2ivATI;
+  glVertexStream2fATI: TglVertexStream2fATI;
+  glVertexStream2fvATI: TglVertexStream2fvATI;
+  glVertexStream2dATI: TglVertexStream2dATI;
+  glVertexStream2dvATI: TglVertexStream2dvATI;
+  glVertexStream3sATI: TglVertexStream3sATI;
+  glVertexStream3svATI: TglVertexStream3svATI;
+  glVertexStream3iATI: TglVertexStream3iATI;
+  glVertexStream3ivATI: TglVertexStream3ivATI;
+  glVertexStream3fATI: TglVertexStream3fATI;
+  glVertexStream3fvATI: TglVertexStream3fvATI;
+  glVertexStream3dATI: TglVertexStream3dATI;
+  glVertexStream3dvATI: TglVertexStream3dvATI;
+  glVertexStream4sATI: TglVertexStream4sATI;
+  glVertexStream4svATI: TglVertexStream4svATI;
+  glVertexStream4iATI: TglVertexStream4iATI;
+  glVertexStream4ivATI: TglVertexStream4ivATI;
+  glVertexStream4fATI: TglVertexStream4fATI;
+  glVertexStream4fvATI: TglVertexStream4fvATI;
+  glVertexStream4dATI: TglVertexStream4dATI;
+  glVertexStream4dvATI: TglVertexStream4dvATI;
+  glNormalStream3bATI: TglNormalStream3bATI;
+  glNormalStream3bvATI: TglNormalStream3bvATI;
+  glNormalStream3sATI: TglNormalStream3sATI;
+  glNormalStream3svATI: TglNormalStream3svATI;
+  glNormalStream3iATI: TglNormalStream3iATI;
+  glNormalStream3ivATI: TglNormalStream3ivATI;
+  glNormalStream3fATI: TglNormalStream3fATI;
+  glNormalStream3fvATI: TglNormalStream3fvATI;
+  glNormalStream3dATI: TglNormalStream3dATI;
+  glNormalStream3dvATI: TglNormalStream3dvATI;
+  glClientActiveVertexStreamATI: TglClientActiveVertexStreamATI;
+  glVertexBlendEnviATI: TglVertexBlendEnviATI;
+  glVertexBlendEnvfATI: TglVertexBlendEnvfATI;
+
+  // GL_AMD_performance_monitor
+  glGetPerfMonitorGroupsAMD: TglGetPerfMonitorGroupsAMD;
+  glGetPerfMonitorCountersAMD: TglGetPerfMonitorCountersAMD;
+  glGetPerfMonitorGroupStringAMD: TglGetPerfMonitorGroupStringAMD;
+  glGetPerfMonitorCounterStringAMD: TglGetPerfMonitorCounterStringAMD;
+  glGetPerfMonitorCounterInfoAMD: TglGetPerfMonitorCounterInfoAMD;
+  glGenPerfMonitorsAMD: TglGenPerfMonitorsAMD;
+  glDeletePerfMonitorsAMD: TglDeletePerfMonitorsAMD;
+  glSelectPerfMonitorCountersAMD: TglSelectPerfMonitorCountersAMD;
+  glBeginPerfMonitorAMD: TglBeginPerfMonitorAMD;
+  glEndPerfMonitorAMD: TglEndPerfMonitorAMD;
+  glGetPerfMonitorCounterDataAMD: TglGetPerfMonitorCounterDataAMD;
+
+  // GL_AMD_vertex_shader_tesselator
+  glTessellationFactorAMD: TglTessellationFactorAMD;
+  glTessellationModeAMD: TglTessellationModeAMD;
+  
+  // GL_AMD_draw_buffers_blend
+  glBlendFuncIndexedAMD: TglBlendFuncIndexedAMD;
+  glBlendFuncSeparateIndexedAMD: TglBlendFuncSeparateIndexedAMD;
+  glBlendEquationIndexedAMD: TglBlendEquationIndexedAMD;
+  glBlendEquationSeparateIndexedAMD: TglBlendEquationSeparateIndexedAMD;
+
+  // GL_AMD_name_gen_delete
+  glGenNamesAMD: TglGenNamesAMD;
+  glDeleteNamesAMD: TglDeleteNamesAMD;
+  glIsNameAMD: TglIsNameAMD;
+
+  // GL_AMD_debug_output
+  glDebugMessageEnableAMD: TglDebugMessageEnableAMD;
+  glDebugMessageInsertAMD: TglDebugMessageInsertAMD;
+  glDebugMessageCallbackAMD: TglDebugMessageCallbackAMD;
+  glGetDebugMessageLogAMD: TglGetDebugMessageLogAMD;
+
+  // GL_EXT_blend_color
+  glBlendColorEXT: TglBlendColorEXT;
+
+  // GL_EXT_blend_func_separate
+  glBlendFuncSeparateEXT: TglBlendFuncSeparateEXT;
+
+  // GL_EXT_blend_minmax
+  glBlendEquationEXT: TglBlendEquationEXT;
+
+  // GL_EXT_color_subtable
+  glColorSubTableEXT: TglColorSubTableEXT;
+  glCopyColorSubTableEXT: TglCopyColorSubTableEXT;
+
+  // GL_EXT_compiled_vertex_array
+  glLockArraysEXT: TglLockArraysEXT;
+  glUnlockArraysEXT: TglUnlockArraysEXT;
+
+  // GL_EXT_convolution
+  glConvolutionFilter1DEXT: TglConvolutionFilter1DEXT;
+  glConvolutionFilter2DEXT: TglConvolutionFilter2DEXT;
+  glConvolutionParameterfEXT: TglConvolutionParameterfEXT;
+  glConvolutionParameterfvEXT: TglConvolutionParameterfvEXT;
+  glConvolutionParameteriEXT: TglConvolutionParameteriEXT;
+  glConvolutionParameterivEXT: TglConvolutionParameterivEXT;
+  glCopyConvolutionFilter1DEXT: TglCopyConvolutionFilter1DEXT;
+  glCopyConvolutionFilter2DEXT: TglCopyConvolutionFilter2DEXT;
+  glGetConvolutionFilterEXT: TglGetConvolutionFilterEXT;
+  glGetConvolutionParameterfvEXT: TglGetConvolutionParameterfvEXT;
+  glGetConvolutionParameterivEXT: TglGetConvolutionParameterivEXT;
+  glGetSeparableFilterEXT: TglGetSeparableFilterEXT;
+  glSeparableFilter2DEXT: TglSeparableFilter2DEXT;
+
+  // GL_EXT_coordinate_frame
+  glTangent3bEXT: TglTangent3bEXT;
+  glTangent3bvEXT: TglTangent3bvEXT;
+  glTangent3dEXT: TglTangent3dEXT;
+  glTangent3dvEXT: TglTangent3dvEXT;
+  glTangent3fEXT: TglTangent3fEXT;
+  glTangent3fvEXT: TglTangent3fvEXT;
+  glTangent3iEXT: TglTangent3iEXT;
+  glTangent3ivEXT: TglTangent3ivEXT;
+  glTangent3sEXT: TglTangent3sEXT;
+  glTangent3svEXT: TglTangent3svEXT;
+  glBinormal3bEXT: TglBinormal3bEXT;
+  glBinormal3bvEXT: TglBinormal3bvEXT;
+  glBinormal3dEXT: TglBinormal3dEXT;
+  glBinormal3dvEXT: TglBinormal3dvEXT;
+  glBinormal3fEXT: TglBinormal3fEXT;
+  glBinormal3fvEXT: TglBinormal3fvEXT;
+  glBinormal3iEXT: TglBinormal3iEXT;
+  glBinormal3ivEXT: TglBinormal3ivEXT;
+  glBinormal3sEXT: TglBinormal3sEXT;
+  glBinormal3svEXT: TglBinormal3svEXT;
+  glTangentPointerEXT: TglTangentPointerEXT;
+  glBinormalPointerEXT: TglBinormalPointerEXT;
+
+  // GL_EXT_copy_texture
+  glCopyTexImage1DEXT: TglCopyTexImage1DEXT;
+  glCopyTexImage2DEXT: TglCopyTexImage2DEXT;
+  glCopyTexSubImage1DEXT: TglCopyTexSubImage1DEXT;
+  glCopyTexSubImage2DEXT: TglCopyTexSubImage2DEXT;
+  glCopyTexSubImage3DEXT: TglCopyTexSubImage3DEXT;
+
+  // GL_EXT_cull_vertex
+  glCullParameterdvEXT: TglCullParameterdvEXT;
+  glCullParameterfvEXT: TglCullParameterfvEXT;
+
+  // GL_EXT_draw_range_elements
+  glDrawRangeElementsEXT: TglDrawRangeElementsEXT;
+
+  // GL_EXT_fog_coord
+  glFogCoordfEXT: TglFogCoordfEXT;
+  glFogCoordfvEXT: TglFogCoordfvEXT;
+  glFogCoorddEXT: TglFogCoorddEXT;
+  glFogCoorddvEXT: TglFogCoorddvEXT;
+  glFogCoordPointerEXT: TglFogCoordPointerEXT;
+
+  // GL_EXT_framebuffer_object
+  glIsRenderbufferEXT: TglIsRenderbufferEXT;
+  glBindRenderbufferEXT: TglBindRenderbufferEXT;
+  glDeleteRenderbuffersEXT: TglDeleteRenderbuffersEXT;
+  glGenRenderbuffersEXT: TglGenRenderbuffersEXT;
+  glRenderbufferStorageEXT: TglRenderbufferStorageEXT;
+  glGetRenderbufferParameterivEXT: TglGetRenderbufferParameterivEXT;
+  glIsFramebufferEXT: TglIsFramebufferEXT;
+  glBindFramebufferEXT: TglBindFramebufferEXT;
+  glDeleteFramebuffersEXT: TglDeleteFramebuffersEXT;
+  glGenFramebuffersEXT: TglGenFramebuffersEXT;
+  glCheckFramebufferStatusEXT: TglCheckFramebufferStatusEXT;
+  glFramebufferTexture1DEXT: TglFramebufferTexture1DEXT;
+  glFramebufferTexture2DEXT: TglFramebufferTexture2DEXT;
+  glFramebufferTexture3DEXT: TglFramebufferTexture3DEXT;
+  glFramebufferRenderbufferEXT: TglFramebufferRenderbufferEXT;
+  glGetFramebufferAttachmentParameterivEXT: TglGetFramebufferAttachmentParameterivEXT;
+  glGenerateMipmapEXT: TglGenerateMipmapEXT;
+
+  // GL_EXT_histogram
+  glGetHistogramEXT: TglGetHistogramEXT;
+  glGetHistogramParameterfvEXT: TglGetHistogramParameterfvEXT;
+  glGetHistogramParameterivEXT: TglGetHistogramParameterivEXT;
+  glGetMinmaxEXT: TglGetMinmaxEXT;
+  glGetMinmaxParameterfvEXT: TglGetMinmaxParameterfvEXT;
+  glGetMinmaxParameterivEXT: TglGetMinmaxParameterivEXT;
+  glHistogramEXT: TglHistogramEXT;
+  glMinmaxEXT: TglMinmaxEXT;
+  glResetHistogramEXT: TglResetHistogramEXT;
+  glResetMinmaxEXT: TglResetMinmaxEXT;
+
+  // GL_EXT_index_func
+  glIndexFuncEXT: TglIndexFuncEXT;
+
+  // GL_EXT_index_material
+  glIndexMaterialEXT: TglIndexMaterialEXT;
+
+  // GL_EXT_light_texture
+  glApplyTextureEXT: TglApplyTextureEXT;
+  glTextureLightEXT: TglTextureLightEXT;
+  glTextureMaterialEXT: TglTextureMaterialEXT;
+
+  // GL_EXT_multi_draw_arrays
+  glMultiDrawArraysEXT: TglMultiDrawArraysEXT;
+  glMultiDrawElementsEXT: TglMultiDrawElementsEXT;
+
+  // GL_EXT_multisample
+  glSampleMaskEXT: TglSampleMaskEXT;
+  glSamplePatternEXT: TglSamplePatternEXT;
+
+  // GL_EXT_paletted_texture
+  glColorTableEXT: TglColorTableEXT;
+  glGetColorTableEXT: TglGetColorTableEXT;
+  glGetColorTableParameterivEXT: TglGetColorTableParameterivEXT;
+  glGetColorTableParameterfvEXT: TglGetColorTableParameterfvEXT;
+
+  // GL_EXT_pixel_transform
+  glPixelTransformParameteriEXT: TglPixelTransformParameteriEXT;
+  glPixelTransformParameterfEXT: TglPixelTransformParameterfEXT;
+  glPixelTransformParameterivEXT: TglPixelTransformParameterivEXT;
+  glPixelTransformParameterfvEXT: TglPixelTransformParameterfvEXT;
+
+  // GL_EXT_point_parameters
+  glPointParameterfEXT: TglPointParameterfEXT;
+  glPointParameterfvEXT: TglPointParameterfvEXT;
+
+  // GL_EXT_polygon_offset
+  glPolygonOffsetEXT: TglPolygonOffsetEXT;
+
+  // GL_EXT_secondary_color
+  glSecondaryColor3bEXT: TglSecondaryColor3bEXT;
+  glSecondaryColor3bvEXT: TglSecondaryColor3bvEXT;
+  glSecondaryColor3dEXT: TglSecondaryColor3dEXT;
+  glSecondaryColor3dvEXT: TglSecondaryColor3dvEXT;
+  glSecondaryColor3fEXT: TglSecondaryColor3fEXT;
+  glSecondaryColor3fvEXT: TglSecondaryColor3fvEXT;
+  glSecondaryColor3iEXT: TglSecondaryColor3iEXT;
+  glSecondaryColor3ivEXT: TglSecondaryColor3ivEXT;
+  glSecondaryColor3sEXT: TglSecondaryColor3sEXT;
+  glSecondaryColor3svEXT: TglSecondaryColor3svEXT;
+  glSecondaryColor3ubEXT: TglSecondaryColor3ubEXT;
+  glSecondaryColor3ubvEXT: TglSecondaryColor3ubvEXT;
+  glSecondaryColor3uiEXT: TglSecondaryColor3uiEXT;
+  glSecondaryColor3uivEXT: TglSecondaryColor3uivEXT;
+  glSecondaryColor3usEXT: TglSecondaryColor3usEXT;
+  glSecondaryColor3usvEXT: TglSecondaryColor3usvEXT;
+  glSecondaryColorPointerEXT: TglSecondaryColorPointerEXT;
+
+  // GL_EXT_stencil_two_side
+  glActiveStencilFaceEXT: TglActiveStencilFaceEXT;
+
+  // GL_EXT_subtexture
+  glTexSubImage1DEXT: TglTexSubImage1DEXT;
+  glTexSubImage2DEXT: TglTexSubImage2DEXT;
+
+  // GL_EXT_texture3D
+  glTexImage3DEXT: TglTexImage3DEXT;
+  glTexSubImage3DEXT: TglTexSubImage3DEXT;
+
+  // GL_EXT_texture_object
+  glAreTexturesResidentEXT: TglAreTexturesResidentEXT;
+  glBindTextureEXT: TglBindTextureEXT;
+  glDeleteTexturesEXT: TglDeleteTexturesEXT;
+  glGenTexturesEXT: TglGenTexturesEXT;
+  glIsTextureEXT: TglIsTextureEXT;
+  glPrioritizeTexturesEXT: TglPrioritizeTexturesEXT;
+
+  // GL_EXT_texture_perturb_normal
+  glTextureNormalEXT: TglTextureNormalEXT;
+
+  // GL_EXT_vertex_array
+  glArrayElementEXT: TglArrayElementEXT;
+  glColorPointerEXT: TglColorPointerEXT;
+  glDrawArraysEXT: TglDrawArraysEXT;
+  glEdgeFlagPointerEXT: TglEdgeFlagPointerEXT;
+  glGetPointervEXT: TglGetPointervEXT;
+  glIndexPointerEXT: TglIndexPointerEXT;
+  glNormalPointerEXT: TglNormalPointerEXT;
+  glTexCoordPointerEXT: TglTexCoordPointerEXT;
+  glVertexPointerEXT: TglVertexPointerEXT;
+
+  // GL_EXT_vertex_shader
+  glBeginVertexShaderEXT: TglBeginVertexShaderEXT;
+  glEndVertexShaderEXT: TglEndVertexShaderEXT;
+  glBindVertexShaderEXT: TglBindVertexShaderEXT;
+  glGenVertexShadersEXT: TglGenVertexShadersEXT;
+  glDeleteVertexShaderEXT: TglDeleteVertexShaderEXT;
+  glShaderOp1EXT: TglShaderOp1EXT;
+  glShaderOp2EXT: TglShaderOp2EXT;
+  glShaderOp3EXT: TglShaderOp3EXT;
+  glSwizzleEXT: TglSwizzleEXT;
+  glWriteMaskEXT: TglWriteMaskEXT;
+  glInsertComponentEXT: TglInsertComponentEXT;
+  glExtractComponentEXT: TglExtractComponentEXT;
+  glGenSymbolsEXT: TglGenSymbolsEXT;
+  glSetInvariantEXT: TglSetInvariantEXT;
+  glSetLocalConstantEXT: TglSetLocalConstantEXT;
+  glVariantbvEXT: TglVariantbvEXT;
+  glVariantsvEXT: TglVariantsvEXT;
+  glVariantivEXT: TglVariantivEXT;
+  glVariantfvEXT: TglVariantfvEXT;
+  glVariantdvEXT: TglVariantdvEXT;
+  glVariantubvEXT: TglVariantubvEXT;
+  glVariantusvEXT: TglVariantusvEXT;
+  glVariantuivEXT: TglVariantuivEXT;
+  glVariantPointerEXT: TglVariantPointerEXT;
+  glEnableVariantClientStateEXT: TglEnableVariantClientStateEXT;
+  glDisableVariantClientStateEXT: TglDisableVariantClientStateEXT;
+  glBindLightParameterEXT: TglBindLightParameterEXT;
+  glBindMaterialParameterEXT: TglBindMaterialParameterEXT;
+  glBindTexGenParameterEXT: TglBindTexGenParameterEXT;
+  glBindTextureUnitParameterEXT: TglBindTextureUnitParameterEXT;
+  glBindParameterEXT: TglBindParameterEXT;
+  glIsVariantEnabledEXT: TglIsVariantEnabledEXT;
+  glGetVariantBooleanvEXT: TglGetVariantBooleanvEXT;
+  glGetVariantIntegervEXT: TglGetVariantIntegervEXT;
+  glGetVariantFloatvEXT: TglGetVariantFloatvEXT;
+  glGetVariantPointervEXT: TglGetVariantPointervEXT;
+  glGetInvariantBooleanvEXT: TglGetInvariantBooleanvEXT;
+  glGetInvariantIntegervEXT: TglGetInvariantIntegervEXT;
+  glGetInvariantFloatvEXT: TglGetInvariantFloatvEXT;
+  glGetLocalConstantBooleanvEXT: TglGetLocalConstantBooleanvEXT;
+  glGetLocalConstantIntegervEXT: TglGetLocalConstantIntegervEXT;
+  glGetLocalConstantFloatvEXT: TglGetLocalConstantFloatvEXT;
+
+  // GL_EXT_vertex_weighting
+  glVertexWeightfEXT: TglVertexWeightfEXT;
+  glVertexWeightfvEXT: TglVertexWeightfvEXT;
+  glVertexWeightPointerEXT: TglVertexWeightPointerEXT;
+
+  // GL_EXT_stencil_clear_tag
+  glStencilClearTagEXT: TglStencilClearTagEXT;
+
+  // GL_EXT_framebuffer_blit
+  glBlitFramebufferEXT: TglBlitFramebufferEXT;
+
+  // GL_EXT_framebuffer_multisample
+  glRenderbufferStorageMultisampleEXT: TglRenderbufferStorageMultisampleEXT;
+
+  // GL_EXT_timer_query
+  glGetQueryObjecti64vEXT: TglGetQueryObjecti64vEXT;
+  glGetQueryObjectui64vEXT: TglGetQueryObjectui64vEXT;
+
+  // GL_EXT_gpu_program_parameters
+  glProgramEnvParameters4fvEXT: TglProgramEnvParameters4fvEXT;
+  glProgramLocalParameters4fvEXT: TglProgramLocalParameters4fvEXT;
+
+  // GL_EXT_bindable_uniform
+  glUniformBufferEXT: TglUniformBufferEXT;
+  glGetUniformBufferSizeEXT: TglGetUniformBufferSizeEXT;
+  glGetUniformOffsetEXT: TglGetUniformOffsetEXT;
+
+  // GL_EXT_draw_buffers2
+  glColorMaskIndexedEXT: TglColorMaskIndexedEXT;
+  glGetBooleanIndexedvEXT: TglGetBooleanIndexedvEXT;
+  glGetIntegerIndexedvEXT: TglGetIntegerIndexedvEXT;
+  glEnableIndexedEXT: TglEnableIndexedEXT;
+  glDisableIndexedEXT: TglDisableIndexedEXT;
+  glIsEnabledIndexedEXT: TglIsEnabledIndexedEXT;
+
+  // GL_EXT_draw_instanced
+  glDrawArraysInstancedEXT: TglDrawArraysInstancedEXT;
+  glDrawElementsInstancedEXT: TglDrawElementsInstancedEXT;
+
+  // GL_EXT_geometry_shader4
+  glProgramParameteriEXT: TglProgramParameteriEXT;
+  glFramebufferTextureEXT: TglFramebufferTextureEXT;
+//  glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT;
+  glFramebufferTextureFaceEXT: TglFramebufferTextureFaceEXT;
+
+  // GL_EXT_gpu_shader4
+  glVertexAttribI1iEXT: TglVertexAttribI1iEXT;
+  glVertexAttribI2iEXT: TglVertexAttribI2iEXT;
+  glVertexAttribI3iEXT: TglVertexAttribI3iEXT;
+  glVertexAttribI4iEXT: TglVertexAttribI4iEXT;
+  glVertexAttribI1uiEXT: TglVertexAttribI1uiEXT;
+  glVertexAttribI2uiEXT: TglVertexAttribI2uiEXT;
+  glVertexAttribI3uiEXT: TglVertexAttribI3uiEXT;
+  glVertexAttribI4uiEXT: TglVertexAttribI4uiEXT;
+  glVertexAttribI1ivEXT: TglVertexAttribI1ivEXT;
+  glVertexAttribI2ivEXT: TglVertexAttribI2ivEXT;
+  glVertexAttribI3ivEXT: TglVertexAttribI3ivEXT;
+  glVertexAttribI4ivEXT: TglVertexAttribI4ivEXT;
+  glVertexAttribI1uivEXT: TglVertexAttribI1uivEXT;
+  glVertexAttribI2uivEXT: TglVertexAttribI2uivEXT;
+  glVertexAttribI3uivEXT: TglVertexAttribI3uivEXT;
+  glVertexAttribI4uivEXT: TglVertexAttribI4uivEXT;
+  glVertexAttribI4bvEXT: TglVertexAttribI4bvEXT;
+  glVertexAttribI4svEXT: TglVertexAttribI4svEXT;
+  glVertexAttribI4ubvEXT: TglVertexAttribI4ubvEXT;
+  glVertexAttribI4usvEXT: TglVertexAttribI4usvEXT;
+  glVertexAttribIPointerEXT: TglVertexAttribIPointerEXT;
+  glGetVertexAttribIivEXT: TglGetVertexAttribIivEXT;
+  glGetVertexAttribIuivEXT: TglGetVertexAttribIuivEXT;
+  glUniform1uiEXT: TglUniform1uiEXT;
+  glUniform2uiEXT: TglUniform2uiEXT;
+  glUniform3uiEXT: TglUniform3uiEXT;
+  glUniform4uiEXT: TglUniform4uiEXT;
+  glUniform1uivEXT: TglUniform1uivEXT;
+  glUniform2uivEXT: TglUniform2uivEXT;
+  glUniform3uivEXT: TglUniform3uivEXT;
+  glUniform4uivEXT: TglUniform4uivEXT;
+  glGetUniformuivEXT: TglGetUniformuivEXT;
+  glBindFragDataLocationEXT: TglBindFragDataLocationEXT;
+  glGetFragDataLocationEXT: TglGetFragDataLocationEXT;
+
+  // GL_EXT_texture_array
+  glFramebufferTextureLayerEXT: TglFramebufferTextureLayerEXT;
+
+  // GL_EXT_texture_buffer_object
+  glTexBufferEXT: TglTexBufferEXT;
+
+  // GL_EXT_texture_integer
+  glClearColorIiEXT: TglClearColorIiEXT;
+  glClearColorIuiEXT: TglClearColorIuiEXT;
+  glTexParameterIivEXT: TglTexParameterIivEXT;
+  glTexParameterIuivEXT: TglTexParameterIuivEXT;
+  glGetTexParameterIivEXT: TglGetTexParameterIivEXT;
+  glGetTexParameterIiuvEXT: TglGetTexParameterIiuvEXT;
+
+  // GL_EXT_transform_feedback
+  glBeginTransformFeedbackEXT: TglBeginTransformFeedbackEXT;
+  glEndTransformFeedbackEXT: TglEndTransformFeedbackEXT;
+  glBindBufferRangeEXT: TglBindBufferRangeEXT;
+  glBindBufferOffsetEXT: TglBindBufferOffsetEXT;
+  glBindBufferBaseEXT: TglBindBufferBaseEXT;
+  glTransformFeedbackVaryingsEXT: TglTransformFeedbackVaryingsEXT;
+  glGetTransformFeedbackVaryingEXT: TglGetTransformFeedbackVaryingEXT;
+
+  // GL_EXT_direct_state_access
+  glClientAttribDefaultEXT: TglClientAttribDefaultEXT;
+  glPushClientAttribDefaultEXT: TglPushClientAttribDefaultEXT;
+  glMatrixLoadfEXT: TglMatrixLoadfEXT;
+  glMatrixLoaddEXT: TglMatrixLoaddEXT;
+  glMatrixMultfEXT: TglMatrixMultfEXT;
+  glMatrixMultdEXT: TglMatrixMultdEXT;
+  glMatrixLoadIdentityEXT: TglMatrixLoadIdentityEXT;
+  glMatrixRotatefEXT: TglMatrixRotatefEXT;
+  glMatrixRotatedEXT: TglMatrixRotatedEXT;
+  glMatrixScalefEXT: TglMatrixScalefEXT;
+  glMatrixScaledEXT: TglMatrixScaledEXT;
+  glMatrixTranslatefEXT: TglMatrixTranslatefEXT;
+  glMatrixTranslatedEXT: TglMatrixTranslatedEXT;
+  glMatrixFrustumEXT: TglMatrixFrustumEXT;
+  glMatrixOrthoEXT: TglMatrixOrthoEXT;
+  glMatrixPopEXT: TglMatrixPopEXT;
+  glMatrixPushEXT: TglMatrixPushEXT;
+  glMatrixLoadTransposefEXT: TglMatrixLoadTransposefEXT;
+  glMatrixLoadTransposedEXT: TglMatrixLoadTransposedEXT;
+  glMatrixMultTransposefEXT: TglMatrixMultTransposefEXT;
+  glMatrixMultTransposedEXT: TglMatrixMultTransposedEXT;
+  glTextureParameterfEXT: TglTextureParameterfEXT;
+  glTextureParameterfvEXT: TglTextureParameterfvEXT;
+  glTextureParameteriEXT: TglTextureParameteriEXT;
+  glTextureParameterivEXT: TglTextureParameterivEXT;
+  glTextureImage1DEXT: TglTextureImage1DEXT;
+  glTextureImage2DEXT: TglTextureImage2DEXT;
+  glTextureSubImage1DEXT: TglTextureSubImage1DEXT;
+  glTextureSubImage2DEXT: TglTextureSubImage2DEXT;
+  glCopyTextureImage1DEXT: TglCopyTextureImage1DEXT;
+  glCopyTextureImage2DEXT: TglCopyTextureImage2DEXT;
+  glCopyTextureSubImage1DEXT: TglCopyTextureSubImage1DEXT;
+  glCopyTextureSubImage2DEXT: TglCopyTextureSubImage2DEXT;
+  glGetTextureImageEXT: TglGetTextureImageEXT;
+  glGetTextureParameterfvEXT: TglGetTextureParameterfvEXT;
+  glGetTextureParameterivEXT: TglGetTextureParameterivEXT;
+  glGetTextureLevelParameterfvEXT: TglGetTextureLevelParameterfvEXT;
+  glGetTextureLevelParameterivEXT: TglGetTextureLevelParameterivEXT;
+  glTextureImage3DEXT: TglTextureImage3DEXT;
+  glTextureSubImage3DEXT: TglTextureSubImage3DEXT;
+  glCopyTextureSubImage3DEXT: TglCopyTextureSubImage3DEXT;
+  glMultiTexParameterfEXT: TglMultiTexParameterfEXT;
+  glMultiTexParameterfvEXT: TglMultiTexParameterfvEXT;
+  glMultiTexParameteriEXT: TglMultiTexParameteriEXT;
+  glMultiTexParameterivEXT: TglMultiTexParameterivEXT;
+  glMultiTexImage1DEXT: TglMultiTexImage1DEXT;
+  glMultiTexImage2DEXT: TglMultiTexImage2DEXT;
+  glMultiTexSubImage1DEXT: TglMultiTexSubImage1DEXT;
+  glMultiTexSubImage2DEXT: TglMultiTexSubImage2DEXT;
+  glCopyMultiTexImage1DEXT: TglCopyMultiTexImage1DEXT;
+  glCopyMultiTexImage2DEXT: TglCopyMultiTexImage2DEXT;
+  glCopyMultiTexSubImage1DEXT: TglCopyMultiTexSubImage1DEXT;
+  glCopyMultiTexSubImage2DEXT: TglCopyMultiTexSubImage2DEXT;
+  glGetMultiTexImageEXT: TglGetMultiTexImageEXT;
+  glGetMultiTexParameterfvEXT: TglGetMultiTexParameterfvEXT;
+  glGetMultiTexParameterivEXT: TglGetMultiTexParameterivEXT;
+  glGetMultiTexLevelParameterfvEXT: TglGetMultiTexLevelParameterfvEXT;
+  glGetMultiTexLevelParameterivEXT: TglGetMultiTexLevelParameterivEXT;
+  glMultiTexImage3DEXT: TglMultiTexImage3DEXT;
+  glMultiTexSubImage3DEXT: TglMultiTexSubImage3DEXT;
+  glCopyMultiTexSubImage3DEXT: TglCopyMultiTexSubImage3DEXT;
+  glBindMultiTextureEXT: TglBindMultiTextureEXT;
+  glEnableClientStateIndexedEXT: TglEnableClientStateIndexedEXT;
+  glDisableClientStateIndexedEXT: TglDisableClientStateIndexedEXT;
+  glMultiTexCoordPointerEXT: TglMultiTexCoordPointerEXT;
+  glMultiTexEnvfEXT: TglMultiTexEnvfEXT;
+  glMultiTexEnvfvEXT: TglMultiTexEnvfvEXT;
+  glMultiTexEnviEXT: TglMultiTexEnviEXT;
+  glMultiTexEnvivEXT: TglMultiTexEnvivEXT;
+  glMultiTexGendEXT: TglMultiTexGendEXT;
+  glMultiTexGendvEXT: TglMultiTexGendvEXT;
+  glMultiTexGenfEXT: TglMultiTexGenfEXT;
+  glMultiTexGenfvEXT: TglMultiTexGenfvEXT;
+  glMultiTexGeniEXT: TglMultiTexGeniEXT;
+  glMultiTexGenivEXT: TglMultiTexGenivEXT;
+  glGetMultiTexEnvfvEXT: TglGetMultiTexEnvfvEXT;
+  glGetMultiTexEnvivEXT: TglGetMultiTexEnvivEXT;
+  glGetMultiTexGendvEXT: TglGetMultiTexGendvEXT;
+  glGetMultiTexGenfvEXT: TglGetMultiTexGenfvEXT;
+  glGetMultiTexGenivEXT: TglGetMultiTexGenivEXT;
+  glGetFloatIndexedvEXT: TglGetFloatIndexedvEXT;
+  glGetDoubleIndexedvEXT: TglGetDoubleIndexedvEXT;
+  glGetPointerIndexedvEXT: TglGetPointerIndexedvEXT;
+  glCompressedTextureImage3DEXT: TglCompressedTextureImage3DEXT;
+  glCompressedTextureImage2DEXT: TglCompressedTextureImage2DEXT;
+  glCompressedTextureImage1DEXT: TglCompressedTextureImage1DEXT;
+  glCompressedTextureSubImage3DEXT: TglCompressedTextureSubImage3DEXT;
+  glCompressedTextureSubImage2DEXT: TglCompressedTextureSubImage2DEXT;
+  glCompressedTextureSubImage1DEXT: TglCompressedTextureSubImage1DEXT;
+  glGetCompressedTextureImageEXT: TglGetCompressedTextureImageEXT;
+  glCompressedMultiTexImage3DEXT: TglCompressedMultiTexImage3DEXT;
+  glCompressedMultiTexImage2DEXT: TglCompressedMultiTexImage2DEXT;
+  glCompressedMultiTexImage1DEXT: TglCompressedMultiTexImage1DEXT;
+  glCompressedMultiTexSubImage3DEXT: TglCompressedMultiTexSubImage3DEXT;
+  glCompressedMultiTexSubImage2DEXT: TglCompressedMultiTexSubImage2DEXT;
+  glCompressedMultiTexSubImage1DEXT: TglCompressedMultiTexSubImage1DEXT;
+  glGetCompressedMultiTexImageEXT: TglGetCompressedMultiTexImageEXT;
+  glNamedProgramStringEXT: TglNamedProgramStringEXT;
+  glNamedProgramLocalParameter4dEXT: TglNamedProgramLocalParameter4dEXT;
+  glNamedProgramLocalParameter4dvEXT: TglNamedProgramLocalParameter4dvEXT;
+  glNamedProgramLocalParameter4fEXT: TglNamedProgramLocalParameter4fEXT;
+  glNamedProgramLocalParameter4fvEXT: TglNamedProgramLocalParameter4fvEXT;
+  glGetNamedProgramLocalParameterdvEXT: TglGetNamedProgramLocalParameterdvEXT;
+  glGetNamedProgramLocalParameterfvEXT: TglGetNamedProgramLocalParameterfvEXT;
+  glGetNamedProgramivEXT: TglGetNamedProgramivEXT;
+  glGetNamedProgramStringEXT: TglGetNamedProgramStringEXT;
+  glNamedProgramLocalParameters4fvEXT: TglNamedProgramLocalParameters4fvEXT;
+  glNamedProgramLocalParameterI4iEXT: TglNamedProgramLocalParameterI4iEXT;
+  glNamedProgramLocalParameterI4ivEXT: TglNamedProgramLocalParameterI4ivEXT;
+  glNamedProgramLocalParametersI4ivEXT: TglNamedProgramLocalParametersI4ivEXT;
+  glNamedProgramLocalParameterI4uiEXT: TglNamedProgramLocalParameterI4uiEXT;
+  glNamedProgramLocalParameterI4uivEXT: TglNamedProgramLocalParameterI4uivEXT;
+  glNamedProgramLocalParametersI4uivEXT: TglNamedProgramLocalParametersI4uivEXT;
+  glGetNamedProgramLocalParameterIivEXT: TglGetNamedProgramLocalParameterIivEXT;
+  glGetNamedProgramLocalParameterIuivEXT: TglGetNamedProgramLocalParameterIuivEXT;
+  glTextureParameterIivEXT: TglTextureParameterIivEXT;
+  glTextureParameterIuivEXT: TglTextureParameterIuivEXT;
+  glGetTextureParameterIivEXT: TglGetTextureParameterIivEXT;
+  glGetTextureParameterIuivEXT: TglGetTextureParameterIuivEXT;
+  glMultiTexParameterIivEXT: TglMultiTexParameterIivEXT;
+  glMultiTexParameterIuivEXT: TglMultiTexParameterIuivEXT;
+  glGetMultiTexParameterIivEXT: TglGetMultiTexParameterIivEXT;
+  glGetMultiTexParameterIuivEXT: TglGetMultiTexParameterIuivEXT;
+  glProgramUniform1fEXT: TglProgramUniform1fEXT;
+  glProgramUniform2fEXT: TglProgramUniform2fEXT;
+  glProgramUniform3fEXT: TglProgramUniform3fEXT;
+  glProgramUniform4fEXT: TglProgramUniform4fEXT;
+  glProgramUniform1iEXT: TglProgramUniform1iEXT;
+  glProgramUniform2iEXT: TglProgramUniform2iEXT;
+  glProgramUniform3iEXT: TglProgramUniform3iEXT;
+  glProgramUniform4iEXT: TglProgramUniform4iEXT;
+  glProgramUniform1fvEXT: TglProgramUniform1fvEXT;
+  glProgramUniform2fvEXT: TglProgramUniform2fvEXT;
+  glProgramUniform3fvEXT: TglProgramUniform3fvEXT;
+  glProgramUniform4fvEXT: TglProgramUniform4fvEXT;
+  glProgramUniform1ivEXT: TglProgramUniform1ivEXT;
+  glProgramUniform2ivEXT: TglProgramUniform2ivEXT;
+  glProgramUniform3ivEXT: TglProgramUniform3ivEXT;
+  glProgramUniform4ivEXT: TglProgramUniform4ivEXT;
+  glProgramUniformMatrix2fvEXT: TglProgramUniformMatrix2fvEXT;
+  glProgramUniformMatrix3fvEXT: TglProgramUniformMatrix3fvEXT;
+  glProgramUniformMatrix4fvEXT: TglProgramUniformMatrix4fvEXT;
+  glProgramUniformMatrix2x3fvEXT: TglProgramUniformMatrix2x3fvEXT;
+  glProgramUniformMatrix3x2fvEXT: TglProgramUniformMatrix3x2fvEXT;
+  glProgramUniformMatrix2x4fvEXT: TglProgramUniformMatrix2x4fvEXT;
+  glProgramUniformMatrix4x2fvEXT: TglProgramUniformMatrix4x2fvEXT;
+  glProgramUniformMatrix3x4fvEXT: TglProgramUniformMatrix3x4fvEXT;
+  glProgramUniformMatrix4x3fvEXT: TglProgramUniformMatrix4x3fvEXT;
+  glProgramUniform1uiEXT: TglProgramUniform1uiEXT;
+  glProgramUniform2uiEXT: TglProgramUniform2uiEXT;
+  glProgramUniform3uiEXT: TglProgramUniform3uiEXT;
+  glProgramUniform4uiEXT: TglProgramUniform4uiEXT;
+  glProgramUniform1uivEXT: TglProgramUniform1uivEXT;
+  glProgramUniform2uivEXT: TglProgramUniform2uivEXT;
+  glProgramUniform3uivEXT: TglProgramUniform3uivEXT;
+  glProgramUniform4uivEXT: TglProgramUniform4uivEXT;
+  glNamedBufferDataEXT: TglNamedBufferDataEXT;
+  glNamedBufferSubDataEXT: TglNamedBufferSubDataEXT;
+  glMapNamedBufferEXT: TglMapNamedBufferEXT;
+  glUnmapNamedBufferEXT: TglUnmapNamedBufferEXT;
+  glMapNamedBufferRangeEXT: TglMapNamedBufferRangeEXT;
+  glFlushMappedNamedBufferRangeEXT: TglFlushMappedNamedBufferRangeEXT;
+  glNamedCopyBufferSubDataEXT: TglNamedCopyBufferSubDataEXT;
+  glGetNamedBufferParameterivEXT: TglGetNamedBufferParameterivEXT;
+  glGetNamedBufferPointervEXT: TglGetNamedBufferPointervEXT;
+  glGetNamedBufferSubDataEXT: TglGetNamedBufferSubDataEXT;
+  glTextureBufferEXT: TglTextureBufferEXT;
+  glMultiTexBufferEXT: TglMultiTexBufferEXT;
+  glNamedRenderbufferStorageEXT: TglNamedRenderbufferStorageEXT;
+  glGetNamedRenderbufferParameterivEXT: TglGetNamedRenderbufferParameterivEXT;
+  glCheckNamedFramebufferStatusEXT: TglCheckNamedFramebufferStatusEXT;
+  glNamedFramebufferTexture1DEXT: TglNamedFramebufferTexture1DEXT;
+  glNamedFramebufferTexture2DEXT: TglNamedFramebufferTexture2DEXT;
+  glNamedFramebufferTexture3DEXT: TglNamedFramebufferTexture3DEXT;
+  glNamedFramebufferRenderbufferEXT: TglNamedFramebufferRenderbufferEXT;
+  glGetNamedFramebufferAttachmentParameterivEXT: TglGetNamedFramebufferAttachmentParameterivEXT;
+  glGenerateTextureMipmapEXT: TglGenerateTextureMipmapEXT;
+  glGenerateMultiTexMipmapEXT: TglGenerateMultiTexMipmapEXT;
+  glFramebufferDrawBufferEXT: TglFramebufferDrawBufferEXT;
+  glFramebufferDrawBuffersEXT: TglFramebufferDrawBuffersEXT;
+  glFramebufferReadBufferEXT: TglFramebufferReadBufferEXT;
+  glGetFramebufferParameterivEXT: TglGetFramebufferParameterivEXT;
+  glNamedRenderbufferStorageMultisampleEXT: TglNamedRenderbufferStorageMultisampleEXT;
+  glNamedRenderbufferStorageMultisampleCoverageEXT: TglNamedRenderbufferStorageMultisampleCoverageEXT;
+  glNamedFramebufferTextureEXT: TglNamedFramebufferTextureEXT;
+  glNamedFramebufferTextureLayerEXT: TglNamedFramebufferTextureLayerEXT;
+  glNamedFramebufferTextureFaceEXT: TglNamedFramebufferTextureFaceEXT;
+  glTextureRenderbufferEXT: TglTextureRenderbufferEXT;
+  glMultiTexRenderbufferEXT: TglMultiTexRenderbufferEXT;
+  glProgramUniform1dEXT: TglProgramUniform1dEXT;
+  glProgramUniform2dEXT: TglProgramUniform2dEXT;
+  glProgramUniform3dEXT: TglProgramUniform3dEXT;
+  glProgramUniform4dEXT: TglProgramUniform4dEXT;
+  glProgramUniform1dvEXT: TglProgramUniform1dvEXT;
+  glProgramUniform2dvEXT: TglProgramUniform2dvEXT;
+  glProgramUniform3dvEXT: TglProgramUniform3dvEXT;
+  glProgramUniform4dvEXT: TglProgramUniform4dvEXT;
+  glProgramUniformMatrix2dvEXT: TglProgramUniformMatrix2dvEXT;
+  glProgramUniformMatrix3dvEXT: TglProgramUniformMatrix3dvEXT;
+  glProgramUniformMatrix4dvEXT: TglProgramUniformMatrix4dvEXT;
+  glProgramUniformMatrix2x3dvEXT: TglProgramUniformMatrix2x3dvEXT;
+  glProgramUniformMatrix2x4dvEXT: TglProgramUniformMatrix2x4dvEXT;
+  glProgramUniformMatrix3x2dvEXT: TglProgramUniformMatrix3x2dvEXT;
+  glProgramUniformMatrix3x4dvEXT: TglProgramUniformMatrix3x4dvEXT;
+  glProgramUniformMatrix4x2dvEXT: TglProgramUniformMatrix4x2dvEXT;
+  glProgramUniformMatrix4x3dvEXT: TglProgramUniformMatrix4x3dvEXT;
+
+  // GL_EXT_separate_shader_objects
+  glUseShaderProgramEXT: TglUseShaderProgramEXT;
+  glActiveProgramEXT: TglActiveProgramEXT;
+  glCreateShaderProgramEXT: TglCreateShaderProgramEXT;
+
+  // GL_EXT_shader_image_load_store
+  glBindImageTextureEXT: TglBindImageTextureEXT;
+  glMemoryBarrierEXT: TglMemoryBarrierEXT;
+
+  // GL_EXT_vertex_attrib_64bit
+  glVertexAttribL1dEXT: TglVertexAttribL1dEXT;
+  glVertexAttribL2dEXT: TglVertexAttribL2dEXT;
+  glVertexAttribL3dEXT: TglVertexAttribL3dEXT;
+  glVertexAttribL4dEXT: TglVertexAttribL4dEXT;
+  glVertexAttribL1dvEXT: TglVertexAttribL1dvEXT;
+  glVertexAttribL2dvEXT: TglVertexAttribL2dvEXT;
+  glVertexAttribL3dvEXT: TglVertexAttribL3dvEXT;
+  glVertexAttribL4dvEXT: TglVertexAttribL4dvEXT;
+  glVertexAttribLPointerEXT: TglVertexAttribLPointerEXT;
+  glGetVertexAttribLdvEXT: TglGetVertexAttribLdvEXT;
+  glVertexArrayVertexAttribLOffsetEXT: TglVertexArrayVertexAttribLOffsetEXT;
+  
+  // GL_HP_image_transform
+  glImageTransformParameteriHP: TglImageTransformParameteriHP;
+  glImageTransformParameterfHP: TglImageTransformParameterfHP;
+  glImageTransformParameterivHP: TglImageTransformParameterivHP;
+  glImageTransformParameterfvHP: TglImageTransformParameterfvHP;
+  glGetImageTransformParameterivHP: TglGetImageTransformParameterivHP;
+  glGetImageTransformParameterfvHP: TglGetImageTransformParameterfvHP;
+
+  // GL_EXT_depth_bounds_test
+  glDepthBoundsEXT: TglDepthBoundsEXT;
+
+  // GL_EXT_blend_equation_separate
+  glBlendEquationSeparateEXT: TglBlendEquationSeparateEXT;
+
+  // GL_IBM_multimode_draw_arrays
+  glMultiModeDrawArraysIBM: TglMultiModeDrawArraysIBM;
+  glMultiModeDrawElementsIBM: TglMultiModeDrawElementsIBM;
+
+  // GL_IBM_vertex_array_lists
+  glColorPointerListIBM: TglColorPointerListIBM;
+  glSecondaryColorPointerListIBM: TglSecondaryColorPointerListIBM;
+  glEdgeFlagPointerListIBM: TglEdgeFlagPointerListIBM;
+  glFogCoordPointerListIBM: TglFogCoordPointerListIBM;
+  glIndexPointerListIBM: TglIndexPointerListIBM;
+  glNormalPointerListIBM: TglNormalPointerListIBM;
+  glTexCoordPointerListIBM: TglTexCoordPointerListIBM;
+  glVertexPointerListIBM: TglVertexPointerListIBM;
+
+  // GL_INGR_blend_func_separate
+  glBlendFuncSeparateINGR: TglBlendFuncSeparateINGR;
+
+  // GL_INTEL_parallel_arrays
+  glVertexPointervINTEL: TglVertexPointervINTEL;
+  glNormalPointervINTEL: TglNormalPointervINTEL;
+  glColorPointervINTEL: TglColorPointervINTEL;
+  glTexCoordPointervINTEL: TglTexCoordPointervINTEL;
+
+  // GL_MESA_resize_buffers
+  glResizeBuffersMESA: TglResizeBuffersMESA;
+
+  // GL_MESA_window_pos
+  glWindowPos2dMESA: TglWindowPos2dMESA;
+  glWindowPos2dvMESA: TglWindowPos2dvMESA;
+  glWindowPos2fMESA: TglWindowPos2fMESA;
+  glWindowPos2fvMESA: TglWindowPos2fvMESA;
+  glWindowPos2iMESA: TglWindowPos2iMESA;
+  glWindowPos2ivMESA: TglWindowPos2ivMESA;
+  glWindowPos2sMESA: TglWindowPos2sMESA;
+  glWindowPos2svMESA: TglWindowPos2svMESA;
+  glWindowPos3dMESA: TglWindowPos3dMESA;
+  glWindowPos3dvMESA: TglWindowPos3dvMESA;
+  glWindowPos3fMESA: TglWindowPos3fMESA;
+  glWindowPos3fvMESA: TglWindowPos3fvMESA;
+  glWindowPos3iMESA: TglWindowPos3iMESA;
+  glWindowPos3ivMESA: TglWindowPos3ivMESA;
+  glWindowPos3sMESA: TglWindowPos3sMESA;
+  glWindowPos3svMESA: TglWindowPos3svMESA;
+  glWindowPos4dMESA: TglWindowPos4dMESA;
+  glWindowPos4dvMESA: TglWindowPos4dvMESA;
+  glWindowPos4fMESA: TglWindowPos4fMESA;
+  glWindowPos4fvMESA: TglWindowPos4fvMESA;
+  glWindowPos4iMESA: TglWindowPos4iMESA;
+  glWindowPos4ivMESA: TglWindowPos4ivMESA;
+  glWindowPos4sMESA: TglWindowPos4sMESA;
+  glWindowPos4svMESA: TglWindowPos4svMESA;
+
+  // GL_NV_evaluators
+  glMapControlPointsNV: TglMapControlPointsNV;
+  glMapParameterivNV: TglMapParameterivNV;
+  glMapParameterfvNV: TglMapParameterfvNV;
+  glGetMapControlPointsNV: TglGetMapControlPointsNV;
+  glGetMapParameterivNV: TglGetMapParameterivNV;
+  glGetMapParameterfvNV: TglGetMapParameterfvNV;
+  glGetMapAttribParameterivNV: TglGetMapAttribParameterivNV;
+  glGetMapAttribParameterfvNV: TglGetMapAttribParameterfvNV;
+  glEvalMapsNV: TglEvalMapsNV;
+
+  // GL_NV_fence
+  glDeleteFencesNV: TglDeleteFencesNV;
+  glGenFencesNV: TglGenFencesNV;
+  glIsFenceNV: TglIsFenceNV;
+  glTestFenceNV: TglTestFenceNV;
+  glGetFenceivNV: TglGetFenceivNV;
+  glFinishFenceNV: TglFinishFenceNV;
+  glSetFenceNV: TglSetFenceNV;
+
+  // GL_NV_fragment_program
+  glProgramNamedParameter4fNV: TglProgramNamedParameter4fNV;
+  glProgramNamedParameter4dNV: TglProgramNamedParameter4dNV;
+  glProgramNamedParameter4fvNV: TglProgramNamedParameter4fvNV;
+  glProgramNamedParameter4dvNV: TglProgramNamedParameter4dvNV;
+  glGetProgramNamedParameterfvNV: TglGetProgramNamedParameterfvNV;
+  glGetProgramNamedParameterdvNV: TglGetProgramNamedParameterdvNV;
+
+  // GL_NV_half_float
+  glVertex2hNV: TglVertex2hNV;
+  glVertex2hvNV: TglVertex2hvNV;
+  glVertex3hNV: TglVertex3hNV;
+  glVertex3hvNV: TglVertex3hvNV;
+  glVertex4hNV: TglVertex4hNV;
+  glVertex4hvNV: TglVertex4hvNV;
+  glNormal3hNV: TglNormal3hNV;
+  glNormal3hvNV: TglNormal3hvNV;
+  glColor3hNV: TglColor3hNV;
+  glColor3hvNV: TglColor3hvNV;
+  glColor4hNV: TglColor4hNV;
+  glColor4hvNV: TglColor4hvNV;
+  glTexCoord1hNV: TglTexCoord1hNV;
+  glTexCoord1hvNV: TglTexCoord1hvNV;
+  glTexCoord2hNV: TglTexCoord2hNV;
+  glTexCoord2hvNV: TglTexCoord2hvNV;
+  glTexCoord3hNV: TglTexCoord3hNV;
+  glTexCoord3hvNV: TglTexCoord3hvNV;
+  glTexCoord4hNV: TglTexCoord4hNV;
+  glTexCoord4hvNV: TglTexCoord4hvNV;
+  glMultiTexCoord1hNV: TglMultiTexCoord1hNV;
+  glMultiTexCoord1hvNV: TglMultiTexCoord1hvNV;
+  glMultiTexCoord2hNV: TglMultiTexCoord2hNV;
+  glMultiTexCoord2hvNV: TglMultiTexCoord2hvNV;
+  glMultiTexCoord3hNV: TglMultiTexCoord3hNV;
+  glMultiTexCoord3hvNV: TglMultiTexCoord3hvNV;
+  glMultiTexCoord4hNV: TglMultiTexCoord4hNV;
+  glMultiTexCoord4hvNV: TglMultiTexCoord4hvNV;
+  glFogCoordhNV: TglFogCoordhNV;
+  glFogCoordhvNV: TglFogCoordhvNV;
+  glSecondaryColor3hNV: TglSecondaryColor3hNV;
+  glSecondaryColor3hvNV: TglSecondaryColor3hvNV;
+  glVertexWeighthNV: TglVertexWeighthNV;
+  glVertexWeighthvNV: TglVertexWeighthvNV;
+  glVertexAttrib1hNV: TglVertexAttrib1hNV;
+  glVertexAttrib1hvNV: TglVertexAttrib1hvNV;
+  glVertexAttrib2hNV: TglVertexAttrib2hNV;
+  glVertexAttrib2hvNV: TglVertexAttrib2hvNV;
+  glVertexAttrib3hNV: TglVertexAttrib3hNV;
+  glVertexAttrib3hvNV: TglVertexAttrib3hvNV;
+  glVertexAttrib4hNV: TglVertexAttrib4hNV;
+  glVertexAttrib4hvNV: TglVertexAttrib4hvNV;
+  glVertexAttribs1hvNV: TglVertexAttribs1hvNV;
+  glVertexAttribs2hvNV: TglVertexAttribs2hvNV;
+  glVertexAttribs3hvNV: TglVertexAttribs3hvNV;
+  glVertexAttribs4hvNV: TglVertexAttribs4hvNV;
+
+  // GL_NV_occlusion_query
+  glGenOcclusionQueriesNV: TglGenOcclusionQueriesNV;
+  glDeleteOcclusionQueriesNV: TglDeleteOcclusionQueriesNV;
+  glIsOcclusionQueryNV: TglIsOcclusionQueryNV;
+  glBeginOcclusionQueryNV: TglBeginOcclusionQueryNV;
+  glEndOcclusionQueryNV: TglEndOcclusionQueryNV;
+  glGetOcclusionQueryivNV: TglGetOcclusionQueryivNV;
+  glGetOcclusionQueryuivNV: TglGetOcclusionQueryuivNV;
+
+  // GL_NV_pixel_data_range
+  glPixelDataRangeNV: TglPixelDataRangeNV;
+  glFlushPixelDataRangeNV: TglFlushPixelDataRangeNV;
+
+  // GL_NV_point_sprite
+  glPointParameteriNV: TglPointParameteriNV;
+  glPointParameterivNV: TglPointParameterivNV;
+
+  // GL_NV_primitive_restart
+  glPrimitiveRestartNV: TglPrimitiveRestartNV;
+  glPrimitiveRestartIndexNV: TglPrimitiveRestartIndexNV;
+
+  // GL_NV_register_combiners
+  glCombinerParameterfvNV: TglCombinerParameterfvNV;
+  glCombinerParameterfNV: TglCombinerParameterfNV;
+  glCombinerParameterivNV: TglCombinerParameterivNV;
+  glCombinerParameteriNV: TglCombinerParameteriNV;
+  glCombinerInputNV: TglCombinerInputNV;
+  glCombinerOutputNV: TglCombinerOutputNV;
+  glFinalCombinerInputNV: TglFinalCombinerInputNV;
+  glGetCombinerInputParameterfvNV: TglGetCombinerInputParameterfvNV;
+  glGetCombinerInputParameterivNV: TglGetCombinerInputParameterivNV;
+  glGetCombinerOutputParameterfvNV: TglGetCombinerOutputParameterfvNV;
+  glGetCombinerOutputParameterivNV: TglGetCombinerOutputParameterivNV;
+  glGetFinalCombinerInputParameterfvNV: TglGetFinalCombinerInputParameterfvNV;
+  glGetFinalCombinerInputParameterivNV: TglGetFinalCombinerInputParameterivNV;
+
+  // GL_NV_register_combiners2
+  glCombinerStageParameterfvNV: TglCombinerStageParameterfvNV;
+  glGetCombinerStageParameterfvNV: TglGetCombinerStageParameterfvNV;
+
+  // GL_NV_vertex_array_range
+  glFlushVertexArrayRangeNV: TglFlushVertexArrayRangeNV;
+  glVertexArrayRangeNV: TglVertexArrayRangeNV;
+
+  // GL_NV_vertex_program
+  glAreProgramsResidentNV: TglAreProgramsResidentNV;
+  glBindProgramNV: TglBindProgramNV;
+  glDeleteProgramsNV: TglDeleteProgramsNV;
+  glExecuteProgramNV: TglExecuteProgramNV;
+  glGenProgramsNV: TglGenProgramsNV;
+  glGetProgramParameterdvNV: TglGetProgramParameterdvNV;
+  glGetProgramParameterfvNV: TglGetProgramParameterfvNV;
+  glGetProgramivNV: TglGetProgramivNV;
+  glGetProgramStringNV: TglGetProgramStringNV;
+  glGetTrackMatrixivNV: TglGetTrackMatrixivNV;
+  glGetVertexAttribdvNV: TglGetVertexAttribdvNV;
+  glGetVertexAttribfvNV: TglGetVertexAttribfvNV;
+  glGetVertexAttribivNV: TglGetVertexAttribivNV;
+  glGetVertexAttribPointervNV: TglGetVertexAttribPointervNV;
+  glIsProgramNV: TglIsProgramNV;
+  glLoadProgramNV: TglLoadProgramNV;
+  glProgramParameter4dNV: TglProgramParameter4dNV;
+  glProgramParameter4dvNV: TglProgramParameter4dvNV;
+  glProgramParameter4fNV: TglProgramParameter4fNV;
+  glProgramParameter4fvNV: TglProgramParameter4fvNV;
+  glProgramParameters4dvNV: TglProgramParameters4dvNV;
+  glProgramParameters4fvNV: TglProgramParameters4fvNV;
+  glRequestResidentProgramsNV: TglRequestResidentProgramsNV;
+  glTrackMatrixNV: TglTrackMatrixNV;
+  glVertexAttribPointerNV: TglVertexAttribPointerNV;
+  glVertexAttrib1dNV: TglVertexAttrib1dNV;
+  glVertexAttrib1dvNV: TglVertexAttrib1dvNV;
+  glVertexAttrib1fNV: TglVertexAttrib1fNV;
+  glVertexAttrib1fvNV: TglVertexAttrib1fvNV;
+  glVertexAttrib1sNV: TglVertexAttrib1sNV;
+  glVertexAttrib1svNV: TglVertexAttrib1svNV;
+  glVertexAttrib2dNV: TglVertexAttrib2dNV;
+  glVertexAttrib2dvNV: TglVertexAttrib2dvNV;
+  glVertexAttrib2fNV: TglVertexAttrib2fNV;
+  glVertexAttrib2fvNV: TglVertexAttrib2fvNV;
+  glVertexAttrib2sNV: TglVertexAttrib2sNV;
+  glVertexAttrib2svNV: TglVertexAttrib2svNV;
+  glVertexAttrib3dNV: TglVertexAttrib3dNV;
+  glVertexAttrib3dvNV: TglVertexAttrib3dvNV;
+  glVertexAttrib3fNV: TglVertexAttrib3fNV;
+  glVertexAttrib3fvNV: TglVertexAttrib3fvNV;
+  glVertexAttrib3sNV: TglVertexAttrib3sNV;
+  glVertexAttrib3svNV: TglVertexAttrib3svNV;
+  glVertexAttrib4dNV: TglVertexAttrib4dNV;
+  glVertexAttrib4dvNV: TglVertexAttrib4dvNV;
+  glVertexAttrib4fNV: TglVertexAttrib4fNV;
+  glVertexAttrib4fvNV: TglVertexAttrib4fvNV;
+  glVertexAttrib4sNV: TglVertexAttrib4sNV;
+  glVertexAttrib4svNV: TglVertexAttrib4svNV;
+  glVertexAttrib4ubNV: TglVertexAttrib4ubNV;
+  glVertexAttrib4ubvNV: TglVertexAttrib4ubvNV;
+  glVertexAttribs1dvNV: TglVertexAttribs1dvNV;
+  glVertexAttribs1fvNV: TglVertexAttribs1fvNV;
+  glVertexAttribs1svNV: TglVertexAttribs1svNV;
+  glVertexAttribs2dvNV: TglVertexAttribs2dvNV;
+  glVertexAttribs2fvNV: TglVertexAttribs2fvNV;
+  glVertexAttribs2svNV: TglVertexAttribs2svNV;
+  glVertexAttribs3dvNV: TglVertexAttribs3dvNV;
+  glVertexAttribs3fvNV: TglVertexAttribs3fvNV;
+  glVertexAttribs3svNV: TglVertexAttribs3svNV;
+  glVertexAttribs4dvNV: TglVertexAttribs4dvNV;
+  glVertexAttribs4fvNV: TglVertexAttribs4fvNV;
+  glVertexAttribs4svNV: TglVertexAttribs4svNV;
+  glVertexAttribs4ubvNV: TglVertexAttribs4ubvNV;
+
+  // GL_NV_depth_buffer_float
+  glDepthRangedNV: TglDepthRangedNV;
+  glClearDepthdNV: TglClearDepthdNV;
+  glDepthBoundsdNV: TglDepthBoundsdNV;
+
+  // GL_NV_framebuffer_multisample_coverage
+  glRenderbufferStorageMultsampleCoverageNV: TglRenderbufferStorageMultsampleCoverageNV;
+
+  // GL_NV_geometry_program4
+  glProgramVertexLimitNV: TglProgramVertexLimitNV;
+
+  // GL_NV_gpu_program4
+  glProgramLocalParameterI4iNV: TglProgramLocalParameterI4iNV;
+  glProgramLocalParameterI4ivNV: TglProgramLocalParameterI4ivNV;
+  glProgramLocalParametersI4ivNV: TglProgramLocalParametersI4ivNV;
+  glProgramLocalParameterI4uiNV: TglProgramLocalParameterI4uiNV;
+  glProgramLocalParameterI4uivNV: TglProgramLocalParameterI4uivNV;
+  glProgramLocalParametersI4uivNV: TglProgramLocalParametersI4uivNV;
+  glProgramEnvParameterI4iNV: TglProgramEnvParameterI4iNV;
+  glProgramEnvParameterI4ivNV: TglProgramEnvParameterI4ivNV;
+  glProgramEnvParametersI4ivNV: TglProgramEnvParametersI4ivNV;
+  glProgramEnvParameterI4uiNV: TglProgramEnvParameterI4uiNV;
+  glProgramEnvParameterI4uivNV: TglProgramEnvParameterI4uivNV;
+  glProgramEnvParametersI4uivNV: TglProgramEnvParametersI4uivNV;
+  glGetProgramLocalParameterIivNV: TglGetProgramLocalParameterIivNV;
+  glGetProgramLocalParameterIuivNV: TglGetProgramLocalParameterIuivNV;
+  glGetProgramEnvParameterIivNV: TglGetProgramEnvParameterIivNV;
+  glGetProgramEnvParameterIuivNV: TglGetProgramEnvParameterIuivNV;
+
+  // GL_NV_parameter_buffer_object
+  glProgramBufferParametersfvNV: TglProgramBufferParametersfvNV;
+  glProgramBufferParametersIivNV: TglProgramBufferParametersIivNV;
+  glProgramBufferParametersIuivNV: TglProgramBufferParametersIuivNV;
+
+  // GL_NV_transform_feedback
+  glBeginTransformFeedbackNV: TglBeginTransformFeedbackNV;
+  glEndTransformFeedbackNV: TglEndTransformFeedbackNV;
+  glTransformFeedbackAttribsNV: TglTransformFeedbackAttribsNV;
+  glBindBufferRangeNV: TglBindBufferRangeNV;
+  glBindBufferOffsetNV: TglBindBufferOffsetNV;
+  glBindBufferBaseNV: TglBindBufferBaseNV;
+  glTransformFeedbackVaryingsNV: TglTransformFeedbackVaryingsNV;
+  glActiveVaryingNV: TglActiveVaryingNV;
+  glGetVaryingLocationNV: TglGetVaryingLocationNV;
+  glGetActiveVaryingNV: TglGetActiveVaryingNV;
+  glGetTransformFeedbackVaryingNV: TglGetTransformFeedbackVaryingNV;
+  glTransformFeedbackStreamAttribsNV: TglTransformFeedbackStreamAttribsNV;
+
+  // GL_NV_conditional_render
+  glBeginConditionalRenderNV: TglBeginConditionalRenderNV;
+  glEndConditionalRenderNV: TglEndConditionalRenderNV;
+
+  // GL_NV_present_video
+  glPresentFrameKeyedNV: TglPresentFrameKeyedNV;
+  glPresentFrameDualFillNV: TglPresentFrameDualFillNV;
+  glGetVideoivNV: TglGetVideoivNV;
+  glGetVideouivNV: TglGetVideouivNV;
+  glGetVideoi64vNV: TglGetVideoi64vNV;
+  glGetVideoui64vNV: TglGetVideoui64vNV;
+//  glVideoParameterivNV: TglVideoParameterivNV;
+
+  // GL_NV_explicit_multisample
+  glGetMultisamplefvNV: TglGetMultisamplefvNV;
+  glSampleMaskIndexedNV: TglSampleMaskIndexedNV;
+  glTexRenderbufferNV: TglTexRenderbufferNV;
+
+  // GL_NV_transform_feedback2
+  glBindTransformFeedbackNV: TglBindTransformFeedbackNV;
+  glDeleteTransformFeedbacksNV: TglDeleteTransformFeedbacksNV;
+  glGenTransformFeedbacksNV: TglGenTransformFeedbacksNV;
+  glIsTransformFeedbackNV: TglIsTransformFeedbackNV;
+  glPauseTransformFeedbackNV: TglPauseTransformFeedbackNV;
+  glResumeTransformFeedbackNV: TglResumeTransformFeedbackNV;
+  glDrawTransformFeedbackNV: TglDrawTransformFeedbackNV;
+
+  // GL_NV_video_capture
+  glBeginVideoCaptureNV: TglBeginVideoCaptureNV;
+  glBindVideoCaptureStreamBufferNV: TglBindVideoCaptureStreamBufferNV;
+  glBindVideoCaptureStreamTextureNV: TglBindVideoCaptureStreamTextureNV;
+  glEndVideoCaptureNV: TglEndVideoCaptureNV;
+  glGetVideoCaptureivNV: TglGetVideoCaptureivNV;
+  glGetVideoCaptureStreamivNV: TglGetVideoCaptureStreamivNV;
+  glGetVideoCaptureStreamfvNV: TglGetVideoCaptureStreamfvNV;
+  glGetVideoCaptureStreamdvNV: TglGetVideoCaptureStreamdvNV;
+  glVideoCaptureNV: TglVideoCaptureNV;
+  glVideoCaptureStreamParameterivNV: TglVideoCaptureStreamParameterivNV;
+  glVideoCaptureStreamParameterfvNV: TglVideoCaptureStreamParameterfvNV;
+  glVideoCaptureStreamParameterdvNV: TglVideoCaptureStreamParameterdvNV;
+
+  // GL_NV_copy_image
+  glCopyImageSubDataNV: TglCopyImageSubDataNV;
+
+  // GL_NV_shader_buffer_load
+  glMakeBufferResidentNV: TglMakeBufferResidentNV;
+  glMakeBufferNonResidentNV: TglMakeBufferNonResidentNV;
+  glIsBufferResidentNV: TglIsBufferResidentNV;
+  glMakeNamedBufferResidentNV: TglMakeNamedBufferResidentNV;
+  glMakeNamedBufferNonResidentNV: TglMakeNamedBufferNonResidentNV;
+  glIsNamedBufferResidentNV: TglIsNamedBufferResidentNV;
+  glGetBufferParameterui64vNV: TglGetBufferParameterui64vNV;
+  glGetNamedBufferParameterui64vNV: TglGetNamedBufferParameterui64vNV;
+  glGetIntegerui64vNV: TglGetIntegerui64vNV;
+  glUniformui64NV: TglUniformui64NV;
+  glUniformui64vNV: TglUniformui64vNV;
+  glGetUniformui64vNV: TglGetUniformui64vNV;
+  glProgramUniformui64NV: TglProgramUniformui64NV;
+  glProgramUniformui64vNV: TglProgramUniformui64vNV;
+
+  // GL_NV_vertex_buffer_unified_memory
+  glBufferAddressRangeNV: TglBufferAddressRangeNV;
+  glVertexFormatNV: TglVertexFormatNV;
+  glNormalFormatNV: TglNormalFormatNV;
+  glColorFormatNV: TglColorFormatNV;
+  glIndexFormatNV: TglIndexFormatNV;
+  glTexCoordFormatNV: TglTexCoordFormatNV;
+  glEdgeFlagFormatNV: TglEdgeFlagFormatNV;
+  glSecondaryColorFormatNV: TglSecondaryColorFormatNV;
+  glFogCoordFormatNV: TglFogCoordFormatNV;
+  glVertexAttribFormatNV: TglVertexAttribFormatNV;
+  glVertexAttribIFormatNV: TglVertexAttribIFormatNV;
+  glGetIntegerui64i_vNV: TglGetIntegerui64i_vNV;
+
+  // GL_NV_gpu_program5
+  glProgramSubroutineParametersuivNV: TglProgramSubroutineParametersuivNV;
+  glGetProgramSubroutineParameteruivNV: TglGetProgramSubroutineParameteruivNV;
+
+  // GL_NV_gpu_shader5
+  glUniform1i64NV: TglUniform1i64NV;
+  glUniform2i64NV: TglUniform2i64NV;
+  glUniform3i64NV: TglUniform3i64NV;
+  glUniform4i64NV: TglUniform4i64NV;
+  glUniform1i64vNV: TglUniform1i64vNV;
+  glUniform2i64vNV: TglUniform2i64vNV;
+  glUniform3i64vNV: TglUniform3i64vNV;
+  glUniform4i64vNV: TglUniform4i64vNV;
+  glUniform1ui64NV: TglUniform1ui64NV;
+  glUniform2ui64NV: TglUniform2ui64NV;
+  glUniform3ui64NV: TglUniform3ui64NV;
+  glUniform4ui64NV: TglUniform4ui64NV;
+  glUniform1ui64vNV: TglUniform1ui64vNV;
+  glUniform2ui64vNV: TglUniform2ui64vNV;
+  glUniform3ui64vNV: TglUniform3ui64vNV;
+  glUniform4ui64vNV: TglUniform4ui64vNV;
+  glGetUniformi64vNV: TglGetUniformi64vNV;
+  glProgramUniform1i64NV: TglProgramUniform1i64NV;
+  glProgramUniform2i64NV: TglProgramUniform2i64NV;
+  glProgramUniform3i64NV: TglProgramUniform3i64NV;
+  glProgramUniform4i64NV: TglProgramUniform4i64NV;
+  glProgramUniform1i64vNV: TglProgramUniform1i64vNV;
+  glProgramUniform2i64vNV: TglProgramUniform2i64vNV;
+  glProgramUniform3i64vNV: TglProgramUniform3i64vNV;
+  glProgramUniform4i64vNV: TglProgramUniform4i64vNV;
+  glProgramUniform1ui64NV: TglProgramUniform1ui64NV;
+  glProgramUniform2ui64NV: TglProgramUniform2ui64NV;
+  glProgramUniform3ui64NV: TglProgramUniform3ui64NV;
+  glProgramUniform4ui64NV: TglProgramUniform4ui64NV;
+  glProgramUniform1ui64vNV: TglProgramUniform1ui64vNV;
+  glProgramUniform2ui64vNV: TglProgramUniform2ui64vNV;
+  glProgramUniform3ui64vNV: TglProgramUniform3ui64vNV;
+  glProgramUniform4ui64vNV: TglProgramUniform4ui64vNV;
+
+  // GL_NV_vertex_attrib_integer_64bit
+  glVertexAttribL1i64NV: TglVertexAttribL1i64NV;
+  glVertexAttribL2i64NV: TglVertexAttribL2i64NV;
+  glVertexAttribL3i64NV: TglVertexAttribL3i64NV;
+  glVertexAttribL4i64NV: TglVertexAttribL4i64NV;
+  glVertexAttribL1i64vNV: TglVertexAttribL1i64vNV;
+  glVertexAttribL2i64vNV: TglVertexAttribL2i64vNV;
+  glVertexAttribL3i64vNV: TglVertexAttribL3i64vNV;
+  glVertexAttribL4i64vNV: TglVertexAttribL4i64vNV;
+  glVertexAttribL1ui64NV: TglVertexAttribL1ui64NV;
+  glVertexAttribL2ui64NV: TglVertexAttribL2ui64NV;
+  glVertexAttribL3ui64NV: TglVertexAttribL3ui64NV;
+  glVertexAttribL4ui64NV: TglVertexAttribL4ui64NV;
+  glVertexAttribL1ui64vNV: TglVertexAttribL1ui64vNV;
+  glVertexAttribL2ui64vNV: TglVertexAttribL2ui64vNV;
+  glVertexAttribL3ui64vNV: TglVertexAttribL3ui64vNV;
+  glVertexAttribL4ui64vNV: TglVertexAttribL4ui64vNV;
+  glGetVertexAttribLi64vNV: TglGetVertexAttribLi64vNV;
+  glGetVertexAttribLui64vNV: TglGetVertexAttribLui64vNV;
+  glVertexAttribLFormatNV: TglVertexAttribLFormatNV;
+
+  // GL_NV_vdpau_interop
+  glVDPAUInitNV: TglVDPAUInitNV;
+  glVDPAUFiniNV: TglVDPAUFiniNV;
+  glVDPAURegisterVideoSurfaceNV: TglVDPAURegisterVideoSurfaceNV;
+  glVDPAURegisterOutputSurfaceNV: TglVDPAURegisterOutputSurfaceNV;
+  glVDPAUIsSurfaceNV: TglVDPAUIsSurfaceNV;
+  glVDPAUUnregisterSurfaceNV: TglVDPAUUnregisterSurfaceNV;
+  glVDPAUGetSurfaceivNV: TglVDPAUGetSurfaceivNV;
+  glVDPAUSurfaceAccessNV: TglVDPAUSurfaceAccessNV;
+  glVDPAUMapSurfacesNV: TglVDPAUMapSurfacesNV;
+  glVDPAUUnmapSurfacesNV: TglVDPAUUnmapSurfacesNV;
+
+  // GL_NV_texture_barrier
+  glTextureBarrierNV: TglTextureBarrierNV;
+
+  // (4.3) GL_NV_path_rendering
+  glGenPathsNV : TglGenPathsNV;
+  glDeletePathsNV : TglDeletePathsNV;
+  glIsPathNV : TglIsPathNV;
+  glPathCommandsNV : TglPathCommandsNV;
+  glPathCoordsNV : TglPathCoordsNV;
+  glPathSubCommandsNV : TglPathSubCommandsNV;
+  glPathSubCoordsNV : TglPathSubCoordsNV;
+  glPathStringNV : TglPathStringNV;
+  glPathGlyphsNV : TglPathGlyphsNV;
+  glPathGlyphRangeNV : TglPathGlyphRangeNV;
+  glWeightPathsNV : TglWeightPathsNV;
+  glCopyPathNV : TglCopyPathNV;
+  glInterpolatePathsNV : TglInterpolatePathsNV;
+  glTransformPathNV : TglTransformPathNV;
+  glPathParameterivNV : TglPathParameterivNV;
+  glPathParameteriNV : TglPathParameteriNV;
+  glPathParameterfvNV : TglPathParameterfvNV;
+  glPathParameterfNV : TglPathParameterfNV;
+  glPathDashArrayNV : TglPathDashArrayNV;
+  glPathStencilFuncNV : TglPathStencilFuncNV;
+  glPathStencilDepthOffsetNV : TglPathStencilDepthOffsetNV;
+  glStencilFillPathNV : TglStencilFillPathNV;
+  glStencilStrokePathNV : TglStencilStrokePathNV;
+  glStencilFillPathInstancedNV : TglStencilFillPathInstancedNV;
+  glStencilStrokePathInstancedNV : TglStencilStrokePathInstancedNV;
+  glPathCoverDepthFuncNV : TglPathCoverDepthFuncNV;
+  glPathColorGenNV : TglPathColorGenNV;
+  glPathTexGenNV : TglPathTexGenNV;
+  glPathFogGenNV : TglPathFogGenNV;
+  glCoverFillPathNV : TglCoverFillPathNV;
+  glCoverStrokePathNV : TglCoverStrokePathNV;
+  glCoverFillPathInstancedNV : TglCoverFillPathInstancedNV;
+  glCoverStrokePathInstancedNV : TglCoverStrokePathInstancedNV;
+  glGetPathParameterivNV : TglGetPathParameterivNV;
+  glGetPathParameterfvNV : TglGetPathParameterfvNV;
+  glGetPathCommandsNV : TglGetPathCommandsNV;
+  glGetPathCoordsNV : TglGetPathCoordsNV;
+  glGetPathDashArrayNV : TglGetPathDashArrayNV;
+  glGetPathMetricsNV : TglGetPathMetricsNV;
+  glGetPathMetricRangeNV : TglGetPathMetricRangeNV;
+  glGetPathSpacingNV : TglGetPathSpacingNV;
+  glGetPathColorGenivNV : TglGetPathColorGenivNV;
+  glGetPathColorGenfvNV : TglGetPathColorGenfvNV;
+  glGetPathTexGenivNV : TglGetPathTexGenivNV;
+  glGetPathTexGenfvNV : TglGetPathTexGenfvNV;
+  glIsPointInFillPathNV : TglIsPointInFillPathNV;
+  glIsPointInStrokePathNV : TglIsPointInStrokePathNV;
+  glGetPathLengthNV : TglGetPathLengthNV;
+  glPointAlongPathNV : TglPointAlongPathNV;
+
+  // GL_AMD_pinned_memory
+
+  // GL_AMD_stencil_operation_extended
+  glStencilOpValueAMD : TglStencilOpValueAMD;
+
+  // GL_AMD_vertex_shader_viewport_index
+
+  // GL_AMD_vertex_shader_layer
+
+  // GL_NV_bindless_texture
+  glGetTextureHandleNV : TglGetTextureHandleNV;
+  glGetTextureSamplerHandleNV : TglGetTextureSamplerHandleNV;
+  glMakeTextureHandleResidentNV : TglMakeTextureHandleResidentNV;
+  glMakeTextureHandleNonResidentNV : TglMakeTextureHandleNonResidentNV;
+  glGetImageHandleNV : TglGetImageHandleNV;
+  glMakeImageHandleResidentNV : TglMakeImageHandleResidentNV;
+  glMakeImageHandleNonResidentNV : TglMakeImageHandleNonResidentNV;
+  glUniformHandleui64NV : TglUniformHandleui64NV;
+  glUniformHandleui64vNV : TglUniformHandleui64vNV;
+  glProgramUniformHandleui64NV : TglProgramUniformHandleui64NV;
+  glProgramUniformHandleui64vNV : TglProgramUniformHandleui64vNV;
+  glIsTextureHandleResidentNV : TglIsTextureHandleResidentNV;
+  glIsImageHandleResidentNV : TglIsImageHandleResidentNV;
+
+  //
+
+  // GL_PGI_misc_hints
+  glHintPGI: TglHintPGI;
+
+  // GL_SGIS_detail_texture
+  glDetailTexFuncSGIS: TglDetailTexFuncSGIS;
+  glGetDetailTexFuncSGIS: TglGetDetailTexFuncSGIS;
+
+  // GL_SGIS_fog_function
+  glFogFuncSGIS: TglFogFuncSGIS;
+  glGetFogFuncSGIS: TglGetFogFuncSGIS;
+
+  // GL_SGIS_multisample
+  glSampleMaskSGIS: TglSampleMaskSGIS;
+  glSamplePatternSGIS: TglSamplePatternSGIS;
+
+  // GL_SGIS_pixel_texture
+  glPixelTexGenParameteriSGIS: TglPixelTexGenParameteriSGIS;
+  glPixelTexGenParameterivSGIS: TglPixelTexGenParameterivSGIS;
+  glPixelTexGenParameterfSGIS: TglPixelTexGenParameterfSGIS;
+  glPixelTexGenParameterfvSGIS: TglPixelTexGenParameterfvSGIS;
+  glGetPixelTexGenParameterivSGIS: TglGetPixelTexGenParameterivSGIS;
+  glGetPixelTexGenParameterfvSGIS: TglGetPixelTexGenParameterfvSGIS;
+
+  // GL_SGIS_point_parameters
+  glPointParameterfSGIS: TglPointParameterfSGIS;
+  glPointParameterfvSGIS: TglPointParameterfvSGIS;
+
+  // GL_SGIS_sharpen_texture
+  glSharpenTexFuncSGIS: TglSharpenTexFuncSGIS;
+  glGetSharpenTexFuncSGIS: TglGetSharpenTexFuncSGIS;
+
+  // GL_SGIS_texture4D
+  glTexImage4DSGIS: TglTexImage4DSGIS;
+  glTexSubImage4DSGIS: TglTexSubImage4DSGIS;
+
+  // GL_SGIS_texture_color_mask
+  glTextureColorMaskSGIS: TglTextureColorMaskSGIS;
+
+  // GL_SGIS_texture_filter4
+  glGetTexFilterFuncSGIS: TglGetTexFilterFuncSGIS;
+  glTexFilterFuncSGIS: TglTexFilterFuncSGIS;
+
+  // GL_SGIX_async
+  glAsyncMarkerSGIX: TglAsyncMarkerSGIX;
+  glFinishAsyncSGIX: TglFinishAsyncSGIX;
+  glPollAsyncSGIX: TglPollAsyncSGIX;
+  glGenAsyncMarkersSGIX: TglGenAsyncMarkersSGIX;
+  glDeleteAsyncMarkersSGIX: TglDeleteAsyncMarkersSGIX;
+  glIsAsyncMarkerSGIX: TglIsAsyncMarkerSGIX;
+
+  // GL_SGIX_flush_raster
+  glFlushRasterSGIX: TglFlushRasterSGIX;
+
+  // GL_SGIX_fragment_lighting
+  glFragmentColorMaterialSGIX: TglFragmentColorMaterialSGIX;
+  glFragmentLightfSGIX: TglFragmentLightfSGIX;
+  glFragmentLightfvSGIX: TglFragmentLightfvSGIX;
+  glFragmentLightiSGIX: TglFragmentLightiSGIX;
+  glFragmentLightivSGIX: TglFragmentLightivSGIX;
+  glFragmentLightModelfSGIX: TglFragmentLightModelfSGIX;
+  glFragmentLightModelfvSGIX: TglFragmentLightModelfvSGIX;
+  glFragmentLightModeliSGIX: TglFragmentLightModeliSGIX;
+  glFragmentLightModelivSGIX: TglFragmentLightModelivSGIX;
+  glFragmentMaterialfSGIX: TglFragmentMaterialfSGIX;
+  glFragmentMaterialfvSGIX: TglFragmentMaterialfvSGIX;
+  glFragmentMaterialiSGIX: TglFragmentMaterialiSGIX;
+  glFragmentMaterialivSGIX: TglFragmentMaterialivSGIX;
+  glGetFragmentLightfvSGIX: TglGetFragmentLightfvSGIX;
+  glGetFragmentLightivSGIX: TglGetFragmentLightivSGIX;
+  glGetFragmentMaterialfvSGIX: TglGetFragmentMaterialfvSGIX;
+  glGetFragmentMaterialivSGIX: TglGetFragmentMaterialivSGIX;
+  glLightEnviSGIX: TglLightEnviSGIX;
+
+  // GL_SGIX_framezoom
+  glFrameZoomSGIX: TglFrameZoomSGIX;
+
+  // GL_SGIX_igloo_interface
+  glIglooInterfaceSGIX: TglIglooInterfaceSGIX;
+
+  // GL_SGIX_instruments
+  glGetInstrumentsSGIX: TglGetInstrumentsSGIX;
+  glInstrumentsBufferSGIX: TglInstrumentsBufferSGIX;
+  glPollInstrumentsSGIX: TglPollInstrumentsSGIX;
+  glReadInstrumentsSGIX: TglReadInstrumentsSGIX;
+  glStartInstrumentsSGIX: TglStartInstrumentsSGIX;
+  glStopInstrumentsSGIX: TglStopInstrumentsSGIX;
+
+  // GL_SGIX_list_priority
+  glGetListParameterfvSGIX: TglGetListParameterfvSGIX;
+  glGetListParameterivSGIX: TglGetListParameterivSGIX;
+  glListParameterfSGIX: TglListParameterfSGIX;
+  glListParameterfvSGIX: TglListParameterfvSGIX;
+  glListParameteriSGIX: TglListParameteriSGIX;
+  glListParameterivSGIX: TglListParameterivSGIX;
+
+  // GL_SGIX_pixel_texture
+  glPixelTexGenSGIX: TglPixelTexGenSGIX;
+
+  // GL_SGIX_polynomial_ffd
+  glDeformationMap3dSGIX: TglDeformationMap3dSGIX;
+  glDeformationMap3fSGIX: TglDeformationMap3fSGIX;
+  glDeformSGIX: TglDeformSGIX;
+  glLoadIdentityDeformationMapSGIX: TglLoadIdentityDeformationMapSGIX;
+
+  // GL_SGIX_reference_plane
+  glReferencePlaneSGIX: TglReferencePlaneSGIX;
+
+  // GL_SGIX_sprite
+  glSpriteParameterfSGIX: TglSpriteParameterfSGIX;
+  glSpriteParameterfvSGIX: TglSpriteParameterfvSGIX;
+  glSpriteParameteriSGIX: TglSpriteParameteriSGIX;
+  glSpriteParameterivSGIX: TglSpriteParameterivSGIX;
+
+  // GL_SGIX_tag_sample_buffer
+  glTagSampleBufferSGIX: TglTagSampleBufferSGIX;
+
+  // GL_SGI_color_table
+  glColorTableSGI: TglColorTableSGI;
+  glColorTableParameterfvSGI: TglColorTableParameterfvSGI;
+  glColorTableParameterivSGI: TglColorTableParameterivSGI;
+  glCopyColorTableSGI: TglCopyColorTableSGI;
+  glGetColorTableSGI: TglGetColorTableSGI;
+  glGetColorTableParameterfvSGI: TglGetColorTableParameterfvSGI;
+  glGetColorTableParameterivSGI: TglGetColorTableParameterivSGI;
+
+  // GL_SUNX_constant_data
+  glFinishTextureSUNX: TglFinishTextureSUNX;
+
+  // GL_SUN_global_alpha
+  glGlobalAlphaFactorbSUN: TglGlobalAlphaFactorbSUN;
+  glGlobalAlphaFactorsSUN: TglGlobalAlphaFactorsSUN;
+  glGlobalAlphaFactoriSUN: TglGlobalAlphaFactoriSUN;
+  glGlobalAlphaFactorfSUN: TglGlobalAlphaFactorfSUN;
+  glGlobalAlphaFactordSUN: TglGlobalAlphaFactordSUN;
+  glGlobalAlphaFactorubSUN: TglGlobalAlphaFactorubSUN;
+  glGlobalAlphaFactorusSUN: TglGlobalAlphaFactorusSUN;
+  glGlobalAlphaFactoruiSUN: TglGlobalAlphaFactoruiSUN;
+
+  // GL_SUN_mesh_array
+  glDrawMeshArraysSUN: TglDrawMeshArraysSUN;
+
+  // GL_SUN_triangle_list
+  glReplacementCodeuiSUN: TglReplacementCodeuiSUN;
+  glReplacementCodeusSUN: TglReplacementCodeusSUN;
+  glReplacementCodeubSUN: TglReplacementCodeubSUN;
+  glReplacementCodeuivSUN: TglReplacementCodeuivSUN;
+  glReplacementCodeusvSUN: TglReplacementCodeusvSUN;
+  glReplacementCodeubvSUN: TglReplacementCodeubvSUN;
+  glReplacementCodePointerSUN: TglReplacementCodePointerSUN;
+
+  // GL_SUN_vertex
+  glColor4ubVertex2fSUN: TglColor4ubVertex2fSUN;
+  glColor4ubVertex2fvSUN: TglColor4ubVertex2fvSUN;
+  glColor4ubVertex3fSUN: TglColor4ubVertex3fSUN;
+  glColor4ubVertex3fvSUN: TglColor4ubVertex3fvSUN;
+  glColor3fVertex3fSUN: TglColor3fVertex3fSUN;
+  glColor3fVertex3fvSUN: TglColor3fVertex3fvSUN;
+  glNormal3fVertex3fSUN: TglNormal3fVertex3fSUN;
+  glNormal3fVertex3fvSUN: TglNormal3fVertex3fvSUN;
+  glColor4fNormal3fVertex3fSUN: TglColor4fNormal3fVertex3fSUN;
+  glColor4fNormal3fVertex3fvSUN: TglColor4fNormal3fVertex3fvSUN;
+  glTexCoord2fVertex3fSUN: TglTexCoord2fVertex3fSUN;
+  glTexCoord2fVertex3fvSUN: TglTexCoord2fVertex3fvSUN;
+  glTexCoord4fVertex4fSUN: TglTexCoord4fVertex4fSUN;
+  glTexCoord4fVertex4fvSUN: TglTexCoord4fVertex4fvSUN;
+  glTexCoord2fColor4ubVertex3fSUN: TglTexCoord2fColor4ubVertex3fSUN;
+  glTexCoord2fColor4ubVertex3fvSUN: TglTexCoord2fColor4ubVertex3fvSUN;
+  glTexCoord2fColor3fVertex3fSUN: TglTexCoord2fColor3fVertex3fSUN;
+  glTexCoord2fColor3fVertex3fvSUN: TglTexCoord2fColor3fVertex3fvSUN;
+  glTexCoord2fNormal3fVertex3fSUN: TglTexCoord2fNormal3fVertex3fSUN;
+  glTexCoord2fNormal3fVertex3fvSUN: TglTexCoord2fNormal3fVertex3fvSUN;
+  glTexCoord2fColor4fNormal3fVertex3fSUN: TglTexCoord2fColor4fNormal3fVertex3fSUN;
+  glTexCoord2fColor4fNormal3fVertex3fvSUN: TglTexCoord2fColor4fNormal3fVertex3fvSUN;
+  glTexCoord4fColor4fNormal3fVertex4fSUN: TglTexCoord4fColor4fNormal3fVertex4fSUN;
+  glTexCoord4fColor4fNormal3fVertex4fvSUN: TglTexCoord4fColor4fNormal3fVertex4fvSUN;
+  glReplacementCodeuiVertex3fSUN: TglReplacementCodeuiVertex3fSUN;
+  glReplacementCodeuiVertex3fvSUN: TglReplacementCodeuiVertex3fvSUN;
+  glReplacementCodeuiColor4ubVertex3fSUN: TglReplacementCodeuiColor4ubVertex3fSUN;
+  glReplacementCodeuiColor4ubVertex3fvSUN: TglReplacementCodeuiColor4ubVertex3fvSUN;
+  glReplacementCodeuiColor3fVertex3fSUN: TglReplacementCodeuiColor3fVertex3fSUN;
+  glReplacementCodeuiColor3fVertex3fvSUN: TglReplacementCodeuiColor3fVertex3fvSUN;
+  glReplacementCodeuiNormal3fVertex3fSUN: TglReplacementCodeuiNormal3fVertex3fSUN;
+  glReplacementCodeuiNormal3fVertex3fvSUN: TglReplacementCodeuiNormal3fVertex3fvSUN;
+  glReplacementCodeuiColor4fNormal3fVertex3fSUN: TglReplacementCodeuiColor4fNormal3fVertex3fSUN;
+  glReplacementCodeuiColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiColor4fNormal3fVertex3fvSUN;
+  glReplacementCodeuiTexCoord2fVertex3fSUN: TglReplacementCodeuiTexCoord2fVertex3fSUN;
+  glReplacementCodeuiTexCoord2fVertex3fvSUN: TglReplacementCodeuiTexCoord2fVertex3fvSUN;
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN;
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN;
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN;
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN: TglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN;
+
+{$IFDEF DGL_WIN}
+  wglGetProcAddress: TwglGetProcAddress;
+  wglCopyContext: TwglCopyContext;
+  wglCreateContext: TwglCreateContext;
+  wglCreateLayerContext: TwglCreateLayerContext;
+  wglDeleteContext: TwglDeleteContext;
+  wglDescribeLayerPlane: TwglDescribeLayerPlane;
+  wglGetCurrentContext: TwglGetCurrentContext;
+  wglGetCurrentDC: TwglGetCurrentDC;
+  wglGetLayerPaletteEntries: TwglGetLayerPaletteEntries;
+  wglMakeCurrent: TwglMakeCurrent;
+  wglRealizeLayerPalette: TwglRealizeLayerPalette;
+  wglSetLayerPaletteEntries: TwglSetLayerPaletteEntries;
+  wglShareLists: TwglShareLists;
+  wglSwapLayerBuffers: TwglSwapLayerBuffers;
+  wglSwapMultipleBuffers: TwglSwapMultipleBuffers;
+  wglUseFontBitmapsA: TwglUseFontBitmapsA;
+  wglUseFontOutlinesA: TwglUseFontOutlinesA;
+  wglUseFontBitmapsW: TwglUseFontBitmapsW;
+  wglUseFontOutlinesW: TwglUseFontOutlinesW;
+  wglUseFontBitmaps: TwglUseFontBitmaps;
+  wglUseFontOutlines: TwglUseFontOutlines;
+
+   // WGL_ARB_buffer_region
+  wglCreateBufferRegionARB: TwglCreateBufferRegionARB;
+  wglDeleteBufferRegionARB: TwglDeleteBufferRegionARB;
+  wglSaveBufferRegionARB: TwglSaveBufferRegionARB;
+  wglRestoreBufferRegionARB: TwglRestoreBufferRegionARB;
+
+  // WGL_ARB_extensions_string
+  wglGetExtensionsStringARB: TwglGetExtensionsStringARB;
+
+  // WGL_ARB_make_current_read
+  wglMakeContextCurrentARB: TwglMakeContextCurrentARB;
+  wglGetCurrentReadDCARB: TwglGetCurrentReadDCARB;
+
+  // WGL_ARB_pbuffer
+  wglCreatePbufferARB: TwglCreatePbufferARB;
+  wglGetPbufferDCARB: TwglGetPbufferDCARB;
+  wglReleasePbufferDCARB: TwglReleasePbufferDCARB;
+  wglDestroyPbufferARB: TwglDestroyPbufferARB;
+  wglQueryPbufferARB: TwglQueryPbufferARB;
+
+  // WGL_ARB_pixel_format
+  wglGetPixelFormatAttribivARB: TwglGetPixelFormatAttribivARB;
+  wglGetPixelFormatAttribfvARB: TwglGetPixelFormatAttribfvARB;
+  wglChoosePixelFormatARB: TwglChoosePixelFormatARB;
+  // WGL_ARB_color_buffer_float
+  wglClampColorARB: TwglClampColorARB;
+
+  // WGL_ARB_render_texture
+  wglBindTexImageARB: TwglBindTexImageARB;
+  wglReleaseTexImageARB: TwglReleaseTexImageARB;
+  wglSetPbufferAttribARB: TwglSetPbufferAttribARB;
+
+  // WGL_ARB_create_context
+  wglCreateContextAttribsARB: TwglCreateContextAttribsARB;
+
+  // WGL_AMD_gpu_association
+  wglGetGPUIDsAMD: TwglGetGPUIDsAMD;
+  wglGetGPUInfoAMD: TwglGetGPUInfoAMD;
+  wglGetContextGPUIDAMD: TwglGetContextGPUIDAMD;
+  wglCreateAssociatedContextAMD: TwglCreateAssociatedContextAMD;
+  wglCreateAssociatedContextAttribsAMD: TwglCreateAssociatedContextAttribsAMD;
+  wglDeleteAssociatedContextAMD: TwglDeleteAssociatedContextAMD;
+  wglMakeAssociatedContextCurrentAMD: TwglMakeAssociatedContextCurrentAMD;
+  wglGetCurrentAssociatedContextAMD: TwglGetCurrentAssociatedContextAMD;
+  wglBlitContextFramebufferAMD: TwglBlitContextFramebufferAMD;
+
+  // WGL_EXT_display_color_table
+  wglCreateDisplayColorTableEXT: TwglCreateDisplayColorTableEXT;
+  wglLoadDisplayColorTableEXT: TwglLoadDisplayColorTableEXT;
+  wglBindDisplayColorTableEXT: TwglBindDisplayColorTableEXT;
+  wglDestroyDisplayColorTableEXT: TwglDestroyDisplayColorTableEXT;
+
+  // WGL_EXT_extensions_string
+  wglGetExtensionsStringEXT: TwglGetExtensionsStringEXT;
+
+  // WGL_EXT_make_current_read
+  wglMakeContextCurrentEXT: TwglMakeContextCurrentEXT;
+  wglGetCurrentReadDCEXT: TwglGetCurrentReadDCEXT;
+
+  // WGL_EXT_pbuffer
+  wglCreatePbufferEXT: TwglCreatePbufferEXT;
+  wglGetPbufferDCEXT: TwglGetPbufferDCEXT;
+  wglReleasePbufferDCEXT: TwglReleasePbufferDCEXT;
+  wglDestroyPbufferEXT: TwglDestroyPbufferEXT;
+  wglQueryPbufferEXT: TwglQueryPbufferEXT;
+
+  // WGL_EXT_pixel_format
+  wglGetPixelFormatAttribivEXT: TwglGetPixelFormatAttribivEXT;
+  wglGetPixelFormatAttribfvEXT: TwglGetPixelFormatAttribfvEXT;
+  wglChoosePixelFormatEXT: TwglChoosePixelFormatEXT;
+
+  // WGL_EXT_swap_control
+  wglSwapIntervalEXT: TwglSwapIntervalEXT;
+  wglGetSwapIntervalEXT: TwglGetSwapIntervalEXT;
+
+  // WGL_I3D_digital_video_control
+  wglGetDigitalVideoParametersI3D: TwglGetDigitalVideoParametersI3D;
+  wglSetDigitalVideoParametersI3D: TwglSetDigitalVideoParametersI3D;
+
+  // WGL_I3D_gamma
+  wglGetGammaTableParametersI3D: TwglGetGammaTableParametersI3D;
+  wglSetGammaTableParametersI3D: TwglSetGammaTableParametersI3D;
+  wglGetGammaTableI3D: TwglGetGammaTableI3D;
+  wglSetGammaTableI3D: TwglSetGammaTableI3D;
+
+  // WGL_I3D_genlock
+  wglEnableGenlockI3D: TwglEnableGenlockI3D;
+  wglDisableGenlockI3D: TwglDisableGenlockI3D;
+  wglIsEnabledGenlockI3D: TwglIsEnabledGenlockI3D;
+  wglGenlockSourceI3D: TwglGenlockSourceI3D;
+  wglGetGenlockSourceI3D: TwglGetGenlockSourceI3D;
+  wglGenlockSourceEdgeI3D: TwglGenlockSourceEdgeI3D;
+  wglGetGenlockSourceEdgeI3D: TwglGetGenlockSourceEdgeI3D;
+  wglGenlockSampleRateI3D: TwglGenlockSampleRateI3D;
+  wglGetGenlockSampleRateI3D: TwglGetGenlockSampleRateI3D;
+  wglGenlockSourceDelayI3D: TwglGenlockSourceDelayI3D;
+  wglGetGenlockSourceDelayI3D: TwglGetGenlockSourceDelayI3D;
+  wglQueryGenlockMaxSourceDelayI3D: TwglQueryGenlockMaxSourceDelayI3D;
+
+  // WGL_I3D_image_buffer
+  wglCreateImageBufferI3D: TwglCreateImageBufferI3D;
+  wglDestroyImageBufferI3D: TwglDestroyImageBufferI3D;
+  wglAssociateImageBufferEventsI3D: TwglAssociateImageBufferEventsI3D;
+  wglReleaseImageBufferEventsI3D: TwglReleaseImageBufferEventsI3D;
+
+  // WGL_I3D_swap_frame_lock
+  wglEnableFrameLockI3D: TwglEnableFrameLockI3D;
+  wglDisableFrameLockI3D: TwglDisableFrameLockI3D;
+  wglIsEnabledFrameLockI3D: TwglIsEnabledFrameLockI3D;
+  wglQueryFrameLockMasterI3D: TwglQueryFrameLockMasterI3D;
+
+  // WGL_I3D_swap_frame_usage
+  wglGetFrameUsageI3D: TwglGetFrameUsageI3D;
+  wglBeginFrameTrackingI3D: TwglBeginFrameTrackingI3D;
+  wglEndFrameTrackingI3D: TwglEndFrameTrackingI3D;
+  wglQueryFrameTrackingI3D: TwglQueryFrameTrackingI3D;
+
+  // WGL_NV_vertex_array_range
+  wglAllocateMemoryNV: TwglAllocateMemoryNV;
+  wglFreeMemoryNV: TwglFreeMemoryNV;
+
+  // WGL_NV_present_video
+  wglEnumerateVideoDevicesNV: TwglEnumerateVideoDevicesNV;
+  wglBindVideoDeviceNV: TwglBindVideoDeviceNV;
+  wglQueryCurrentContextNV: TwglQueryCurrentContextNV;
+
+  // WGL_NV_video_output
+  wglGetVideoDeviceNV: TwglGetVideoDeviceNV;
+  wglReleaseVideoDeviceNV: TwglReleaseVideoDeviceNV;
+  wglBindVideoImageNV: TwglBindVideoImageNV;
+  wglReleaseVideoImageNV: TwglReleaseVideoImageNV;
+  wglSendPbufferToVideoNV: TwglSendPbufferToVideoNV;
+  wglGetVideoInfoNV: TwglGetVideoInfoNV;
+
+  // WGL_NV_swap_group
+  wglJoinSwapGroupNV: TwglJoinSwapGroupNV;
+  wglBindSwapBarrierNV: TwglBindSwapBarrierNV;
+  wglQuerySwapGroupNV: TwglQuerySwapGroupNV;
+  wglQueryMaxSwapGroupsNV: TwglQueryMaxSwapGroupsNV;
+  wglQueryFrameCountNV: TwglQueryFrameCountNV;
+  wglResetFrameCountNV: TwglResetFrameCountNV;
+
+  // WGL_NV_gpu_affinity
+  wglEnumGpusNV: TwglEnumGpusNV;
+  wglEnumGpuDevicesNV: TwglEnumGpuDevicesNV;
+  wglCreateAffinityDCNV: TwglCreateAffinityDCNV;
+  wglEnumGpusFromAffinityDCNV: TwglEnumGpusFromAffinityDCNV;
+  wglDeleteDCNV: TwglDeleteDCNV;
+
+  // WGL_NV_video_capture
+  wglBindVideoCaptureDeviceNV: TwglBindVideoCaptureDeviceNV;
+  wglEnumerateVideoCaptureDevicesNV: TwglEnumerateVideoCaptureDevicesNV;
+  wglLockVideoCaptureDeviceNV: TwglLockVideoCaptureDeviceNV;
+  wglQueryVideoCaptureDeviceNV: TwglQueryVideoCaptureDeviceNV;
+  wglReleaseVideoCaptureDeviceNV: TwglReleaseVideoCaptureDeviceNV;
+
+  // WGL_NV_copy_image
+  wglCopyImageSubDataNV: TwglCopyImageSubDataNV;
+
+  // WGL_NV_DX_interop
+  wglDXSetResourceShareHandleNV : TwglDXSetResourceShareHandleNV;
+  wglDXOpenDeviceNV : TwglDXOpenDeviceNV;
+  wglDXCloseDeviceNV : TwglDXCloseDeviceNV;
+  wglDXRegisterObjectNV : TwglDXRegisterObjectNV;
+  wglDXUnregisterObjectNV : TwglDXUnregisterObjectNV;
+  wglDXObjectAccessNV : TwglDXObjectAccessNV;
+  wglDXLockObjectsNV : TwglDXLockObjectsNV;
+  wglDXUnlockObjectsNV : TwglDXUnlockObjectsNV;
+
+  // WGL_OML_sync_control
+  wglGetSyncValuesOML: TwglGetSyncValuesOML;
+  wglGetMscRateOML: TwglGetMscRateOML;
+  wglSwapBuffersMscOML: TwglSwapBuffersMscOML;
+  wglSwapLayerBuffersMscOML: TwglSwapLayerBuffersMscOML;
+  wglWaitForMscOML: TwglWaitForMscOML;
+  wglWaitForSbcOML: TwglWaitForSbcOML;
+
+  // WGL_3DL_stereo_control
+  wglSetStereoEmitterState3DL: TwglSetStereoEmitterState3DL;
+
+  // WIN_draw_range_elements
+  glDrawRangeElementsWIN: TglDrawRangeElementsWIN;
+
+  // WIN_swap_hint
+  glAddSwapHintRectWIN: TglAddSwapHintRectWIN;
+{$ENDIF}
+
+{$IFDEF DGL_LINUX}
+  glXChooseVisual: TglXChooseVisual;
+  glXCopyContext: TglXCopyContext;
+  glXCreateContext: TglXCreateContext;
+  glXCreateGLXPixmap: TglXCreateGLXPixmap;
+  glXDestroyContext: TglXDestroyContext;
+  glXDestroyGLXPixmap: TglXDestroyGLXPixmap;
+  glXGetConfig: TglXGetConfig;
+  glXGetCurrentContext: TglXGetCurrentContext;
+  glXGetCurrentDrawable: TglXGetCurrentDrawable;
+  glXIsDirect: TglXIsDirect;
+  glXMakeCurrent: TglXMakeCurrent;
+  glXQueryExtension: TglXQueryExtension;
+  glXQueryVersion: TglXQueryVersion;
+  glXSwapBuffers: TglXSwapBuffers;
+  glXUseXFont: TglXUseXFont;
+  glXWaitGL: TglXWaitGL;
+  glXWaitX: TglXWaitX;
+
+  glXGetClientString: TglXGetClientString;
+  glXQueryServerString: TglXQueryServerString;
+  glXQueryExtensionsString: TglXQueryExtensionsString;
+
+  // GLX_VERSION_1_3
+  glXGetFBConfigs: TglXGetFBConfigs;
+  glXChooseFBConfig: TglXChooseFBConfig;
+  glXGetFBConfigAttrib: TglXGetFBConfigAttrib;
+  glXGetVisualFromFBConfig: TglXGetVisualFromFBConfig;
+  glXCreateWindow: TglXCreateWindow;
+  glXDestroyWindow: TglXDestroyWindow;
+  glXCreatePixmap: TglXCreatePixmap;
+
+  glXDestroyPixmap: TglXDestroyPixmap;
+  glXCreatePbuffer: TglXCreatePbuffer;
+  glXDestroyPbuffer: TglXDestroyPbuffer;
+  glXQueryDrawable: TglXQueryDrawable;
+  glXCreateNewContext: TglXCreateNewContext;
+  glXMakeContextCurrent: TglXMakeContextCurrent;
+  glXGetCurrentReadDrawable: TglXGetCurrentReadDrawable;
+  glXGetCurreentDisplay: TglXGetCurreentDisplay;
+
+  glXQueryContext: TglXQueryContext;
+  glXSelectEvent: TglXSelectEvent;
+  glXGetSelectedEvent: TglXGetSelectedEvent;
+
+  // GLX_VERSION_1_4
+  glXGetProcAddress: TglXGetProcAddress;
+
+  // GLX_ARB_get_proc_address
+  glXGetProcAddressARB: TglXGetProcAddressARB;
+
+  // GLX_ARB_create_context
+  glXCreateContextAttribsARB: TglXCreateContextAttribsARB;
+  
+  // GLX_EXT_import_context
+  glXGetCurrentDisplayEXT: TglXGetCurrentDisplayEXT;
+  glXQueryContextInfoEXT: TglXQueryContextInfoEXT;
+  glXGetContextIDEXT: TglXGetContextIDEXT;
+  glXImportContextEXT: TglXImportContextEXT;
+  glXFreeContextEXT: TglXFreeContextEXT;
+  
+  // GLX_EXT_texture_from_pixmap
+  glXBindTexImageEXT: TglXBindTexImageEXT;
+  glXReleaseTexImageEXT: TglXReleaseTexImageEXT;
+{$ENDIF}
+
+  // GL utility functions and procedures
+  gluErrorString: TgluErrorString;
+  gluGetString: TgluGetString;
+  gluOrtho2D: TgluOrtho2D;
+  gluPerspective: TgluPerspective;
+  gluPickMatrix: TgluPickMatrix;
+  gluLookAt: TgluLookAt;
+  gluProject: TgluProject;
+  gluUnProject: TgluUnProject;
+  gluScaleImage: TgluScaleImage;
+  gluBuild1DMipmaps: TgluBuild1DMipmaps;
+  gluBuild2DMipmaps: TgluBuild2DMipmaps;
+  gluNewQuadric: TgluNewQuadric;
+  gluDeleteQuadric: TgluDeleteQuadric;
+  gluQuadricNormals: TgluQuadricNormals;
+  gluQuadricTexture: TgluQuadricTexture;
+  gluQuadricOrientation: TgluQuadricOrientation;
+  gluQuadricDrawStyle: TgluQuadricDrawStyle;
+  gluCylinder: TgluCylinder;
+  gluDisk: TgluDisk;
+  gluPartialDisk: TgluPartialDisk;
+  gluSphere: TgluSphere;
+  gluQuadricCallback: TgluQuadricCallback;
+  gluNewTess: TgluNewTess;
+  gluDeleteTess: TgluDeleteTess;
+  gluTessBeginPolygon: TgluTessBeginPolygon;
+  gluTessBeginContour: TgluTessBeginContour;
+  gluTessVertex: TgluTessVertex;
+  gluTessEndContour: TgluTessEndContour;
+  gluTessEndPolygon: TgluTessEndPolygon;
+  gluTessProperty: TgluTessProperty;
+  gluTessNormal: TgluTessNormal;
+  gluTessCallback: TgluTessCallback;
+  gluGetTessProperty: TgluGetTessProperty;
+  gluNewNurbsRenderer: TgluNewNurbsRenderer;
+  gluDeleteNurbsRenderer: TgluDeleteNurbsRenderer;
+  gluBeginSurface: TgluBeginSurface;
+  gluBeginCurve: TgluBeginCurve;
+  gluEndCurve: TgluEndCurve;
+  gluEndSurface: TgluEndSurface;
+  gluBeginTrim: TgluBeginTrim;
+  gluEndTrim: TgluEndTrim;
+  gluPwlCurve: TgluPwlCurve;
+  gluNurbsCurve: TgluNurbsCurve;
+  gluNurbsSurface: TgluNurbsSurface;
+  gluLoadSamplingMatrices: TgluLoadSamplingMatrices;
+  gluNurbsProperty: TgluNurbsProperty;
+  gluGetNurbsProperty: TgluGetNurbsProperty;
+  gluNurbsCallback: TgluNurbsCallback;
+  gluBeginPolygon: TgluBeginPolygon;
+  gluNextContour: TgluNextContour;
+  gluEndPolygon: TgluEndPolygon;
+
+
+type
+  TRCOptions = set of (opDoubleBuffered, opGDI, opStereo);
+
+var
+  GL_LibHandle: Pointer = nil;
+  GLU_LibHandle: Pointer = nil;
+
+  LastPixelFormat: Integer;
+  ExtensionsRead: Boolean;
+  ImplementationRead: Boolean;
+
+
+const
+{$IFDEF DGL_WIN}
+  OPENGL_LIBNAME = 'OpenGL32.dll';
+  GLU_LIBNAME = 'GLU32.dll';
+{$ELSE}
+  {$IFDEF darwin}
+    OPENGL_LIBNAME = 'libGL.dylib';
+    GLU_LIBNAME = 'libGLU.dylib';
+  {$ELSE}
+    OPENGL_LIBNAME = 'libGL.so.1';
+    GLU_LIBNAME = 'libGLU.so.1';
+  {$ENDIF}
+{$ENDIF}
+
+function InitOpenGL(LibName: String = OPENGL_LIBNAME; GLULibName: String = GLU_LIBNAME): Boolean;
+
+function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer;
+function dglCheckExtension(Extension: AnsiString): Boolean;
+
+procedure ReadExtensions;
+procedure ReadImplementationProperties;
+
+// =============================================================================
+// Helper-Functions
+// =============================================================================
+{$IFDEF DGL_WIN}
+  function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
+  function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
+  procedure DestroyRenderingContext(RC: HGLRC);
+
+  procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true);
+  procedure DeactivateRenderingContext;
+{$ENDIF}
+
+
+procedure ReadOpenGLCore;
+procedure Read_GL_3DFX_tbuffer;
+procedure Read_GL_APPLE_element_array;
+procedure Read_GL_APPLE_fence;
+procedure Read_GL_APPLE_vertex_array_object;
+procedure Read_GL_APPLE_vertex_array_range;
+procedure Read_GL_APPLE_texture_range;
+procedure Read_GL_APPLE_vertex_program_evaluators;
+procedure Read_GL_APPLE_object_purgeable;
+procedure Read_GL_ARB_matrix_palette;
+procedure Read_GL_ARB_multitexture;
+procedure Read_GL_ARB_point_parameters;
+procedure Read_GL_ARB_texture_compression;
+procedure Read_GL_ARB_transpose_matrix;
+procedure Read_GL_ARB_vertex_blend;
+procedure Read_GL_ARB_vertex_buffer_object;
+procedure Read_GL_ARB_vertex_program;
+procedure Read_GL_ARB_window_pos;
+procedure Read_GL_ARB_color_buffer_float;
+procedure Read_GL_ARB_Shader_Objects;
+procedure Read_GL_ARB_occlusion_query;
+procedure Read_GL_ARB_draw_instanced;
+procedure Read_GL_ARB_framebuffer_object;
+procedure Read_GL_ARB_geometry_shader4;
+procedure Read_GL_ARB_instanced_arrays;
+procedure Read_GL_ARB_map_buffer_range;
+procedure Read_GL_ARB_texture_buffer_object;
+procedure Read_GL_ARB_vertex_array_object;
+procedure Read_GL_ARB_uniform_buffer_object;
+procedure Read_GL_ARB_copy_buffer;
+procedure Read_GL_ARB_draw_elements_base_vertex;
+procedure Read_GL_ARB_provoking_vertex;
+procedure Read_GL_ARB_sync;
+procedure Read_GL_ARB_texture_multisample;
+procedure Read_GL_ARB_draw_buffers_blend;
+procedure Read_GL_ARB_sample_shading;
+procedure Read_GL_ARB_shading_language_include;
+procedure Read_GL_ARB_blend_func_extended;
+procedure Read_GL_ARB_sampler_objects;
+procedure Read_GL_ARB_timer_query;
+procedure Read_GL_ARB_vertex_type_2_10_10_10_rev;
+procedure Read_GL_ARB_draw_indirect;
+procedure Read_GL_ARB_gpu_shader_fp64;
+procedure Read_GL_ARB_shader_subroutine;
+procedure Read_GL_ARB_tessellation_shader;
+procedure Read_GL_ARB_transform_feedback2;
+procedure Read_GL_ARB_transform_feedback3;
+procedure Read_GL_ARB_ES2_compatibility;
+procedure Read_GL_ARB_get_program_binary;
+procedure Read_GL_ARB_separate_shader_objects;
+procedure Read_GL_ARB_vertex_attrib_64bit;
+procedure Read_GL_ARB_viewport_array;
+// GL 4.2
+procedure Read_GL_ARB_base_instance;
+procedure Read_GL_ARB_transform_feedback_instanced;
+procedure Read_GL_ARB_internalformat_query;
+procedure Read_GL_ARB_shader_atomic_counters;
+procedure Read_GL_ARB_shader_image_load_store;
+procedure Read_GL_ARB_texture_storage;
+// GL 4.3
+procedure Read_GL_KHR_debug;
+procedure Read_GL_ARB_clear_buffer_object;
+procedure Read_GL_ARB_compute_shader;
+procedure Read_GL_ARB_copy_image;
+procedure Read_GL_ARB_framebuffer_no_attachments;
+procedure Read_GL_ARB_internalformat_query2;
+procedure Read_GL_ARB_invalidate_subdata;
+procedure Read_GL_ARB_multi_draw_indirect;
+procedure Read_GL_ARB_program_interface_query;
+procedure Read_GL_ARB_shader_storage_buffer_object;
+procedure Read_GL_ARB_texture_buffer_range;
+procedure Read_GL_ARB_texture_storage_multisample;
+procedure Read_GL_ARB_texture_view;
+procedure Read_GL_ARB_vertex_attrib_binding;
+
+// GL 4.4
+procedure Read_GL_4_4;
+
+//
+procedure Read_GL_ARB_cl_event;
+procedure Read_GL_ARB_debug_output;
+procedure Read_GL_ARB_robustness;
+procedure Read_GL_ATI_draw_buffers;
+procedure Read_GL_ATI_element_array;
+procedure Read_GL_ATI_envmap_bumpmap;
+procedure Read_GL_ATI_fragment_shader;
+procedure Read_GL_ATI_map_object_buffer;
+procedure Read_GL_ATI_pn_triangles;
+procedure Read_GL_ATI_separate_stencil;
+procedure Read_GL_ATI_vertex_array_object;
+procedure Read_GL_ATI_vertex_attrib_array_object;
+procedure Read_GL_ATI_vertex_streams;
+procedure Read_GL_AMD_performance_monitor;
+procedure Read_GL_AMD_vertex_shader_tesselator;
+procedure Read_GL_AMD_draw_buffers_blend;
+procedure Read_GL_AMD_name_gen_delete;
+procedure Read_GL_AMD_debug_output;
+procedure Read_GL_EXT_blend_color;
+procedure Read_GL_EXT_blend_func_separate;
+procedure Read_GL_EXT_blend_minmax;
+procedure Read_GL_EXT_color_subtable;
+procedure Read_GL_EXT_compiled_vertex_array;
+procedure Read_GL_EXT_convolution;
+procedure Read_GL_EXT_coordinate_frame;
+procedure Read_GL_EXT_copy_texture;
+procedure Read_GL_EXT_cull_vertex;
+procedure Read_GL_EXT_draw_range_elements;
+procedure Read_GL_EXT_fog_coord;
+procedure Read_GL_EXT_framebuffer_object;
+procedure Read_GL_EXT_histogram;
+procedure Read_GL_EXT_index_func;
+procedure Read_GL_EXT_index_material;
+procedure Read_GL_EXT_multi_draw_arrays;
+procedure Read_GL_EXT_multisample;
+procedure Read_GL_EXT_paletted_texture;
+procedure Read_GL_EXT_pixel_transform;
+procedure Read_GL_EXT_point_parameters;
+procedure Read_GL_EXT_polygon_offset;
+procedure Read_GL_EXT_secondary_color;
+procedure Read_GL_EXT_stencil_two_side;
+procedure Read_GL_EXT_subtexture;
+procedure Read_GL_EXT_texture3D;
+procedure Read_GL_EXT_texture_object;
+procedure Read_GL_EXT_texture_perturb_normal;
+procedure Read_GL_EXT_vertex_array;
+procedure Read_GL_EXT_vertex_shader;
+procedure Read_GL_EXT_vertex_weighting;
+procedure Read_GL_EXT_depth_bounds_test;
+procedure Read_GL_EXT_blend_equation_separate;
+procedure Read_GL_EXT_stencil_clear_tag;
+procedure Read_GL_EXT_framebuffer_blit;
+procedure Read_GL_EXT_framebuffer_multisample;
+procedure Read_GL_EXT_timer_query;
+procedure Read_GL_EXT_gpu_program_parameters;
+procedure Read_GL_EXT_bindable_uniform;
+procedure Read_GL_EXT_draw_buffers2;
+procedure Read_GL_EXT_draw_instanced;
+procedure Read_GL_EXT_geometry_shader4;
+procedure Read_GL_EXT_gpu_shader4;
+procedure Read_GL_EXT_texture_array;
+procedure Read_GL_EXT_texture_buffer_object;
+procedure Read_GL_EXT_texture_integer;
+procedure Read_GL_EXT_transform_feedback;
+procedure Read_GL_EXT_direct_state_access;
+procedure Read_GL_EXT_separate_shader_objects;
+procedure Read_GL_EXT_shader_image_load_store;
+procedure Read_GL_EXT_vertex_attrib_64bit;
+procedure Read_GL_HP_image_transform;
+procedure Read_GL_IBM_multimode_draw_arrays;
+procedure Read_GL_IBM_vertex_array_lists;
+procedure Read_GL_INGR_blend_func_separate;
+procedure Read_GL_INTEL_parallel_arrays;
+procedure Read_GL_MESA_resize_buffers;
+procedure Read_GL_MESA_window_pos;
+procedure Read_GL_NV_evaluators;
+procedure Read_GL_NV_fence;
+procedure Read_GL_NV_fragment_program;
+procedure Read_GL_NV_half_float;
+procedure Read_GL_NV_occlusion_query;
+procedure Read_GL_NV_pixel_data_range;
+procedure Read_GL_NV_point_sprite;
+procedure Read_GL_NV_primitive_restart;
+procedure Read_GL_NV_register_combiners;
+procedure Read_GL_NV_register_combiners2;
+procedure Read_GL_NV_vertex_array_range;
+procedure Read_GL_NV_vertex_program;
+procedure Read_GL_NV_depth_buffer_float;
+procedure Read_GL_NV_framebuffer_multisample_coverage;
+procedure Read_GL_NV_geometry_program4;
+procedure Read_GL_NV_gpu_program4;
+procedure Read_GL_NV_parameter_buffer_object;
+procedure Read_GL_NV_transform_feedback;
+procedure Read_GL_NV_conditional_render;
+procedure Read_GL_NV_present_video;
+procedure Read_GL_NV_explicit_multisample;
+procedure Read_GL_NV_transform_feedback2;
+procedure Read_GL_NV_video_capture;
+procedure Read_GL_NV_copy_image;
+procedure Read_GL_NV_shader_buffer_load;
+procedure Read_GL_NV_vertex_buffer_unified_memory;
+procedure Read_GL_NV_gpu_program5;
+procedure Read_GL_NV_gpu_shader5;
+procedure Read_GL_NV_vertex_attrib_integer_64bit;
+procedure Read_GL_NV_vdpau_interop;
+procedure Read_GL_NV_texture_barrier;
+procedure Read_GL_PGI_misc_hints;
+procedure Read_GL_SGIS_detail_texture;
+procedure Read_GL_SGIS_fog_function;
+procedure Read_GL_SGIS_multisample;
+procedure Read_GL_SGIS_pixel_texture;
+procedure Read_GL_SGIS_point_parameters;
+procedure Read_GL_SGIS_sharpen_texture;
+procedure Read_GL_SGIS_texture4D;
+procedure Read_GL_SGIS_texture_color_mask;
+procedure Read_GL_SGIS_texture_filter4;
+procedure Read_GL_SGIX_async;
+procedure Read_GL_SGIX_flush_raster;
+procedure Read_GL_SGIX_fragment_lighting;
+procedure Read_GL_SGIX_framezoom;
+procedure Read_GL_SGIX_igloo_interface;
+procedure Read_GL_SGIX_instruments;
+procedure Read_GL_SGIX_list_priority;
+procedure Read_GL_SGIX_pixel_texture;
+procedure Read_GL_SGIX_polynomial_ffd;
+procedure Read_GL_SGIX_reference_plane;
+procedure Read_GL_SGIX_sprite;
+procedure Read_GL_SGIX_tag_sample_buffer;
+procedure Read_GL_SGI_color_table;
+procedure Read_GL_SUNX_constant_data;
+procedure Read_GL_SUN_global_alpha;
+procedure Read_GL_SUN_mesh_array;
+procedure Read_GL_SUN_triangle_list;
+procedure Read_GL_SUN_vertex;
+
+{$IFDEF DGL_WIN}
+procedure Read_WGL_ARB_buffer_region;
+procedure Read_WGL_ARB_extensions_string;
+procedure Read_WGL_ARB_make_current_read;
+procedure Read_WGL_ARB_pbuffer;
+procedure Read_WGL_ARB_pixel_format;
+procedure Read_WGL_ARB_pixel_format_float;
+procedure Read_WGL_ARB_render_texture;
+procedure Read_WGL_ARB_create_context;
+procedure Read_WGL_AMD_gpu_association;
+procedure Read_WGL_EXT_display_color_table;
+procedure Read_WGL_EXT_extensions_string;
+procedure Read_WGL_EXT_make_current_read;
+procedure Read_WGL_EXT_pbuffer;
+procedure Read_WGL_EXT_pixel_format;
+procedure Read_WGL_EXT_swap_control;
+procedure Read_WGL_I3D_digital_video_control;
+procedure Read_WGL_I3D_gamma;
+procedure Read_WGL_I3D_genlock;
+procedure Read_WGL_I3D_image_buffer;
+procedure Read_WGL_I3D_swap_frame_lock;
+procedure Read_WGL_I3D_swap_frame_usage;
+procedure Read_WGL_NV_vertex_array_range;
+procedure Read_WGL_NV_present_video;
+procedure Read_WGL_NV_video_output;
+procedure Read_WGL_NV_swap_group;
+procedure Read_WGL_NV_gpu_affinity;
+procedure Read_WGL_NV_video_capture;
+procedure Read_WGL_NV_copy_image;
+procedure Read_WGL_OML_sync_control;
+procedure Read_WGL_3DL_stereo_control;
+
+procedure Read_WIN_draw_range_elements;
+procedure Read_WIN_swap_hint;
+{$ENDIF}
+
+
+implementation
+
+
+{$IFDEF DGL_LINUX}
+const
+  RTLD_LAZY = $001;
+  RTLD_NOW = $002;
+  RTLD_BINDING_MASK = $003;
+
+  // Seems to work on Debian / Fedora
+  LibraryLib = {$IFDEF Linux} 'libdl.so.2'{$ELSE} 'c'{$ENDIF};
+
+function dlopen(Name: PAnsiChar; Flags: LongInt): Pointer; cdecl; external LibraryLib name 'dlopen';
+function dlclose(Lib: Pointer): LongInt; cdecl; external LibraryLib name 'dlclose';
+
+function dlsym(Lib: Pointer; Name: PAnsiChar): Pointer; cdecl; external LibraryLib name 'dlsym';
+{$ENDIF}
+
+{$IFDEF DGL_MAC}{$IFDEF OPENGL_FRAMEWORK}  // OpenGL framework used
+const
+  RTLD_DEFAULT = Pointer(-2);
+{$ENDIF}{$ENDIF}
+
+function dglLoadLibrary(Name: PChar): Pointer;
+begin
+  {$IFDEF DGL_WIN}
+  Result := Pointer(LoadLibrary(Name));
+  {$ENDIF}
+
+  {$IFDEF DGL_LINUX}
+  Result := dlopen(Name, RTLD_LAZY);
+  {$ENDIF}
+  
+  {$IFDEF DGL_MAC}
+  {$IFDEF OPENGL_FRAMEWORK}
+  Result := RTLD_DEFAULT;
+  {$ELSE}
+  Result := Pointer(LoadLibrary(Name));
+  {$ENDIF}  
+  {$ENDIF}  
+end;
+
+
+function dglFreeLibrary(LibHandle: Pointer): Boolean;
+begin
+  if LibHandle = nil then
+    Result := False
+  else
+    {$IFDEF DGL_WIN}
+    Result := FreeLibrary(HMODULE(LibHandle));
+    {$ENDIF}
+
+    {$IFDEF DGL_LINUX}
+    Result := dlclose(LibHandle) = 0;
+    {$ENDIF}
+       
+    {$IFDEF DGL_MAC}
+    {$IFDEF OPENGL_FRAMEWORK}
+       Result := true;
+       {$ELSE}
+    Result := FreeLibrary(HMODULE(LibHandle));
+    {$ENDIF}   
+       {$ENDIF}
+end;
+
+
+function dglGetProcAddress(ProcName: PAnsiChar; LibHandle: Pointer = nil {$IFDEF DGL_LINUX}; ForceDLSym: Boolean = False{$ENDIF}): Pointer;
+begin
+  if LibHandle = nil then
+    LibHandle := GL_LibHandle;
+
+  Result :=  nil;
+
+  {$IFDEF DGL_WIN}
+    Result := GetProcAddress(HMODULE(LibHandle), ProcName);
+
+    if result <> nil then
+      exit;
+
+    if Addr(wglGetProcAddress) <> nil then
+      Result := wglGetProcAddress(ProcName);
+  {$ENDIF}
+
+  {$IFDEF DGL_LINUX}
+    if not ForceDLSym then begin
+      if Addr(glXGetProcAddress) <> nil then
+        Result := glXGetProcAddress(ProcName);
+
+      if result <> nil then
+        exit;
+
+      if Addr(glXGetProcAddressARB) <> nil then
+        Result := glXGetProcAddressARB(ProcName);
+
+      if result <> nil then
+        exit;
+    end;
+
+    Result := dlsym(LibHandle, ProcName);
+  {$ENDIF}
+  
+  {$IFDEF DGL_MAC}
+    Result := GetProcAddress(HMODULE(LibHandle), ProcName);
+  {$ENDIF}  
+end;
+
+
+function Int_GetExtensionString: AnsiString;
+var
+       ExtensionCount : GLuint;
+  i : Integer;
+begin
+  if GL_VERSION_3_0
+    then
+      begin
+        if not Assigned(@glGetIntegerv) then glGetIntegerv := dglGetProcAddress('glGetIntegerv');
+        if not Assigned(@glGetStringi)  then glGetStringi  := dglGetProcAddress('glGetStringi');
+
+        result := '';
+
+        if Assigned(@glGetIntegerv) and Assigned(@glGetStringi)
+          then
+            begin
+              glGetIntegerv(GL_NUM_EXTENSIONS, @extensionCount);
+
+              For I := 0 to extensionCount - 1 do
+                result := result + #32 + PAnsiChar(glGetStringi(GL_EXTENSIONS, I));
+            end;
+      end
+    else
+      begin
+        if not Assigned(@glGetString) then glGetString := dglGetProcAddress('glGetString');
+
+        if Assigned(@glGetString)
+          then result := glGetString(GL_EXTENSIONS)
+          else result := '';
+      end;
+
+  if (GL_LibHandle <> nil) then begin
+    {$IFDEF DGL_WIN}
+      // wglGetExtensionsStringEXT
+      if not Assigned(@wglGetExtensionsStringEXT) then
+        wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
+
+      if Assigned(@wglGetExtensionsStringEXT) then
+        Result := Result + #32 + wglGetExtensionsStringEXT;
+
+      // wglGetExtensionsStringARB
+      if not Assigned(@wglGetExtensionsStringARB) then
+        wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
+
+      if Assigned(@wglGetExtensionsStringARB) then
+        Result := Result + #32 + wglGetExtensionsStringARB(wglGetCurrentDC);
+    {$ENDIF}
+  end;
+
+  Result := #32 + Result + #32;
+end;
+
+
+function Int_CheckExtension(AllExtensions, CheckExtension: AnsiString): Boolean;
+begin
+  Result := Pos(#32 + CheckExtension + #32, AllExtensions) > 0;
+end;
+
+
+function dglCheckExtension(Extension: AnsiString): Boolean;
+var
+  Extensions: AnsiString;
+begin
+  Extensions := Int_GetExtensionString;
+  Result := Int_CheckExtension(Extensions, Extension);
+end;
+
+
+
+function InitOpenGL(LibName: String; GLULibName: String): Boolean;
+begin
+  Result := False;
+
+  // free opened libraries
+  if GL_LibHandle <> nil then
+    dglFreeLibrary(GL_LibHandle);
+
+  if GLU_LibHandle <> nil then
+    dglFreeLibrary(GLU_LibHandle);
+
+  // load library
+  GL_LibHandle := dglLoadLibrary(PChar(LibName));
+  GLU_LibHandle := dglLoadLibrary(PChar(GLULibName));
+
+  // load GL functions
+  if (GL_LibHandle <> nil) then begin
+    {$IFDEF DGL_WIN}
+      wglCopyContext := dglGetProcAddress('wglCopyContext');
+      wglCreateLayerContext := dglGetProcAddress('wglCreateLayerContext');
+      wglCreateContext := dglGetProcAddress('wglCreateContext');
+      wglDeleteContext := dglGetProcAddress('wglDeleteContext');
+      wglDescribeLayerPlane := dglGetProcAddress('wglDescribeLayerPlane');
+      wglGetCurrentContext := dglGetProcAddress('wglGetCurrentContext');
+      wglGetCurrentDC := dglGetProcAddress('wglGetCurrentDC');
+      wglGetLayerPaletteEntries := dglGetProcAddress('wglGetLayerPaletteEntries');
+      wglGetProcAddress := dglGetProcAddress('wglGetProcAddress');
+      wglMakeCurrent := dglGetProcAddress('wglMakeCurrent');
+      wglRealizeLayerPalette := dglGetProcAddress('wglRealizeLayerPalette');
+      wglSetLayerPaletteEntries := dglGetProcAddress('wglSetLayerPaletteEntries');
+      wglShareLists := dglGetProcAddress('wglShareLists');
+      wglSwapLayerBuffers := dglGetProcAddress('wglSwapLayerBuffers');
+      wglSwapMultipleBuffers := dglGetProcAddress('wglSwapMultipleBuffers');
+      wglUseFontBitmapsA := dglGetProcAddress('wglUseFontBitmapsA');
+      wglUseFontOutlinesA := dglGetProcAddress('wglUseFontOutlinesA');
+      wglUseFontBitmapsW := dglGetProcAddress('wglUseFontBitmapsW');
+      wglUseFontOutlinesW := dglGetProcAddress('wglUseFontOutlinesW');
+      wglUseFontBitmaps := dglGetProcAddress('wglUseFontBitmapsA');
+      wglUseFontOutlines := dglGetProcAddress('wglUseFontOutlinesA');
+    {$ENDIF}
+
+    {$IFDEF DGL_LINUX}
+      // GLX_VERSION_1_4 (needs to be first)
+      glXGetProcAddress := dglGetProcAddress('glXGetProcAddress', nil, True);
+
+      // GLX_ARB_get_proc_address  (also needs to be first)
+      glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB', nil, True);
+
+      glXChooseVisual := dglGetProcAddress('glXChooseVisual');
+      glXCopyContext := dglGetProcAddress('glXCopyContext');
+      glXCreateContext := dglGetProcAddress('glXCreateContext');
+      glXCreateGLXPixmap := dglGetProcAddress('glXCreateGLXPixmap');
+      glXDestroyContext := dglGetProcAddress('glXDestroyContext');
+      glXDestroyGLXPixmap := dglGetProcAddress('glXDestroyGLXPixmap');
+      glXGetConfig := dglGetProcAddress('glXGetConfig');
+      glXGetCurrentContext := dglGetProcAddress('glXGetCurrentContext');
+      glXGetCurrentDrawable := dglGetProcAddress('glXGetCurrentDrawable');
+      glXIsDirect := dglGetProcAddress('glXIsDirect');
+      glXMakeCurrent := dglGetProcAddress('glXMakeCurrent');
+      glXQueryExtension := dglGetProcAddress('glXQueryExtension');
+      glXQueryVersion := dglGetProcAddress('glXQueryVersion');
+      glXSwapBuffers := dglGetProcAddress('glXSwapBuffers');
+      glXUseXFont := dglGetProcAddress('glXUseXFont');
+      glXWaitGL := dglGetProcAddress('glXWaitGL');
+      glXWaitX := dglGetProcAddress('glXWaitX');
+
+      glXGetClientString := dglGetProcAddress('glXGetClientString');
+      glXQueryServerString := dglGetProcAddress('glXQueryServerString');
+      glXQueryExtensionsString := dglGetProcAddress('glXQueryExtensionsString');
+
+      // GLX_VERSION_1_3
+      glXGetFBConfigs := dglGetProcAddress('glXGetFBConfigs');
+      glXChooseFBConfig := dglGetProcAddress('glXChooseFBConfig');
+      glXGetFBConfigAttrib := dglGetProcAddress('glXGetFBConfigAttrib');
+      glXGetVisualFromFBConfig := dglGetProcAddress('glXGetVisualFromFBConfig');
+      glXCreateWindow := dglGetProcAddress('glXCreateWindow');
+      glXDestroyWindow := dglGetProcAddress('glXDestroyWindow');
+      glXCreatePixmap := dglGetProcAddress('glXCreatePixmap');
+
+      glXDestroyPixmap := dglGetProcAddress('glXDestroyPixmap');
+      glXCreatePbuffer := dglGetProcAddress('glXCreatePbuffer');
+      glXDestroyPbuffer := dglGetProcAddress('glXDestroyPbuffer');
+      glXQueryDrawable := dglGetProcAddress('glXQueryDrawable');
+      glXCreateNewContext := dglGetProcAddress('glXCreateNewContext');
+      glXMakeContextCurrent := dglGetProcAddress('glXMakeContextCurrent');
+      glXGetCurrentReadDrawable := dglGetProcAddress('glXGetCurrentReadDrawable');
+      glXGetCurreentDisplay := dglGetProcAddress('glXGetCurreentDisplay');
+
+      glXQueryContext := dglGetProcAddress('glXQueryContext');
+      glXSelectEvent := dglGetProcAddress('glXSelectEvent');
+      glXGetSelectedEvent := dglGetProcAddress('glXGetSelectedEvent');
+
+      // GLX_ARB_create_context
+      glXCreateContextAttribsARB := dglGetProcAddress('glXCreateContextAttribsARB');
+
+      // GLX_EXT_import_context
+      glXGetCurrentDisplayEXT := dglGetProcAddress('glXGetCurrentDisplayEXT');
+      glXQueryContextInfoEXT := dglGetProcAddress('glXQueryContextInfoEXT');
+      glXGetContextIDEXT := dglGetProcAddress('glXGetContextIDEXT');
+      glXImportContextEXT := dglGetProcAddress('glXImportContextEXT');
+      glXFreeContextEXT := dglGetProcAddress('glXFreeContextEXT');
+      
+      // GLX_EXT_texture_from_pixmap
+      glXBindTexImageEXT := dglGetProcAddress('glXBindTexImageEXT');
+      glXReleaseTexImageEXT := dglGetProcAddress('glXReleaseTexImageEXT');
+    {$ENDIF}
+
+    Result := True;
+  end;
+
+  // load GLU functions
+  if GLU_LibHandle <> nil then begin
+    // GLU ========================================================================
+    gluBeginCurve := dglGetProcAddress('gluBeginCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluBeginPolygon := dglGetProcAddress('gluBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluBeginSurface := dglGetProcAddress('gluBeginSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluBeginTrim := dglGetProcAddress('gluBeginTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluBuild1DMipmaps := dglGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluBuild2DMipmaps := dglGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluCylinder := dglGetProcAddress('gluCylinder', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluDeleteNurbsRenderer := dglGetProcAddress('gluDeleteNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluDeleteQuadric := dglGetProcAddress('gluDeleteQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluDeleteTess := dglGetProcAddress('gluDeleteTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluDisk := dglGetProcAddress('gluDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluEndCurve := dglGetProcAddress('gluEndCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluEndPolygon := dglGetProcAddress('gluEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluEndSurface := dglGetProcAddress('gluEndSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluEndTrim := dglGetProcAddress('gluEndTrim', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluErrorString := dglGetProcAddress('gluErrorString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluGetNurbsProperty := dglGetProcAddress('gluGetNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluGetString := dglGetProcAddress('gluGetString', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluGetTessProperty := dglGetProcAddress('gluGetTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluLoadSamplingMatrices := dglGetProcAddress('gluLoadSamplingMatrices', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluLookAt := dglGetProcAddress('gluLookAt', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNewNurbsRenderer := dglGetProcAddress('gluNewNurbsRenderer', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNewQuadric := dglGetProcAddress('gluNewQuadric', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNewTess := dglGetProcAddress('gluNewTess', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNextContour := dglGetProcAddress('gluNextContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNurbsCallback := dglGetProcAddress('gluNurbsCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNurbsCurve := dglGetProcAddress('gluNurbsCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNurbsProperty := dglGetProcAddress('gluNurbsProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluNurbsSurface := dglGetProcAddress('gluNurbsSurface', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluOrtho2D := dglGetProcAddress('gluOrtho2D', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluPartialDisk := dglGetProcAddress('gluPartialDisk', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluPerspective := dglGetProcAddress('gluPerspective', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluPickMatrix := dglGetProcAddress('gluPickMatrix', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluProject := dglGetProcAddress('gluProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluPwlCurve := dglGetProcAddress('gluPwlCurve', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluQuadricCallback := dglGetProcAddress('gluQuadricCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluQuadricDrawStyle := dglGetProcAddress('gluQuadricDrawStyle', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluQuadricNormals := dglGetProcAddress('gluQuadricNormals', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluQuadricOrientation := dglGetProcAddress('gluQuadricOrientation', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluQuadricTexture := dglGetProcAddress('gluQuadricTexture', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluScaleImage := dglGetProcAddress('gluScaleImage', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluSphere := dglGetProcAddress('gluSphere', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessBeginContour := dglGetProcAddress('gluTessBeginContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessBeginPolygon := dglGetProcAddress('gluTessBeginPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessCallback := dglGetProcAddress('gluTessCallback', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessEndContour := dglGetProcAddress('gluTessEndContour', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessEndPolygon := dglGetProcAddress('gluTessEndPolygon', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessNormal := dglGetProcAddress('gluTessNormal', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessProperty := dglGetProcAddress('gluTessProperty', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluTessVertex := dglGetProcAddress('gluTessVertex', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+    gluUnProject := dglGetProcAddress('gluUnProject', GLU_LibHandle {$IFDEF DGL_LINUX}, True{$ENDIF});
+  end;
+end;
+
+procedure ReadOpenGLCore;
+begin
+  // GL_VERSION_1_0
+  glCullFace := dglGetProcAddress('glCullFace');
+  glFrontFace := dglGetProcAddress('glFrontFace');
+  glHint := dglGetProcAddress('glHint');
+  glLineWidth := dglGetProcAddress('glLineWidth');
+  glPointSize := dglGetProcAddress('glPointSize');
+  glPolygonMode := dglGetProcAddress('glPolygonMode');
+  glScissor := dglGetProcAddress('glScissor');
+  glTexParameterf := dglGetProcAddress('glTexParameterf');
+  glTexParameterfv := dglGetProcAddress('glTexParameterfv');
+  glTexParameteri := dglGetProcAddress('glTexParameteri');
+  glTexParameteriv := dglGetProcAddress('glTexParameteriv');
+  glTexImage1D := dglGetProcAddress('glTexImage1D');
+  glTexImage2D := dglGetProcAddress('glTexImage2D');
+  glDrawBuffer := dglGetProcAddress('glDrawBuffer');
+  glClear := dglGetProcAddress('glClear');
+  glClearColor := dglGetProcAddress('glClearColor');
+  glClearStencil := dglGetProcAddress('glClearStencil');
+  glClearDepth := dglGetProcAddress('glClearDepth');
+  glStencilMask := dglGetProcAddress('glStencilMask');
+  glColorMask := dglGetProcAddress('glColorMask');
+  glDepthMask := dglGetProcAddress('glDepthMask');
+  glDisable := dglGetProcAddress('glDisable');
+  glEnable := dglGetProcAddress('glEnable');
+  glFinish := dglGetProcAddress('glFinish');
+  glFlush := dglGetProcAddress('glFlush');
+  glBlendFunc := dglGetProcAddress('glBlendFunc');
+  glLogicOp := dglGetProcAddress('glLogicOp');
+  glStencilFunc := dglGetProcAddress('glStencilFunc');
+  glStencilOp := dglGetProcAddress('glStencilOp');
+  glDepthFunc := dglGetProcAddress('glDepthFunc');
+  glPixelStoref := dglGetProcAddress('glPixelStoref');
+  glPixelStorei := dglGetProcAddress('glPixelStorei');
+  glReadBuffer := dglGetProcAddress('glReadBuffer');
+  glReadPixels := dglGetProcAddress('glReadPixels');
+  glGetBooleanv := dglGetProcAddress('glGetBooleanv');
+  glGetDoublev := dglGetProcAddress('glGetDoublev');
+  glGetError := dglGetProcAddress('glGetError');
+  glGetFloatv := dglGetProcAddress('glGetFloatv');
+  glGetIntegerv := dglGetProcAddress('glGetIntegerv');
+  glGetString := dglGetProcAddress('glGetString');
+  glGetTexImage := dglGetProcAddress('glGetTexImage');
+  glGetTexParameteriv := dglGetProcAddress('glGetTexParameteriv');
+  glGetTexParameterfv := dglGetProcAddress('glGetTexParameterfv');
+  glGetTexLevelParameterfv := dglGetProcAddress('glGetTexLevelParameterfv');
+  glGetTexLevelParameteriv := dglGetProcAddress('glGetTexLevelParameteriv');
+  glIsEnabled := dglGetProcAddress('glIsEnabled');
+  glDepthRange := dglGetProcAddress('glDepthRange');
+  glViewport := dglGetProcAddress('glViewport');
+
+  // GL_VERSION_1_1
+  glDrawArrays := dglGetProcAddress('glDrawArrays');
+  glDrawElements := dglGetProcAddress('glDrawElements');
+  glGetPointerv := dglGetProcAddress('glGetPointerv');
+  glPolygonOffset := dglGetProcAddress('glPolygonOffset');
+  glCopyTexImage1D := dglGetProcAddress('glCopyTexImage1D');
+  glCopyTexImage2D := dglGetProcAddress('glCopyTexImage2D');
+  glCopyTexSubImage1D := dglGetProcAddress('glCopyTexSubImage1D');
+  glCopyTexSubImage2D := dglGetProcAddress('glCopyTexSubImage2D');
+  glTexSubImage1D := dglGetProcAddress('glTexSubImage1D');
+  glTexSubImage2D := dglGetProcAddress('glTexSubImage2D');
+  glBindTexture := dglGetProcAddress('glBindTexture');
+  glDeleteTextures := dglGetProcAddress('glDeleteTextures');
+  glGenTextures := dglGetProcAddress('glGenTextures');
+
+{$ifdef DGL_DEPRECATED}
+  glAccum := dglGetProcAddress('glAccum');
+  glAlphaFunc := dglGetProcAddress('glAlphaFunc');
+  glAreTexturesResident := dglGetProcAddress('glAreTexturesResident');
+  glArrayElement := dglGetProcAddress('glArrayElement');
+  glBegin := dglGetProcAddress('glBegin');
+  glBitmap := dglGetProcAddress('glBitmap');
+  glCallList := dglGetProcAddress('glCallList');
+  glCallLists := dglGetProcAddress('glCallLists');
+  glClearAccum := dglGetProcAddress('glClearAccum');
+  glClearIndex := dglGetProcAddress('glClearIndex');
+  glClipPlane := dglGetProcAddress('glClipPlane');
+  glColor3b := dglGetProcAddress('glColor3b');
+  glColor3bv := dglGetProcAddress('glColor3bv');
+  glColor3d := dglGetProcAddress('glColor3d');
+  glColor3dv := dglGetProcAddress('glColor3dv');
+  glColor3f := dglGetProcAddress('glColor3f');
+  glColor3fv := dglGetProcAddress('glColor3fv');
+  glColor3i := dglGetProcAddress('glColor3i');
+  glColor3iv := dglGetProcAddress('glColor3iv');
+  glColor3s := dglGetProcAddress('glColor3s');
+  glColor3sv := dglGetProcAddress('glColor3sv');
+  glColor3ub := dglGetProcAddress('glColor3ub');
+  glColor3ubv := dglGetProcAddress('glColor3ubv');
+  glColor3ui := dglGetProcAddress('glColor3ui');
+  glColor3uiv := dglGetProcAddress('glColor3uiv');
+  glColor3us := dglGetProcAddress('glColor3us');
+  glColor3usv := dglGetProcAddress('glColor3usv');
+  glColor4b := dglGetProcAddress('glColor4b');
+  glColor4bv := dglGetProcAddress('glColor4bv');
+  glColor4d := dglGetProcAddress('glColor4d');
+  glColor4dv := dglGetProcAddress('glColor4dv');
+  glColor4f := dglGetProcAddress('glColor4f');
+  glColor4fv := dglGetProcAddress('glColor4fv');
+  glColor4i := dglGetProcAddress('glColor4i');
+  glColor4iv := dglGetProcAddress('glColor4iv');
+  glColor4s := dglGetProcAddress('glColor4s');
+  glColor4sv := dglGetProcAddress('glColor4sv');
+  glColor4ub := dglGetProcAddress('glColor4ub');
+  glColor4ubv := dglGetProcAddress('glColor4ubv');
+  glColor4ui := dglGetProcAddress('glColor4ui');
+  glColor4uiv := dglGetProcAddress('glColor4uiv');
+  glColor4us := dglGetProcAddress('glColor4us');
+  glColor4usv := dglGetProcAddress('glColor4usv');
+  glColorMaterial := dglGetProcAddress('glColorMaterial');
+  glColorPointer := dglGetProcAddress('glColorPointer');
+  glCopyPixels := dglGetProcAddress('glCopyPixels');
+  glDeleteLists := dglGetProcAddress('glDeleteLists');
+  glDisableClientState := dglGetProcAddress('glDisableClientState');
+  glDrawPixels := dglGetProcAddress('glDrawPixels');
+  glEdgeFlag := dglGetProcAddress('glEdgeFlag');
+  glEdgeFlagPointer := dglGetProcAddress('glEdgeFlagPointer');
+  glEdgeFlagv := dglGetProcAddress('glEdgeFlagv');
+  glEnableClientState := dglGetProcAddress('glEnableClientState');
+  glEnd := dglGetProcAddress('glEnd');
+  glEndList := dglGetProcAddress('glEndList');
+  glEvalCoord1d := dglGetProcAddress('glEvalCoord1d');
+  glEvalCoord1dv := dglGetProcAddress('glEvalCoord1dv');
+  glEvalCoord1f := dglGetProcAddress('glEvalCoord1f');
+  glEvalCoord1fv := dglGetProcAddress('glEvalCoord1fv');
+  glEvalCoord2d := dglGetProcAddress('glEvalCoord2d');
+  glEvalCoord2dv := dglGetProcAddress('glEvalCoord2dv');
+  glEvalCoord2f := dglGetProcAddress('glEvalCoord2f');
+  glEvalCoord2fv := dglGetProcAddress('glEvalCoord2fv');
+  glEvalMesh1 := dglGetProcAddress('glEvalMesh1');
+  glEvalMesh2 := dglGetProcAddress('glEvalMesh2');
+  glEvalPoint1 := dglGetProcAddress('glEvalPoint1');
+  glEvalPoint2 := dglGetProcAddress('glEvalPoint2');
+  glFeedbackBuffer := dglGetProcAddress('glFeedbackBuffer');
+  glFogf := dglGetProcAddress('glFogf');
+  glFogfv := dglGetProcAddress('glFogfv');
+  glFogi := dglGetProcAddress('glFogi');
+  glFogiv := dglGetProcAddress('glFogiv');
+  glFrustum := dglGetProcAddress('glFrustum');
+  glGenLists := dglGetProcAddress('glGenLists');
+  glGetClipPlane := dglGetProcAddress('glGetClipPlane');
+  glGetLightfv := dglGetProcAddress('glGetLightfv');
+  glGetLightiv := dglGetProcAddress('glGetLightiv');
+  glGetMapdv := dglGetProcAddress('glGetMapdv');
+  glGetMapfv := dglGetProcAddress('glGetMapfv');
+  glGetMapiv := dglGetProcAddress('glGetMapiv');
+  glGetMaterialfv := dglGetProcAddress('glGetMaterialfv');
+  glGetMaterialiv := dglGetProcAddress('glGetMaterialiv');
+  glGetPixelMapfv := dglGetProcAddress('glGetPixelMapfv');
+  glGetPixelMapuiv := dglGetProcAddress('glGetPixelMapuiv');
+  glGetPixelMapusv := dglGetProcAddress('glGetPixelMapusv');
+  glGetPolygonStipple := dglGetProcAddress('glGetPolygonStipple');
+  glGetTexEnvfv := dglGetProcAddress('glGetTexEnvfv');
+  glGetTexEnviv := dglGetProcAddress('glGetTexEnviv');
+  glGetTexGendv := dglGetProcAddress('glGetTexGendv');
+  glGetTexGenfv := dglGetProcAddress('glGetTexGenfv');
+  glGetTexGeniv := dglGetProcAddress('glGetTexGeniv');
+  glIndexMask := dglGetProcAddress('glIndexMask');
+  glIndexPointer := dglGetProcAddress('glIndexPointer');
+  glIndexd := dglGetProcAddress('glIndexd');
+  glIndexdv := dglGetProcAddress('glIndexdv');
+  glIndexf := dglGetProcAddress('glIndexf');
+  glIndexfv := dglGetProcAddress('glIndexfv');
+  glIndexi := dglGetProcAddress('glIndexi');
+  glIndexiv := dglGetProcAddress('glIndexiv');
+  glIndexs := dglGetProcAddress('glIndexs');
+  glIndexsv := dglGetProcAddress('glIndexsv');
+  glIndexub := dglGetProcAddress('glIndexub');
+  glIndexubv := dglGetProcAddress('glIndexubv');
+  glInitNames := dglGetProcAddress('glInitNames');
+  glInterleavedArrays := dglGetProcAddress('glInterleavedArrays');
+  glIsList := dglGetProcAddress('glIsList');
+  glIsTexture := dglGetProcAddress('glIsTexture');
+  glLightModelf := dglGetProcAddress('glLightModelf');
+  glLightModelfv := dglGetProcAddress('glLightModelfv');
+  glLightModeli := dglGetProcAddress('glLightModeli');
+  glLightModeliv := dglGetProcAddress('glLightModeliv');
+  glLightf := dglGetProcAddress('glLightf');
+  glLightfv := dglGetProcAddress('glLightfv');
+  glLighti := dglGetProcAddress('glLighti');
+  glLightiv := dglGetProcAddress('glLightiv');
+  glLineStipple := dglGetProcAddress('glLineStipple');
+  glListBase := dglGetProcAddress('glListBase');
+  glLoadIdentity := dglGetProcAddress('glLoadIdentity');
+  glLoadMatrixd := dglGetProcAddress('glLoadMatrixd');
+  glLoadMatrixf := dglGetProcAddress('glLoadMatrixf');
+  glLoadName := dglGetProcAddress('glLoadName');
+  glMap1d := dglGetProcAddress('glMap1d');
+  glMap1f := dglGetProcAddress('glMap1f');
+  glMap2d := dglGetProcAddress('glMap2d');
+  glMap2f := dglGetProcAddress('glMap2f');
+  glMapGrid1d := dglGetProcAddress('glMapGrid1d');
+  glMapGrid1f := dglGetProcAddress('glMapGrid1f');
+  glMapGrid2d := dglGetProcAddress('glMapGrid2d');
+  glMapGrid2f := dglGetProcAddress('glMapGrid2f');
+  glMaterialf := dglGetProcAddress('glMaterialf');
+  glMaterialfv := dglGetProcAddress('glMaterialfv');
+  glMateriali := dglGetProcAddress('glMateriali');
+  glMaterialiv := dglGetProcAddress('glMaterialiv');
+  glMatrixMode := dglGetProcAddress('glMatrixMode');
+  glMultMatrixd := dglGetProcAddress('glMultMatrixd');
+  glMultMatrixf := dglGetProcAddress('glMultMatrixf');
+  glNewList := dglGetProcAddress('glNewList');
+  glNormal3b := dglGetProcAddress('glNormal3b');
+  glNormal3bv := dglGetProcAddress('glNormal3bv');
+  glNormal3d := dglGetProcAddress('glNormal3d');
+  glNormal3dv := dglGetProcAddress('glNormal3dv');
+  glNormal3f := dglGetProcAddress('glNormal3f');
+  glNormal3fv := dglGetProcAddress('glNormal3fv');
+  glNormal3i := dglGetProcAddress('glNormal3i');
+  glNormal3iv := dglGetProcAddress('glNormal3iv');
+  glNormal3s := dglGetProcAddress('glNormal3s');
+  glNormal3sv := dglGetProcAddress('glNormal3sv');
+  glNormalPointer := dglGetProcAddress('glNormalPointer');
+  glOrtho := dglGetProcAddress('glOrtho');
+  glPassThrough := dglGetProcAddress('glPassThrough');
+  glPixelMapfv := dglGetProcAddress('glPixelMapfv');
+  glPixelMapuiv := dglGetProcAddress('glPixelMapuiv');
+  glPixelMapusv := dglGetProcAddress('glPixelMapusv');
+  glPixelTransferf := dglGetProcAddress('glPixelTransferf');
+  glPixelTransferi := dglGetProcAddress('glPixelTransferi');
+  glPixelZoom := dglGetProcAddress('glPixelZoom');
+  glPolygonStipple := dglGetProcAddress('glPolygonStipple');
+  glPopAttrib := dglGetProcAddress('glPopAttrib');
+  glPopClientAttrib := dglGetProcAddress('glPopClientAttrib');
+  glPopMatrix := dglGetProcAddress('glPopMatrix');
+  glPopName := dglGetProcAddress('glPopName');
+  glPrioritizeTextures := dglGetProcAddress('glPrioritizeTextures');
+  glPushAttrib := dglGetProcAddress('glPushAttrib');
+  glPushClientAttrib := dglGetProcAddress('glPushClientAttrib');
+  glPushMatrix := dglGetProcAddress('glPushMatrix');
+  glPushName := dglGetProcAddress('glPushName');
+  glRasterPos2d := dglGetProcAddress('glRasterPos2d');
+  glRasterPos2dv := dglGetProcAddress('glRasterPos2dv');
+  glRasterPos2f := dglGetProcAddress('glRasterPos2f');
+  glRasterPos2fv := dglGetProcAddress('glRasterPos2fv');
+  glRasterPos2i := dglGetProcAddress('glRasterPos2i');
+  glRasterPos2iv := dglGetProcAddress('glRasterPos2iv');
+  glRasterPos2s := dglGetProcAddress('glRasterPos2s');
+  glRasterPos2sv := dglGetProcAddress('glRasterPos2sv');
+  glRasterPos3d := dglGetProcAddress('glRasterPos3d');
+  glRasterPos3dv := dglGetProcAddress('glRasterPos3dv');
+  glRasterPos3f := dglGetProcAddress('glRasterPos3f');
+  glRasterPos3fv := dglGetProcAddress('glRasterPos3fv');
+  glRasterPos3i := dglGetProcAddress('glRasterPos3i');
+  glRasterPos3iv := dglGetProcAddress('glRasterPos3iv');
+  glRasterPos3s := dglGetProcAddress('glRasterPos3s');
+  glRasterPos3sv := dglGetProcAddress('glRasterPos3sv');
+  glRasterPos4d := dglGetProcAddress('glRasterPos4d');
+  glRasterPos4dv := dglGetProcAddress('glRasterPos4dv');
+  glRasterPos4f := dglGetProcAddress('glRasterPos4f');
+  glRasterPos4fv := dglGetProcAddress('glRasterPos4fv');
+  glRasterPos4i := dglGetProcAddress('glRasterPos4i');
+  glRasterPos4iv := dglGetProcAddress('glRasterPos4iv');
+  glRasterPos4s := dglGetProcAddress('glRasterPos4s');
+  glRasterPos4sv := dglGetProcAddress('glRasterPos4sv');
+  glRectd := dglGetProcAddress('glRectd');
+  glRectdv := dglGetProcAddress('glRectdv');
+  glRectf := dglGetProcAddress('glRectf');
+  glRectfv := dglGetProcAddress('glRectfv');
+  glRecti := dglGetProcAddress('glRecti');
+  glRectiv := dglGetProcAddress('glRectiv');
+  glRects := dglGetProcAddress('glRects');
+  glRectsv := dglGetProcAddress('glRectsv');
+  glRenderMode := dglGetProcAddress('glRenderMode');
+  glRotated := dglGetProcAddress('glRotated');
+  glRotatef := dglGetProcAddress('glRotatef');
+  glScaled := dglGetProcAddress('glScaled');
+  glScalef := dglGetProcAddress('glScalef');
+  glSelectBuffer := dglGetProcAddress('glSelectBuffer');
+  glShadeModel := dglGetProcAddress('glShadeModel');
+  glTexCoord1d := dglGetProcAddress('glTexCoord1d');
+  glTexCoord1dv := dglGetProcAddress('glTexCoord1dv');
+  glTexCoord1f := dglGetProcAddress('glTexCoord1f');
+  glTexCoord1fv := dglGetProcAddress('glTexCoord1fv');
+  glTexCoord1i := dglGetProcAddress('glTexCoord1i');
+  glTexCoord1iv := dglGetProcAddress('glTexCoord1iv');
+  glTexCoord1s := dglGetProcAddress('glTexCoord1s');
+  glTexCoord1sv := dglGetProcAddress('glTexCoord1sv');
+  glTexCoord2d := dglGetProcAddress('glTexCoord2d');
+  glTexCoord2dv := dglGetProcAddress('glTexCoord2dv');
+  glTexCoord2f := dglGetProcAddress('glTexCoord2f');
+  glTexCoord2fv := dglGetProcAddress('glTexCoord2fv');
+  glTexCoord2i := dglGetProcAddress('glTexCoord2i');
+  glTexCoord2iv := dglGetProcAddress('glTexCoord2iv');
+  glTexCoord2s := dglGetProcAddress('glTexCoord2s');
+  glTexCoord2sv := dglGetProcAddress('glTexCoord2sv');
+  glTexCoord3d := dglGetProcAddress('glTexCoord3d');
+  glTexCoord3dv := dglGetProcAddress('glTexCoord3dv');
+  glTexCoord3f := dglGetProcAddress('glTexCoord3f');
+  glTexCoord3fv := dglGetProcAddress('glTexCoord3fv');
+  glTexCoord3i := dglGetProcAddress('glTexCoord3i');
+  glTexCoord3iv := dglGetProcAddress('glTexCoord3iv');
+  glTexCoord3s := dglGetProcAddress('glTexCoord3s');
+  glTexCoord3sv := dglGetProcAddress('glTexCoord3sv');
+  glTexCoord4d := dglGetProcAddress('glTexCoord4d');
+  glTexCoord4dv := dglGetProcAddress('glTexCoord4dv');
+  glTexCoord4f := dglGetProcAddress('glTexCoord4f');
+  glTexCoord4fv := dglGetProcAddress('glTexCoord4fv');
+  glTexCoord4i := dglGetProcAddress('glTexCoord4i');
+  glTexCoord4iv := dglGetProcAddress('glTexCoord4iv');
+  glTexCoord4s := dglGetProcAddress('glTexCoord4s');
+  glTexCoord4sv := dglGetProcAddress('glTexCoord4sv');
+  glTexCoordPointer := dglGetProcAddress('glTexCoordPointer');
+  glTexEnvf := dglGetProcAddress('glTexEnvf');
+  glTexEnvfv := dglGetProcAddress('glTexEnvfv');
+  glTexEnvi := dglGetProcAddress('glTexEnvi');
+  glTexEnviv := dglGetProcAddress('glTexEnviv');
+  glTexGend := dglGetProcAddress('glTexGend');
+  glTexGendv := dglGetProcAddress('glTexGendv');
+  glTexGenf := dglGetProcAddress('glTexGenf');
+  glTexGenfv := dglGetProcAddress('glTexGenfv');
+  glTexGeni := dglGetProcAddress('glTexGeni');
+  glTexGeniv := dglGetProcAddress('glTexGeniv');
+  glTranslated := dglGetProcAddress('glTranslated');
+  glTranslatef := dglGetProcAddress('glTranslatef');
+  glVertex2d := dglGetProcAddress('glVertex2d');
+  glVertex2dv := dglGetProcAddress('glVertex2dv');
+  glVertex2f := dglGetProcAddress('glVertex2f');
+  glVertex2fv := dglGetProcAddress('glVertex2fv');
+  glVertex2i := dglGetProcAddress('glVertex2i');
+  glVertex2iv := dglGetProcAddress('glVertex2iv');
+  glVertex2s := dglGetProcAddress('glVertex2s');
+  glVertex2sv := dglGetProcAddress('glVertex2sv');
+  glVertex3d := dglGetProcAddress('glVertex3d');
+  glVertex3dv := dglGetProcAddress('glVertex3dv');
+  glVertex3f := dglGetProcAddress('glVertex3f');
+  glVertex3fv := dglGetProcAddress('glVertex3fv');
+  glVertex3i := dglGetProcAddress('glVertex3i');
+  glVertex3iv := dglGetProcAddress('glVertex3iv');
+  glVertex3s := dglGetProcAddress('glVertex3s');
+  glVertex3sv := dglGetProcAddress('glVertex3sv');
+  glVertex4d := dglGetProcAddress('glVertex4d');
+  glVertex4dv := dglGetProcAddress('glVertex4dv');
+  glVertex4f := dglGetProcAddress('glVertex4f');
+  glVertex4fv := dglGetProcAddress('glVertex4fv');
+  glVertex4i := dglGetProcAddress('glVertex4i');
+  glVertex4iv := dglGetProcAddress('glVertex4iv');
+  glVertex4s := dglGetProcAddress('glVertex4s');
+  glVertex4sv := dglGetProcAddress('glVertex4sv');
+  glVertexPointer := dglGetProcAddress('glVertexPointer');
+{$endif}
+
+  // GL_VERSION_1_2
+  glBlendColor := dglGetProcAddress('glBlendColor');
+  glBlendEquation := dglGetProcAddress('glBlendEquation');
+  glDrawRangeElements := dglGetProcAddress('glDrawRangeElements');
+  glTexImage3D := dglGetProcAddress('glTexImage3D');
+  glTexSubImage3D := dglGetProcAddress('glTexSubImage3D');
+  glCopyTexSubImage3D := dglGetProcAddress('glCopyTexSubImage3D');
+{$ifdef DGL_DEPRECATED}
+  glColorTable := dglGetProcAddress('glColorTable');
+  glColorTableParameterfv := dglGetProcAddress('glColorTableParameterfv');
+  glColorTableParameteriv := dglGetProcAddress('glColorTableParameteriv');
+  glCopyColorTable := dglGetProcAddress('glCopyColorTable');
+  glGetColorTable := dglGetProcAddress('glGetColorTable');
+  glGetColorTableParameterfv := dglGetProcAddress('glGetColorTableParameterfv');
+  glGetColorTableParameteriv := dglGetProcAddress('glGetColorTableParameteriv');
+  glColorSubTable := dglGetProcAddress('glColorSubTable');
+  glCopyColorSubTable := dglGetProcAddress('glCopyColorSubTable');
+  glConvolutionFilter1D := dglGetProcAddress('glConvolutionFilter1D');
+  glConvolutionFilter2D := dglGetProcAddress('glConvolutionFilter2D');
+  glConvolutionParameterf := dglGetProcAddress('glConvolutionParameterf');
+  glConvolutionParameterfv := dglGetProcAddress('glConvolutionParameterfv');
+  glConvolutionParameteri := dglGetProcAddress('glConvolutionParameteri');
+  glConvolutionParameteriv := dglGetProcAddress('glConvolutionParameteriv');
+  glCopyConvolutionFilter1D := dglGetProcAddress('glCopyConvolutionFilter1D');
+  glCopyConvolutionFilter2D := dglGetProcAddress('glCopyConvolutionFilter2D');
+  glGetConvolutionFilter := dglGetProcAddress('glGetConvolutionFilter');
+  glGetConvolutionParameterfv := dglGetProcAddress('glGetConvolutionParameterfv');
+  glGetConvolutionParameteriv := dglGetProcAddress('glGetConvolutionParameteriv');
+  glGetSeparableFilter := dglGetProcAddress('glGetSeparableFilter');
+  glSeparableFilter2D := dglGetProcAddress('glSeparableFilter2D');
+  glGetHistogram := dglGetProcAddress('glGetHistogram');
+  glGetHistogramParameterfv := dglGetProcAddress('glGetHistogramParameterfv');
+  glGetHistogramParameteriv := dglGetProcAddress('glGetHistogramParameteriv');
+  glGetMinmax := dglGetProcAddress('glGetMinmax');
+  glGetMinmaxParameterfv := dglGetProcAddress('glGetMinmaxParameterfv');
+  glGetMinmaxParameteriv := dglGetProcAddress('glGetMinmaxParameteriv');
+  glHistogram := dglGetProcAddress('glHistogram');
+  glMinmax := dglGetProcAddress('glMinmax');
+  glResetHistogram := dglGetProcAddress('glResetHistogram');
+  glResetMinmax := dglGetProcAddress('glResetMinmax');
+{$endif}
+
+  // GL_VERSION_1_3
+  glActiveTexture := dglGetProcAddress('glActiveTexture');
+  glSampleCoverage := dglGetProcAddress('glSampleCoverage');
+  glCompressedTexImage3D := dglGetProcAddress('glCompressedTexImage3D');
+  glCompressedTexImage2D := dglGetProcAddress('glCompressedTexImage2D');
+  glCompressedTexImage1D := dglGetProcAddress('glCompressedTexImage1D');
+  glCompressedTexSubImage3D := dglGetProcAddress('glCompressedTexSubImage3D');
+  glCompressedTexSubImage2D := dglGetProcAddress('glCompressedTexSubImage2D');
+  glCompressedTexSubImage1D := dglGetProcAddress('glCompressedTexSubImage1D');
+  glGetCompressedTexImage := dglGetProcAddress('glGetCompressedTexImage');
+{$ifdef DGL_DEPRECATED}
+  glClientActiveTexture := dglGetProcAddress('glClientActiveTexture');
+  glMultiTexCoord1d := dglGetProcAddress('glMultiTexCoord1d');
+  glMultiTexCoord1dv := dglGetProcAddress('glMultiTexCoord1dv');
+  glMultiTexCoord1f := dglGetProcAddress('glMultiTexCoord1f');
+  glMultiTexCoord1fv := dglGetProcAddress('glMultiTexCoord1fv');
+  glMultiTexCoord1i := dglGetProcAddress('glMultiTexCoord1i');
+  glMultiTexCoord1iv := dglGetProcAddress('glMultiTexCoord1iv');
+  glMultiTexCoord1s := dglGetProcAddress('glMultiTexCoord1s');
+  glMultiTexCoord1sv := dglGetProcAddress('glMultiTexCoord1sv');
+  glMultiTexCoord2d := dglGetProcAddress('glMultiTexCoord2d');
+  glMultiTexCoord2dv := dglGetProcAddress('glMultiTexCoord2dv');
+  glMultiTexCoord2f := dglGetProcAddress('glMultiTexCoord2f');
+  glMultiTexCoord2fv := dglGetProcAddress('glMultiTexCoord2fv');
+  glMultiTexCoord2i := dglGetProcAddress('glMultiTexCoord2i');
+  glMultiTexCoord2iv := dglGetProcAddress('glMultiTexCoord2iv');
+  glMultiTexCoord2s := dglGetProcAddress('glMultiTexCoord2s');
+  glMultiTexCoord2sv := dglGetProcAddress('glMultiTexCoord2sv');
+  glMultiTexCoord3d := dglGetProcAddress('glMultiTexCoord3d');
+  glMultiTexCoord3dv := dglGetProcAddress('glMultiTexCoord3dv');
+  glMultiTexCoord3f := dglGetProcAddress('glMultiTexCoord3f');
+  glMultiTexCoord3fv := dglGetProcAddress('glMultiTexCoord3fv');
+  glMultiTexCoord3i := dglGetProcAddress('glMultiTexCoord3i');
+  glMultiTexCoord3iv := dglGetProcAddress('glMultiTexCoord3iv');
+  glMultiTexCoord3s := dglGetProcAddress('glMultiTexCoord3s');
+  glMultiTexCoord3sv := dglGetProcAddress('glMultiTexCoord3sv');
+  glMultiTexCoord4d := dglGetProcAddress('glMultiTexCoord4d');
+  glMultiTexCoord4dv := dglGetProcAddress('glMultiTexCoord4dv');
+  glMultiTexCoord4f := dglGetProcAddress('glMultiTexCoord4f');
+  glMultiTexCoord4fv := dglGetProcAddress('glMultiTexCoord4fv');
+  glMultiTexCoord4i := dglGetProcAddress('glMultiTexCoord4i');
+  glMultiTexCoord4iv := dglGetProcAddress('glMultiTexCoord4iv');
+  glMultiTexCoord4s := dglGetProcAddress('glMultiTexCoord4s');
+  glMultiTexCoord4sv := dglGetProcAddress('glMultiTexCoord4sv');
+  glLoadTransposeMatrixf := dglGetProcAddress('glLoadTransposeMatrixf');
+  glLoadTransposeMatrixd := dglGetProcAddress('glLoadTransposeMatrixd');
+  glMultTransposeMatrixf := dglGetProcAddress('glMultTransposeMatrixf');
+  glMultTransposeMatrixd := dglGetProcAddress('glMultTransposeMatrixd');
+{$endif}
+
+  // GL_VERSION_1_4
+  glBlendFuncSeparate := dglGetProcAddress('glBlendFuncSeparate');
+  glMultiDrawArrays := dglGetProcAddress('glMultiDrawArrays');
+  glMultiDrawElements := dglGetProcAddress('glMultiDrawElements');
+  glPointParameterf := dglGetProcAddress('glPointParameterf');
+  glPointParameterfv := dglGetProcAddress('glPointParameterfv');
+  glPointParameteri := dglGetProcAddress('glPointParameteri');
+  glPointParameteriv := dglGetProcAddress('glPointParameteriv');
+{$ifdef DGL_DEPRECATED}
+  glFogCoordf := dglGetProcAddress('glFogCoordf');
+  glFogCoordfv := dglGetProcAddress('glFogCoordfv');
+  glFogCoordd := dglGetProcAddress('glFogCoordd');
+  glFogCoorddv := dglGetProcAddress('glFogCoorddv');
+  glFogCoordPointer := dglGetProcAddress('glFogCoordPointer');
+  glSecondaryColor3b := dglGetProcAddress('glSecondaryColor3b');
+  glSecondaryColor3bv := dglGetProcAddress('glSecondaryColor3bv');
+  glSecondaryColor3d := dglGetProcAddress('glSecondaryColor3d');
+  glSecondaryColor3dv := dglGetProcAddress('glSecondaryColor3dv');
+  glSecondaryColor3f := dglGetProcAddress('glSecondaryColor3f');
+  glSecondaryColor3fv := dglGetProcAddress('glSecondaryColor3fv');
+  glSecondaryColor3i := dglGetProcAddress('glSecondaryColor3i');
+  glSecondaryColor3iv := dglGetProcAddress('glSecondaryColor3iv');
+  glSecondaryColor3s := dglGetProcAddress('glSecondaryColor3s');
+  glSecondaryColor3sv := dglGetProcAddress('glSecondaryColor3sv');
+  glSecondaryColor3ub := dglGetProcAddress('glSecondaryColor3ub');
+  glSecondaryColor3ubv := dglGetProcAddress('glSecondaryColor3ubv');
+  glSecondaryColor3ui := dglGetProcAddress('glSecondaryColor3ui');
+  glSecondaryColor3uiv := dglGetProcAddress('glSecondaryColor3uiv');
+  glSecondaryColor3us := dglGetProcAddress('glSecondaryColor3us');
+  glSecondaryColor3usv := dglGetProcAddress('glSecondaryColor3usv');
+  glSecondaryColorPointer := dglGetProcAddress('glSecondaryColorPointer');
+  glWindowPos2d := dglGetProcAddress('glWindowPos2d');
+  glWindowPos2dv := dglGetProcAddress('glWindowPos2dv');
+  glWindowPos2f := dglGetProcAddress('glWindowPos2f');
+  glWindowPos2fv := dglGetProcAddress('glWindowPos2fv');
+  glWindowPos2i := dglGetProcAddress('glWindowPos2i');
+  glWindowPos2iv := dglGetProcAddress('glWindowPos2iv');
+  glWindowPos2s := dglGetProcAddress('glWindowPos2s');
+  glWindowPos2sv := dglGetProcAddress('glWindowPos2sv');
+  glWindowPos3d := dglGetProcAddress('glWindowPos3d');
+  glWindowPos3dv := dglGetProcAddress('glWindowPos3dv');
+  glWindowPos3f := dglGetProcAddress('glWindowPos3f');
+  glWindowPos3fv := dglGetProcAddress('glWindowPos3fv');
+  glWindowPos3i := dglGetProcAddress('glWindowPos3i');
+  glWindowPos3iv := dglGetProcAddress('glWindowPos3iv');
+  glWindowPos3s := dglGetProcAddress('glWindowPos3s');
+  glWindowPos3sv := dglGetProcAddress('glWindowPos3sv');
+{$endif}
+
+  // GL_VERSION_1_5
+  glGenQueries := dglGetProcAddress('glGenQueries');
+  glDeleteQueries := dglGetProcAddress('glDeleteQueries');
+  glIsQuery := dglGetProcAddress('glIsQuery');
+  glBeginQuery := dglGetProcAddress('glBeginQuery');
+  glEndQuery := dglGetProcAddress('glEndQuery');
+  glGetQueryiv := dglGetProcAddress('glGetQueryiv');
+  glGetQueryObjectiv := dglGetProcAddress('glGetQueryObjectiv');
+  glGetQueryObjectuiv := dglGetProcAddress('glGetQueryObjectuiv');
+  glBindBuffer := dglGetProcAddress('glBindBuffer');
+  glDeleteBuffers := dglGetProcAddress('glDeleteBuffers');
+  glGenBuffers := dglGetProcAddress('glGenBuffers');
+  glIsBuffer := dglGetProcAddress('glIsBuffer');
+  glBufferData := dglGetProcAddress('glBufferData');
+  glBufferSubData := dglGetProcAddress('glBufferSubData');
+  glGetBufferSubData := dglGetProcAddress('glGetBufferSubData');
+  glMapBuffer := dglGetProcAddress('glMapBuffer');
+  glUnmapBuffer := dglGetProcAddress('glUnmapBuffer');
+  glGetBufferParameteriv := dglGetProcAddress('glGetBufferParameteriv');
+  glGetBufferPointerv := dglGetProcAddress('glGetBufferPointerv');
+
+  // GL_VERSION_2_0
+  glBlendEquationSeparate := dglGetProcAddress('glBlendEquationSeparate');
+  glDrawBuffers := dglGetProcAddress('glDrawBuffers');
+  glStencilOpSeparate := dglGetProcAddress('glStencilOpSeparate');
+  glStencilFuncSeparate := dglGetProcAddress('glStencilFuncSeparate');
+  glStencilMaskSeparate := dglGetProcAddress('glStencilMaskSeparate');
+  glAttachShader := dglGetProcAddress('glAttachShader');
+  glBindAttribLocation := dglGetProcAddress('glBindAttribLocation');
+  glCompileShader := dglGetProcAddress('glCompileShader');
+  glCreateProgram := dglGetProcAddress('glCreateProgram');
+  glCreateShader := dglGetProcAddress('glCreateShader');
+  glDeleteProgram := dglGetProcAddress('glDeleteProgram');
+  glDeleteShader := dglGetProcAddress('glDeleteShader');
+  glDetachShader := dglGetProcAddress('glDetachShader');
+  glDisableVertexAttribArray := dglGetProcAddress('glDisableVertexAttribArray');
+  glEnableVertexAttribArray := dglGetProcAddress('glEnableVertexAttribArray');
+  glGetActiveAttrib := dglGetProcAddress('glGetActiveAttrib');
+  glGetActiveUniform := dglGetProcAddress('glGetActiveUniform');
+  glGetAttachedShaders := dglGetProcAddress('glGetAttachedShaders');
+  glGetAttribLocation := dglGetProcAddress('glGetAttribLocation');
+  glGetProgramiv := dglGetProcAddress('glGetProgramiv');
+  glGetProgramInfoLog := dglGetProcAddress('glGetProgramInfoLog');
+  glGetShaderiv := dglGetProcAddress('glGetShaderiv');
+  glGetShaderInfoLog := dglGetProcAddress('glGetShaderInfoLog');
+  glGetShaderSource := dglGetProcAddress('glGetShaderSource');
+  glGetUniformLocation := dglGetProcAddress('glGetUniformLocation');
+  glGetUniformfv := dglGetProcAddress('glGetUniformfv');
+  glGetUniformiv := dglGetProcAddress('glGetUniformiv');
+  glGetVertexAttribfv := dglGetProcAddress('glGetVertexAttribfv');
+  glGetVertexAttribiv := dglGetProcAddress('glGetVertexAttribiv');
+  glGetVertexAttribPointerv := dglGetProcAddress('glGetVertexAttribPointerv');
+  glIsProgram := dglGetProcAddress('glIsProgram');
+  glIsShader := dglGetProcAddress('glIsShader');
+  glLinkProgram := dglGetProcAddress('glLinkProgram');
+  glShaderSource := dglGetProcAddress('glShaderSource');
+  glUseProgram := dglGetProcAddress('glUseProgram');
+  glUniform1f := dglGetProcAddress('glUniform1f');
+  glUniform2f := dglGetProcAddress('glUniform2f');
+  glUniform3f := dglGetProcAddress('glUniform3f');
+  glUniform4f := dglGetProcAddress('glUniform4f');
+  glUniform1i := dglGetProcAddress('glUniform1i');
+  glUniform2i := dglGetProcAddress('glUniform2i');
+  glUniform3i := dglGetProcAddress('glUniform3i');
+  glUniform4i := dglGetProcAddress('glUniform4i');
+  glUniform1fv := dglGetProcAddress('glUniform1fv');
+  glUniform2fv := dglGetProcAddress('glUniform2fv');
+  glUniform3fv := dglGetProcAddress('glUniform3fv');
+  glUniform4fv := dglGetProcAddress('glUniform4fv');
+  glUniform1iv := dglGetProcAddress('glUniform1iv');
+  glUniform2iv := dglGetProcAddress('glUniform2iv');
+  glUniform3iv := dglGetProcAddress('glUniform3iv');
+  glUniform4iv := dglGetProcAddress('glUniform4iv');
+  glUniformMatrix2fv := dglGetProcAddress('glUniformMatrix2fv');
+  glUniformMatrix3fv := dglGetProcAddress('glUniformMatrix3fv');
+  glUniformMatrix4fv := dglGetProcAddress('glUniformMatrix4fv');
+  glValidateProgram := dglGetProcAddress('glValidateProgram');
+  glVertexAttrib1d := dglGetProcAddress('glVertexAttrib1d');
+  glVertexAttrib1dv := dglGetProcAddress('glVertexAttrib1dv');
+  glVertexAttrib1f := dglGetProcAddress('glVertexAttrib1f');
+  glVertexAttrib1fv := dglGetProcAddress('glVertexAttrib1fv');
+  glVertexAttrib1s := dglGetProcAddress('glVertexAttrib1s');
+  glVertexAttrib1sv := dglGetProcAddress('glVertexAttrib1sv');
+  glVertexAttrib2d := dglGetProcAddress('glVertexAttrib2d');
+  glVertexAttrib2dv := dglGetProcAddress('glVertexAttrib2dv');
+  glVertexAttrib2f := dglGetProcAddress('glVertexAttrib2f');
+  glVertexAttrib2fv := dglGetProcAddress('glVertexAttrib2fv');
+  glVertexAttrib2s := dglGetProcAddress('glVertexAttrib2s');
+  glVertexAttrib2sv := dglGetProcAddress('glVertexAttrib2sv');
+  glVertexAttrib3d := dglGetProcAddress('glVertexAttrib3d');
+  glVertexAttrib3dv := dglGetProcAddress('glVertexAttrib3dv');
+  glVertexAttrib3f := dglGetProcAddress('glVertexAttrib3f');
+  glVertexAttrib3fv := dglGetProcAddress('glVertexAttrib3fv');
+  glVertexAttrib3s := dglGetProcAddress('glVertexAttrib3s');
+  glVertexAttrib3sv := dglGetProcAddress('glVertexAttrib3sv');
+  glVertexAttrib4Nbv := dglGetProcAddress('glVertexAttrib4Nbv');
+  glVertexAttrib4Niv := dglGetProcAddress('glVertexAttrib4Niv');
+  glVertexAttrib4Nsv := dglGetProcAddress('glVertexAttrib4Nsv');
+  glVertexAttrib4Nub := dglGetProcAddress('glVertexAttrib4Nub');
+  glVertexAttrib4Nubv := dglGetProcAddress('glVertexAttrib4Nubv');
+  glVertexAttrib4Nuiv := dglGetProcAddress('glVertexAttrib4Nuiv');
+  glVertexAttrib4Nusv := dglGetProcAddress('glVertexAttrib4Nusv');
+  glVertexAttrib4bv := dglGetProcAddress('glVertexAttrib4bv');
+  glVertexAttrib4d := dglGetProcAddress('glVertexAttrib4d');
+  glVertexAttrib4dv := dglGetProcAddress('glVertexAttrib4dv');
+  glVertexAttrib4f := dglGetProcAddress('glVertexAttrib4f');
+  glVertexAttrib4fv := dglGetProcAddress('glVertexAttrib4fv');
+  glVertexAttrib4iv := dglGetProcAddress('glVertexAttrib4iv');
+  glVertexAttrib4s := dglGetProcAddress('glVertexAttrib4s');
+  glVertexAttrib4sv := dglGetProcAddress('glVertexAttrib4sv');
+  glVertexAttrib4ubv := dglGetProcAddress('glVertexAttrib4ubv');
+  glVertexAttrib4uiv := dglGetProcAddress('glVertexAttrib4uiv');
+  glVertexAttrib4usv := dglGetProcAddress('glVertexAttrib4usv');
+  glVertexAttribPointer := dglGetProcAddress('glVertexAttribPointer');
+
+  // GL_VERSION_2_1
+  glUniformMatrix2x3fv := dglGetProcAddress('glUniformMatrix2x3fv');
+  glUniformMatrix3x2fv := dglGetProcAddress('glUniformMatrix3x2fv');
+  glUniformMatrix2x4fv := dglGetProcAddress('glUniformMatrix2x4fv');
+  glUniformMatrix4x2fv := dglGetProcAddress('glUniformMatrix4x2fv');
+  glUniformMatrix3x4fv := dglGetProcAddress('glUniformMatrix3x4fv');
+  glUniformMatrix4x3fv := dglGetProcAddress('glUniformMatrix4x3fv');
+  
+  // GL_VERSION_3_0
+  { OpenGL 3.0 also reuses entry points from these extensions: }
+  Read_GL_ARB_framebuffer_object;
+  Read_GL_ARB_map_buffer_range;
+  Read_GL_ARB_vertex_array_object;
+
+  glColorMaski := dglGetProcAddress('glColorMaski');
+  glGetBooleani_v := dglGetProcAddress('glGetBooleani_v');
+  glGetIntegeri_v := dglGetProcAddress('glGetIntegeri_v');
+  glEnablei := dglGetProcAddress('glEnablei');
+  glDisablei := dglGetProcAddress('glDisablei');
+  glIsEnabledi := dglGetProcAddress('glIsEnabledi');
+  glBeginTransformFeedback := dglGetProcAddress('glBeginTransformFeedback');
+  glEndTransformFeedback := dglGetProcAddress('glEndTransformFeedback');
+  glBindBufferRange := dglGetProcAddress('glBindBufferRange');
+  glBindBufferBase := dglGetProcAddress('glBindBufferBase');
+  glTransformFeedbackVaryings := dglGetProcAddress('glTransformFeedbackVaryings');
+  glGetTransformFeedbackVarying := dglGetProcAddress('glGetTransformFeedbackVarying');
+  glClampColor := dglGetProcAddress('glClampColor');
+  glBeginConditionalRender := dglGetProcAddress('glBeginConditionalRender');
+  glEndConditionalRender := dglGetProcAddress('glEndConditionalRender');
+  glVertexAttribI1i := dglGetProcAddress('glVertexAttribI1i');
+  glVertexAttribI2i := dglGetProcAddress('glVertexAttribI2i');
+  glVertexAttribI3i := dglGetProcAddress('glVertexAttribI3i');
+  glVertexAttribI4i := dglGetProcAddress('glVertexAttribI4i');
+  glVertexAttribI1ui := dglGetProcAddress('glVertexAttribI1ui');
+  glVertexAttribI2ui := dglGetProcAddress('glVertexAttribI2ui');
+  glVertexAttribI3ui := dglGetProcAddress('glVertexAttribI3ui');
+  glVertexAttribI4ui := dglGetProcAddress('glVertexAttribI4ui');
+  glVertexAttribI1iv := dglGetProcAddress('glVertexAttribI1iv');
+  glVertexAttribI2iv := dglGetProcAddress('glVertexAttribI2iv');
+  glVertexAttribI3iv := dglGetProcAddress('glVertexAttribI3iv');
+  glVertexAttribI4iv := dglGetProcAddress('glVertexAttribI4iv');
+  glVertexAttribI1uiv := dglGetProcAddress('glVertexAttribI1uiv');
+  glVertexAttribI2uiv := dglGetProcAddress('glVertexAttribI2uiv');
+  glVertexAttribI3uiv := dglGetProcAddress('glVertexAttribI3uiv');
+  glVertexAttribI4uiv := dglGetProcAddress('glVertexAttribI4uiv');
+  glVertexAttribI4bv := dglGetProcAddress('glVertexAttribI4bv');
+  glVertexAttribI4sv := dglGetProcAddress('glVertexAttribI4sv');
+  glVertexAttribI4ubv := dglGetProcAddress('glVertexAttribI4ubv');
+  glVertexAttribI4usv := dglGetProcAddress('glVertexAttribI4usv');
+  glVertexAttribIPointer := dglGetProcAddress('glVertexAttribIPointer');
+  glGetVertexAttribIiv := dglGetProcAddress('glGetVertexAttribIiv');
+  glGetVertexAttribIuiv := dglGetProcAddress('glGetVertexAttribIuiv');
+  glGetUniformuiv := dglGetProcAddress('glGetUniformuiv');
+  glBindFragDataLocation := dglGetProcAddress('glBindFragDataLocation');
+  glGetFragDataLocation := dglGetProcAddress('glGetFragDataLocation');
+  glUniform1ui := dglGetProcAddress('glUniform1ui');
+  glUniform2ui := dglGetProcAddress('glUniform2ui');
+  glUniform3ui := dglGetProcAddress('glUniform3ui');
+  glUniform4ui := dglGetProcAddress('glUniform4ui');
+  glUniform1uiv := dglGetProcAddress('glUniform1uiv');
+  glUniform2uiv := dglGetProcAddress('glUniform2uiv');
+  glUniform3uiv := dglGetProcAddress('glUniform3uiv');
+  glUniform4uiv := dglGetProcAddress('glUniform4uiv');
+  glTexParameterIiv := dglGetProcAddress('glTexParameterIiv');
+  glTexParameterIuiv := dglGetProcAddress('glTexParameterIuiv');
+  glGetTexParameterIiv := dglGetProcAddress('glGetTexParameterIiv');
+  glGetTexParameterIuiv := dglGetProcAddress('glGetTexParameterIuiv');
+  glClearBufferiv := dglGetProcAddress('glClearBufferiv');
+  glClearBufferuiv := dglGetProcAddress('glClearBufferuiv');
+  glClearBufferfv := dglGetProcAddress('glClearBufferfv');
+  glClearBufferfi := dglGetProcAddress('glClearBufferfi');
+  glGetStringi := dglGetProcAddress('glGetStringi');
+
+  // GL_VERSION_2_1
+  glEnableVertexArrayEXT := dglGetProcAddress('glEnableVertexArrayEXT');
+  glEnableVertexArrayAttribEXT := dglGetProcAddress('glEnableVertexArrayAttribEXT');
+  glVertexArrayVertexAttribOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribOffsetEXT');
+
+  // GL_VERSION_3_1
+  { OpenGL 3.1 also reuses entry points from these extensions: }
+  Read_GL_ARB_copy_buffer;
+  Read_GL_ARB_uniform_buffer_object;
+
+  glDrawArraysInstanced := dglGetProcAddress('glDrawArraysInstanced');
+  glDrawElementsInstanced := dglGetProcAddress('glDrawElementsInstanced');
+  glTexBuffer := dglGetProcAddress('glTexBuffer');
+  glPrimitiveRestartIndex := dglGetProcAddress('glPrimitiveRestartIndex');
+
+  // GL_VERSION_3_2
+  { OpenGL 3.2 also reuses entry points from these extensions: }
+  Read_GL_ARB_draw_elements_base_vertex;
+  Read_GL_ARB_provoking_vertex;
+  Read_GL_ARB_sync;
+  Read_GL_ARB_texture_multisample;
+
+  glGetInteger64i_v := dglGetProcAddress('glGetInteger64i_v');
+  glGetBufferParameteri64v := dglGetProcAddress('glGetBufferParameteri64v');
+  glFramebufferTexture := dglGetProcAddress('glFramebufferTexture');
+//  glFramebufferTextureFace := dglGetProcAddress('glFramebufferTextureFace');
+
+  // GL_VERSION_3_3
+  { OpenGL 3.3 also reuses entry points from these extensions: }
+  Read_GL_ARB_blend_func_extended;
+  Read_GL_ARB_sampler_objects;
+  { ARB_explicit_attrib_location, but it has none }
+  { ARB_occlusion_query2 (no entry points) }
+  { ARB_shader_bit_encoding (no entry points) }
+  { ARB_texture_rgb10_a2ui (no entry points) }
+  { ARB_texture_swizzle (no entry points) }
+  Read_GL_ARB_timer_query;
+  Read_GL_ARB_vertex_type_2_10_10_10_rev;
+
+  glVertexAttribDivisor := dglGetProcAddress('glVertexAttribDivisor');
+
+  // GL_VERSION_4_0
+  { OpenGL 4.0 also reuses entry points from these extensions: }
+  { ARB_texture_query_lod (no entry points) }
+  Read_GL_ARB_draw_indirect;
+  { ARB_gpu_shader5 (no entry points) }
+  Read_GL_ARB_gpu_shader_fp64;
+  Read_GL_ARB_shader_subroutine;
+  Read_GL_ARB_tessellation_shader;
+  { ARB_texture_buffer_object_rgb32 (no entry points) }
+  { ARB_texture_cube_map_array (no entry points) }
+  { ARB_texture_gather (no entry points) }
+  Read_GL_ARB_transform_feedback2;
+  Read_GL_ARB_transform_feedback3;
+
+  glMinSampleShading := dglGetProcAddress('glMinSampleShading');
+  glBlendEquationi := dglGetProcAddress('glBlendEquationi');
+  glBlendEquationSeparatei := dglGetProcAddress('glBlendEquationSeparatei');
+  glBlendFunci := dglGetProcAddress('glBlendFunci');
+  glBlendFuncSeparatei := dglGetProcAddress('glBlendFuncSeparatei');
+
+  // GL_VERSION_4_1
+  { OpenGL 4.1 also reuses entry points from these extensions: }
+  Read_GL_ARB_ES2_compatibility;
+  Read_GL_ARB_get_program_binary;
+  Read_GL_ARB_separate_shader_objects;
+  { ARB_shader_precision (no entry points) }
+  Read_GL_ARB_vertex_attrib_64bit;
+  Read_GL_ARB_viewport_array;
+
+  // GL_VERSION_4_2
+  { OpenGL 4.2 reuses entry points from these extensions: }
+  Read_GL_ARB_base_instance;
+  //Read_GL_ARB_shading_language_420pack (no entry points)
+  Read_GL_ARB_transform_feedback_instanced;
+  //Read_GL_ARB_compressed_texture_pixel_storage (no entry points)
+  //Read_GL_ARB_conservative_depth;
+  Read_GL_ARB_internalformat_query;
+  //Read_GL_ARB_map_buffer_alignment;
+  Read_GL_ARB_shader_atomic_counters;
+  Read_GL_ARB_shader_image_load_store;
+  //Read_GL_ARB_shading_language_packing;
+  Read_GL_ARB_texture_storage;
+
+  // GL_VERSION_4_3
+  // OpenGL 4.3 reuses entry points from these extensions:
+  // Read_GL_ARB_arrays_of_arrays (none, GLSL only) (no entry points)
+  // Read_GL_ARB_fragment_layer_viewport (none, GLSL only) (no entry points)
+  // Read_GL_ARB_shader_image_size (none, GLSL only) (no entry points)
+  // Read_GL_ARB_ES3_compatibility (no entry points)
+  Read_GL_ARB_clear_buffer_object;
+  Read_GL_ARB_compute_shader;
+  Read_GL_ARB_copy_image;
+  Read_GL_KHR_debug;
+  // Read_GL_ARB_explicit_uniform_location  (no entry points)
+  Read_GL_ARB_framebuffer_no_attachments;
+  Read_GL_ARB_internalformat_query2;
+  Read_GL_ARB_invalidate_subdata;
+  Read_GL_ARB_multi_draw_indirect;
+  Read_GL_ARB_program_interface_query;
+  // Read_GL_ARB_robust_buffer_access_behavior (none)  (no entry points)
+  Read_GL_ARB_shader_storage_buffer_object;
+  // Read_GL_ARB_stencil_texturing  (no entry points)
+  Read_GL_ARB_texture_buffer_range;
+  // Read_GL_ARB_texture_query_levels (none)  (no entry points)
+  Read_GL_ARB_texture_storage_multisample;
+  Read_GL_ARB_texture_view;
+  Read_GL_ARB_vertex_attrib_binding;
+
+  // GL_VERSION_4_4
+  //  Note (Due to Khronos' change in header conventions, no more single read_ functions)
+  Read_GL_4_4;
+end;
+
+procedure Read_GL_3DFX_tbuffer;
+begin
+  glTbufferMask3DFX := dglGetProcAddress('glTbufferMask3DFX');
+end;
+
+procedure Read_GL_APPLE_element_array;
+begin
+  glElementPointerAPPLE := dglGetProcAddress('glElementPointerAPPLE');
+  glDrawElementArrayAPPLE := dglGetProcAddress('glDrawElementArrayAPPLE');
+  glDrawRangeElementArrayAPPLE := dglGetProcAddress('glDrawRangeElementArrayAPPLE');
+  glMultiDrawElementArrayAPPLE := dglGetProcAddress('glMultiDrawElementArrayAPPLE');
+  glMultiDrawRangeElementArrayAPPLE := dglGetProcAddress('glMultiDrawRangeElementArrayAPPLE');
+end;
+
+procedure Read_GL_APPLE_fence;
+begin
+  glGenFencesAPPLE := dglGetProcAddress('glGenFencesAPPLE');
+  glDeleteFencesAPPLE := dglGetProcAddress('glDeleteFencesAPPLE');
+  glSetFenceAPPLE := dglGetProcAddress('glSetFenceAPPLE');
+  glIsFenceAPPLE := dglGetProcAddress('glIsFenceAPPLE');
+  glTestFenceAPPLE := dglGetProcAddress('glTestFenceAPPLE');
+  glFinishFenceAPPLE := dglGetProcAddress('glFinishFenceAPPLE');
+  glTestObjectAPPLE := dglGetProcAddress('glTestObjectAPPLE');
+  glFinishObjectAPPLE := dglGetProcAddress('glFinishObjectAPPLE');
+end;
+
+procedure Read_GL_APPLE_vertex_array_object;
+begin
+  glBindVertexArrayAPPLE := dglGetProcAddress('glBindVertexArrayAPPLE');
+  glDeleteVertexArraysAPPLE := dglGetProcAddress('glDeleteVertexArraysAPPLE');
+  glGenVertexArraysAPPLE := dglGetProcAddress('glGenVertexArraysAPPLE');
+  glIsVertexArrayAPPLE := dglGetProcAddress('glIsVertexArrayAPPLE');
+end;
+
+procedure Read_GL_APPLE_vertex_array_range;
+begin
+  glVertexArrayRangeAPPLE := dglGetProcAddress('glVertexArrayRangeAPPLE');
+  glFlushVertexArrayRangeAPPLE := dglGetProcAddress('glFlushVertexArrayRangeAPPLE');
+  glVertexArrayParameteriAPPLE := dglGetProcAddress('glVertexArrayParameteriAPPLE');
+end;
+
+procedure Read_GL_APPLE_texture_range;
+begin
+  glTextureRangeAPPLE := dglGetProcAddress('glTextureRangeAPPLE');
+  glGetTexParameterPointervAPPLE := dglGetProcAddress('glGetTexParameterPointervAPPLE');
+end;
+
+procedure Read_GL_APPLE_vertex_program_evaluators;
+begin
+  glEnableVertexAttribAPPLE := dglGetProcAddress('glEnableVertexAttribAPPLE');
+  glDisableVertexAttribAPPLE := dglGetProcAddress('glDisableVertexAttribAPPLE');
+  glIsVertexAttribEnabledAPPLE := dglGetProcAddress('glIsVertexAttribEnabledAPPLE');
+  glMapVertexAttrib1dAPPLE := dglGetProcAddress('glMapVertexAttrib1dAPPLE');
+  glMapVertexAttrib1fAPPLE := dglGetProcAddress('glMapVertexAttrib1fAPPLE');
+  glMapVertexAttrib2dAPPLE := dglGetProcAddress('glMapVertexAttrib2dAPPLE');
+  glMapVertexAttrib2fAPPLE := dglGetProcAddress('glMapVertexAttrib2fAPPLE');
+end;
+
+procedure Read_GL_APPLE_object_purgeable;
+begin
+  glObjectPurgeableAPPLE := dglGetProcAddress('glObjectPurgeableAPPLE');
+  glObjectUnpurgeableAPPLE := dglGetProcAddress('glObjectUnpurgeableAPPLE');
+  glGetObjectParameterivAPPLE := dglGetProcAddress('glGetObjectParameterivAPPLE');
+end;
+
+procedure Read_GL_ARB_matrix_palette;
+begin
+  glCurrentPaletteMatrixARB := dglGetProcAddress('glCurrentPaletteMatrixARB');
+  glMatrixIndexubvARB := dglGetProcAddress('glMatrixIndexubvARB');
+  glMatrixIndexusvARB := dglGetProcAddress('glMatrixIndexusvARB');
+  glMatrixIndexuivARB := dglGetProcAddress('glMatrixIndexuivARB');
+  glMatrixIndexPointerARB := dglGetProcAddress('glMatrixIndexPointerARB');
+end;
+
+procedure Read_GL_ARB_multisample;
+begin
+  glSampleCoverageARB := dglGetProcAddress('glSampleCoverageARB');
+end;
+
+procedure Read_GL_ARB_multitexture;
+begin
+  glActiveTextureARB := dglGetProcAddress('glActiveTextureARB');
+  glClientActiveTextureARB := dglGetProcAddress('glClientActiveTextureARB');
+  glMultiTexCoord1dARB := dglGetProcAddress('glMultiTexCoord1dARB');
+  glMultiTexCoord1dvARB := dglGetProcAddress('glMultiTexCoord1dvARB');
+  glMultiTexCoord1fARB := dglGetProcAddress('glMultiTexCoord1fARB');
+  glMultiTexCoord1fvARB := dglGetProcAddress('glMultiTexCoord1fvARB');
+  glMultiTexCoord1iARB := dglGetProcAddress('glMultiTexCoord1iARB');
+  glMultiTexCoord1ivARB := dglGetProcAddress('glMultiTexCoord1ivARB');
+  glMultiTexCoord1sARB := dglGetProcAddress('glMultiTexCoord1sARB');
+  glMultiTexCoord1svARB := dglGetProcAddress('glMultiTexCoord1svARB');
+  glMultiTexCoord2dARB := dglGetProcAddress('glMultiTexCoord2dARB');
+  glMultiTexCoord2dvARB := dglGetProcAddress('glMultiTexCoord2dvARB');
+  glMultiTexCoord2fARB := dglGetProcAddress('glMultiTexCoord2fARB');
+  glMultiTexCoord2fvARB := dglGetProcAddress('glMultiTexCoord2fvARB');
+  glMultiTexCoord2iARB := dglGetProcAddress('glMultiTexCoord2iARB');
+  glMultiTexCoord2ivARB := dglGetProcAddress('glMultiTexCoord2ivARB');
+  glMultiTexCoord2sARB := dglGetProcAddress('glMultiTexCoord2sARB');
+  glMultiTexCoord2svARB := dglGetProcAddress('glMultiTexCoord2svARB');
+  glMultiTexCoord3dARB := dglGetProcAddress('glMultiTexCoord3dARB');
+  glMultiTexCoord3dvARB := dglGetProcAddress('glMultiTexCoord3dvARB');
+  glMultiTexCoord3fARB := dglGetProcAddress('glMultiTexCoord3fARB');
+  glMultiTexCoord3fvARB := dglGetProcAddress('glMultiTexCoord3fvARB');
+  glMultiTexCoord3iARB := dglGetProcAddress('glMultiTexCoord3iARB');
+  glMultiTexCoord3ivARB := dglGetProcAddress('glMultiTexCoord3ivARB');
+  glMultiTexCoord3sARB := dglGetProcAddress('glMultiTexCoord3sARB');
+  glMultiTexCoord3svARB := dglGetProcAddress('glMultiTexCoord3svARB');
+  glMultiTexCoord4dARB := dglGetProcAddress('glMultiTexCoord4dARB');
+  glMultiTexCoord4dvARB := dglGetProcAddress('glMultiTexCoord4dvARB');
+  glMultiTexCoord4fARB := dglGetProcAddress('glMultiTexCoord4fARB');
+  glMultiTexCoord4fvARB := dglGetProcAddress('glMultiTexCoord4fvARB');
+  glMultiTexCoord4iARB := dglGetProcAddress('glMultiTexCoord4iARB');
+  glMultiTexCoord4ivARB := dglGetProcAddress('glMultiTexCoord4ivARB');
+  glMultiTexCoord4sARB := dglGetProcAddress('glMultiTexCoord4sARB');
+  glMultiTexCoord4svARB := dglGetProcAddress('glMultiTexCoord4svARB');
+end;
+
+procedure Read_GL_ARB_point_parameters;
+begin
+  glPointParameterfARB := dglGetProcAddress('glPointParameterfARB');
+  glPointParameterfvARB := dglGetProcAddress('glPointParameterfvARB');
+end;
+
+procedure Read_GL_ARB_texture_compression;
+begin
+  glCompressedTexImage3DARB := dglGetProcAddress('glCompressedTexImage3DARB');
+  glCompressedTexImage2DARB := dglGetProcAddress('glCompressedTexImage2DARB');
+  glCompressedTexImage1DARB := dglGetProcAddress('glCompressedTexImage1DARB');
+  glCompressedTexSubImage3DARB := dglGetProcAddress('glCompressedTexSubImage3DARB');
+  glCompressedTexSubImage2DARB := dglGetProcAddress('glCompressedTexSubImage2DARB');
+  glCompressedTexSubImage1DARB := dglGetProcAddress('glCompressedTexSubImage1DARB');
+  glGetCompressedTexImageARB := dglGetProcAddress('glGetCompressedTexImageARB');
+end;
+
+procedure Read_GL_ARB_transpose_matrix;
+begin
+  glLoadTransposeMatrixfARB := dglGetProcAddress('glLoadTransposeMatrixfARB');
+  glLoadTransposeMatrixdARB := dglGetProcAddress('glLoadTransposeMatrixdARB');
+  glMultTransposeMatrixfARB := dglGetProcAddress('glMultTransposeMatrixfARB');
+  glMultTransposeMatrixdARB := dglGetProcAddress('glMultTransposeMatrixdARB');
+end;
+
+procedure Read_GL_ARB_vertex_blend;
+begin
+  glWeightbvARB := dglGetProcAddress('glWeightbvARB');
+  glWeightsvARB := dglGetProcAddress('glWeightsvARB');
+  glWeightivARB := dglGetProcAddress('glWeightivARB');
+  glWeightfvARB := dglGetProcAddress('glWeightfvARB');
+  glWeightdvARB := dglGetProcAddress('glWeightdvARB');
+  glWeightubvARB := dglGetProcAddress('glWeightubvARB');
+  glWeightusvARB := dglGetProcAddress('glWeightusvARB');
+  glWeightuivARB := dglGetProcAddress('glWeightuivARB');
+  glWeightPointerARB := dglGetProcAddress('glWeightPointerARB');
+  glVertexBlendARB := dglGetProcAddress('glVertexBlendARB');
+end;
+
+procedure Read_GL_ARB_vertex_buffer_object;
+begin
+  glBindBufferARB := dglGetProcAddress('glBindBufferARB');
+  glDeleteBuffersARB := dglGetProcAddress('glDeleteBuffersARB');
+  glGenBuffersARB := dglGetProcAddress('glGenBuffersARB');
+  glIsBufferARB := dglGetProcAddress('glIsBufferARB');
+  glBufferDataARB := dglGetProcAddress('glBufferDataARB');
+  glBufferSubDataARB := dglGetProcAddress('glBufferSubDataARB');
+  glGetBufferSubDataARB := dglGetProcAddress('glGetBufferSubDataARB');
+  glMapBufferARB := dglGetProcAddress('glMapBufferARB');
+  glUnmapBufferARB := dglGetProcAddress('glUnmapBufferARB');
+  glGetBufferParameterivARB := dglGetProcAddress('glGetBufferParameterivARB');
+  glGetBufferPointervARB := dglGetProcAddress('glGetBufferPointervARB');
+end;
+
+procedure Read_GL_ARB_vertex_program;
+begin
+  glVertexAttrib1dARB := dglGetProcAddress('glVertexAttrib1dARB');
+  glVertexAttrib1dvARB := dglGetProcAddress('glVertexAttrib1dvARB');
+  glVertexAttrib1fARB := dglGetProcAddress('glVertexAttrib1fARB');
+  glVertexAttrib1fvARB := dglGetProcAddress('glVertexAttrib1fvARB');
+  glVertexAttrib1sARB := dglGetProcAddress('glVertexAttrib1sARB');
+  glVertexAttrib1svARB := dglGetProcAddress('glVertexAttrib1svARB');
+  glVertexAttrib2dARB := dglGetProcAddress('glVertexAttrib2dARB');
+  glVertexAttrib2dvARB := dglGetProcAddress('glVertexAttrib2dvARB');
+  glVertexAttrib2fARB := dglGetProcAddress('glVertexAttrib2fARB');
+  glVertexAttrib2fvARB := dglGetProcAddress('glVertexAttrib2fvARB');
+  glVertexAttrib2sARB := dglGetProcAddress('glVertexAttrib2sARB');
+  glVertexAttrib2svARB := dglGetProcAddress('glVertexAttrib2svARB');
+  glVertexAttrib3dARB := dglGetProcAddress('glVertexAttrib3dARB');
+  glVertexAttrib3dvARB := dglGetProcAddress('glVertexAttrib3dvARB');
+  glVertexAttrib3fARB := dglGetProcAddress('glVertexAttrib3fARB');
+  glVertexAttrib3fvARB := dglGetProcAddress('glVertexAttrib3fvARB');
+  glVertexAttrib3sARB := dglGetProcAddress('glVertexAttrib3sARB');
+  glVertexAttrib3svARB := dglGetProcAddress('glVertexAttrib3svARB');
+  glVertexAttrib4NbvARB := dglGetProcAddress('glVertexAttrib4NbvARB');
+  glVertexAttrib4NivARB := dglGetProcAddress('glVertexAttrib4NivARB');
+  glVertexAttrib4NsvARB := dglGetProcAddress('glVertexAttrib4NsvARB');
+  glVertexAttrib4NubARB := dglGetProcAddress('glVertexAttrib4NubARB');
+  glVertexAttrib4NubvARB := dglGetProcAddress('glVertexAttrib4NubvARB');
+  glVertexAttrib4NuivARB := dglGetProcAddress('glVertexAttrib4NuivARB');
+  glVertexAttrib4NusvARB := dglGetProcAddress('glVertexAttrib4NusvARB');
+  glVertexAttrib4bvARB := dglGetProcAddress('glVertexAttrib4bvARB');
+  glVertexAttrib4dARB := dglGetProcAddress('glVertexAttrib4dARB');
+  glVertexAttrib4dvARB := dglGetProcAddress('glVertexAttrib4dvARB');
+  glVertexAttrib4fARB := dglGetProcAddress('glVertexAttrib4fARB');
+  glVertexAttrib4fvARB := dglGetProcAddress('glVertexAttrib4fvARB');
+  glVertexAttrib4ivARB := dglGetProcAddress('glVertexAttrib4ivARB');
+  glVertexAttrib4sARB := dglGetProcAddress('glVertexAttrib4sARB');
+  glVertexAttrib4svARB := dglGetProcAddress('glVertexAttrib4svARB');
+  glVertexAttrib4ubvARB := dglGetProcAddress('glVertexAttrib4ubvARB');
+  glVertexAttrib4uivARB := dglGetProcAddress('glVertexAttrib4uivARB');
+  glVertexAttrib4usvARB := dglGetProcAddress('glVertexAttrib4usvARB');
+  glVertexAttribPointerARB := dglGetProcAddress('glVertexAttribPointerARB');
+  glEnableVertexAttribArrayARB := dglGetProcAddress('glEnableVertexAttribArrayARB');
+  glDisableVertexAttribArrayARB := dglGetProcAddress('glDisableVertexAttribArrayARB');
+  glProgramStringARB := dglGetProcAddress('glProgramStringARB');
+  glBindProgramARB := dglGetProcAddress('glBindProgramARB');
+  glDeleteProgramsARB := dglGetProcAddress('glDeleteProgramsARB');
+  glGenProgramsARB := dglGetProcAddress('glGenProgramsARB');
+  glProgramEnvParameter4dARB := dglGetProcAddress('glProgramEnvParameter4dARB');
+  glProgramEnvParameter4dvARB := dglGetProcAddress('glProgramEnvParameter4dvARB');
+  glProgramEnvParameter4fARB := dglGetProcAddress('glProgramEnvParameter4fARB');
+  glProgramEnvParameter4fvARB := dglGetProcAddress('glProgramEnvParameter4fvARB');
+  glProgramLocalParameter4dARB := dglGetProcAddress('glProgramLocalParameter4dARB');
+  glProgramLocalParameter4dvARB := dglGetProcAddress('glProgramLocalParameter4dvARB');
+  glProgramLocalParameter4fARB := dglGetProcAddress('glProgramLocalParameter4fARB');
+  glProgramLocalParameter4fvARB := dglGetProcAddress('glProgramLocalParameter4fvARB');
+  glGetProgramEnvParameterdvARB := dglGetProcAddress('glGetProgramEnvParameterdvARB');
+  glGetProgramEnvParameterfvARB := dglGetProcAddress('glGetProgramEnvParameterfvARB');
+  glGetProgramLocalParameterdvARB := dglGetProcAddress('glGetProgramLocalParameterdvARB');
+  glGetProgramLocalParameterfvARB := dglGetProcAddress('glGetProgramLocalParameterfvARB');
+  glGetProgramivARB := dglGetProcAddress('glGetProgramivARB');
+  glGetProgramStringARB := dglGetProcAddress('glGetProgramStringARB');
+  glGetVertexAttribdvARB := dglGetProcAddress('glGetVertexAttribdvARB');
+  glGetVertexAttribfvARB := dglGetProcAddress('glGetVertexAttribfvARB');
+  glGetVertexAttribivARB := dglGetProcAddress('glGetVertexAttribivARB');
+  glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB');
+  glIsProgramARB := dglGetProcAddress('glIsProgramARB');
+end;
+
+procedure Read_GL_ARB_window_pos;
+begin
+  glWindowPos2dARB := dglGetProcAddress('glWindowPos2dARB');
+  glWindowPos2dvARB := dglGetProcAddress('glWindowPos2dvARB');
+  glWindowPos2fARB := dglGetProcAddress('glWindowPos2fARB');
+  glWindowPos2fvARB := dglGetProcAddress('glWindowPos2fvARB');
+  glWindowPos2iARB := dglGetProcAddress('glWindowPos2iARB');
+  glWindowPos2ivARB := dglGetProcAddress('glWindowPos2ivARB');
+  glWindowPos2sARB := dglGetProcAddress('glWindowPos2sARB');
+  glWindowPos2svARB := dglGetProcAddress('glWindowPos2svARB');
+  glWindowPos3dARB := dglGetProcAddress('glWindowPos3dARB');
+  glWindowPos3dvARB := dglGetProcAddress('glWindowPos3dvARB');
+  glWindowPos3fARB := dglGetProcAddress('glWindowPos3fARB');
+  glWindowPos3fvARB := dglGetProcAddress('glWindowPos3fvARB');
+  glWindowPos3iARB := dglGetProcAddress('glWindowPos3iARB');
+  glWindowPos3ivARB := dglGetProcAddress('glWindowPos3ivARB');
+  glWindowPos3sARB := dglGetProcAddress('glWindowPos3sARB');
+  glWindowPos3svARB := dglGetProcAddress('glWindowPos3svARB');
+end;
+
+procedure Read_GL_ARB_draw_buffers;
+begin
+  glDrawBuffersARB := dglGetProcAddress('glDrawBuffersARB');
+end;
+
+procedure Read_GL_ARB_color_buffer_float;
+begin
+  glClampColorARB := dglGetProcAddress('glClampColorARB');
+end;
+
+procedure Read_GL_ARB_Shader_Objects;
+begin
+  // GL_ARB_Shader_Objects
+  glCreateShaderObjectARB := dglGetProcAddress('glCreateShaderObjectARB');
+  glShaderSourceARB := dglGetProcAddress('glShaderSourceARB');
+  glCompileShaderARB := dglGetProcAddress('glCompileShaderARB');
+  glDeleteObjectARB := dglGetProcAddress('glDeleteObjectARB');
+  glGetHandleARB := dglGetProcAddress('glGetHandleARB');
+  glDetachObjectARB := dglGetProcAddress('glDetachObjectARB');
+  glCreateProgramObjectARB := dglGetProcAddress('glCreateProgramObjectARB');
+  glAttachObjectARB := dglGetProcAddress('glAttachObjectARB');
+  glLinkProgramARB := dglGetProcAddress('glLinkProgramARB');
+  glUseProgramObjectARB := dglGetProcAddress('glUseProgramObjectARB');
+  glValidateProgramARB := dglGetProcAddress('glValidateProgramARB');
+  glGetObjectParameterfvARB := dglGetProcAddress('glGetObjectParameterfvARB');
+  glGetObjectParameterivARB := dglGetProcAddress('glGetObjectParameterivARB');
+  glGetActiveUniformARB := dglGetProcAddress('glGetActiveUniformARB');
+  glGetAttachedObjectsARB := dglGetProcAddress('glGetAttachedObjectsARB');
+  glGetShaderSourceARB := dglGetProcAddress('glGetShaderSourceARB');
+  glGetUniformfvARB := dglGetProcAddress('glGetUniformfvARB');
+  glGetUniformivARB := dglGetProcAddress('glGetUniformivARB');
+  glGetUniformLocationARB := dglGetProcAddress('glGetUniformLocationARB');
+  glGetInfoLogARB := dglGetProcAddress('glGetInfoLogARB');
+  glUniform1fARB := dglGetProcAddress('glUniform1fARB');
+  glUniform2fARB := dglGetProcAddress('glUniform2fARB');
+  glUniform3fARB := dglGetProcAddress('glUniform3fARB');
+  glUniform4fARB := dglGetProcAddress('glUniform4fARB');
+  glUniform1iARB := dglGetProcAddress('glUniform1iARB');
+  glUniform2iARB := dglGetProcAddress('glUniform2iARB');
+  glUniform3iARB := dglGetProcAddress('glUniform3iARB');
+  glUniform4iARB := dglGetProcAddress('glUniform4iARB');
+  glUniform1fvARB := dglGetProcAddress('glUniform1fvARB');
+  glUniform2fvARB := dglGetProcAddress('glUniform2fvARB');
+  glUniform3fvARB := dglGetProcAddress('glUniform3fvARB');
+  glUniform4fvARB := dglGetProcAddress('glUniform4fvARB');
+  glUniform1ivARB := dglGetProcAddress('glUniform1ivARB');
+  glUniform2ivARB := dglGetProcAddress('glUniform2ivARB');
+  glUniform3ivARB := dglGetProcAddress('glUniform3ivARB');
+  glUniform4ivARB := dglGetProcAddress('glUniform4ivARB');
+  glUniformMatrix2fvARB := dglGetProcAddress('glUniformMatrix2fvARB');
+  glUniformMatrix3fvARB := dglGetProcAddress('glUniformMatrix3fvARB');
+  glUniformMatrix4fvARB := dglGetProcAddress('glUniformMatrix4fvARB');
+
+  // GL_ARB_vertex_shader
+  glGetActiveAttribARB := dglGetProcAddress('glGetActiveAttribARB');
+  glGetAttribLocationARB := dglGetProcAddress('glGetAttribLocationARB');
+  glBindAttribLocationARB := dglGetProcAddress('glBindAttribLocationARB');
+  glGetVertexAttribPointervARB := dglGetProcAddress('glGetVertexAttribPointervARB');
+end;
+
+procedure Read_GL_ARB_occlusion_query;
+begin
+  glGenQueriesARB := dglGetProcAddress('glGenQueriesARB');
+  glDeleteQueriesARB := dglGetProcAddress('glDeleteQueriesARB');
+  glIsQueryARB := dglGetProcAddress('glIsQueryARB');
+  glBeginQueryARB := dglGetProcAddress('glBeginQueryARB');
+  glEndQueryARB := dglGetProcAddress('glEndQueryARB');
+  glGetQueryivARB := dglGetProcAddress('glGetQueryivARB');
+  glGetQueryObjectivARB := dglGetProcAddress('glGetQueryObjectivARB');
+  glGetQueryObjectuivARB := dglGetProcAddress('glGetQueryObjectuivARB');
+end;
+
+procedure Read_GL_ARB_draw_instanced;
+begin
+  glDrawArraysInstancedARB := dglGetProcAddress('glDrawArraysInstancedARB');
+  glDrawElementsInstancedARB := dglGetProcAddress('glDrawElementsInstancedARB');
+end;
+
+procedure Read_GL_ARB_framebuffer_object;
+begin
+  glIsRenderbuffer := dglGetProcAddress('glIsRenderbuffer');
+  glBindRenderbuffer := dglGetProcAddress('glBindRenderbuffer');
+  glDeleteRenderbuffers := dglGetProcAddress('glDeleteRenderbuffers');
+  glGenRenderbuffers := dglGetProcAddress('glGenRenderbuffers');
+  glRenderbufferStorage := dglGetProcAddress('glRenderbufferStorage');
+  glGetRenderbufferParameteriv := dglGetProcAddress('glGetRenderbufferParameteriv');
+  glIsFramebuffer := dglGetProcAddress('glIsFramebuffer');
+  glBindFramebuffer := dglGetProcAddress('glBindFramebuffer');
+  glDeleteFramebuffers := dglGetProcAddress('glDeleteFramebuffers');
+  glGenFramebuffers := dglGetProcAddress('glGenFramebuffers');
+  glCheckFramebufferStatus := dglGetProcAddress('glCheckFramebufferStatus');
+  glFramebufferTexture1D := dglGetProcAddress('glFramebufferTexture1D');
+  glFramebufferTexture2D := dglGetProcAddress('glFramebufferTexture2D');
+  glFramebufferTexture3D := dglGetProcAddress('glFramebufferTexture3D');
+  glFramebufferRenderbuffer := dglGetProcAddress('glFramebufferRenderbuffer');
+  glGetFramebufferAttachmentParameteriv := dglGetProcAddress('glGetFramebufferAttachmentParameteriv');
+  glGenerateMipmap := dglGetProcAddress('glGenerateMipmap');
+  glBlitFramebuffer := dglGetProcAddress('glBlitFramebuffer');
+  glRenderbufferStorageMultisample := dglGetProcAddress('glRenderbufferStorageMultisample');
+  glFramebufferTextureLayer := dglGetProcAddress('glFramebufferTextureLayer');
+end;
+
+procedure Read_GL_ARB_geometry_shader4;
+begin
+  glProgramParameteriARB := dglGetProcAddress('glProgramParameteriARB');
+  glFramebufferTextureARB := dglGetProcAddress('glFramebufferTextureARB');
+  glFramebufferTextureLayerARB := dglGetProcAddress('glFramebufferTextureLayerARB');
+  glFramebufferTextureFaceARB := dglGetProcAddress('glFramebufferTextureFaceARB');
+end;
+
+procedure Read_GL_ARB_instanced_arrays;
+begin
+  glVertexAttribDivisorARB := dglGetProcAddress('glVertexAttribDivisorARB');
+end;
+
+procedure Read_GL_ARB_map_buffer_range;
+begin
+  glMapBufferRange := dglGetProcAddress('glMapBufferRange');
+  glFlushMappedBufferRange := dglGetProcAddress('glFlushMappedBufferRange');
+end;
+
+procedure Read_GL_ARB_texture_buffer_object;
+begin
+  glTexBufferARB := dglGetProcAddress('glTexBufferARB');
+end;
+
+procedure Read_GL_ARB_vertex_array_object;
+begin
+  glBindVertexArray := dglGetProcAddress('glBindVertexArray');
+  glDeleteVertexArrays := dglGetProcAddress('glDeleteVertexArrays');
+  glGenVertexArrays := dglGetProcAddress('glGenVertexArrays');
+  glIsVertexArray := dglGetProcAddress('glIsVertexArray');
+end;
+
+procedure Read_GL_ARB_uniform_buffer_object;
+begin
+  glGetUniformIndices := dglGetProcAddress('glGetUniformIndices');
+  glGetActiveUniformsiv := dglGetProcAddress('glGetActiveUniformsiv');
+  glGetActiveUniformName := dglGetProcAddress('glGetActiveUniformName');
+  glGetUniformBlockIndex := dglGetProcAddress('glGetUniformBlockIndex');
+  glGetActiveUniformBlockiv := dglGetProcAddress('glGetActiveUniformBlockiv');
+  glGetActiveUniformBlockName := dglGetProcAddress('glGetActiveUniformBlockName');
+  glUniformBlockBinding := dglGetProcAddress('glUniformBlockBinding');
+end;
+
+procedure Read_GL_ARB_copy_buffer;
+begin
+  glCopyBufferSubData := dglGetProcAddress('glCopyBufferSubData');
+end;
+
+procedure Read_GL_ARB_draw_elements_base_vertex;
+begin
+  glDrawElementsBaseVertex := dglGetProcAddress('glDrawElementsBaseVertex');
+  glDrawRangeElementsBaseVertex := dglGetProcAddress('glDrawRangeElementsBaseVertex');
+  glDrawElementsInstancedBaseVertex := dglGetProcAddress('glDrawElementsInstancedBaseVertex');
+  glMultiDrawElementsBaseVertex := dglGetProcAddress('glMultiDrawElementsBaseVertex');
+end;
+
+procedure Read_GL_ARB_provoking_vertex;
+begin
+  glProvokingVertex := dglGetProcAddress('glProvokingVertex');
+end;
+
+procedure Read_GL_ARB_sync;
+begin
+  glFenceSync := dglGetProcAddress('glFenceSync');
+  glIsSync := dglGetProcAddress('glIsSync');
+  glDeleteSync := dglGetProcAddress('glDeleteSync');
+  glClientWaitSync := dglGetProcAddress('glClientWaitSync');
+  glWaitSync := dglGetProcAddress('glWaitSync');
+  glGetInteger64v := dglGetProcAddress('glGetInteger64v');
+  glGetSynciv := dglGetProcAddress('glGetSynciv');
+end;
+
+procedure Read_GL_ARB_texture_multisample;
+begin
+  glTexImage2DMultisample := dglGetProcAddress('glTexImage2DMultisample');
+  glTexImage3DMultisample := dglGetProcAddress('glTexImage3DMultisample');
+  glGetMultisamplefv := dglGetProcAddress('glGetMultisamplefv');
+  glSampleMaski := dglGetProcAddress('glSampleMaski');
+end;
+
+procedure Read_GL_ARB_draw_buffers_blend;
+begin
+  glBlendEquationiARB := dglGetProcAddress('glBlendEquationiARB');
+  glBlendEquationSeparateiARB := dglGetProcAddress('glBlendEquationSeparateiARB');
+  glBlendFunciARB := dglGetProcAddress('glBlendFunciARB');
+  glBlendFuncSeparateiARB := dglGetProcAddress('glBlendFuncSeparateiARB');
+end;
+
+procedure Read_GL_ARB_sample_shading;
+begin
+  glMinSampleShadingARB := dglGetProcAddress('glMinSampleShadingARB');
+end;
+
+procedure Read_GL_ARB_shading_language_include;
+begin
+  glNamedStringARB := dglGetProcAddress('glNamedStringARB');
+  glDeleteNamedStringARB := dglGetProcAddress('glDeleteNamedStringARB');
+  glCompileShaderIncludeARB := dglGetProcAddress('glCompileShaderIncludeARB');
+  glIsNamedStringARB := dglGetProcAddress('glIsNamedStringARB');
+  glGetNamedStringARB := dglGetProcAddress('glGetNamedStringARB');
+  glGetNamedStringivARB := dglGetProcAddress('glGetNamedStringivARB');
+end;
+
+procedure Read_GL_ARB_blend_func_extended;
+begin
+  glBindFragDataLocationIndexed := dglGetProcAddress('glBindFragDataLocationIndexed');
+  glGetFragDataIndex := dglGetProcAddress('glGetFragDataIndex');
+end;
+
+procedure Read_GL_ARB_sampler_objects;
+begin
+  glGenSamplers := dglGetProcAddress('glGenSamplers');
+  glDeleteSamplers := dglGetProcAddress('glDeleteSamplers');
+  glIsSampler := dglGetProcAddress('glIsSampler');
+  glBindSampler := dglGetProcAddress('glBindSampler');
+  glSamplerParameteri := dglGetProcAddress('glSamplerParameteri');
+  glSamplerParameteriv := dglGetProcAddress('glSamplerParameteriv');
+  glSamplerParameterf := dglGetProcAddress('glSamplerParameterf');
+  glSamplerParameterfv := dglGetProcAddress('glSamplerParameterfv');
+  glSamplerParameterIiv := dglGetProcAddress('glSamplerParameterIiv');
+  glSamplerParameterIuiv := dglGetProcAddress('glSamplerParameterIuiv');
+  glGetSamplerParameteriv := dglGetProcAddress('glGetSamplerParameteriv');
+  glGetSamplerParameterIiv := dglGetProcAddress('glGetSamplerParameterIiv');
+  glGetSamplerParameterfv := dglGetProcAddress('glGetSamplerParameterfv');
+  glGetSamplerParameterIuiv := dglGetProcAddress('glGetSamplerParameterIuiv');
+end;
+
+procedure Read_GL_ARB_timer_query;
+begin
+  glQueryCounter := dglGetProcAddress('glQueryCounter');
+  glGetQueryObjecti64v := dglGetProcAddress('glGetQueryObjecti64v');
+  glGetQueryObjectui64v := dglGetProcAddress('glGetQueryObjectui64v');
+end;
+
+procedure Read_GL_ARB_vertex_type_2_10_10_10_rev;
+begin
+  glVertexP2ui := dglGetProcAddress('glVertexP2ui');
+  glVertexP2uiv := dglGetProcAddress('glVertexP2uiv');
+  glVertexP3ui := dglGetProcAddress('glVertexP3ui');
+  glVertexP3uiv := dglGetProcAddress('glVertexP3uiv');
+  glVertexP4ui := dglGetProcAddress('glVertexP4ui');
+  glVertexP4uiv := dglGetProcAddress('glVertexP4uiv');
+  glTexCoordP1ui := dglGetProcAddress('glTexCoordP1ui');
+  glTexCoordP1uiv := dglGetProcAddress('glTexCoordP1uiv');
+  glTexCoordP2ui := dglGetProcAddress('glTexCoordP2ui');
+  glTexCoordP2uiv := dglGetProcAddress('glTexCoordP2uiv');
+  glTexCoordP3ui := dglGetProcAddress('glTexCoordP3ui');
+  glTexCoordP3uiv := dglGetProcAddress('glTexCoordP3uiv');
+  glTexCoordP4ui := dglGetProcAddress('glTexCoordP4ui');
+  glTexCoordP4uiv := dglGetProcAddress('glTexCoordP4uiv');
+  glMultiTexCoordP1ui := dglGetProcAddress('glMultiTexCoordP1ui');
+  glMultiTexCoordP1uiv := dglGetProcAddress('glMultiTexCoordP1uiv');
+  glMultiTexCoordP2ui := dglGetProcAddress('glMultiTexCoordP2ui');
+  glMultiTexCoordP2uiv := dglGetProcAddress('glMultiTexCoordP2uiv');
+  glMultiTexCoordP3ui := dglGetProcAddress('glMultiTexCoordP3ui');
+  glMultiTexCoordP3uiv := dglGetProcAddress('glMultiTexCoordP3uiv');
+  glMultiTexCoordP4ui := dglGetProcAddress('glMultiTexCoordP4ui');
+  glMultiTexCoordP4uiv := dglGetProcAddress('glMultiTexCoordP4uiv');
+  glNormalP3ui := dglGetProcAddress('glNormalP3ui');
+  glNormalP3uiv := dglGetProcAddress('glNormalP3uiv');
+  glColorP3ui := dglGetProcAddress('glColorP3ui');
+  glColorP3uiv := dglGetProcAddress('glColorP3uiv');
+  glColorP4ui := dglGetProcAddress('glColorP4ui');
+  glColorP4uiv := dglGetProcAddress('glColorP4uiv');
+  glSecondaryColorP3ui := dglGetProcAddress('glSecondaryColorP3ui');
+  glSecondaryColorP3uiv := dglGetProcAddress('glSecondaryColorP3uiv');
+  glVertexAttribP1ui := dglGetProcAddress('glVertexAttribP1ui');
+  glVertexAttribP1uiv := dglGetProcAddress('glVertexAttribP1uiv');
+  glVertexAttribP2ui := dglGetProcAddress('glVertexAttribP2ui');
+  glVertexAttribP2uiv := dglGetProcAddress('glVertexAttribP2uiv');
+  glVertexAttribP3ui := dglGetProcAddress('glVertexAttribP3ui');
+  glVertexAttribP3uiv := dglGetProcAddress('glVertexAttribP3uiv');
+  glVertexAttribP4ui := dglGetProcAddress('glVertexAttribP4ui');
+  glVertexAttribP4uiv := dglGetProcAddress('glVertexAttribP4uiv');
+end;
+
+procedure Read_GL_ARB_draw_indirect;
+begin
+  glDrawArraysIndirect := dglGetProcAddress('glDrawArraysIndirect');
+  glDrawElementsIndirect := dglGetProcAddress('glDrawElementsIndirect');
+end;
+
+procedure Read_GL_ARB_gpu_shader_fp64;
+begin
+  glUniform1d := dglGetProcAddress('glUniform1d');
+  glUniform2d := dglGetProcAddress('glUniform2d');
+  glUniform3d := dglGetProcAddress('glUniform3d');
+  glUniform4d := dglGetProcAddress('glUniform4d');
+  glUniform1dv := dglGetProcAddress('glUniform1dv');
+  glUniform2dv := dglGetProcAddress('glUniform2dv');
+  glUniform3dv := dglGetProcAddress('glUniform3dv');
+  glUniform4dv := dglGetProcAddress('glUniform4dv');
+  glUniformMatrix2dv := dglGetProcAddress('glUniformMatrix2dv');
+  glUniformMatrix3dv := dglGetProcAddress('glUniformMatrix3dv');
+  glUniformMatrix4dv := dglGetProcAddress('glUniformMatrix4dv');
+  glUniformMatrix2x3dv := dglGetProcAddress('glUniformMatrix2x3dv');
+  glUniformMatrix2x4dv := dglGetProcAddress('glUniformMatrix2x4dv');
+  glUniformMatrix3x2dv := dglGetProcAddress('glUniformMatrix3x2dv');
+  glUniformMatrix3x4dv := dglGetProcAddress('glUniformMatrix3x4dv');
+  glUniformMatrix4x2dv := dglGetProcAddress('glUniformMatrix4x2dv');
+  glUniformMatrix4x3dv := dglGetProcAddress('glUniformMatrix4x3dv');
+  glGetUniformdv := dglGetProcAddress('glGetUniformdv');
+end;
+
+procedure Read_GL_ARB_shader_subroutine;
+begin
+  glGetSubroutineUniformLocation := dglGetProcAddress('glGetSubroutineUniformLocation');
+  glGetSubroutineIndex := dglGetProcAddress('glGetSubroutineIndex');
+  glGetActiveSubroutineUniformiv := dglGetProcAddress('glGetActiveSubroutineUniformiv');
+  glGetActiveSubroutineUniformName := dglGetProcAddress('glGetActiveSubroutineUniformName');
+  glGetActiveSubroutineName := dglGetProcAddress('glGetActiveSubroutineName');
+  glUniformSubroutinesuiv := dglGetProcAddress('glUniformSubroutinesuiv');
+  glGetUniformSubroutineuiv := dglGetProcAddress('glGetUniformSubroutineuiv');
+  glGetProgramStageiv := dglGetProcAddress('glGetProgramStageiv');
+end;
+
+procedure Read_GL_ARB_tessellation_shader;
+begin
+  glPatchParameteri := dglGetProcAddress('glPatchParameteri');
+  glPatchParameterfv := dglGetProcAddress('glPatchParameterfv');
+end;
+
+procedure Read_GL_ARB_transform_feedback2;
+begin
+  glBindTransformFeedback := dglGetProcAddress('glBindTransformFeedback');
+  glDeleteTransformFeedbacks := dglGetProcAddress('glDeleteTransformFeedbacks');
+  glGenTransformFeedbacks := dglGetProcAddress('glGenTransformFeedbacks');
+  glIsTransformFeedback := dglGetProcAddress('glIsTransformFeedback');
+  glPauseTransformFeedback := dglGetProcAddress('glPauseTransformFeedback');
+  glResumeTransformFeedback := dglGetProcAddress('glResumeTransformFeedback');
+  glDrawTransformFeedback := dglGetProcAddress('glDrawTransformFeedback');
+end;
+
+procedure Read_GL_ARB_transform_feedback3;
+begin
+  glDrawTransformFeedbackStream := dglGetProcAddress('glDrawTransformFeedbackStream');
+  glBeginQueryIndexed := dglGetProcAddress('glBeginQueryIndexed');
+  glEndQueryIndexed := dglGetProcAddress('glEndQueryIndexed');
+  glGetQueryIndexediv := dglGetProcAddress('glGetQueryIndexediv');
+end;
+
+procedure Read_GL_ARB_ES2_compatibility;
+begin
+  glReleaseShaderCompiler := dglGetProcAddress('glReleaseShaderCompiler');
+  glShaderBinary := dglGetProcAddress('glShaderBinary');
+  glGetShaderPrecisionFormat := dglGetProcAddress('glGetShaderPrecisionFormat');
+  glDepthRangef := dglGetProcAddress('glDepthRangef');
+  glClearDepthf := dglGetProcAddress('glClearDepthf');
+end;
+
+procedure Read_GL_ARB_get_program_binary;
+begin
+  glGetProgramBinary := dglGetProcAddress('glGetProgramBinary');
+  glProgramBinary := dglGetProcAddress('glProgramBinary');
+  glProgramParameteri := dglGetProcAddress('glProgramParameteri');
+end;
+
+procedure Read_GL_ARB_separate_shader_objects;
+begin
+  glUseProgramStages := dglGetProcAddress('glUseProgramStages');
+  glActiveShaderProgram := dglGetProcAddress('glActiveShaderProgram');
+  glCreateShaderProgramv := dglGetProcAddress('glCreateShaderProgramv');
+  glBindProgramPipeline := dglGetProcAddress('glBindProgramPipeline');
+  glDeleteProgramPipelines := dglGetProcAddress('glDeleteProgramPipelines');
+  glGenProgramPipelines := dglGetProcAddress('glGenProgramPipelines');
+  glIsProgramPipeline := dglGetProcAddress('glIsProgramPipeline');
+  glGetProgramPipelineiv := dglGetProcAddress('glGetProgramPipelineiv');
+  glProgramUniform1i := dglGetProcAddress('glProgramUniform1i');
+  glProgramUniform1iv := dglGetProcAddress('glProgramUniform1iv');
+  glProgramUniform1f := dglGetProcAddress('glProgramUniform1f');
+  glProgramUniform1fv := dglGetProcAddress('glProgramUniform1fv');
+  glProgramUniform1d := dglGetProcAddress('glProgramUniform1d');
+  glProgramUniform1dv := dglGetProcAddress('glProgramUniform1dv');
+  glProgramUniform1ui := dglGetProcAddress('glProgramUniform1ui');
+  glProgramUniform1uiv := dglGetProcAddress('glProgramUniform1uiv');
+  glProgramUniform2i := dglGetProcAddress('glProgramUniform2i');
+  glProgramUniform2iv := dglGetProcAddress('glProgramUniform2iv');
+  glProgramUniform2f := dglGetProcAddress('glProgramUniform2f');
+  glProgramUniform2fv := dglGetProcAddress('glProgramUniform2fv');
+  glProgramUniform2d := dglGetProcAddress('glProgramUniform2d');
+  glProgramUniform2dv := dglGetProcAddress('glProgramUniform2dv');
+  glProgramUniform2ui := dglGetProcAddress('glProgramUniform2ui');
+  glProgramUniform2uiv := dglGetProcAddress('glProgramUniform2uiv');
+  glProgramUniform3i := dglGetProcAddress('glProgramUniform3i');
+  glProgramUniform3iv := dglGetProcAddress('glProgramUniform3iv');
+  glProgramUniform3f := dglGetProcAddress('glProgramUniform3f');
+  glProgramUniform3fv := dglGetProcAddress('glProgramUniform3fv');
+  glProgramUniform3d := dglGetProcAddress('glProgramUniform3d');
+  glProgramUniform3dv := dglGetProcAddress('glProgramUniform3dv');
+  glProgramUniform3ui := dglGetProcAddress('glProgramUniform3ui');
+  glProgramUniform3uiv := dglGetProcAddress('glProgramUniform3uiv');
+  glProgramUniform4i := dglGetProcAddress('glProgramUniform4i');
+  glProgramUniform4iv := dglGetProcAddress('glProgramUniform4iv');
+  glProgramUniform4f := dglGetProcAddress('glProgramUniform4f');
+  glProgramUniform4fv := dglGetProcAddress('glProgramUniform4fv');
+  glProgramUniform4d := dglGetProcAddress('glProgramUniform4d');
+  glProgramUniform4dv := dglGetProcAddress('glProgramUniform4dv');
+  glProgramUniform4ui := dglGetProcAddress('glProgramUniform4ui');
+  glProgramUniform4uiv := dglGetProcAddress('glProgramUniform4uiv');
+  glProgramUniformMatrix2fv := dglGetProcAddress('glProgramUniformMatrix2fv');
+  glProgramUniformMatrix3fv := dglGetProcAddress('glProgramUniformMatrix3fv');
+  glProgramUniformMatrix4fv := dglGetProcAddress('glProgramUniformMatrix4fv');
+  glProgramUniformMatrix2dv := dglGetProcAddress('glProgramUniformMatrix2dv');
+  glProgramUniformMatrix3dv := dglGetProcAddress('glProgramUniformMatrix3dv');
+  glProgramUniformMatrix4dv := dglGetProcAddress('glProgramUniformMatrix4dv');
+  glProgramUniformMatrix2x3fv := dglGetProcAddress('glProgramUniformMatrix2x3fv');
+  glProgramUniformMatrix3x2fv := dglGetProcAddress('glProgramUniformMatrix3x2fv');
+  glProgramUniformMatrix2x4fv := dglGetProcAddress('glProgramUniformMatrix2x4fv');
+  glProgramUniformMatrix4x2fv := dglGetProcAddress('glProgramUniformMatrix4x2fv');
+  glProgramUniformMatrix3x4fv := dglGetProcAddress('glProgramUniformMatrix3x4fv');
+  glProgramUniformMatrix4x3fv := dglGetProcAddress('glProgramUniformMatrix4x3fv');
+  glProgramUniformMatrix2x3dv := dglGetProcAddress('glProgramUniformMatrix2x3dv');
+  glProgramUniformMatrix3x2dv := dglGetProcAddress('glProgramUniformMatrix3x2dv');
+  glProgramUniformMatrix2x4dv := dglGetProcAddress('glProgramUniformMatrix2x4dv');
+  glProgramUniformMatrix4x2dv := dglGetProcAddress('glProgramUniformMatrix4x2dv');
+  glProgramUniformMatrix3x4dv := dglGetProcAddress('glProgramUniformMatrix3x4dv');
+  glProgramUniformMatrix4x3dv := dglGetProcAddress('glProgramUniformMatrix4x3dv');
+  glValidateProgramPipeline := dglGetProcAddress('glValidateProgramPipeline');
+  glGetProgramPipelineInfoLog := dglGetProcAddress('glGetProgramPipelineInfoLog');
+end;
+
+procedure Read_GL_ARB_vertex_attrib_64bit;
+begin
+  glVertexAttribL1d := dglGetProcAddress('glVertexAttribL1d');
+  glVertexAttribL2d := dglGetProcAddress('glVertexAttribL2d');
+  glVertexAttribL3d := dglGetProcAddress('glVertexAttribL3d');
+  glVertexAttribL4d := dglGetProcAddress('glVertexAttribL4d');
+  glVertexAttribL1dv := dglGetProcAddress('glVertexAttribL1dv');
+  glVertexAttribL2dv := dglGetProcAddress('glVertexAttribL2dv');
+  glVertexAttribL3dv := dglGetProcAddress('glVertexAttribL3dv');
+  glVertexAttribL4dv := dglGetProcAddress('glVertexAttribL4dv');
+  glVertexAttribLPointer := dglGetProcAddress('glVertexAttribLPointer');
+  glGetVertexAttribLdv := dglGetProcAddress('glGetVertexAttribLdv');
+end;
+
+procedure Read_GL_ARB_viewport_array;
+begin
+  glViewportArrayv := dglGetProcAddress('glViewportArrayv');
+  glViewportIndexedf := dglGetProcAddress('glViewportIndexedf');
+  glViewportIndexedfv := dglGetProcAddress('glViewportIndexedfv');
+  glScissorArrayv := dglGetProcAddress('glScissorArrayv');
+  glScissorIndexed := dglGetProcAddress('glScissorIndexed');
+  glScissorIndexedv := dglGetProcAddress('glScissorIndexedv');
+  glDepthRangeArrayv := dglGetProcAddress('glDepthRangeArrayv');
+  glDepthRangeIndexed := dglGetProcAddress('glDepthRangeIndexed');
+  glGetFloati_v := dglGetProcAddress('glGetFloati_v');
+  glGetDoublei_v := dglGetProcAddress('glGetDoublei_v');
+end;
+
+// GL 4.2
+
+procedure Read_GL_ARB_base_instance;
+begin
+glDrawArraysInstancedBaseInstance := dglGetProcAddress('glDrawArraysInstancedBaseInstance');
+glDrawElementsInstancedBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseInstance');
+glDrawElementsInstancedBaseVertexBaseInstance := dglGetProcAddress('glDrawElementsInstancedBaseVertexBaseInstance');
+end;
+
+procedure Read_GL_ARB_transform_feedback_instanced;
+begin
+glDrawTransformFeedbackInstanced := dglGetProcAddress('glDrawTransformFeedbackInstanced');
+glDrawTransformFeedbackStreamInstanced := dglGetProcAddress('glDrawTransformFeedbackStreamInstanced');
+end;
+
+procedure Read_GL_ARB_internalformat_query;
+begin
+glGetInternalformativ := dglGetProcAddress('glGetInternalformativ');
+end;
+
+procedure Read_GL_ARB_shader_atomic_counters;
+begin
+glGetActiveAtomicCounterBufferiv := dglGetProcAddress('glGetActiveAtomicCounterBufferiv');
+end;
+
+procedure Read_GL_ARB_shader_image_load_store;
+begin
+glBindImageTexture := dglGetProcAddress('glBindImageTexture');
+glMemoryBarrier := dglGetProcAddress('glMemoryBarrier');
+end;
+
+procedure Read_GL_ARB_texture_storage;
+begin
+glTexStorage1D := dglGetProcAddress('glTexStorage1D');
+glTexStorage2D := dglGetProcAddress('glTexStorage2D');
+glTexStorage3D := dglGetProcAddress('glTexStorage3D');
+glTextureStorage1DEXT := dglGetProcAddress('glTextureStorage1DEXT');
+glTextureStorage2DEXT := dglGetProcAddress('glTextureStorage2DEXT');
+glTextureStorage3DEXT := dglGetProcAddress('glTextureStorage3DEXT');
+end;
+
+
+// GL 4.3
+procedure Read_GL_KHR_debug;
+begin
+  glDebugMessageControl := dglGetProcAddress('glDebugMessageControl');
+  glDebugMessageInsert := dglGetProcAddress('glDebugMessageInsert');
+  glDebugMessageCallback := dglGetProcAddress('glDebugMessageCallback');
+  glGetDebugMessageLog := dglGetProcAddress('glGetDebugMessageLog');
+  glPushDebugGroup := dglGetProcAddress('glPushDebugGroup');
+  glPopDebugGroup := dglGetProcAddress('glPopDebugGroup');
+  glObjectLabel := dglGetProcAddress('glObjectLabel');
+  glGetObjectLabel := dglGetProcAddress('glGetObjectLabel');
+  glObjectPtrLabel := dglGetProcAddress('glObjectPtrLabel');
+  glGetObjectPtrLabel := dglGetProcAddress('glGetObjectPtrLabel');
+end;
+
+procedure Read_GL_ARB_clear_buffer_object;
+begin
+  glClearBufferData := dglGetProcAddress('glClearBufferData');
+  glClearBufferSubData := dglGetProcAddress('glClearBufferSubData');
+  glClearNamedBufferDataEXT := dglGetProcAddress('glClearNamedBufferDataEXT');
+  glClearNamedBufferSubDataEXT := dglGetProcAddress('glClearNamedBufferSubDataEXT');
+end;
+
+procedure Read_GL_ARB_compute_shader;
+begin
+  glDispatchCompute := dglGetProcAddress('glDispatchCompute');
+  glDispatchComputeIndirect := dglGetProcAddress('glDispatchComputeIndirect');
+end;
+
+procedure Read_GL_ARB_copy_image;
+begin
+  glCopyImageSubData := dglGetProcAddress('glCopyImageSubData');
+end;
+
+procedure Read_GL_ARB_framebuffer_no_attachments;
+begin
+  glFramebufferParameteri := dglGetProcAddress('glFramebufferParameteri');
+  glGetFramebufferParameteriv := dglGetProcAddress('glGetFramebufferParameteriv');
+  glNamedFramebufferParameteriEXT := dglGetProcAddress('glNamedFramebufferParameteriEXT');
+  glGetNamedFramebufferParameterivEXT := dglGetProcAddress('glGetNamedFramebufferParameterivEXT');
+end;
+
+procedure Read_GL_ARB_internalformat_query2;
+begin
+  glGetInternalformati64v := dglGetProcAddress('glGetInternalformati64v');;
+end;
+
+procedure Read_GL_ARB_invalidate_subdata;
+begin
+  glInvalidateTexSubImage := dglGetProcAddress('glInvalidateTexSubImage');
+  glInvalidateTexImage := dglGetProcAddress('glInvalidateTexImage');
+  glInvalidateBufferSubData := dglGetProcAddress('glInvalidateBufferSubData');
+  glInvalidateBufferData := dglGetProcAddress('glInvalidateBufferData');
+  glInvalidateFramebuffer := dglGetProcAddress('glInvalidateFramebuffer');
+  glInvalidateSubFramebuffer := dglGetProcAddress('glInvalidateSubFramebuffer');
+end;
+
+procedure Read_GL_ARB_multi_draw_indirect;
+begin
+  glMultiDrawArraysIndirect := dglGetProcAddress('glMultiDrawArraysIndirect');
+  glMultiDrawElementsIndirect := dglGetProcAddress('glMultiDrawElementsIndirect');
+end;
+
+procedure Read_GL_ARB_program_interface_query;
+begin
+  glGetProgramInterfaceiv := dglGetProcAddress('glGetProgramInterfaceiv');
+  glGetProgramResourceIndex := dglGetProcAddress('glGetProgramResourceIndex');
+  glGetProgramResourceName := dglGetProcAddress('glGetProgramResourceName');
+  glGetProgramResourceiv := dglGetProcAddress('glGetProgramResourceiv');
+  glGetProgramResourceLocation := dglGetProcAddress('glGetProgramResourceLocation');
+  glGetProgramResourceLocationIndex := dglGetProcAddress('glGetProgramResourceLocationIndex');
+end;
+
+procedure Read_GL_ARB_shader_storage_buffer_object;
+begin
+  glShaderStorageBlockBinding := dglGetProcAddress('glShaderStorageBlockBinding');
+end;
+
+procedure Read_GL_ARB_texture_buffer_range;
+begin
+  glTexBufferRange := dglGetProcAddress('glTexBufferRange');
+  glTextureBufferRangeEXT := dglGetProcAddress('glTextureBufferRangeEXT');
+end;
+
+procedure Read_GL_ARB_texture_storage_multisample;
+begin
+  glTexStorage2DMultisample := dglGetProcAddress('glTexStorage2DMultisample');
+  glTexStorage3DMultisample := dglGetProcAddress('glTexStorage3DMultisample');
+  glTextureStorage2DMultisampleEXT := dglGetProcAddress('glTextureStorage2DMultisampleEXT');
+  glTextureStorage3DMultisampleEXT := dglGetProcAddress('glTextureStorage3DMultisampleEXT');
+end;
+
+procedure Read_GL_ARB_texture_view;
+begin
+  glTextureView := dglGetProcAddress('glTextureView');
+end;
+
+procedure Read_GL_ARB_vertex_attrib_binding;
+begin
+  glBindVertexBuffer := dglGetProcAddress('glBindVertexBuffer');
+  glVertexAttribFormat := dglGetProcAddress('glVertexAttribFormat');
+  glVertexAttribIFormat := dglGetProcAddress('glVertexAttribIFormat');
+  glVertexAttribLFormat := dglGetProcAddress('glVertexAttribLFormat');
+  glVertexAttribBinding := dglGetProcAddress('glVertexAttribBinding');
+  glVertexBindingDivisor := dglGetProcAddress('glVertexBindingDivisor');
+  glVertexArrayBindVertexBufferEXT := dglGetProcAddress('glVertexArrayBindVertexBufferEXT');
+  glVertexArrayVertexAttribFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribFormatEXT');
+  glVertexArrayVertexAttribIFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribIFormatEXT');
+  glVertexArrayVertexAttribLFormatEXT := dglGetProcAddress('glVertexArrayVertexAttribLFormatEXT');
+  glVertexArrayVertexAttribBindingEXT := dglGetProcAddress('glVertexArrayVertexAttribBindingEXT');
+  glVertexArrayVertexBindingDivisorEXT := dglGetProcAddress('glVertexArrayVertexBindingDivisorEXT');
+end;
+
+procedure Read_GL_4_4;
+begin
+  glBufferStorage     := dglGetProcAddress('glBufferStorage');
+  glClearTexImage     := dglGetProcAddress('glClearTexImage');
+  glClearTexSubImage  := dglGetProcAddress('glClearTexSubImage');
+  glBindBuffersBase   := dglGetProcAddress('glBindBuffersBase');
+  glBindBuffersRange  := dglGetProcAddress('glBindBuffersRange');
+  glBindTextures      := dglGetProcAddress('glBindTextures');
+  glBindSamplers      := dglGetProcAddress('glBindSamplers');
+  glBindImageTextures := dglGetProcAddress('glBindImageTextures');
+  glBindVertexBuffers := dglGetProcAddress('glBindVertexBuffers');
+end;
+
+
+procedure Read_GL_NV_path_rendering;
+begin
+  glGenPathsNV := dglGetProcAddress('glGenPathsNV');
+  glDeletePathsNV := dglGetProcAddress('glDeletePathsNV');
+  glIsPathNV := dglGetProcAddress('glIsPathNV');
+  glPathCommandsNV := dglGetProcAddress('glPathCommandsNV');
+  glPathCoordsNV := dglGetProcAddress('glPathCoordsNV');
+  glPathSubCommandsNV := dglGetProcAddress('glPathSubCommandsNV');
+  glPathSubCoordsNV := dglGetProcAddress('glPathSubCoordsNV');
+  glPathStringNV := dglGetProcAddress('glPathStringNV');
+  glPathGlyphsNV := dglGetProcAddress('glPathGlyphsNV');
+  glPathGlyphRangeNV := dglGetProcAddress('glPathGlyphRangeNV');
+  glWeightPathsNV := dglGetProcAddress('glWeightPathsNV');
+  glCopyPathNV := dglGetProcAddress('glCopyPathNV');
+  glInterpolatePathsNV := dglGetProcAddress('glInterpolatePathsNV');
+  glTransformPathNV := dglGetProcAddress('glTransformPathNV');
+  glPathParameterivNV := dglGetProcAddress('glPathParameterivNV');
+  glPathParameteriNV := dglGetProcAddress('glPathParameteriNV');
+  glPathParameterfvNV := dglGetProcAddress('glPathParameterfvNV');
+  glPathParameterfNV := dglGetProcAddress('glPathParameterfNV');
+  glPathDashArrayNV := dglGetProcAddress('glPathDashArrayNV');
+  glPathStencilFuncNV := dglGetProcAddress('glPathStencilFuncNV');
+  glPathStencilDepthOffsetNV := dglGetProcAddress('glPathStencilDepthOffsetNV');
+  glStencilFillPathNV := dglGetProcAddress('glStencilFillPathNV');
+  glStencilStrokePathNV := dglGetProcAddress('glStencilStrokePathNV');
+  glStencilFillPathInstancedNV := dglGetProcAddress('glStencilFillPathInstancedNV');
+  glStencilStrokePathInstancedNV := dglGetProcAddress('glStencilStrokePathInstancedNV');
+  glPathCoverDepthFuncNV := dglGetProcAddress('glPathCoverDepthFuncNV');
+  glPathColorGenNV := dglGetProcAddress('glPathColorGenNV');
+  glPathTexGenNV := dglGetProcAddress('glPathTexGenNV');
+  glPathFogGenNV := dglGetProcAddress('glPathFogGenNV');
+  glCoverFillPathNV := dglGetProcAddress('glCoverFillPathNV');
+  glCoverStrokePathNV := dglGetProcAddress('glCoverStrokePathNV');
+  glCoverFillPathInstancedNV := dglGetProcAddress('glCoverFillPathInstancedNV');
+  glCoverStrokePathInstancedNV := dglGetProcAddress('glCoverStrokePathInstancedNV');
+  glGetPathParameterivNV := dglGetProcAddress('glGetPathParameterivNV');
+  glGetPathParameterfvNV := dglGetProcAddress('glGetPathParameterfvNV');
+  glGetPathCommandsNV := dglGetProcAddress('glGetPathCommandsNV');
+  glGetPathCoordsNV := dglGetProcAddress('glGetPathCoordsNV');
+  glGetPathDashArrayNV := dglGetProcAddress('glGetPathDashArrayNV');
+  glGetPathMetricsNV := dglGetProcAddress('glGetPathMetricsNV');
+  glGetPathMetricRangeNV := dglGetProcAddress('glGetPathMetricRangeNV');
+  glGetPathSpacingNV := dglGetProcAddress('glGetPathSpacingNV');
+  glGetPathColorGenivNV := dglGetProcAddress('glGetPathColorGenivNV');
+  glGetPathColorGenfvNV := dglGetProcAddress('glGetPathColorGenfvNV');
+  glGetPathTexGenivNV := dglGetProcAddress('glGetPathTexGenivNV');
+  glGetPathTexGenfvNV := dglGetProcAddress('glGetPathTexGenfvNV');
+  glIsPointInFillPathNV := dglGetProcAddress('glIsPointInFillPathNV');
+  glIsPointInStrokePathNV := dglGetProcAddress('glIsPointInStrokePathNV');
+  glGetPathLengthNV := dglGetProcAddress('glGetPathLengthNV');
+  glPointAlongPathNV := dglGetProcAddress('glPointAlongPathNV');
+end;
+
+procedure Read_GL_AMD_stencil_operation_extended;
+begin
+       glStencilOpValueAMD := dglGetProcAddress('glStencilOpValueAMD');
+end;
+
+procedure Read_GL_NV_bindless_texture;
+begin
+  glGetTextureHandleNV := dglGetProcAddress('glGetTextureHandleNV');
+  glGetTextureSamplerHandleNV := dglGetProcAddress('glGetTextureSamplerHandleNV');
+  glMakeTextureHandleResidentNV := dglGetProcAddress('glMakeTextureHandleResidentNV');
+  glMakeTextureHandleNonResidentNV := dglGetProcAddress('glMakeTextureHandleNonResidentNV');
+  glGetImageHandleNV := dglGetProcAddress('glGetImageHandleNV');
+  glMakeImageHandleResidentNV := dglGetProcAddress('glMakeImageHandleResidentNV');
+  glMakeImageHandleNonResidentNV := dglGetProcAddress('glMakeImageHandleNonResidentNV');
+  glUniformHandleui64NV := dglGetProcAddress('glUniformHandleui64NV');
+  glUniformHandleui64vNV := dglGetProcAddress('glUniformHandleui64vNV');
+  glProgramUniformHandleui64NV := dglGetProcAddress('glProgramUniformHandleui64NV');
+  glProgramUniformHandleui64vNV := dglGetProcAddress('glProgramUniformHandleui64vNV');
+  glIsTextureHandleResidentNV := dglGetProcAddress('glIsTextureHandleResidentNV');
+  glIsImageHandleResidentNV := dglGetProcAddress('glIsImageHandleResidentNV');
+end;
+
+procedure Read_GL_ARB_cl_event;
+begin
+  glCreateSyncFromCLeventARB := dglGetProcAddress('glCreateSyncFromCLeventARB');
+end;
+
+procedure Read_GL_ARB_debug_output;
+begin
+  glDebugMessageControlARB := dglGetProcAddress('glDebugMessageControlARB');
+  glDebugMessageInsertARB := dglGetProcAddress('glDebugMessageInsertARB');
+  glDebugMessageCallbackARB := dglGetProcAddress('glDebugMessageCallbackARB');
+  glGetDebugMessageLogARB := dglGetProcAddress('glGetDebugMessageLogARB');
+end;
+
+procedure Read_GL_ARB_robustness;
+begin
+  glGetGraphicsResetStatusARB := dglGetProcAddress('glGetGraphicsResetStatusARB');
+  glGetnMapdvARB := dglGetProcAddress('glGetnMapdvARB');
+  glGetnMapfvARB := dglGetProcAddress('glGetnMapfvARB');
+  glGetnMapivARB := dglGetProcAddress('glGetnMapivARB');
+  glGetnPixelMapfvARB := dglGetProcAddress('glGetnPixelMapfvARB');
+  glGetnPixelMapuivARB := dglGetProcAddress('glGetnPixelMapuivARB');
+  glGetnPixelMapusvARB := dglGetProcAddress('glGetnPixelMapusvARB');
+  glGetnPolygonStippleARB := dglGetProcAddress('glGetnPolygonStippleARB');
+  glGetnColorTableARB := dglGetProcAddress('glGetnColorTableARB');
+  glGetnConvolutionFilterARB := dglGetProcAddress('glGetnConvolutionFilterARB');
+  glGetnSeparableFilterARB := dglGetProcAddress('glGetnSeparableFilterARB');
+  glGetnHistogramARB := dglGetProcAddress('glGetnHistogramARB');
+  glGetnMinmaxARB := dglGetProcAddress('glGetnMinmaxARB');
+  glGetnTexImageARB := dglGetProcAddress('glGetnTexImageARB');
+  glReadnPixelsARB := dglGetProcAddress('glReadnPixelsARB');
+  glGetnCompressedTexImageARB := dglGetProcAddress('glGetnCompressedTexImageARB');
+  glGetnUniformfvARB := dglGetProcAddress('glGetnUniformfvARB');
+  glGetnUniformivARB := dglGetProcAddress('glGetnUniformivARB');
+  glGetnUniformuivARB := dglGetProcAddress('glGetnUniformuivARB');
+  glGetnUniformdvARB := dglGetProcAddress('glGetnUniformdvARB');
+end;
+  
+procedure Read_GL_ATI_draw_buffers;
+begin
+  glDrawBuffersATI := dglGetProcAddress('glDrawBuffersATI');
+end;
+
+procedure Read_GL_ATI_element_array;
+begin
+  glElementPointerATI := dglGetProcAddress('glElementPointerATI');
+  glDrawElementArrayATI := dglGetProcAddress('glDrawElementArrayATI');
+  glDrawRangeElementArrayATI := dglGetProcAddress('glDrawRangeElementArrayATI');
+end;
+
+procedure Read_GL_ATI_envmap_bumpmap;
+begin
+  glTexBumpParameterivATI := dglGetProcAddress('glTexBumpParameterivATI');
+  glTexBumpParameterfvATI := dglGetProcAddress('glTexBumpParameterfvATI');
+  glGetTexBumpParameterivATI := dglGetProcAddress('glGetTexBumpParameterivATI');
+  glGetTexBumpParameterfvATI := dglGetProcAddress('glGetTexBumpParameterfvATI');
+end;
+
+procedure Read_GL_ATI_fragment_shader;
+begin
+  glGenFragmentShadersATI := dglGetProcAddress('glGenFragmentShadersATI');
+  glBindFragmentShaderATI := dglGetProcAddress('glBindFragmentShaderATI');
+  glDeleteFragmentShaderATI := dglGetProcAddress('glDeleteFragmentShaderATI');
+  glBeginFragmentShaderATI := dglGetProcAddress('glBeginFragmentShaderATI');
+  glEndFragmentShaderATI := dglGetProcAddress('glEndFragmentShaderATI');
+  glPassTexCoordATI := dglGetProcAddress('glPassTexCoordATI');
+  glSampleMapATI := dglGetProcAddress('glSampleMapATI');
+  glColorFragmentOp1ATI := dglGetProcAddress('glColorFragmentOp1ATI');
+  glColorFragmentOp2ATI := dglGetProcAddress('glColorFragmentOp2ATI');
+  glColorFragmentOp3ATI := dglGetProcAddress('glColorFragmentOp3ATI');
+  glAlphaFragmentOp1ATI := dglGetProcAddress('glAlphaFragmentOp1ATI');
+  glAlphaFragmentOp2ATI := dglGetProcAddress('glAlphaFragmentOp2ATI');
+  glAlphaFragmentOp3ATI := dglGetProcAddress('glAlphaFragmentOp3ATI');
+  glSetFragmentShaderConstantATI := dglGetProcAddress('glSetFragmentShaderConstantATI');
+end;
+
+procedure Read_GL_ATI_map_object_buffer;
+begin
+  glMapObjectBufferATI := dglGetProcAddress('glMapObjectBufferATI');
+  glUnmapObjectBufferATI := dglGetProcAddress('glUnmapObjectBufferATI');
+end;
+
+procedure Read_GL_ATI_pn_triangles;
+begin
+  glPNTrianglesiATI := dglGetProcAddress('glPNTrianglesiATI');
+  glPNTrianglesfATI := dglGetProcAddress('glPNTrianglesfATI');
+end;
+
+procedure Read_GL_ATI_separate_stencil;
+begin
+  glStencilOpSeparateATI := dglGetProcAddress('glStencilOpSeparateATI');
+  glStencilFuncSeparateATI := dglGetProcAddress('glStencilFuncSeparateATI');
+end;
+
+procedure Read_GL_ATI_vertex_array_object;
+begin
+  glNewObjectBufferATI := dglGetProcAddress('glNewObjectBufferATI');
+  glIsObjectBufferATI := dglGetProcAddress('glIsObjectBufferATI');
+  glUpdateObjectBufferATI := dglGetProcAddress('glUpdateObjectBufferATI');
+  glGetObjectBufferfvATI := dglGetProcAddress('glGetObjectBufferfvATI');
+  glGetObjectBufferivATI := dglGetProcAddress('glGetObjectBufferivATI');
+  glFreeObjectBufferATI := dglGetProcAddress('glFreeObjectBufferATI');
+  glArrayObjectATI := dglGetProcAddress('glArrayObjectATI');
+  glGetArrayObjectfvATI := dglGetProcAddress('glGetArrayObjectfvATI');
+  glGetArrayObjectivATI := dglGetProcAddress('glGetArrayObjectivATI');
+  glVariantArrayObjectATI := dglGetProcAddress('glVariantArrayObjectATI');
+  glGetVariantArrayObjectfvATI := dglGetProcAddress('glGetVariantArrayObjectfvATI');
+  glGetVariantArrayObjectivATI := dglGetProcAddress('glGetVariantArrayObjectivATI');
+
+end;
+
+procedure Read_GL_ATI_vertex_attrib_array_object;
+begin
+  glVertexAttribArrayObjectATI := dglGetProcAddress('glVertexAttribArrayObjectATI');
+  glGetVertexAttribArrayObjectfvATI := dglGetProcAddress('glGetVertexAttribArrayObjectfvATI');
+  glGetVertexAttribArrayObjectivATI := dglGetProcAddress('glGetVertexAttribArrayObjectivATI');
+end;
+
+procedure Read_GL_ATI_vertex_streams;
+begin
+  glVertexStream1sATI := dglGetProcAddress('glVertexStream1sATI');
+  glVertexStream1svATI := dglGetProcAddress('glVertexStream1svATI');
+  glVertexStream1iATI := dglGetProcAddress('glVertexStream1iATI');
+  glVertexStream1ivATI := dglGetProcAddress('glVertexStream1ivATI');
+  glVertexStream1fATI := dglGetProcAddress('glVertexStream1fATI');
+  glVertexStream1fvATI := dglGetProcAddress('glVertexStream1fvATI');
+  glVertexStream1dATI := dglGetProcAddress('glVertexStream1dATI');
+  glVertexStream1dvATI := dglGetProcAddress('glVertexStream1dvATI');
+  glVertexStream2sATI := dglGetProcAddress('glVertexStream2sATI');
+  glVertexStream2svATI := dglGetProcAddress('glVertexStream2svATI');
+  glVertexStream2iATI := dglGetProcAddress('glVertexStream2iATI');
+  glVertexStream2ivATI := dglGetProcAddress('glVertexStream2ivATI');
+  glVertexStream2fATI := dglGetProcAddress('glVertexStream2fATI');
+  glVertexStream2fvATI := dglGetProcAddress('glVertexStream2fvATI');
+  glVertexStream2dATI := dglGetProcAddress('glVertexStream2dATI');
+  glVertexStream2dvATI := dglGetProcAddress('glVertexStream2dvATI');
+  glVertexStream3sATI := dglGetProcAddress('glVertexStream3sATI');
+  glVertexStream3svATI := dglGetProcAddress('glVertexStream3svATI');
+  glVertexStream3iATI := dglGetProcAddress('glVertexStream3iATI');
+  glVertexStream3ivATI := dglGetProcAddress('glVertexStream3ivATI');
+  glVertexStream3fATI := dglGetProcAddress('glVertexStream3fATI');
+  glVertexStream3fvATI := dglGetProcAddress('glVertexStream3fvATI');
+  glVertexStream3dATI := dglGetProcAddress('glVertexStream3dATI');
+  glVertexStream3dvATI := dglGetProcAddress('glVertexStream3dvATI');
+  glVertexStream4sATI := dglGetProcAddress('glVertexStream4sATI');
+  glVertexStream4svATI := dglGetProcAddress('glVertexStream4svATI');
+  glVertexStream4iATI := dglGetProcAddress('glVertexStream4iATI');
+  glVertexStream4ivATI := dglGetProcAddress('glVertexStream4ivATI');
+  glVertexStream4fATI := dglGetProcAddress('glVertexStream4fATI');
+  glVertexStream4fvATI := dglGetProcAddress('glVertexStream4fvATI');
+  glVertexStream4dATI := dglGetProcAddress('glVertexStream4dATI');
+  glVertexStream4dvATI := dglGetProcAddress('glVertexStream4dvATI');
+  glNormalStream3bATI := dglGetProcAddress('glNormalStream3bATI');
+  glNormalStream3bvATI := dglGetProcAddress('glNormalStream3bvATI');
+  glNormalStream3sATI := dglGetProcAddress('glNormalStream3sATI');
+  glNormalStream3svATI := dglGetProcAddress('glNormalStream3svATI');
+  glNormalStream3iATI := dglGetProcAddress('glNormalStream3iATI');
+  glNormalStream3ivATI := dglGetProcAddress('glNormalStream3ivATI');
+  glNormalStream3fATI := dglGetProcAddress('glNormalStream3fATI');
+  glNormalStream3fvATI := dglGetProcAddress('glNormalStream3fvATI');
+  glNormalStream3dATI := dglGetProcAddress('glNormalStream3dATI');
+  glNormalStream3dvATI := dglGetProcAddress('glNormalStream3dvATI');
+  glClientActiveVertexStreamATI := dglGetProcAddress('glClientActiveVertexStreamATI');
+  glVertexBlendEnviATI := dglGetProcAddress('glVertexBlendEnviATI');
+  glVertexBlendEnvfATI := dglGetProcAddress('glVertexBlendEnvfATI');
+end;
+
+procedure Read_GL_AMD_performance_monitor;
+begin
+  glGetPerfMonitorGroupsAMD := dglGetProcAddress('glGetPerfMonitorGroupsAMD');
+  glGetPerfMonitorCountersAMD := dglGetProcAddress('glGetPerfMonitorCountersAMD');
+  glGetPerfMonitorGroupStringAMD := dglGetProcAddress('glGetPerfMonitorGroupStringAMD');
+  glGetPerfMonitorCounterStringAMD := dglGetProcAddress('glGetPerfMonitorCounterStringAMD');
+  glGetPerfMonitorCounterInfoAMD := dglGetProcAddress('glGetPerfMonitorCounterInfoAMD');
+  glGenPerfMonitorsAMD := dglGetProcAddress('glGenPerfMonitorsAMD');
+  glDeletePerfMonitorsAMD := dglGetProcAddress('glDeletePerfMonitorsAMD');
+  glSelectPerfMonitorCountersAMD := dglGetProcAddress('glSelectPerfMonitorCountersAMD');
+  glBeginPerfMonitorAMD := dglGetProcAddress('glBeginPerfMonitorAMD');
+  glEndPerfMonitorAMD := dglGetProcAddress('glEndPerfMonitorAMD');
+  glGetPerfMonitorCounterDataAMD := dglGetProcAddress('glGetPerfMonitorCounterDataAMD');
+end;
+
+procedure Read_GL_AMD_vertex_shader_tesselator;
+begin
+  glTessellationFactorAMD := dglGetProcAddress('glTessellationFactorAMD');
+  glTessellationModeAMD := dglGetProcAddress('glTessellationModeAMD');
+end;
+
+procedure Read_GL_AMD_draw_buffers_blend;
+begin
+  glBlendFuncIndexedAMD := dglGetProcAddress('glBlendFuncIndexedAMD');
+  glBlendFuncSeparateIndexedAMD := dglGetProcAddress('glBlendFuncSeparateIndexedAMD');
+  glBlendEquationIndexedAMD := dglGetProcAddress('glBlendEquationIndexedAMD');
+  glBlendEquationSeparateIndexedAMD := dglGetProcAddress('glBlendEquationSeparateIndexedAMD');
+end;
+
+procedure Read_GL_AMD_name_gen_delete;
+begin
+  glGenNamesAMD := dglGetProcAddress('glGenNamesAMD');
+  glDeleteNamesAMD := dglGetProcAddress('glDeleteNamesAMD');
+  glIsNameAMD := dglGetProcAddress('glIsNameAMD');
+end;
+
+procedure Read_GL_AMD_debug_output;
+begin
+  glDebugMessageEnableAMD := dglGetProcAddress('glDebugMessageEnableAMD');
+  glDebugMessageInsertAMD := dglGetProcAddress('glDebugMessageInsertAMD');
+  glDebugMessageCallbackAMD := dglGetProcAddress('glDebugMessageCallbackAMD');
+  glGetDebugMessageLogAMD := dglGetProcAddress('glGetDebugMessageLogAMD');
+end;
+procedure Read_GL_EXT_blend_color;
+begin
+  glBlendColorEXT := dglGetProcAddress('glBlendColorEXT');
+end;
+
+procedure Read_GL_EXT_blend_func_separate;
+begin
+  glBlendFuncSeparateEXT := dglGetProcAddress('glBlendFuncSeparateEXT');
+end;
+
+procedure Read_GL_EXT_blend_minmax;
+begin
+  glBlendEquationEXT := dglGetProcAddress('glBlendEquationEXT');
+end;
+
+procedure Read_GL_EXT_color_subtable;
+begin
+  glColorSubTableEXT := dglGetProcAddress('glColorSubTableEXT');
+  glCopyColorSubTableEXT := dglGetProcAddress('glCopyColorSubTableEXT');
+end;
+
+procedure Read_GL_EXT_compiled_vertex_array;
+begin
+  glLockArraysEXT := dglGetProcAddress('glLockArraysEXT');
+  glUnlockArraysEXT := dglGetProcAddress('glUnlockArraysEXT');
+end;
+
+procedure Read_GL_EXT_convolution;
+begin
+  glConvolutionFilter1DEXT := dglGetProcAddress('glConvolutionFilter1DEXT');
+  glConvolutionFilter2DEXT := dglGetProcAddress('glConvolutionFilter2DEXT');
+  glConvolutionParameterfEXT := dglGetProcAddress('glConvolutionParameterfEXT');
+  glConvolutionParameterfvEXT := dglGetProcAddress('glConvolutionParameterfvEXT');
+  glConvolutionParameteriEXT := dglGetProcAddress('glConvolutionParameteriEXT');
+  glConvolutionParameterivEXT := dglGetProcAddress('glConvolutionParameterivEXT');
+  glCopyConvolutionFilter1DEXT := dglGetProcAddress('glCopyConvolutionFilter1DEXT');
+  glCopyConvolutionFilter2DEXT := dglGetProcAddress('glCopyConvolutionFilter2DEXT');
+  glGetConvolutionFilterEXT := dglGetProcAddress('glGetConvolutionFilterEXT');
+  glGetConvolutionParameterfvEXT := dglGetProcAddress('glGetConvolutionParameterfvEXT');
+  glGetConvolutionParameterivEXT := dglGetProcAddress('glGetConvolutionParameterivEXT');
+  glGetSeparableFilterEXT := dglGetProcAddress('glGetSeparableFilterEXT');
+  glSeparableFilter2DEXT := dglGetProcAddress('glSeparableFilter2DEXT');
+end;
+
+procedure Read_GL_EXT_coordinate_frame;
+begin
+  glTangent3bEXT := dglGetProcAddress('glTangent3bEXT');
+  glTangent3bvEXT := dglGetProcAddress('glTangent3bvEXT');
+  glTangent3dEXT := dglGetProcAddress('glTangent3dEXT');
+  glTangent3dvEXT := dglGetProcAddress('glTangent3dvEXT');
+  glTangent3fEXT := dglGetProcAddress('glTangent3fEXT');
+  glTangent3fvEXT := dglGetProcAddress('glTangent3fvEXT');
+  glTangent3iEXT := dglGetProcAddress('glTangent3iEXT');
+  glTangent3ivEXT := dglGetProcAddress('glTangent3ivEXT');
+  glTangent3sEXT := dglGetProcAddress('glTangent3sEXT');
+  glTangent3svEXT := dglGetProcAddress('glTangent3svEXT');
+  glBinormal3bEXT := dglGetProcAddress('glBinormal3bEXT');
+  glBinormal3bvEXT := dglGetProcAddress('glBinormal3bvEXT');
+  glBinormal3dEXT := dglGetProcAddress('glBinormal3dEXT');
+  glBinormal3dvEXT := dglGetProcAddress('glBinormal3dvEXT');
+  glBinormal3fEXT := dglGetProcAddress('glBinormal3fEXT');
+  glBinormal3fvEXT := dglGetProcAddress('glBinormal3fvEXT');
+  glBinormal3iEXT := dglGetProcAddress('glBinormal3iEXT');
+  glBinormal3ivEXT := dglGetProcAddress('glBinormal3ivEXT');
+  glBinormal3sEXT := dglGetProcAddress('glBinormal3sEXT');
+  glBinormal3svEXT := dglGetProcAddress('glBinormal3svEXT');
+  glTangentPointerEXT := dglGetProcAddress('glTangentPointerEXT');
+  glBinormalPointerEXT := dglGetProcAddress('glBinormalPointerEXT');
+end;
+
+procedure Read_GL_EXT_copy_texture;
+begin
+  glCopyTexImage1DEXT := dglGetProcAddress('glCopyTexImage1DEXT');
+  glCopyTexImage2DEXT := dglGetProcAddress('glCopyTexImage2DEXT');
+  glCopyTexSubImage1DEXT := dglGetProcAddress('glCopyTexSubImage1DEXT');
+  glCopyTexSubImage2DEXT := dglGetProcAddress('glCopyTexSubImage2DEXT');
+  glCopyTexSubImage3DEXT := dglGetProcAddress('glCopyTexSubImage3DEXT');
+end;
+
+procedure Read_GL_EXT_cull_vertex;
+begin
+  glCullParameterdvEXT := dglGetProcAddress('glCullParameterdvEXT');
+  glCullParameterfvEXT := dglGetProcAddress('glCullParameterfvEXT');
+end;
+
+procedure Read_GL_EXT_draw_range_elements;
+begin
+  glDrawRangeElementsEXT := dglGetProcAddress('glDrawRangeElementsEXT');
+end;
+
+procedure Read_GL_EXT_fog_coord;
+begin
+  glFogCoordfEXT := dglGetProcAddress('glFogCoordfEXT');
+  glFogCoordfvEXT := dglGetProcAddress('glFogCoordfvEXT');
+  glFogCoorddEXT := dglGetProcAddress('glFogCoorddEXT');
+  glFogCoorddvEXT := dglGetProcAddress('glFogCoorddvEXT');
+  glFogCoordPointerEXT := dglGetProcAddress('glFogCoordPointerEXT');
+end;
+
+procedure Read_GL_EXT_framebuffer_object;
+begin
+  glIsRenderbufferEXT := dglGetProcAddress('glIsRenderbufferEXT');
+  glBindRenderbufferEXT := dglGetProcAddress('glBindRenderbufferEXT');
+  glDeleteRenderbuffersEXT := dglGetProcAddress('glDeleteRenderbuffersEXT');
+  glGenRenderbuffersEXT := dglGetProcAddress('glGenRenderbuffersEXT');
+  glRenderbufferStorageEXT := dglGetProcAddress('glRenderbufferStorageEXT');
+  glGetRenderbufferParameterivEXT := dglGetProcAddress('glGetRenderbufferParameterivEXT');
+  glIsFramebufferEXT := dglGetProcAddress('glIsFramebufferEXT');
+  glBindFramebufferEXT := dglGetProcAddress('glBindFramebufferEXT');
+  glDeleteFramebuffersEXT := dglGetProcAddress('glDeleteFramebuffersEXT');
+  glGenFramebuffersEXT := dglGetProcAddress('glGenFramebuffersEXT');
+  glCheckFramebufferStatusEXT := dglGetProcAddress('glCheckFramebufferStatusEXT');
+  glFramebufferTexture1DEXT := dglGetProcAddress('glFramebufferTexture1DEXT');
+  glFramebufferTexture2DEXT := dglGetProcAddress('glFramebufferTexture2DEXT');
+  glFramebufferTexture3DEXT := dglGetProcAddress('glFramebufferTexture3DEXT');
+  glFramebufferRenderbufferEXT := dglGetProcAddress('glFramebufferRenderbufferEXT');
+  glGetFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetFramebufferAttachmentParameterivEXT');
+  glGenerateMipmapEXT := dglGetProcAddress('glGenerateMipmapEXT');
+end;
+
+procedure Read_GL_EXT_histogram;
+begin
+  glGetHistogramEXT := dglGetProcAddress('glGetHistogramEXT');
+  glGetHistogramParameterfvEXT := dglGetProcAddress('glGetHistogramParameterfvEXT');
+  glGetHistogramParameterivEXT := dglGetProcAddress('glGetHistogramParameterivEXT');
+  glGetMinmaxEXT := dglGetProcAddress('glGetMinmaxEXT');
+  glGetMinmaxParameterfvEXT := dglGetProcAddress('glGetMinmaxParameterfvEXT');
+  glGetMinmaxParameterivEXT := dglGetProcAddress('glGetMinmaxParameterivEXT');
+  glHistogramEXT := dglGetProcAddress('glHistogramEXT');
+  glMinmaxEXT := dglGetProcAddress('glMinmaxEXT');
+  glResetHistogramEXT := dglGetProcAddress('glResetHistogramEXT');
+  glResetMinmaxEXT := dglGetProcAddress('glResetMinmaxEXT');
+end;
+
+procedure Read_GL_EXT_index_func;
+begin
+  glIndexFuncEXT := dglGetProcAddress('glIndexFuncEXT');
+end;
+
+procedure Read_GL_EXT_index_material;
+begin
+  glIndexMaterialEXT := dglGetProcAddress('glIndexMaterialEXT');
+end;
+
+procedure Read_GL_EXT_light_texture;
+begin
+  glApplyTextureEXT := dglGetProcAddress('glApplyTextureEXT');
+  glTextureLightEXT := dglGetProcAddress('glTextureLightEXT');
+  glTextureMaterialEXT := dglGetProcAddress('glTextureMaterialEXT');
+end;
+
+procedure Read_GL_EXT_multi_draw_arrays;
+begin
+  glMultiDrawArraysEXT := dglGetProcAddress('glMultiDrawArraysEXT');
+  glMultiDrawElementsEXT := dglGetProcAddress('glMultiDrawElementsEXT');
+end;
+
+procedure Read_GL_EXT_multisample;
+begin
+  glSampleMaskEXT := dglGetProcAddress('glSampleMaskEXT');
+  glSamplePatternEXT := dglGetProcAddress('glSamplePatternEXT');
+end;
+
+procedure Read_GL_EXT_paletted_texture;
+begin
+  glColorTableEXT := dglGetProcAddress('glColorTableEXT');
+  glGetColorTableEXT := dglGetProcAddress('glGetColorTableEXT');
+  glGetColorTableParameterivEXT := dglGetProcAddress('glGetColorTableParameterivEXT');
+  glGetColorTableParameterfvEXT := dglGetProcAddress('glGetColorTableParameterfvEXT');
+end;
+
+procedure Read_GL_EXT_pixel_transform;
+begin
+  glPixelTransformParameteriEXT := dglGetProcAddress('glPixelTransformParameteriEXT');
+  glPixelTransformParameterfEXT := dglGetProcAddress('glPixelTransformParameterfEXT');
+  glPixelTransformParameterivEXT := dglGetProcAddress('glPixelTransformParameterivEXT');
+  glPixelTransformParameterfvEXT := dglGetProcAddress('glPixelTransformParameterfvEXT');
+end;
+
+procedure Read_GL_EXT_point_parameters;
+begin
+  glPointParameterfEXT := dglGetProcAddress('glPointParameterfEXT');
+  glPointParameterfvEXT := dglGetProcAddress('glPointParameterfvEXT');
+end;
+
+procedure Read_GL_EXT_polygon_offset;
+begin
+  glPolygonOffsetEXT := dglGetProcAddress('glPolygonOffsetEXT');
+end;
+
+procedure Read_GL_EXT_secondary_color;
+begin
+  glSecondaryColor3bEXT := dglGetProcAddress('glSecondaryColor3bEXT');
+  glSecondaryColor3bvEXT := dglGetProcAddress('glSecondaryColor3bvEXT');
+  glSecondaryColor3dEXT := dglGetProcAddress('glSecondaryColor3dEXT');
+  glSecondaryColor3dvEXT := dglGetProcAddress('glSecondaryColor3dvEXT');
+  glSecondaryColor3fEXT := dglGetProcAddress('glSecondaryColor3fEXT');
+  glSecondaryColor3fvEXT := dglGetProcAddress('glSecondaryColor3fvEXT');
+  glSecondaryColor3iEXT := dglGetProcAddress('glSecondaryColor3iEXT');
+  glSecondaryColor3ivEXT := dglGetProcAddress('glSecondaryColor3ivEXT');
+  glSecondaryColor3sEXT := dglGetProcAddress('glSecondaryColor3sEXT');
+  glSecondaryColor3svEXT := dglGetProcAddress('glSecondaryColor3svEXT');
+  glSecondaryColor3ubEXT := dglGetProcAddress('glSecondaryColor3ubEXT');
+  glSecondaryColor3ubvEXT := dglGetProcAddress('glSecondaryColor3ubvEXT');
+  glSecondaryColor3uiEXT := dglGetProcAddress('glSecondaryColor3uiEXT');
+  glSecondaryColor3uivEXT := dglGetProcAddress('glSecondaryColor3uivEXT');
+  glSecondaryColor3usEXT := dglGetProcAddress('glSecondaryColor3usEXT');
+  glSecondaryColor3usvEXT := dglGetProcAddress('glSecondaryColor3usvEXT');
+  glSecondaryColorPointerEXT := dglGetProcAddress('glSecondaryColorPointerEXT');
+end;
+
+procedure Read_GL_EXT_stencil_two_side;
+begin
+  glActiveStencilFaceEXT := dglGetProcAddress('glActiveStencilFaceEXT');
+end;
+
+procedure Read_GL_EXT_subtexture;
+begin
+  glTexSubImage1DEXT := dglGetProcAddress('glTexSubImage1DEXT');
+  glTexSubImage2DEXT := dglGetProcAddress('glTexSubImage2DEXT');
+end;
+
+procedure Read_GL_EXT_texture3D;
+begin
+  glTexImage3DEXT := dglGetProcAddress('glTexImage3DEXT');
+  glTexSubImage3DEXT := dglGetProcAddress('glTexSubImage3DEXT');
+end;
+
+procedure Read_GL_EXT_texture_object;
+begin
+  glAreTexturesResidentEXT := dglGetProcAddress('glAreTexturesResidentEXT');
+  glBindTextureEXT := dglGetProcAddress('glBindTextureEXT');
+  glDeleteTexturesEXT := dglGetProcAddress('glDeleteTexturesEXT');
+  glGenTexturesEXT := dglGetProcAddress('glGenTexturesEXT');
+  glIsTextureEXT := dglGetProcAddress('glIsTextureEXT');
+  glPrioritizeTexturesEXT := dglGetProcAddress('glPrioritizeTexturesEXT');
+end;
+
+procedure Read_GL_EXT_texture_perturb_normal;
+begin
+  glTextureNormalEXT := dglGetProcAddress('glTextureNormalEXT');
+end;
+
+procedure Read_GL_EXT_vertex_array;
+begin
+  glArrayElementEXT := dglGetProcAddress('glArrayElementEXT');
+  glColorPointerEXT := dglGetProcAddress('glColorPointerEXT');
+  glDrawArraysEXT := dglGetProcAddress('glDrawArraysEXT');
+  glEdgeFlagPointerEXT := dglGetProcAddress('glEdgeFlagPointerEXT');
+  glGetPointervEXT := dglGetProcAddress('glGetPointervEXT');
+  glIndexPointerEXT := dglGetProcAddress('glIndexPointerEXT');
+  glNormalPointerEXT := dglGetProcAddress('glNormalPointerEXT');
+  glTexCoordPointerEXT := dglGetProcAddress('glTexCoordPointerEXT');
+  glVertexPointerEXT := dglGetProcAddress('glVertexPointerEXT');
+end;
+
+procedure Read_GL_EXT_vertex_shader;
+begin
+  glBeginVertexShaderEXT := dglGetProcAddress('glBeginVertexShaderEXT');
+  glEndVertexShaderEXT := dglGetProcAddress('glEndVertexShaderEXT');
+  glBindVertexShaderEXT := dglGetProcAddress('glBindVertexShaderEXT');
+  glGenVertexShadersEXT := dglGetProcAddress('glGenVertexShadersEXT');
+  glDeleteVertexShaderEXT := dglGetProcAddress('glDeleteVertexShaderEXT');
+  glShaderOp1EXT := dglGetProcAddress('glShaderOp1EXT');
+  glShaderOp2EXT := dglGetProcAddress('glShaderOp2EXT');
+  glShaderOp3EXT := dglGetProcAddress('glShaderOp3EXT');
+  glSwizzleEXT := dglGetProcAddress('glSwizzleEXT');
+  glWriteMaskEXT := dglGetProcAddress('glWriteMaskEXT');
+  glInsertComponentEXT := dglGetProcAddress('glInsertComponentEXT');
+  glExtractComponentEXT := dglGetProcAddress('glExtractComponentEXT');
+  glGenSymbolsEXT := dglGetProcAddress('glGenSymbolsEXT');
+  glSetInvariantEXT := dglGetProcAddress('glSetInvariantEXT');
+  glSetLocalConstantEXT := dglGetProcAddress('glSetLocalConstantEXT');
+  glVariantbvEXT := dglGetProcAddress('glVariantbvEXT');
+  glVariantsvEXT := dglGetProcAddress('glVariantsvEXT');
+  glVariantivEXT := dglGetProcAddress('glVariantivEXT');
+  glVariantfvEXT := dglGetProcAddress('glVariantfvEXT');
+  glVariantdvEXT := dglGetProcAddress('glVariantdvEXT');
+  glVariantubvEXT := dglGetProcAddress('glVariantubvEXT');
+  glVariantusvEXT := dglGetProcAddress('glVariantusvEXT');
+  glVariantuivEXT := dglGetProcAddress('glVariantuivEXT');
+  glVariantPointerEXT := dglGetProcAddress('glVariantPointerEXT');
+  glEnableVariantClientStateEXT := dglGetProcAddress('glEnableVariantClientStateEXT');
+  glDisableVariantClientStateEXT := dglGetProcAddress('glDisableVariantClientStateEXT');
+  glBindLightParameterEXT := dglGetProcAddress('glBindLightParameterEXT');
+  glBindMaterialParameterEXT := dglGetProcAddress('glBindMaterialParameterEXT');
+  glBindTexGenParameterEXT := dglGetProcAddress('glBindTexGenParameterEXT');
+  glBindTextureUnitParameterEXT := dglGetProcAddress('glBindTextureUnitParameterEXT');
+  glBindParameterEXT := dglGetProcAddress('glBindParameterEXT');
+  glIsVariantEnabledEXT := dglGetProcAddress('glIsVariantEnabledEXT');
+  glGetVariantBooleanvEXT := dglGetProcAddress('glGetVariantBooleanvEXT');
+  glGetVariantIntegervEXT := dglGetProcAddress('glGetVariantIntegervEXT');
+  glGetVariantFloatvEXT := dglGetProcAddress('glGetVariantFloatvEXT');
+  glGetVariantPointervEXT := dglGetProcAddress('glGetVariantPointervEXT');
+  glGetInvariantBooleanvEXT := dglGetProcAddress('glGetInvariantBooleanvEXT');
+  glGetInvariantIntegervEXT := dglGetProcAddress('glGetInvariantIntegervEXT');
+  glGetInvariantFloatvEXT := dglGetProcAddress('glGetInvariantFloatvEXT');
+  glGetLocalConstantBooleanvEXT := dglGetProcAddress('glGetLocalConstantBooleanvEXT');
+  glGetLocalConstantIntegervEXT := dglGetProcAddress('glGetLocalConstantIntegervEXT');
+  glGetLocalConstantFloatvEXT := dglGetProcAddress('glGetLocalConstantFloatvEXT');
+end;
+
+procedure Read_GL_EXT_vertex_weighting;
+begin
+  glVertexWeightfEXT := dglGetProcAddress('glVertexWeightfEXT');
+  glVertexWeightfvEXT := dglGetProcAddress('glVertexWeightfvEXT');
+  glVertexWeightPointerEXT := dglGetProcAddress('glVertexWeightPointerEXT');
+end;
+
+procedure Read_GL_EXT_depth_bounds_test;
+begin
+  glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP');
+  glDepthBoundsEXT := dglGetProcAddress('glDepthBoundsEXT');
+end;
+
+procedure Read_GL_EXT_blend_equation_separate;
+begin
+  glBlendEquationSeparateEXT := dglGetProcAddress('glBlendEquationSeparateEXT');
+end;
+
+procedure Read_GL_EXT_stencil_clear_tag;
+begin
+  glStencilClearTagEXT := dglGetProcAddress('glStencilClearTagEXT');
+end;
+
+procedure Read_GL_EXT_framebuffer_blit;
+begin
+  glBlitFramebufferEXT := dglGetProcAddress('glBlitFramebufferEXT');
+end;
+
+procedure Read_GL_EXT_framebuffer_multisample;
+begin
+  glRenderbufferStorageMultisampleEXT := dglGetProcAddress('glRenderbufferStorageMultisampleEXT');
+end;
+
+procedure Read_GL_EXT_timer_query;
+begin
+  glGetQueryObjecti64vEXT := dglGetProcAddress('glGetQueryObjecti64vEXT');
+  glGetQueryObjectui64vEXT := dglGetProcAddress('glGetQueryObjectui64vEXT');
+end;
+
+procedure Read_GL_EXT_gpu_program_parameters;
+begin
+  glProgramEnvParameters4fvEXT := dglGetProcAddress('glProgramEnvParameters4fvEXT');
+  glProgramLocalParameters4fvEXT := dglGetProcAddress('glProgramLocalParameters4fvEXT');
+end;
+
+procedure Read_GL_EXT_bindable_uniform;
+begin
+  glUniformBufferEXT := dglGetProcAddress('glUniformBufferEXT');
+  glGetUniformBufferSizeEXT := dglGetProcAddress('glGetUniformBufferSizeEXT');
+  glGetUniformOffsetEXT := dglGetProcAddress('glGetUniformOffsetEXT');
+end;
+
+procedure Read_GL_EXT_draw_buffers2;
+begin
+  glColorMaskIndexedEXT := dglGetProcAddress('glColorMaskIndexedEXT');
+  glGetBooleanIndexedvEXT := dglGetProcAddress('glGetBooleanIndexedvEXT');
+  glGetIntegerIndexedvEXT := dglGetProcAddress('glGetIntegerIndexedvEXT');
+  glEnableIndexedEXT := dglGetProcAddress('glEnableIndexedEXT');
+  glDisableIndexedEXT := dglGetProcAddress('glDisableIndexedEXT');
+  glIsEnabledIndexedEXT := dglGetProcAddress('glIsEnabledIndexedEXT');
+end;
+
+procedure Read_GL_EXT_draw_instanced;
+begin
+  glDrawArraysInstancedEXT := dglGetProcAddress('glDrawArraysInstancedEXT');
+  glDrawElementsInstancedEXT := dglGetProcAddress('glDrawElementsInstancedEXT');
+end;
+
+procedure Read_GL_EXT_geometry_shader4;
+begin
+  glProgramParameteriEXT := dglGetProcAddress('glProgramParameteriEXT');
+  glFramebufferTextureEXT := dglGetProcAddress('glFramebufferTextureEXT');
+//  glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT');
+  glFramebufferTextureFaceEXT := dglGetProcAddress('glFramebufferTextureFaceEXT');
+end;
+
+procedure Read_GL_EXT_gpu_shader4;
+begin
+  glVertexAttribI1iEXT := dglGetProcAddress('glVertexAttribI1iEXT');
+  glVertexAttribI2iEXT := dglGetProcAddress('glVertexAttribI2iEXT');
+  glVertexAttribI3iEXT := dglGetProcAddress('glVertexAttribI3iEXT');
+  glVertexAttribI4iEXT := dglGetProcAddress('glVertexAttribI4iEXT');
+  glVertexAttribI1uiEXT := dglGetProcAddress('glVertexAttribI1uiEXT');
+  glVertexAttribI2uiEXT := dglGetProcAddress('glVertexAttribI2uiEXT');
+  glVertexAttribI3uiEXT := dglGetProcAddress('glVertexAttribI3uiEXT');
+  glVertexAttribI4uiEXT := dglGetProcAddress('glVertexAttribI4uiEXT');
+  glVertexAttribI1ivEXT := dglGetProcAddress('glVertexAttribI1ivEXT');
+  glVertexAttribI2ivEXT := dglGetProcAddress('glVertexAttribI2ivEXT');
+  glVertexAttribI3ivEXT := dglGetProcAddress('glVertexAttribI3ivEXT');
+  glVertexAttribI4ivEXT := dglGetProcAddress('glVertexAttribI4ivEXT');
+  glVertexAttribI1uivEXT := dglGetProcAddress('glVertexAttribI1uivEXT');
+  glVertexAttribI2uivEXT := dglGetProcAddress('glVertexAttribI2uivEXT');
+  glVertexAttribI3uivEXT := dglGetProcAddress('glVertexAttribI3uivEXT');
+  glVertexAttribI4uivEXT := dglGetProcAddress('glVertexAttribI4uivEXT');
+  glVertexAttribI4bvEXT := dglGetProcAddress('glVertexAttribI4bvEXT');
+  glVertexAttribI4svEXT := dglGetProcAddress('glVertexAttribI4svEXT');
+  glVertexAttribI4ubvEXT := dglGetProcAddress('glVertexAttribI4ubvEXT');
+  glVertexAttribI4usvEXT := dglGetProcAddress('glVertexAttribI4usvEXT');
+  glVertexAttribIPointerEXT := dglGetProcAddress('glVertexAttribIPointerEXT');
+  glGetVertexAttribIivEXT := dglGetProcAddress('glGetVertexAttribIivEXT');
+  glGetVertexAttribIuivEXT := dglGetProcAddress('glGetVertexAttribIuivEXT');
+  glUniform1uiEXT := dglGetProcAddress('glUniform1uiEXT');
+  glUniform2uiEXT := dglGetProcAddress('glUniform2uiEXT');
+  glUniform3uiEXT := dglGetProcAddress('glUniform3uiEXT');
+  glUniform4uiEXT := dglGetProcAddress('glUniform4uiEXT');
+  glUniform1uivEXT := dglGetProcAddress('glUniform1uivEXT');
+  glUniform2uivEXT := dglGetProcAddress('glUniform2uivEXT');
+  glUniform3uivEXT := dglGetProcAddress('glUniform3uivEXT');
+  glUniform4uivEXT := dglGetProcAddress('glUniform4uivEXT');
+  glGetUniformuivEXT := dglGetProcAddress('glGetUniformuivEXT');
+  glBindFragDataLocationEXT := dglGetProcAddress('glBindFragDataLocationEXT');
+  glGetFragDataLocationEXT := dglGetProcAddress('glGetFragDataLocationEXT');
+end;
+
+procedure Read_GL_EXT_texture_array;
+begin
+  glFramebufferTextureLayerEXT := dglGetProcAddress('glFramebufferTextureLayerEXT');
+end;
+
+procedure Read_GL_EXT_texture_buffer_object;
+begin
+  glTexBufferEXT := dglGetProcAddress('glTexBufferEXT');
+end;
+
+procedure Read_GL_EXT_texture_integer;
+begin
+  glClearColorIiEXT := dglGetProcAddress('glClearColorIiEXT');
+  glClearColorIuiEXT := dglGetProcAddress('glClearColorIuiEXT');
+  glTexParameterIivEXT := dglGetProcAddress('glTexParameterIivEXT');
+  glTexParameterIuivEXT := dglGetProcAddress('glTexParameterIuivEXT');
+  glGetTexParameterIivEXT := dglGetProcAddress('glGetTexParameterIivEXT');
+  glGetTexParameterIiuvEXT := dglGetProcAddress('glGetTexParameterIiuvEXT');
+end;
+
+procedure Read_GL_EXT_transform_feedback;
+begin
+  glBeginTransformFeedbackEXT := dglGetProcAddress('lBeginTransformFeedbackEXT');
+  glEndTransformFeedbackEXT := dglGetProcAddress('glEndTransformFeedbackEXT');
+  glBindBufferRangeEXT := dglGetProcAddress('glBindBufferRangeEXT');
+  glBindBufferOffsetEXT := dglGetProcAddress('glBindBufferOffsetEXT');
+  glBindBufferBaseEXT := dglGetProcAddress('glBindBufferBaseEXT');
+  glTransformFeedbackVaryingsEXT := dglGetProcAddress('glTransformFeedbackVaryingsEXT');
+  glGetTransformFeedbackVaryingEXT := dglGetProcAddress('glGetTransformFeedbackVaryingEXT');
+end;
+
+procedure Read_GL_EXT_direct_state_access;
+begin
+  glClientAttribDefaultEXT := dglGetProcAddress('glClientAttribDefaultEXT');
+  glPushClientAttribDefaultEXT := dglGetProcAddress('glPushClientAttribDefaultEXT');
+  glMatrixLoadfEXT := dglGetProcAddress('glMatrixLoadfEXT');
+  glMatrixLoaddEXT := dglGetProcAddress('glMatrixLoaddEXT');
+  glMatrixMultfEXT := dglGetProcAddress('glMatrixMultfEXT');
+  glMatrixMultdEXT := dglGetProcAddress('glMatrixMultdEXT');
+  glMatrixLoadIdentityEXT := dglGetProcAddress('glMatrixLoadIdentityEXT');
+  glMatrixRotatefEXT := dglGetProcAddress('glMatrixRotatefEXT');
+  glMatrixRotatedEXT := dglGetProcAddress('glMatrixRotatedEXT');
+  glMatrixScalefEXT := dglGetProcAddress('glMatrixScalefEXT');
+  glMatrixScaledEXT := dglGetProcAddress('glMatrixScaledEXT');
+  glMatrixTranslatefEXT := dglGetProcAddress('glMatrixTranslatefEXT');
+  glMatrixTranslatedEXT := dglGetProcAddress('glMatrixTranslatedEXT');
+  glMatrixFrustumEXT := dglGetProcAddress('glMatrixFrustumEXT');
+  glMatrixOrthoEXT := dglGetProcAddress('glMatrixOrthoEXT');
+  glMatrixPopEXT := dglGetProcAddress('glMatrixPopEXT');
+  glMatrixPushEXT := dglGetProcAddress('glMatrixPushEXT');
+  glMatrixLoadTransposefEXT := dglGetProcAddress('glMatrixLoadTransposefEXT');
+  glMatrixLoadTransposedEXT := dglGetProcAddress('glMatrixLoadTransposedEXT');
+  glMatrixMultTransposefEXT := dglGetProcAddress('glMatrixMultTransposefEXT');
+  glMatrixMultTransposedEXT := dglGetProcAddress('glMatrixMultTransposedEXT');
+  glTextureParameterfEXT := dglGetProcAddress('glTextureParameterfEXT');
+  glTextureParameterfvEXT := dglGetProcAddress('glTextureParameterfvEXT');
+  glTextureParameteriEXT := dglGetProcAddress('glTextureParameteriEXT');
+  glTextureParameterivEXT := dglGetProcAddress('glTextureParameterivEXT');
+  glTextureImage1DEXT := dglGetProcAddress('glTextureImage1DEXT');
+  glTextureImage2DEXT := dglGetProcAddress('glTextureImage2DEXT');
+  glTextureSubImage1DEXT := dglGetProcAddress('glTextureSubImage1DEXT');
+  glTextureSubImage2DEXT := dglGetProcAddress('glTextureSubImage2DEXT');
+  glCopyTextureImage1DEXT := dglGetProcAddress('glCopyTextureImage1DEXT');
+  glCopyTextureImage2DEXT := dglGetProcAddress('glCopyTextureImage2DEXT');
+  glCopyTextureSubImage1DEXT := dglGetProcAddress('glCopyTextureSubImage1DEXT');
+  glCopyTextureSubImage2DEXT := dglGetProcAddress('glCopyTextureSubImage2DEXT');
+  glGetTextureImageEXT := dglGetProcAddress('glGetTextureImageEXT');
+  glGetTextureParameterfvEXT := dglGetProcAddress('glGetTextureParameterfvEXT');
+  glGetTextureParameterivEXT := dglGetProcAddress('glGetTextureParameterivEXT');
+  glGetTextureLevelParameterfvEXT := dglGetProcAddress('glGetTextureLevelParameterfvEXT');
+  glGetTextureLevelParameterivEXT := dglGetProcAddress('glGetTextureLevelParameterivEXT');
+  glTextureImage3DEXT := dglGetProcAddress('glTextureImage3DEXT');
+  glTextureSubImage3DEXT := dglGetProcAddress('glTextureSubImage3DEXT');
+  glCopyTextureSubImage3DEXT := dglGetProcAddress('glCopyTextureSubImage3DEXT');
+  glMultiTexParameterfEXT := dglGetProcAddress('glMultiTexParameterfEXT');
+  glMultiTexParameterfvEXT := dglGetProcAddress('glMultiTexParameterfvEXT');
+  glMultiTexParameteriEXT := dglGetProcAddress('glMultiTexParameteriEXT');
+  glMultiTexParameterivEXT := dglGetProcAddress('glMultiTexParameterivEXT');
+  glMultiTexImage1DEXT := dglGetProcAddress('glMultiTexImage1DEXT');
+  glMultiTexImage2DEXT := dglGetProcAddress('glMultiTexImage2DEXT');
+  glMultiTexSubImage1DEXT := dglGetProcAddress('glMultiTexSubImage1DEXT');
+  glMultiTexSubImage2DEXT := dglGetProcAddress('glMultiTexSubImage2DEXT');
+  glCopyMultiTexImage1DEXT := dglGetProcAddress('glCopyMultiTexImage1DEXT');
+  glCopyMultiTexImage2DEXT := dglGetProcAddress('glCopyMultiTexImage2DEXT');
+  glCopyMultiTexSubImage1DEXT := dglGetProcAddress('glCopyMultiTexSubImage1DEXT');
+  glCopyMultiTexSubImage2DEXT := dglGetProcAddress('glCopyMultiTexSubImage2DEXT');
+  glGetMultiTexImageEXT := dglGetProcAddress('glGetMultiTexImageEXT');
+  glGetMultiTexParameterfvEXT := dglGetProcAddress('glGetMultiTexParameterfvEXT');
+  glGetMultiTexParameterivEXT := dglGetProcAddress('glGetMultiTexParameterivEXT');
+  glGetMultiTexLevelParameterfvEXT := dglGetProcAddress('glGetMultiTexLevelParameterfvEXT');
+  glGetMultiTexLevelParameterivEXT := dglGetProcAddress('glGetMultiTexLevelParameterivEXT');
+  glMultiTexImage3DEXT := dglGetProcAddress('glMultiTexImage3DEXT');
+  glMultiTexSubImage3DEXT := dglGetProcAddress('glMultiTexSubImage3DEXT');
+  glCopyMultiTexSubImage3DEXT := dglGetProcAddress('glCopyMultiTexSubImage3DEXT');
+  glBindMultiTextureEXT := dglGetProcAddress('glBindMultiTextureEXT');
+  glEnableClientStateIndexedEXT := dglGetProcAddress('glEnableClientStateIndexedEXT');
+  glDisableClientStateIndexedEXT := dglGetProcAddress('glDisableClientStateIndexedEXT');
+  glMultiTexCoordPointerEXT := dglGetProcAddress('glMultiTexCoordPointerEXT');
+  glMultiTexEnvfEXT := dglGetProcAddress('glMultiTexEnvfEXT');
+  glMultiTexEnvfvEXT := dglGetProcAddress('glMultiTexEnvfvEXT');
+  glMultiTexEnviEXT := dglGetProcAddress('glMultiTexEnviEXT');
+  glMultiTexEnvivEXT := dglGetProcAddress('glMultiTexEnvivEXT');
+  glMultiTexGendEXT := dglGetProcAddress('glMultiTexGendEXT');
+  glMultiTexGendvEXT := dglGetProcAddress('glMultiTexGendvEXT');
+  glMultiTexGenfEXT := dglGetProcAddress('glMultiTexGenfEXT');
+  glMultiTexGenfvEXT := dglGetProcAddress('glMultiTexGenfvEXT');
+  glMultiTexGeniEXT := dglGetProcAddress('glMultiTexGeniEXT');
+  glMultiTexGenivEXT := dglGetProcAddress('glMultiTexGenivEXT');
+  glGetMultiTexEnvfvEXT := dglGetProcAddress('glGetMultiTexEnvfvEXT');
+  glGetMultiTexEnvivEXT := dglGetProcAddress('glGetMultiTexEnvivEXT');
+  glGetMultiTexGendvEXT := dglGetProcAddress('glGetMultiTexGendvEXT');
+  glGetMultiTexGenfvEXT := dglGetProcAddress('glGetMultiTexGenfvEXT');
+  glGetMultiTexGenivEXT := dglGetProcAddress('glGetMultiTexGenivEXT');
+  glGetFloatIndexedvEXT := dglGetProcAddress('glGetFloatIndexedvEXT');
+  glGetDoubleIndexedvEXT := dglGetProcAddress('glGetDoubleIndexedvEXT');
+  glGetPointerIndexedvEXT := dglGetProcAddress('glGetPointerIndexedvEXT');
+  glCompressedTextureImage3DEXT := dglGetProcAddress('glCompressedTextureImage3DEXT');
+  glCompressedTextureImage2DEXT := dglGetProcAddress('glCompressedTextureImage2DEXT');
+  glCompressedTextureImage1DEXT := dglGetProcAddress('glCompressedTextureImage1DEXT');
+  glCompressedTextureSubImage3DEXT := dglGetProcAddress('glCompressedTextureSubImage3DEXT');
+  glCompressedTextureSubImage2DEXT := dglGetProcAddress('glCompressedTextureSubImage2DEXT');
+  glCompressedTextureSubImage1DEXT := dglGetProcAddress('glCompressedTextureSubImage1DEXT');
+  glGetCompressedTextureImageEXT := dglGetProcAddress('glGetCompressedTextureImageEXT');
+  glCompressedMultiTexImage3DEXT := dglGetProcAddress('glCompressedMultiTexImage3DEXT');
+  glCompressedMultiTexImage2DEXT := dglGetProcAddress('glCompressedMultiTexImage2DEXT');
+  glCompressedMultiTexImage1DEXT := dglGetProcAddress('glCompressedMultiTexImage1DEXT');
+  glCompressedMultiTexSubImage3DEXT := dglGetProcAddress('glCompressedMultiTexSubImage3DEXT');
+  glCompressedMultiTexSubImage2DEXT := dglGetProcAddress('glCompressedMultiTexSubImage2DEXT');
+  glCompressedMultiTexSubImage1DEXT := dglGetProcAddress('glCompressedMultiTexSubImage1DEXT');
+  glGetCompressedMultiTexImageEXT := dglGetProcAddress('glGetCompressedMultiTexImageEXT');
+  glNamedProgramStringEXT := dglGetProcAddress('glNamedProgramStringEXT');
+  glNamedProgramLocalParameter4dEXT := dglGetProcAddress('glNamedProgramLocalParameter4dEXT');
+  glNamedProgramLocalParameter4dvEXT := dglGetProcAddress('glNamedProgramLocalParameter4dvEXT');
+  glNamedProgramLocalParameter4fEXT := dglGetProcAddress('glNamedProgramLocalParameter4fEXT');
+  glNamedProgramLocalParameter4fvEXT := dglGetProcAddress('glNamedProgramLocalParameter4fvEXT');
+  glGetNamedProgramLocalParameterdvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterdvEXT');
+  glGetNamedProgramLocalParameterfvEXT := dglGetProcAddress('glGetNamedProgramLocalParameterfvEXT');
+  glGetNamedProgramivEXT := dglGetProcAddress('glGetNamedProgramivEXT');
+  glGetNamedProgramStringEXT := dglGetProcAddress('glGetNamedProgramStringEXT');
+  glNamedProgramLocalParameters4fvEXT := dglGetProcAddress('glNamedProgramLocalParameters4fvEXT');
+  glNamedProgramLocalParameterI4iEXT := dglGetProcAddress('glNamedProgramLocalParameterI4iEXT');
+  glNamedProgramLocalParameterI4ivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4ivEXT');
+  glNamedProgramLocalParametersI4ivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4ivEXT');
+  glNamedProgramLocalParameterI4uiEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uiEXT');
+  glNamedProgramLocalParameterI4uivEXT := dglGetProcAddress('glNamedProgramLocalParameterI4uivEXT');
+  glNamedProgramLocalParametersI4uivEXT := dglGetProcAddress('glNamedProgramLocalParametersI4uivEXT');
+  glGetNamedProgramLocalParameterIivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIivEXT');
+  glGetNamedProgramLocalParameterIuivEXT := dglGetProcAddress('glGetNamedProgramLocalParameterIuivEXT');
+  glTextureParameterIivEXT := dglGetProcAddress('glTextureParameterIivEXT');
+  glTextureParameterIuivEXT := dglGetProcAddress('glTextureParameterIuivEXT');
+  glGetTextureParameterIivEXT := dglGetProcAddress('glGetTextureParameterIivEXT');
+  glGetTextureParameterIuivEXT := dglGetProcAddress('glGetTextureParameterIuivEXT');
+  glMultiTexParameterIivEXT := dglGetProcAddress('glMultiTexParameterIivEXT');
+  glMultiTexParameterIuivEXT := dglGetProcAddress('glMultiTexParameterIuivEXT');
+  glGetMultiTexParameterIivEXT := dglGetProcAddress('glGetMultiTexParameterIivEXT');
+  glGetMultiTexParameterIuivEXT := dglGetProcAddress('glGetMultiTexParameterIuivEXT');
+  glProgramUniform1fEXT := dglGetProcAddress('glProgramUniform1fEXT');
+  glProgramUniform2fEXT := dglGetProcAddress('glProgramUniform2fEXT');
+  glProgramUniform3fEXT := dglGetProcAddress('glProgramUniform3fEXT');
+  glProgramUniform4fEXT := dglGetProcAddress('glProgramUniform4fEXT');
+  glProgramUniform1iEXT := dglGetProcAddress('glProgramUniform1iEXT');
+  glProgramUniform2iEXT := dglGetProcAddress('glProgramUniform2iEXT');
+  glProgramUniform3iEXT := dglGetProcAddress('glProgramUniform3iEXT');
+  glProgramUniform4iEXT := dglGetProcAddress('glProgramUniform4iEXT');
+  glProgramUniform1fvEXT := dglGetProcAddress('glProgramUniform1fvEXT');
+  glProgramUniform2fvEXT := dglGetProcAddress('glProgramUniform2fvEXT');
+  glProgramUniform3fvEXT := dglGetProcAddress('glProgramUniform3fvEXT');
+  glProgramUniform4fvEXT := dglGetProcAddress('glProgramUniform4fvEXT');
+  glProgramUniform1ivEXT := dglGetProcAddress('glProgramUniform1ivEXT');
+  glProgramUniform2ivEXT := dglGetProcAddress('glProgramUniform2ivEXT');
+  glProgramUniform3ivEXT := dglGetProcAddress('glProgramUniform3ivEXT');
+  glProgramUniform4ivEXT := dglGetProcAddress('glProgramUniform4ivEXT');
+  glProgramUniformMatrix2fvEXT := dglGetProcAddress('glProgramUniformMatrix2fvEXT');
+  glProgramUniformMatrix3fvEXT := dglGetProcAddress('glProgramUniformMatrix3fvEXT');
+  glProgramUniformMatrix4fvEXT := dglGetProcAddress('glProgramUniformMatrix4fvEXT');
+  glProgramUniformMatrix2x3fvEXT := dglGetProcAddress('glProgramUniformMatrix2x3fvEXT');
+  glProgramUniformMatrix3x2fvEXT := dglGetProcAddress('glProgramUniformMatrix3x2fvEXT');
+  glProgramUniformMatrix2x4fvEXT := dglGetProcAddress('glProgramUniformMatrix2x4fvEXT');
+  glProgramUniformMatrix4x2fvEXT := dglGetProcAddress('glProgramUniformMatrix4x2fvEXT');
+  glProgramUniformMatrix3x4fvEXT := dglGetProcAddress('glProgramUniformMatrix3x4fvEXT');
+  glProgramUniformMatrix4x3fvEXT := dglGetProcAddress('glProgramUniformMatrix4x3fvEXT');
+  glProgramUniform1uiEXT := dglGetProcAddress('glProgramUniform1uiEXT');
+  glProgramUniform2uiEXT := dglGetProcAddress('glProgramUniform2uiEXT');
+  glProgramUniform3uiEXT := dglGetProcAddress('glProgramUniform3uiEXT');
+  glProgramUniform4uiEXT := dglGetProcAddress('glProgramUniform4uiEXT');
+  glProgramUniform1uivEXT := dglGetProcAddress('glProgramUniform1uivEXT');
+  glProgramUniform2uivEXT := dglGetProcAddress('glProgramUniform2uivEXT');
+  glProgramUniform3uivEXT := dglGetProcAddress('glProgramUniform3uivEXT');
+  glProgramUniform4uivEXT := dglGetProcAddress('glProgramUniform4uivEXT');
+  glNamedBufferDataEXT := dglGetProcAddress('glNamedBufferDataEXT');
+  glNamedBufferSubDataEXT := dglGetProcAddress('glNamedBufferSubDataEXT');
+  glMapNamedBufferEXT := dglGetProcAddress('glMapNamedBufferEXT');
+  glUnmapNamedBufferEXT := dglGetProcAddress('glUnmapNamedBufferEXT');
+  glMapNamedBufferRangeEXT := dglGetProcAddress('glMapNamedBufferRangeEXT');
+  glFlushMappedNamedBufferRangeEXT := dglGetProcAddress('glFlushMappedNamedBufferRangeEXT');
+  glNamedCopyBufferSubDataEXT := dglGetProcAddress('glNamedCopyBufferSubDataEXT');
+  glGetNamedBufferParameterivEXT := dglGetProcAddress('glGetNamedBufferParameterivEXT');
+  glGetNamedBufferPointervEXT := dglGetProcAddress('glGetNamedBufferPointervEXT');
+  glGetNamedBufferSubDataEXT := dglGetProcAddress('glGetNamedBufferSubDataEXT');
+  glTextureBufferEXT := dglGetProcAddress('glTextureBufferEXT');
+  glMultiTexBufferEXT := dglGetProcAddress('glMultiTexBufferEXT');
+  glNamedRenderbufferStorageEXT := dglGetProcAddress('glNamedRenderbufferStorageEXT');
+  glGetNamedRenderbufferParameterivEXT := dglGetProcAddress('glGetNamedRenderbufferParameterivEXT');
+  glCheckNamedFramebufferStatusEXT := dglGetProcAddress('glCheckNamedFramebufferStatusEXT');
+  glNamedFramebufferTexture1DEXT := dglGetProcAddress('glNamedFramebufferTexture1DEXT');
+  glNamedFramebufferTexture2DEXT := dglGetProcAddress('glNamedFramebufferTexture2DEXT');
+  glNamedFramebufferTexture3DEXT := dglGetProcAddress('glNamedFramebufferTexture3DEXT');
+  glNamedFramebufferRenderbufferEXT := dglGetProcAddress('glNamedFramebufferRenderbufferEXT');
+  glGetNamedFramebufferAttachmentParameterivEXT := dglGetProcAddress('glGetNamedFramebufferAttachmentParameterivEXT');
+  glGenerateTextureMipmapEXT := dglGetProcAddress('glGenerateTextureMipmapEXT');
+  glGenerateMultiTexMipmapEXT := dglGetProcAddress('glGenerateMultiTexMipmapEXT');
+  glFramebufferDrawBufferEXT := dglGetProcAddress('glFramebufferDrawBufferEXT');
+  glFramebufferDrawBuffersEXT := dglGetProcAddress('glFramebufferDrawBuffersEXT');
+  glFramebufferReadBufferEXT := dglGetProcAddress('glFramebufferReadBufferEXT');
+  glGetFramebufferParameterivEXT := dglGetProcAddress('glGetFramebufferParameterivEXT');
+  glNamedRenderbufferStorageMultisampleEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleEXT');
+  glNamedRenderbufferStorageMultisampleCoverageEXT := dglGetProcAddress('glNamedRenderbufferStorageMultisampleCoverageEXT');
+  glNamedFramebufferTextureEXT := dglGetProcAddress('glNamedFramebufferTextureEXT');
+  glNamedFramebufferTextureLayerEXT := dglGetProcAddress('glNamedFramebufferTextureLayerEXT');
+  glNamedFramebufferTextureFaceEXT := dglGetProcAddress('glNamedFramebufferTextureFaceEXT');
+  glTextureRenderbufferEXT := dglGetProcAddress('glTextureRenderbufferEXT');
+  glMultiTexRenderbufferEXT := dglGetProcAddress('glMultiTexRenderbufferEXT');
+  glProgramUniform1dEXT := dglGetProcAddress('glProgramUniform1dEXT');
+  glProgramUniform2dEXT := dglGetProcAddress('glProgramUniform2dEXT');
+  glProgramUniform3dEXT := dglGetProcAddress('glProgramUniform3dEXT');
+  glProgramUniform4dEXT := dglGetProcAddress('glProgramUniform4dEXT');
+  glProgramUniform1dvEXT := dglGetProcAddress('glProgramUniform1dvEXT');
+  glProgramUniform2dvEXT := dglGetProcAddress('glProgramUniform2dvEXT');
+  glProgramUniform3dvEXT := dglGetProcAddress('glProgramUniform3dvEXT');
+  glProgramUniform4dvEXT := dglGetProcAddress('glProgramUniform4dvEXT');
+  glProgramUniformMatrix2dvEXT := dglGetProcAddress('glProgramUniformMatrix2dvEXT');
+  glProgramUniformMatrix3dvEXT := dglGetProcAddress('glProgramUniformMatrix3dvEXT');
+  glProgramUniformMatrix4dvEXT := dglGetProcAddress('glProgramUniformMatrix4dvEXT');
+  glProgramUniformMatrix2x3dvEXT := dglGetProcAddress('glProgramUniformMatrix2x3dvEXT');
+  glProgramUniformMatrix2x4dvEXT := dglGetProcAddress('glProgramUniformMatrix2x4dvEXT');
+  glProgramUniformMatrix3x2dvEXT := dglGetProcAddress('glProgramUniformMatrix3x2dvEXT');
+  glProgramUniformMatrix3x4dvEXT := dglGetProcAddress('glProgramUniformMatrix3x4dvEXT');
+  glProgramUniformMatrix4x2dvEXT := dglGetProcAddress('glProgramUniformMatrix4x2dvEXT');
+  glProgramUniformMatrix4x3dvEXT := dglGetProcAddress('glProgramUniformMatrix4x3dvEXT');
+end;
+
+procedure Read_GL_EXT_separate_shader_objects;
+begin
+  glUseShaderProgramEXT := dglGetProcAddress('glUseShaderProgramEXT');
+  glActiveProgramEXT := dglGetProcAddress('glActiveProgramEXT');
+  glCreateShaderProgramEXT := dglGetProcAddress('glCreateShaderProgramEXT');
+end;
+
+procedure Read_GL_EXT_shader_image_load_store;
+begin
+  glBindImageTextureEXT := dglGetProcAddress('glBindImageTextureEXT');
+  glMemoryBarrierEXT := dglGetProcAddress('glMemoryBarrierEXT');
+end;
+
+procedure Read_GL_EXT_vertex_attrib_64bit;
+begin
+  glVertexAttribL1dEXT := dglGetProcAddress('glVertexAttribL1dEXT');
+  glVertexAttribL2dEXT := dglGetProcAddress('glVertexAttribL2dEXT');
+  glVertexAttribL3dEXT := dglGetProcAddress('glVertexAttribL3dEXT');
+  glVertexAttribL4dEXT := dglGetProcAddress('glVertexAttribL4dEXT');
+  glVertexAttribL1dvEXT := dglGetProcAddress('glVertexAttribL1dvEXT');
+  glVertexAttribL2dvEXT := dglGetProcAddress('glVertexAttribL2dvEXT');
+  glVertexAttribL3dvEXT := dglGetProcAddress('glVertexAttribL3dvEXT');
+  glVertexAttribL4dvEXT := dglGetProcAddress('glVertexAttribL4dvEXT');
+  glVertexAttribLPointerEXT := dglGetProcAddress('glVertexAttribLPointerEXT');
+  glGetVertexAttribLdvEXT := dglGetProcAddress('glGetVertexAttribLdvEXT');
+  glVertexArrayVertexAttribLOffsetEXT := dglGetProcAddress('glVertexArrayVertexAttribLOffsetEXT');
+end;
+
+procedure Read_GL_HP_image_transform;
+begin
+  glImageTransformParameteriHP := dglGetProcAddress('glImageTransformParameteriHP');
+  glImageTransformParameterfHP := dglGetProcAddress('glImageTransformParameterfHP');
+  glImageTransformParameterivHP := dglGetProcAddress('glImageTransformParameterivHP');
+  glImageTransformParameterfvHP := dglGetProcAddress('glImageTransformParameterfvHP');
+  glGetImageTransformParameterivHP := dglGetProcAddress('glGetImageTransformParameterivHP');
+  glGetImageTransformParameterfvHP := dglGetProcAddress('glGetImageTransformParameterfvHP');
+end;
+
+procedure Read_GL_IBM_multimode_draw_arrays;
+begin
+  glMultiModeDrawArraysIBM := dglGetProcAddress('glMultiModeDrawArraysIBM');
+  glMultiModeDrawElementsIBM := dglGetProcAddress('glMultiModeDrawElementsIBM');
+end;
+
+procedure Read_GL_IBM_vertex_array_lists;
+begin
+  glColorPointerListIBM := dglGetProcAddress('glColorPointerListIBM');
+  glSecondaryColorPointerListIBM := dglGetProcAddress('glSecondaryColorPointerListIBM');
+  glEdgeFlagPointerListIBM := dglGetProcAddress('glEdgeFlagPointerListIBM');
+  glFogCoordPointerListIBM := dglGetProcAddress('glFogCoordPointerListIBM');
+  glIndexPointerListIBM := dglGetProcAddress('glIndexPointerListIBM');
+  glNormalPointerListIBM := dglGetProcAddress('glNormalPointerListIBM');
+  glTexCoordPointerListIBM := dglGetProcAddress('glTexCoordPointerListIBM');
+  glVertexPointerListIBM := dglGetProcAddress('glVertexPointerListIBM');
+end;
+
+procedure Read_GL_INGR_blend_func_separate;
+begin
+  glBlendFuncSeparateINGR := dglGetProcAddress('glBlendFuncSeparateINGR');
+end;
+
+procedure Read_GL_INTEL_parallel_arrays;
+begin
+  glVertexPointervINTEL := dglGetProcAddress('glVertexPointervINTEL');
+  glNormalPointervINTEL := dglGetProcAddress('glNormalPointervINTEL');
+  glColorPointervINTEL := dglGetProcAddress('glColorPointervINTEL');
+  glTexCoordPointervINTEL := dglGetProcAddress('glTexCoordPointervINTEL');
+end;
+
+procedure Read_GL_MESA_resize_buffers;
+begin
+  glResizeBuffersMESA := dglGetProcAddress('glResizeBuffersMESA');
+end;
+
+procedure Read_GL_MESA_window_pos;
+begin
+  glWindowPos2dMESA := dglGetProcAddress('glWindowPos2dMESA');
+  glWindowPos2dvMESA := dglGetProcAddress('glWindowPos2dvMESA');
+  glWindowPos2fMESA := dglGetProcAddress('glWindowPos2fMESA');
+  glWindowPos2fvMESA := dglGetProcAddress('glWindowPos2fvMESA');
+  glWindowPos2iMESA := dglGetProcAddress('glWindowPos2iMESA');
+  glWindowPos2ivMESA := dglGetProcAddress('glWindowPos2ivMESA');
+  glWindowPos2sMESA := dglGetProcAddress('glWindowPos2sMESA');
+  glWindowPos2svMESA := dglGetProcAddress('glWindowPos2svMESA');
+  glWindowPos3dMESA := dglGetProcAddress('glWindowPos3dMESA');
+  glWindowPos3dvMESA := dglGetProcAddress('glWindowPos3dvMESA');
+  glWindowPos3fMESA := dglGetProcAddress('glWindowPos3fMESA');
+  glWindowPos3fvMESA := dglGetProcAddress('glWindowPos3fvMESA');
+  glWindowPos3iMESA := dglGetProcAddress('glWindowPos3iMESA');
+  glWindowPos3ivMESA := dglGetProcAddress('glWindowPos3ivMESA');
+  glWindowPos3sMESA := dglGetProcAddress('glWindowPos3sMESA');
+  glWindowPos3svMESA := dglGetProcAddress('glWindowPos3svMESA');
+  glWindowPos4dMESA := dglGetProcAddress('glWindowPos4dMESA');
+  glWindowPos4dvMESA := dglGetProcAddress('glWindowPos4dvMESA');
+  glWindowPos4fMESA := dglGetProcAddress('glWindowPos4fMESA');
+  glWindowPos4fvMESA := dglGetProcAddress('glWindowPos4fvMESA');
+  glWindowPos4iMESA := dglGetProcAddress('glWindowPos4iMESA');
+  glWindowPos4ivMESA := dglGetProcAddress('glWindowPos4ivMESA');
+  glWindowPos4sMESA := dglGetProcAddress('glWindowPos4sMESA');
+  glWindowPos4svMESA := dglGetProcAddress('glWindowPos4svMESA');
+end;
+
+procedure Read_GL_NV_evaluators;
+begin
+  glMapControlPointsNV := dglGetProcAddress('glMapControlPointsNV');
+  glMapParameterivNV := dglGetProcAddress('glMapParameterivNV');
+  glMapParameterfvNV := dglGetProcAddress('glMapParameterfvNV');
+  glGetMapControlPointsNV := dglGetProcAddress('glGetMapControlPointsNV');
+  glGetMapParameterivNV := dglGetProcAddress('glGetMapParameterivNV');
+  glGetMapParameterfvNV := dglGetProcAddress('glGetMapParameterfvNV');
+  glGetMapAttribParameterivNV := dglGetProcAddress('glGetMapAttribParameterivNV');
+  glGetMapAttribParameterfvNV := dglGetProcAddress('glGetMapAttribParameterfvNV');
+  glEvalMapsNV := dglGetProcAddress('glEvalMapsNV');
+end;
+
+procedure Read_GL_NV_fence;
+begin
+  glDeleteFencesNV := dglGetProcAddress('glDeleteFencesNV');
+  glGenFencesNV := dglGetProcAddress('glGenFencesNV');
+  glIsFenceNV := dglGetProcAddress('glIsFenceNV');
+  glTestFenceNV := dglGetProcAddress('glTestFenceNV');
+  glGetFenceivNV := dglGetProcAddress('glGetFenceivNV');
+  glFinishFenceNV := dglGetProcAddress('glFinishFenceNV');
+  glSetFenceNV := dglGetProcAddress('glSetFenceNV');
+end;
+
+procedure Read_GL_NV_fragment_program;
+begin
+  glProgramNamedParameter4fNV := dglGetProcAddress('glProgramNamedParameter4fNV');
+  glProgramNamedParameter4dNV := dglGetProcAddress('glProgramNamedParameter4dNV');
+  glProgramNamedParameter4fvNV := dglGetProcAddress('glProgramNamedParameter4fvNV');
+  glProgramNamedParameter4dvNV := dglGetProcAddress('glProgramNamedParameter4dvNV');
+  glGetProgramNamedParameterfvNV := dglGetProcAddress('glGetProgramNamedParameterfvNV');
+  glGetProgramNamedParameterdvNV := dglGetProcAddress('glGetProgramNamedParameterdvNV');
+end;
+
+procedure Read_GL_NV_half_float;
+begin
+  glVertex2hNV := dglGetProcAddress('glVertex2hNV');
+  glVertex2hvNV := dglGetProcAddress('glVertex2hvNV');
+  glVertex3hNV := dglGetProcAddress('glVertex3hNV');
+  glVertex3hvNV := dglGetProcAddress('glVertex3hvNV');
+  glVertex4hNV := dglGetProcAddress('glVertex4hNV');
+  glVertex4hvNV := dglGetProcAddress('glVertex4hvNV');
+  glNormal3hNV := dglGetProcAddress('glNormal3hNV');
+  glNormal3hvNV := dglGetProcAddress('glNormal3hvNV');
+  glColor3hNV := dglGetProcAddress('glColor3hNV');
+  glColor3hvNV := dglGetProcAddress('glColor3hvNV');
+  glColor4hNV := dglGetProcAddress('glColor4hNV');
+  glColor4hvNV := dglGetProcAddress('glColor4hvNV');
+  glTexCoord1hNV := dglGetProcAddress('glTexCoord1hNV');
+  glTexCoord1hvNV := dglGetProcAddress('glTexCoord1hvNV');
+  glTexCoord2hNV := dglGetProcAddress('glTexCoord2hNV');
+  glTexCoord2hvNV := dglGetProcAddress('glTexCoord2hvNV');
+  glTexCoord3hNV := dglGetProcAddress('glTexCoord3hNV');
+  glTexCoord3hvNV := dglGetProcAddress('glTexCoord3hvNV');
+  glTexCoord4hNV := dglGetProcAddress('glTexCoord4hNV');
+  glTexCoord4hvNV := dglGetProcAddress('glTexCoord4hvNV');
+  glMultiTexCoord1hNV := dglGetProcAddress('glMultiTexCoord1hNV');
+  glMultiTexCoord1hvNV := dglGetProcAddress('glMultiTexCoord1hvNV');
+  glMultiTexCoord2hNV := dglGetProcAddress('glMultiTexCoord2hNV');
+  glMultiTexCoord2hvNV := dglGetProcAddress('glMultiTexCoord2hvNV');
+  glMultiTexCoord3hNV := dglGetProcAddress('glMultiTexCoord3hNV');
+  glMultiTexCoord3hvNV := dglGetProcAddress('glMultiTexCoord3hvNV');
+  glMultiTexCoord4hNV := dglGetProcAddress('glMultiTexCoord4hNV');
+  glMultiTexCoord4hvNV := dglGetProcAddress('glMultiTexCoord4hvNV');
+  glFogCoordhNV := dglGetProcAddress('glFogCoordhNV');
+  glFogCoordhvNV := dglGetProcAddress('glFogCoordhvNV');
+  glSecondaryColor3hNV := dglGetProcAddress('glSecondaryColor3hNV');
+  glSecondaryColor3hvNV := dglGetProcAddress('glSecondaryColor3hvNV');
+  glVertexWeighthNV := dglGetProcAddress('glVertexWeighthNV');
+  glVertexWeighthvNV := dglGetProcAddress('glVertexWeighthvNV');
+  glVertexAttrib1hNV := dglGetProcAddress('glVertexAttrib1hNV');
+  glVertexAttrib1hvNV := dglGetProcAddress('glVertexAttrib1hvNV');
+  glVertexAttrib2hNV := dglGetProcAddress('glVertexAttrib2hNV');
+  glVertexAttrib2hvNV := dglGetProcAddress('glVertexAttrib2hvNV');
+  glVertexAttrib3hNV := dglGetProcAddress('glVertexAttrib3hNV');
+  glVertexAttrib3hvNV := dglGetProcAddress('glVertexAttrib3hvNV');
+  glVertexAttrib4hNV := dglGetProcAddress('glVertexAttrib4hNV');
+  glVertexAttrib4hvNV := dglGetProcAddress('glVertexAttrib4hvNV');
+  glVertexAttribs1hvNV := dglGetProcAddress('glVertexAttribs1hvNV');
+  glVertexAttribs2hvNV := dglGetProcAddress('glVertexAttribs2hvNV');
+  glVertexAttribs3hvNV := dglGetProcAddress('glVertexAttribs3hvNV');
+  glVertexAttribs4hvNV := dglGetProcAddress('glVertexAttribs4hvNV');
+end;
+
+procedure Read_GL_NV_occlusion_query;
+begin
+  glGenOcclusionQueriesNV := dglGetProcAddress('glGenOcclusionQueriesNV');
+  glDeleteOcclusionQueriesNV := dglGetProcAddress('glDeleteOcclusionQueriesNV');
+  glIsOcclusionQueryNV := dglGetProcAddress('glIsOcclusionQueryNV');
+  glBeginOcclusionQueryNV := dglGetProcAddress('glBeginOcclusionQueryNV');
+  glEndOcclusionQueryNV := dglGetProcAddress('glEndOcclusionQueryNV');
+  glGetOcclusionQueryivNV := dglGetProcAddress('glGetOcclusionQueryivNV');
+  glGetOcclusionQueryuivNV := dglGetProcAddress('glGetOcclusionQueryuivNV');
+end;
+
+procedure Read_GL_NV_pixel_data_range;
+begin
+  glPixelDataRangeNV := dglGetProcAddress('glPixelDataRangeNV');
+  glFlushPixelDataRangeNV := dglGetProcAddress('glFlushPixelDataRangeNV');
+end;
+
+procedure Read_GL_NV_point_sprite;
+begin
+  glPointParameteriNV := dglGetProcAddress('glPointParameteriNV');
+  glPointParameterivNV := dglGetProcAddress('glPointParameterivNV');
+end;
+
+procedure Read_GL_NV_primitive_restart;
+begin
+  glPrimitiveRestartNV := dglGetProcAddress('glPrimitiveRestartNV');
+  glPrimitiveRestartIndexNV := dglGetProcAddress('glPrimitiveRestartIndexNV');
+end;
+
+procedure Read_GL_NV_register_combiners;
+begin
+  glCombinerParameterfvNV := dglGetProcAddress('glCombinerParameterfvNV');
+  glCombinerParameterfNV := dglGetProcAddress('glCombinerParameterfNV');
+  glCombinerParameterivNV := dglGetProcAddress('glCombinerParameterivNV');
+  glCombinerParameteriNV := dglGetProcAddress('glCombinerParameteriNV');
+  glCombinerInputNV := dglGetProcAddress('glCombinerInputNV');
+  glCombinerOutputNV := dglGetProcAddress('glCombinerOutputNV');
+  glFinalCombinerInputNV := dglGetProcAddress('glFinalCombinerInputNV');
+  glGetCombinerInputParameterfvNV := dglGetProcAddress('glGetCombinerInputParameterfvNV');
+  glGetCombinerInputParameterivNV := dglGetProcAddress('glGetCombinerInputParameterivNV');
+  glGetCombinerOutputParameterfvNV := dglGetProcAddress('glGetCombinerOutputParameterfvNV');
+  glGetCombinerOutputParameterivNV := dglGetProcAddress('glGetCombinerOutputParameterivNV');
+  glGetFinalCombinerInputParameterfvNV := dglGetProcAddress('glGetFinalCombinerInputParameterfvNV');
+  glGetFinalCombinerInputParameterivNV := dglGetProcAddress('glGetFinalCombinerInputParameterivNV');
+end;
+
+procedure Read_GL_NV_register_combiners2;
+begin
+  glCombinerStageParameterfvNV := dglGetProcAddress('glCombinerStageParameterfvNV');
+  glGetCombinerStageParameterfvNV := dglGetProcAddress('glGetCombinerStageParameterfvNV');
+end;
+
+procedure Read_GL_NV_vertex_array_range;
+begin
+  glFlushVertexArrayRangeNV := dglGetProcAddress('glFlushVertexArrayRangeNV');
+  glVertexArrayRangeNV := dglGetProcAddress('glVertexArrayRangeNV');
+end;
+
+procedure Read_GL_NV_vertex_program;
+begin
+  glAreProgramsResidentNV := dglGetProcAddress('glAreProgramsResidentNV');
+  glBindProgramNV := dglGetProcAddress('glBindProgramNV');
+  glDeleteProgramsNV := dglGetProcAddress('glDeleteProgramsNV');
+  glExecuteProgramNV := dglGetProcAddress('glExecuteProgramNV');
+  glGenProgramsNV := dglGetProcAddress('glGenProgramsNV');
+  glGetProgramParameterdvNV := dglGetProcAddress('glGetProgramParameterdvNV');
+  glGetProgramParameterfvNV := dglGetProcAddress('glGetProgramParameterfvNV');
+  glGetProgramivNV := dglGetProcAddress('glGetProgramivNV');
+  glGetProgramStringNV := dglGetProcAddress('glGetProgramStringNV');
+  glGetTrackMatrixivNV := dglGetProcAddress('glGetTrackMatrixivNV');
+  glGetVertexAttribdvNV := dglGetProcAddress('glGetVertexAttribdvNV');
+  glGetVertexAttribfvNV := dglGetProcAddress('glGetVertexAttribfvNV');
+  glGetVertexAttribivNV := dglGetProcAddress('glGetVertexAttribivNV');
+  glGetVertexAttribPointervNV := dglGetProcAddress('glGetVertexAttribPointervNV');
+  glIsProgramNV := dglGetProcAddress('glIsProgramNV');
+  glLoadProgramNV := dglGetProcAddress('glLoadProgramNV');
+  glProgramParameter4dNV := dglGetProcAddress('glProgramParameter4dNV');
+  glProgramParameter4dvNV := dglGetProcAddress('glProgramParameter4dvNV');
+  glProgramParameter4fNV := dglGetProcAddress('glProgramParameter4fNV');
+  glProgramParameter4fvNV := dglGetProcAddress('glProgramParameter4fvNV');
+  glProgramParameters4dvNV := dglGetProcAddress('glProgramParameters4dvNV');
+  glProgramParameters4fvNV := dglGetProcAddress('glProgramParameters4fvNV');
+  glRequestResidentProgramsNV := dglGetProcAddress('glRequestResidentProgramsNV');
+  glTrackMatrixNV := dglGetProcAddress('glTrackMatrixNV');
+  glVertexAttribPointerNV := dglGetProcAddress('glVertexAttribPointerNV');
+  glVertexAttrib1dNV := dglGetProcAddress('glVertexAttrib1dNV');
+  glVertexAttrib1dvNV := dglGetProcAddress('glVertexAttrib1dvNV');
+  glVertexAttrib1fNV := dglGetProcAddress('glVertexAttrib1fNV');
+  glVertexAttrib1fvNV := dglGetProcAddress('glVertexAttrib1fvNV');
+  glVertexAttrib1sNV := dglGetProcAddress('glVertexAttrib1sNV');
+  glVertexAttrib1svNV := dglGetProcAddress('glVertexAttrib1svNV');
+  glVertexAttrib2dNV := dglGetProcAddress('glVertexAttrib2dNV');
+  glVertexAttrib2dvNV := dglGetProcAddress('glVertexAttrib2dvNV');
+  glVertexAttrib2fNV := dglGetProcAddress('glVertexAttrib2fNV');
+  glVertexAttrib2fvNV := dglGetProcAddress('glVertexAttrib2fvNV');
+  glVertexAttrib2sNV := dglGetProcAddress('glVertexAttrib2sNV');
+  glVertexAttrib2svNV := dglGetProcAddress('glVertexAttrib2svNV');
+  glVertexAttrib3dNV := dglGetProcAddress('glVertexAttrib3dNV');
+  glVertexAttrib3dvNV := dglGetProcAddress('glVertexAttrib3dvNV');
+  glVertexAttrib3fNV := dglGetProcAddress('glVertexAttrib3fNV');
+  glVertexAttrib3fvNV := dglGetProcAddress('glVertexAttrib3fvNV');
+  glVertexAttrib3sNV := dglGetProcAddress('glVertexAttrib3sNV');
+  glVertexAttrib3svNV := dglGetProcAddress('glVertexAttrib3svNV');
+  glVertexAttrib4dNV := dglGetProcAddress('glVertexAttrib4dNV');
+  glVertexAttrib4dvNV := dglGetProcAddress('glVertexAttrib4dvNV');
+  glVertexAttrib4fNV := dglGetProcAddress('glVertexAttrib4fNV');
+  glVertexAttrib4fvNV := dglGetProcAddress('glVertexAttrib4fvNV');
+  glVertexAttrib4sNV := dglGetProcAddress('glVertexAttrib4sNV');
+  glVertexAttrib4svNV := dglGetProcAddress('glVertexAttrib4svNV');
+  glVertexAttrib4ubNV := dglGetProcAddress('glVertexAttrib4ubNV');
+  glVertexAttrib4ubvNV := dglGetProcAddress('glVertexAttrib4ubvNV');
+  glVertexAttribs1dvNV := dglGetProcAddress('glVertexAttribs1dvNV');
+  glVertexAttribs1fvNV := dglGetProcAddress('glVertexAttribs1fvNV');
+  glVertexAttribs1svNV := dglGetProcAddress('glVertexAttribs1svNV');
+  glVertexAttribs2dvNV := dglGetProcAddress('glVertexAttribs2dvNV');
+  glVertexAttribs2fvNV := dglGetProcAddress('glVertexAttribs2fvNV');
+  glVertexAttribs2svNV := dglGetProcAddress('glVertexAttribs2svNV');
+  glVertexAttribs3dvNV := dglGetProcAddress('glVertexAttribs3dvNV');
+  glVertexAttribs3fvNV := dglGetProcAddress('glVertexAttribs3fvNV');
+  glVertexAttribs3svNV := dglGetProcAddress('glVertexAttribs3svNV');
+  glVertexAttribs4dvNV := dglGetProcAddress('glVertexAttribs4dvNV');
+  glVertexAttribs4fvNV := dglGetProcAddress('glVertexAttribs4fvNV');
+  glVertexAttribs4svNV := dglGetProcAddress('glVertexAttribs4svNV');
+  glVertexAttribs4ubvNV := dglGetProcAddress('glVertexAttribs4ubvNV');
+end;
+
+procedure Read_GL_NV_depth_buffer_float;
+begin
+  glDepthRangedNV := dglGetProcAddress('glDepthRangedNV');
+  glClearDepthdNV := dglGetProcAddress('glClearDepthdNV');
+  glDepthBoundsdNV := dglGetProcAddress('glDepthBoundsdNV');
+end;
+
+procedure Read_GL_NV_framebuffer_multisample_coverage;
+begin
+  glRenderbufferStorageMultsampleCoverageNV := dglGetProcAddress('glRenderbufferStorageMultsampleCoverageNV');
+end;
+
+procedure Read_GL_NV_geometry_program4;
+begin
+  glProgramVertexLimitNV := dglGetProcAddress('glProgramVertexLimitNV');
+end;
+
+procedure Read_GL_NV_gpu_program4;
+begin
+  glProgramLocalParameterI4iNV := dglGetProcAddress('glProgramLocalParameterI4iNV');
+  glProgramLocalParameterI4ivNV := dglGetProcAddress('glProgramLocalParameterI4ivNV');
+  glProgramLocalParametersI4ivNV := dglGetProcAddress('glProgramLocalParametersI4ivNV');
+  glProgramLocalParameterI4uiNV := dglGetProcAddress('glProgramLocalParameterI4uiNV');
+  glProgramLocalParameterI4uivNV := dglGetProcAddress('glProgramLocalParameterI4uivNV');
+  glProgramLocalParametersI4uivNV := dglGetProcAddress('glProgramLocalParametersI4uivNV');
+  glProgramEnvParameterI4iNV := dglGetProcAddress('glProgramEnvParameterI4iNV');
+  glProgramEnvParameterI4ivNV := dglGetProcAddress('glProgramEnvParameterI4ivNV');
+  glProgramEnvParametersI4ivNV := dglGetProcAddress('glProgramEnvParametersI4ivNV');
+  glProgramEnvParameterI4uiNV := dglGetProcAddress('glProgramEnvParameterI4uiNV');
+  glProgramEnvParameterI4uivNV := dglGetProcAddress('glProgramEnvParameterI4uivNV');
+  glProgramEnvParametersI4uivNV := dglGetProcAddress('glProgramEnvParametersI4uivNV');
+  glGetProgramLocalParameterIivNV := dglGetProcAddress('glGetProgramLocalParameterIivNV');
+  glGetProgramLocalParameterIuivNV := dglGetProcAddress('glGetProgramLocalParameterIuivNV');
+  glGetProgramEnvParameterIivNV := dglGetProcAddress('glGetProgramEnvParameterIivNV');
+  glGetProgramEnvParameterIuivNV := dglGetProcAddress('glGetProgramEnvParameterIuivNV');
+end;
+
+procedure Read_GL_NV_parameter_buffer_object;
+begin
+  glProgramBufferParametersfvNV := dglGetProcAddress('glProgramBufferParametersfvNV');
+  glProgramBufferParametersIivNV := dglGetProcAddress('glProgramBufferParametersIivNV');
+  glProgramBufferParametersIuivNV := dglGetProcAddress('glProgramBufferParametersIuivNV');
+end;
+
+procedure Read_GL_NV_transform_feedback;
+begin
+  glBeginTransformFeedbackNV := dglGetProcAddress('glBeginTransformFeedbackNV');
+  glEndTransformFeedbackNV := dglGetProcAddress('glEndTransformFeedbackNV');
+  glTransformFeedbackAttribsNV := dglGetProcAddress('glTransformFeedbackAttribsNV');
+  glBindBufferRangeNV := dglGetProcAddress('glBindBufferRangeNV');
+  glBindBufferOffsetNV := dglGetProcAddress('glBindBufferOffsetNV');
+  glBindBufferBaseNV := dglGetProcAddress('glBindBufferBaseNV');
+  glTransformFeedbackVaryingsNV := dglGetProcAddress('glTransformFeedbackVaryingsNV');
+  glActiveVaryingNV := dglGetProcAddress('glActiveVaryingNV');
+  glGetVaryingLocationNV := dglGetProcAddress('glGetVaryingLocationNV');
+  glGetActiveVaryingNV := dglGetProcAddress('glGetActiveVaryingNV');
+  glGetTransformFeedbackVaryingNV := dglGetProcAddress('glGetTransformFeedbackVaryingNV');
+  glTransformFeedbackStreamAttribsNV := dglGetProcAddress('glTransformFeedbackStreamAttribsNV');
+end;
+
+procedure Read_GL_NV_conditional_render;
+begin
+  glBeginConditionalRenderNV := dglGetProcAddress('glBeginConditionalRenderNV');
+  glEndConditionalRenderNV := dglGetProcAddress('glEndConditionalRenderNV');
+end;
+
+procedure Read_GL_NV_present_video;
+begin
+  glPresentFrameKeyedNV := dglGetProcAddress('glPresentFrameKeyedNV');
+  glPresentFrameDualFillNV := dglGetProcAddress('glPresentFrameDualFillNV');
+  glGetVideoivNV := dglGetProcAddress('glGetVideoivNV');
+  glGetVideouivNV := dglGetProcAddress('glGetVideouivNV');
+  glGetVideoi64vNV := dglGetProcAddress('glGetVideoi64vNV');
+  glGetVideoui64vNV := dglGetProcAddress('glGetVideoui64vNV');
+//  glVideoParameterivNV := dglGetProcAddress('glVideoParameterivNV');
+end;
+
+procedure Read_GL_NV_explicit_multisample;
+begin
+  glGetMultisamplefvNV := dglGetProcAddress('glGetMultisamplefvNV');
+  glSampleMaskIndexedNV := dglGetProcAddress('glSampleMaskIndexedNV');
+  glTexRenderbufferNV := dglGetProcAddress('glTexRenderbufferNV');
+end;
+
+procedure Read_GL_NV_transform_feedback2;
+begin
+  glBindTransformFeedbackNV := dglGetProcAddress('glBindTransformFeedbackNV');
+  glDeleteTransformFeedbacksNV := dglGetProcAddress('glDeleteTransformFeedbacksNV');
+  glGenTransformFeedbacksNV := dglGetProcAddress('glGenTransformFeedbacksNV');
+  glIsTransformFeedbackNV := dglGetProcAddress('glIsTransformFeedbackNV');
+  glPauseTransformFeedbackNV := dglGetProcAddress('glPauseTransformFeedbackNV');
+  glResumeTransformFeedbackNV := dglGetProcAddress('glResumeTransformFeedbackNV');
+  glDrawTransformFeedbackNV := dglGetProcAddress('glDrawTransformFeedbackNV');
+end;
+
+procedure Read_GL_NV_video_capture;
+begin
+  glBeginVideoCaptureNV := dglGetProcAddress('glBeginVideoCaptureNV');
+  glBindVideoCaptureStreamBufferNV := dglGetProcAddress('glBindVideoCaptureStreamBufferNV');
+  glBindVideoCaptureStreamTextureNV := dglGetProcAddress('glBindVideoCaptureStreamTextureNV');
+  glEndVideoCaptureNV := dglGetProcAddress('glEndVideoCaptureNV');
+  glGetVideoCaptureivNV := dglGetProcAddress('glGetVideoCaptureivNV');
+  glGetVideoCaptureStreamivNV := dglGetProcAddress('glGetVideoCaptureStreamivNV');
+  glGetVideoCaptureStreamfvNV := dglGetProcAddress('glGetVideoCaptureStreamfvNV');
+  glGetVideoCaptureStreamdvNV := dglGetProcAddress('glGetVideoCaptureStreamdvNV');
+  glVideoCaptureNV := dglGetProcAddress('glVideoCaptureNV');
+  glVideoCaptureStreamParameterivNV := dglGetProcAddress('glVideoCaptureStreamParameterivNV');
+  glVideoCaptureStreamParameterfvNV := dglGetProcAddress('glVideoCaptureStreamParameterfvNV');
+  glVideoCaptureStreamParameterdvNV := dglGetProcAddress('glVideoCaptureStreamParameterdvNV');
+end;
+
+procedure Read_GL_NV_copy_image;
+begin
+  glCopyImageSubDataNV := dglGetProcAddress('glCopyImageSubDataNV');
+end;
+
+procedure Read_GL_NV_shader_buffer_load;
+begin
+  glMakeBufferResidentNV := dglGetProcAddress('glMakeBufferResidentNV');
+  glMakeBufferNonResidentNV := dglGetProcAddress('glMakeBufferNonResidentNV');
+  glIsBufferResidentNV := dglGetProcAddress('glIsBufferResidentNV');
+  glMakeNamedBufferResidentNV := dglGetProcAddress('glMakeNamedBufferResidentNV');
+  glMakeNamedBufferNonResidentNV := dglGetProcAddress('glMakeNamedBufferNonResidentNV');
+  glIsNamedBufferResidentNV := dglGetProcAddress('glIsNamedBufferResidentNV');
+  glGetBufferParameterui64vNV := dglGetProcAddress('glGetBufferParameterui64vNV');
+  glGetNamedBufferParameterui64vNV := dglGetProcAddress('glGetNamedBufferParameterui64vNV');
+  glGetIntegerui64vNV := dglGetProcAddress('glGetIntegerui64vNV');
+  glUniformui64NV := dglGetProcAddress('glUniformui64NV');
+  glUniformui64vNV := dglGetProcAddress('glUniformui64vNV');
+  glGetUniformui64vNV := dglGetProcAddress('glGetUniformui64vNV');
+  glProgramUniformui64NV := dglGetProcAddress('glProgramUniformui64NV');
+  glProgramUniformui64vNV := dglGetProcAddress('glProgramUniformui64vNV');
+end;
+
+procedure Read_GL_NV_vertex_buffer_unified_memory;
+begin
+  glBufferAddressRangeNV := dglGetProcAddress('glBufferAddressRangeNV');
+  glVertexFormatNV := dglGetProcAddress('glVertexFormatNV');
+  glNormalFormatNV := dglGetProcAddress('glNormalFormatNV');
+  glColorFormatNV := dglGetProcAddress('glColorFormatNV');
+  glIndexFormatNV := dglGetProcAddress('glIndexFormatNV');
+  glTexCoordFormatNV := dglGetProcAddress('glTexCoordFormatNV');
+  glEdgeFlagFormatNV := dglGetProcAddress('glEdgeFlagFormatNV');
+  glSecondaryColorFormatNV := dglGetProcAddress('glSecondaryColorFormatNV');
+  glFogCoordFormatNV := dglGetProcAddress('glFogCoordFormatNV');
+  glVertexAttribFormatNV := dglGetProcAddress('glVertexAttribFormatNV');
+  glVertexAttribIFormatNV := dglGetProcAddress('glVertexAttribIFormatNV');
+  glGetIntegerui64i_vNV := dglGetProcAddress('glGetIntegerui64i_vNV');
+end;
+
+procedure Read_GL_NV_gpu_program5;
+begin
+  glProgramSubroutineParametersuivNV := dglGetProcAddress('glProgramSubroutineParametersuivNV');
+  glGetProgramSubroutineParameteruivNV := dglGetProcAddress('glGetProgramSubroutineParameteruivNV');
+end;
+
+procedure Read_GL_NV_gpu_shader5;
+begin
+  glUniform1i64NV := dglGetProcAddress('glUniform1i64NV');
+  glUniform2i64NV := dglGetProcAddress('glUniform2i64NV');
+  glUniform3i64NV := dglGetProcAddress('glUniform3i64NV');
+  glUniform4i64NV := dglGetProcAddress('glUniform4i64NV');
+  glUniform1i64vNV := dglGetProcAddress('glUniform1i64vNV');
+  glUniform2i64vNV := dglGetProcAddress('glUniform2i64vNV');
+  glUniform3i64vNV := dglGetProcAddress('glUniform3i64vNV');
+  glUniform4i64vNV := dglGetProcAddress('glUniform4i64vNV');
+  glUniform1ui64NV := dglGetProcAddress('glUniform1ui64NV');
+  glUniform2ui64NV := dglGetProcAddress('glUniform2ui64NV');
+  glUniform3ui64NV := dglGetProcAddress('glUniform3ui64NV');
+  glUniform4ui64NV := dglGetProcAddress('glUniform4ui64NV');
+  glUniform1ui64vNV := dglGetProcAddress('glUniform1ui64vNV');
+  glUniform2ui64vNV := dglGetProcAddress('glUniform2ui64vNV');
+  glUniform3ui64vNV := dglGetProcAddress('glUniform3ui64vNV');
+  glUniform4ui64vNV := dglGetProcAddress('glUniform4ui64vNV');
+  glGetUniformi64vNV := dglGetProcAddress('glGetUniformi64vNV');
+  glProgramUniform1i64NV := dglGetProcAddress('glProgramUniform1i64NV');
+  glProgramUniform2i64NV := dglGetProcAddress('glProgramUniform2i64NV');
+  glProgramUniform3i64NV := dglGetProcAddress('glProgramUniform3i64NV');
+  glProgramUniform4i64NV := dglGetProcAddress('glProgramUniform4i64NV');
+  glProgramUniform1i64vNV := dglGetProcAddress('glProgramUniform1i64vNV');
+  glProgramUniform2i64vNV := dglGetProcAddress('glProgramUniform2i64vNV');
+  glProgramUniform3i64vNV := dglGetProcAddress('glProgramUniform3i64vNV');
+  glProgramUniform4i64vNV := dglGetProcAddress('glProgramUniform4i64vNV');
+  glProgramUniform1ui64NV := dglGetProcAddress('glProgramUniform1ui64NV');
+  glProgramUniform2ui64NV := dglGetProcAddress('glProgramUniform2ui64NV');
+  glProgramUniform3ui64NV := dglGetProcAddress('glProgramUniform3ui64NV');
+  glProgramUniform4ui64NV := dglGetProcAddress('glProgramUniform4ui64NV');
+  glProgramUniform1ui64vNV := dglGetProcAddress('glProgramUniform1ui64vNV');
+  glProgramUniform2ui64vNV := dglGetProcAddress('glProgramUniform2ui64vNV');
+  glProgramUniform3ui64vNV := dglGetProcAddress('glProgramUniform3ui64vNV');
+  glProgramUniform4ui64vNV := dglGetProcAddress('glProgramUniform4ui64vNV');
+end;
+
+procedure Read_GL_NV_vertex_attrib_integer_64bit;
+begin
+  glVertexAttribL1i64NV := dglGetProcAddress('glVertexAttribL1i64NV');
+  glVertexAttribL2i64NV := dglGetProcAddress('glVertexAttribL2i64NV');
+  glVertexAttribL3i64NV := dglGetProcAddress('glVertexAttribL3i64NV');
+  glVertexAttribL4i64NV := dglGetProcAddress('glVertexAttribL4i64NV');
+  glVertexAttribL1i64vNV := dglGetProcAddress('glVertexAttribL1i64vNV');
+  glVertexAttribL2i64vNV := dglGetProcAddress('glVertexAttribL2i64vNV');
+  glVertexAttribL3i64vNV := dglGetProcAddress('glVertexAttribL3i64vNV');
+  glVertexAttribL4i64vNV := dglGetProcAddress('glVertexAttribL4i64vNV');
+  glVertexAttribL1ui64NV := dglGetProcAddress('glVertexAttribL1ui64NV');
+  glVertexAttribL2ui64NV := dglGetProcAddress('glVertexAttribL2ui64NV');
+  glVertexAttribL3ui64NV := dglGetProcAddress('glVertexAttribL3ui64NV');
+  glVertexAttribL4ui64NV := dglGetProcAddress('glVertexAttribL4ui64NV');
+  glVertexAttribL1ui64vNV := dglGetProcAddress('glVertexAttribL1ui64vNV');
+  glVertexAttribL2ui64vNV := dglGetProcAddress('glVertexAttribL2ui64vNV');
+  glVertexAttribL3ui64vNV := dglGetProcAddress('glVertexAttribL3ui64vNV');
+  glVertexAttribL4ui64vNV := dglGetProcAddress('glVertexAttribL4ui64vNV');
+  glGetVertexAttribLi64vNV := dglGetProcAddress('glGetVertexAttribLi64vNV');
+  glGetVertexAttribLui64vNV := dglGetProcAddress('glGetVertexAttribLui64vNV');
+  glVertexAttribLFormatNV := dglGetProcAddress('glVertexAttribLFormatNV');
+end;  
+
+procedure Read_GL_NV_vdpau_interop;
+begin
+  glVDPAUInitNV := dglGetProcAddress('glVDPAUInitNV');
+  glVDPAUFiniNV := dglGetProcAddress('glVDPAUFiniNV');
+  glVDPAURegisterVideoSurfaceNV := dglGetProcAddress('glVDPAURegisterVideoSurfaceNV');
+  glVDPAURegisterOutputSurfaceNV := dglGetProcAddress('glVDPAURegisterOutputSurfaceNV');
+  glVDPAUIsSurfaceNV := dglGetProcAddress('glVDPAUIsSurfaceNV');
+  glVDPAUUnregisterSurfaceNV := dglGetProcAddress('glVDPAUUnregisterSurfaceNV');
+  glVDPAUGetSurfaceivNV := dglGetProcAddress('glVDPAUGetSurfaceivNV');
+  glVDPAUSurfaceAccessNV := dglGetProcAddress('glVDPAUSurfaceAccessNV');
+  glVDPAUMapSurfacesNV := dglGetProcAddress('glVDPAUMapSurfacesNV');
+  glVDPAUUnmapSurfacesNV := dglGetProcAddress('glVDPAUUnmapSurfacesNV');
+end;
+  
+procedure Read_GL_NV_texture_barrier;
+begin
+  glTextureBarrierNV := dglGetProcAddress('glTextureBarrierNV');
+end;
+
+procedure Read_GL_PGI_misc_hints;
+begin
+  glHintPGI := dglGetProcAddress('glHintPGI');
+end;
+
+procedure Read_GL_SGIS_detail_texture;
+begin
+  glDetailTexFuncSGIS := dglGetProcAddress('glDetailTexFuncSGIS');
+  glGetDetailTexFuncSGIS := dglGetProcAddress('glGetDetailTexFuncSGIS');
+end;
+
+procedure Read_GL_SGIS_fog_function;
+begin
+  glFogFuncSGIS := dglGetProcAddress('glFogFuncSGIS');
+  glGetFogFuncSGIS := dglGetProcAddress('glGetFogFuncSGIS');
+end;
+
+procedure Read_GL_SGIS_multisample;
+begin
+  glSampleMaskSGIS := dglGetProcAddress('glSampleMaskSGIS');
+  glSamplePatternSGIS := dglGetProcAddress('glSamplePatternSGIS');
+end;
+
+procedure Read_GL_SGIS_pixel_texture;
+begin
+  glPixelTexGenParameteriSGIS := dglGetProcAddress('glPixelTexGenParameteriSGIS');
+  glPixelTexGenParameterivSGIS := dglGetProcAddress('glPixelTexGenParameterivSGIS');
+  glPixelTexGenParameterfSGIS := dglGetProcAddress('glPixelTexGenParameterfSGIS');
+  glPixelTexGenParameterfvSGIS := dglGetProcAddress('glPixelTexGenParameterfvSGIS');
+  glGetPixelTexGenParameterivSGIS := dglGetProcAddress('glGetPixelTexGenParameterivSGIS');
+  glGetPixelTexGenParameterfvSGIS := dglGetProcAddress('glGetPixelTexGenParameterfvSGIS');
+end;
+
+procedure Read_GL_SGIS_point_parameters;
+begin
+  glPointParameterfSGIS := dglGetProcAddress('glPointParameterfSGIS');
+  glPointParameterfvSGIS := dglGetProcAddress('glPointParameterfvSGIS');
+end;
+
+procedure Read_GL_SGIS_sharpen_texture;
+begin
+  glSharpenTexFuncSGIS := dglGetProcAddress('glSharpenTexFuncSGIS');
+  glGetSharpenTexFuncSGIS := dglGetProcAddress('glGetSharpenTexFuncSGIS');
+end;
+
+procedure Read_GL_SGIS_texture4D;
+begin
+  glTexImage4DSGIS := dglGetProcAddress('glTexImage4DSGIS');
+  glTexSubImage4DSGIS := dglGetProcAddress('glTexSubImage4DSGIS');
+end;
+
+procedure Read_GL_SGIS_texture_color_mask;
+begin
+  glTextureColorMaskSGIS := dglGetProcAddress('glTextureColorMaskSGIS');
+end;
+
+procedure Read_GL_SGIS_texture_filter4;
+begin
+  glGetTexFilterFuncSGIS := dglGetProcAddress('glGetTexFilterFuncSGIS');
+  glTexFilterFuncSGIS := dglGetProcAddress('glTexFilterFuncSGIS');
+end;
+
+procedure Read_GL_SGIX_async;
+begin
+  glAsyncMarkerSGIX := dglGetProcAddress('glAsyncMarkerSGIX');
+  glFinishAsyncSGIX := dglGetProcAddress('glFinishAsyncSGIX');
+  glPollAsyncSGIX := dglGetProcAddress('glPollAsyncSGIX');
+  glGenAsyncMarkersSGIX := dglGetProcAddress('glGenAsyncMarkersSGIX');
+  glDeleteAsyncMarkersSGIX := dglGetProcAddress('glDeleteAsyncMarkersSGIX');
+  glIsAsyncMarkerSGIX := dglGetProcAddress('glIsAsyncMarkerSGIX');
+end;
+
+procedure Read_GL_SGIX_flush_raster;
+begin
+  glFlushRasterSGIX := dglGetProcAddress('glFlushRasterSGIX');
+end;
+
+procedure Read_GL_SGIX_fragment_lighting;
+begin
+  glFragmentColorMaterialSGIX := dglGetProcAddress('glFragmentColorMaterialSGIX');
+  glFragmentLightfSGIX := dglGetProcAddress('glFragmentLightfSGIX');
+  glFragmentLightfvSGIX := dglGetProcAddress('glFragmentLightfvSGIX');
+  glFragmentLightiSGIX := dglGetProcAddress('glFragmentLightiSGIX');
+  glFragmentLightivSGIX := dglGetProcAddress('glFragmentLightivSGIX');
+  glFragmentLightModelfSGIX := dglGetProcAddress('glFragmentLightModelfSGIX');
+  glFragmentLightModelfvSGIX := dglGetProcAddress('glFragmentLightModelfvSGIX');
+  glFragmentLightModeliSGIX := dglGetProcAddress('glFragmentLightModeliSGIX');
+  glFragmentLightModelivSGIX := dglGetProcAddress('glFragmentLightModelivSGIX');
+  glFragmentMaterialfSGIX := dglGetProcAddress('glFragmentMaterialfSGIX');
+  glFragmentMaterialfvSGIX := dglGetProcAddress('glFragmentMaterialfvSGIX');
+  glFragmentMaterialiSGIX := dglGetProcAddress('glFragmentMaterialiSGIX');
+  glFragmentMaterialivSGIX := dglGetProcAddress('glFragmentMaterialivSGIX');
+  glGetFragmentLightfvSGIX := dglGetProcAddress('glGetFragmentLightfvSGIX');
+  glGetFragmentLightivSGIX := dglGetProcAddress('glGetFragmentLightivSGIX');
+  glGetFragmentMaterialfvSGIX := dglGetProcAddress('glGetFragmentMaterialfvSGIX');
+  glGetFragmentMaterialivSGIX := dglGetProcAddress('glGetFragmentMaterialivSGIX');
+  glLightEnviSGIX := dglGetProcAddress('glLightEnviSGIX');
+end;
+
+procedure Read_GL_SGIX_framezoom;
+begin
+  glFrameZoomSGIX := dglGetProcAddress('glFrameZoomSGIX');
+end;
+
+procedure Read_GL_SGIX_igloo_interface;
+begin
+  glIglooInterfaceSGIX := dglGetProcAddress('glIglooInterfaceSGIX');
+end;
+
+procedure Read_GL_SGIX_instruments;
+begin
+  glGetInstrumentsSGIX := dglGetProcAddress('glGetInstrumentsSGIX');
+  glInstrumentsBufferSGIX := dglGetProcAddress('glInstrumentsBufferSGIX');
+  glPollInstrumentsSGIX := dglGetProcAddress('glPollInstrumentsSGIX');
+  glReadInstrumentsSGIX := dglGetProcAddress('glReadInstrumentsSGIX');
+  glStartInstrumentsSGIX := dglGetProcAddress('glStartInstrumentsSGIX');
+  glStopInstrumentsSGIX := dglGetProcAddress('glStopInstrumentsSGIX');
+end;
+
+procedure Read_GL_SGIX_list_priority;
+begin
+  glGetListParameterfvSGIX := dglGetProcAddress('glGetListParameterfvSGIX');
+  glGetListParameterivSGIX := dglGetProcAddress('glGetListParameterivSGIX');
+  glListParameterfSGIX := dglGetProcAddress('glListParameterfSGIX');
+  glListParameterfvSGIX := dglGetProcAddress('glListParameterfvSGIX');
+  glListParameteriSGIX := dglGetProcAddress('glListParameteriSGIX');
+  glListParameterivSGIX := dglGetProcAddress('glListParameterivSGIX');
+end;
+
+procedure Read_GL_SGIX_pixel_texture;
+begin
+  glPixelTexGenSGIX := dglGetProcAddress('glPixelTexGenSGIX');
+end;
+
+procedure Read_GL_SGIX_polynomial_ffd;
+begin
+  glDeformationMap3dSGIX := dglGetProcAddress('glDeformationMap3dSGIX');
+  glDeformationMap3fSGIX := dglGetProcAddress('glDeformationMap3fSGIX');
+  glDeformSGIX := dglGetProcAddress('glDeformSGIX');
+  glLoadIdentityDeformationMapSGIX := dglGetProcAddress('glLoadIdentityDeformationMapSGIX');
+end;
+
+procedure Read_GL_SGIX_reference_plane;
+begin
+  glReferencePlaneSGIX := dglGetProcAddress('glReferencePlaneSGIX');
+end;
+
+procedure Read_GL_SGIX_sprite;
+begin
+  glSpriteParameterfSGIX := dglGetProcAddress('glSpriteParameterfSGIX');
+  glSpriteParameterfvSGIX := dglGetProcAddress('glSpriteParameterfvSGIX');
+  glSpriteParameteriSGIX := dglGetProcAddress('glSpriteParameteriSGIX');
+  glSpriteParameterivSGIX := dglGetProcAddress('glSpriteParameterivSGIX');
+end;
+
+procedure Read_GL_SGIX_tag_sample_buffer;
+begin
+  glTagSampleBufferSGIX := dglGetProcAddress('glTagSampleBufferSGIX');
+end;
+
+procedure Read_GL_SGI_color_table;
+begin
+  glColorTableSGI := dglGetProcAddress('glColorTableSGI');
+  glColorTableParameterfvSGI := dglGetProcAddress('glColorTableParameterfvSGI');
+  glColorTableParameterivSGI := dglGetProcAddress('glColorTableParameterivSGI');
+  glCopyColorTableSGI := dglGetProcAddress('glCopyColorTableSGI');
+  glGetColorTableSGI := dglGetProcAddress('glGetColorTableSGI');
+  glGetColorTableParameterfvSGI := dglGetProcAddress('glGetColorTableParameterfvSGI');
+  glGetColorTableParameterivSGI := dglGetProcAddress('glGetColorTableParameterivSGI');
+end;
+
+procedure Read_GL_SUNX_constant_data;
+begin
+  glFinishTextureSUNX := dglGetProcAddress('glFinishTextureSUNX');
+end;
+
+procedure Read_GL_SUN_global_alpha;
+begin
+  glGlobalAlphaFactorbSUN := dglGetProcAddress('glGlobalAlphaFactorbSUN');
+  glGlobalAlphaFactorsSUN := dglGetProcAddress('glGlobalAlphaFactorsSUN');
+  glGlobalAlphaFactoriSUN := dglGetProcAddress('glGlobalAlphaFactoriSUN');
+  glGlobalAlphaFactorfSUN := dglGetProcAddress('glGlobalAlphaFactorfSUN');
+  glGlobalAlphaFactordSUN := dglGetProcAddress('glGlobalAlphaFactordSUN');
+  glGlobalAlphaFactorubSUN := dglGetProcAddress('glGlobalAlphaFactorubSUN');
+  glGlobalAlphaFactorusSUN := dglGetProcAddress('glGlobalAlphaFactorusSUN');
+  glGlobalAlphaFactoruiSUN := dglGetProcAddress('glGlobalAlphaFactoruiSUN');
+end;
+
+procedure Read_GL_SUN_mesh_array;
+begin
+  glDrawMeshArraysSUN := dglGetProcAddress('glDrawMeshArraysSUN');
+end;
+
+procedure Read_GL_SUN_triangle_list;
+begin
+  glReplacementCodeuiSUN := dglGetProcAddress('glReplacementCodeuiSUN');
+  glReplacementCodeusSUN := dglGetProcAddress('glReplacementCodeusSUN');
+  glReplacementCodeubSUN := dglGetProcAddress('glReplacementCodeubSUN');
+  glReplacementCodeuivSUN := dglGetProcAddress('glReplacementCodeuivSUN');
+  glReplacementCodeusvSUN := dglGetProcAddress('glReplacementCodeusvSUN');
+  glReplacementCodeubvSUN := dglGetProcAddress('glReplacementCodeubvSUN');
+  glReplacementCodePointerSUN := dglGetProcAddress('glReplacementCodePointerSUN');
+end;
+
+procedure Read_GL_SUN_vertex;
+begin
+  glColor4ubVertex2fSUN := dglGetProcAddress('glColor4ubVertex2fSUN');
+  glColor4ubVertex2fvSUN := dglGetProcAddress('glColor4ubVertex2fvSUN');
+  glColor4ubVertex3fSUN := dglGetProcAddress('glColor4ubVertex3fSUN');
+  glColor4ubVertex3fvSUN := dglGetProcAddress('glColor4ubVertex3fvSUN');
+  glColor3fVertex3fSUN := dglGetProcAddress('glColor3fVertex3fSUN');
+  glColor3fVertex3fvSUN := dglGetProcAddress('glColor3fVertex3fvSUN');
+  glNormal3fVertex3fSUN := dglGetProcAddress('glNormal3fVertex3fSUN');
+  glNormal3fVertex3fvSUN := dglGetProcAddress('glNormal3fVertex3fvSUN');
+  glColor4fNormal3fVertex3fSUN := dglGetProcAddress('glColor4fNormal3fVertex3fSUN');
+  glColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glColor4fNormal3fVertex3fvSUN');
+  glTexCoord2fVertex3fSUN := dglGetProcAddress('glTexCoord2fVertex3fSUN');
+  glTexCoord2fVertex3fvSUN := dglGetProcAddress('glTexCoord2fVertex3fvSUN');
+  glTexCoord4fVertex4fSUN := dglGetProcAddress('glTexCoord4fVertex4fSUN');
+  glTexCoord4fVertex4fvSUN := dglGetProcAddress('glTexCoord4fVertex4fvSUN');
+  glTexCoord2fColor4ubVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fSUN');
+  glTexCoord2fColor4ubVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4ubVertex3fvSUN');
+  glTexCoord2fColor3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fSUN');
+  glTexCoord2fColor3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor3fVertex3fvSUN');
+  glTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fSUN');
+  glTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fNormal3fVertex3fvSUN');
+  glTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fSUN');
+  glTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glTexCoord2fColor4fNormal3fVertex3fvSUN');
+  glTexCoord4fColor4fNormal3fVertex4fSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fSUN');
+  glTexCoord4fColor4fNormal3fVertex4fvSUN := dglGetProcAddress('glTexCoord4fColor4fNormal3fVertex4fvSUN');
+  glReplacementCodeuiVertex3fSUN := dglGetProcAddress('glReplacementCodeuiVertex3fSUN');
+  glReplacementCodeuiVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiVertex3fvSUN');
+  glReplacementCodeuiColor4ubVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fSUN');
+  glReplacementCodeuiColor4ubVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4ubVertex3fvSUN');
+  glReplacementCodeuiColor3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fSUN');
+  glReplacementCodeuiColor3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor3fVertex3fvSUN');
+  glReplacementCodeuiNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fSUN');
+  glReplacementCodeuiNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiNormal3fVertex3fvSUN');
+  glReplacementCodeuiColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fSUN');
+  glReplacementCodeuiColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiColor4fNormal3fVertex3fvSUN');
+  glReplacementCodeuiTexCoord2fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fSUN');
+  glReplacementCodeuiTexCoord2fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fVertex3fvSUN');
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN');
+  glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN');
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN');
+  glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN := dglGetProcAddress('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN');
+end;
+
+{$IFDEF DGL_WIN}
+procedure Read_WGL_ARB_buffer_region;
+begin
+  wglCreateBufferRegionARB := dglGetProcAddress('wglCreateBufferRegionARB');
+  wglDeleteBufferRegionARB := dglGetProcAddress('wglDeleteBufferRegionARB');
+  wglSaveBufferRegionARB := dglGetProcAddress('wglSaveBufferRegionARB');
+  wglRestoreBufferRegionARB := dglGetProcAddress('wglRestoreBufferRegionARB');
+end;
+
+procedure Read_WGL_ARB_extensions_string;
+begin
+  wglGetExtensionsStringARB := dglGetProcAddress('wglGetExtensionsStringARB');
+end;
+
+procedure Read_WGL_ARB_make_current_read;
+begin
+  wglMakeContextCurrentARB := dglGetProcAddress('wglMakeContextCurrentARB');
+  wglGetCurrentReadDCARB := dglGetProcAddress('wglGetCurrentReadDCARB');
+end;
+
+procedure Read_WGL_ARB_pbuffer;
+begin
+  wglCreatePbufferARB := dglGetProcAddress('wglCreatePbufferARB');
+  wglGetPbufferDCARB := dglGetProcAddress('wglGetPbufferDCARB');
+  wglReleasePbufferDCARB := dglGetProcAddress('wglReleasePbufferDCARB');
+  wglDestroyPbufferARB := dglGetProcAddress('wglDestroyPbufferARB');
+  wglQueryPbufferARB := dglGetProcAddress('wglQueryPbufferARB');
+end;
+
+procedure Read_WGL_ARB_pixel_format;
+begin
+  wglGetPixelFormatAttribivARB := dglGetProcAddress('wglGetPixelFormatAttribivARB');
+  wglGetPixelFormatAttribfvARB := dglGetProcAddress('wglGetPixelFormatAttribfvARB');
+  wglChoosePixelFormatARB := dglGetProcAddress('wglChoosePixelFormatARB');
+end;
+
+procedure Read_WGL_ARB_pixel_format_float;
+begin
+  wglClampColorARB := dglGetProcAddress('wglClampColorARB');
+end;
+
+procedure Read_WGL_ARB_render_texture;
+begin
+  wglBindTexImageARB := dglGetProcAddress('wglBindTexImageARB');
+  wglReleaseTexImageARB := dglGetProcAddress('wglReleaseTexImageARB');
+  wglSetPbufferAttribARB := dglGetProcAddress('wglSetPbufferAttribARB');
+end;
+
+procedure Read_WGL_ARB_create_context;
+begin
+  wglCreateContextAttribsARB := dglGetProcAddress('wglCreateContextAttribsARB');
+end;
+
+procedure Read_WGL_AMD_gpu_association;
+begin
+  wglGetGPUIDsAMD := dglGetProcAddress('wglGetGPUIDsAMD');
+  wglGetGPUInfoAMD := dglGetProcAddress('wglGetGPUInfoAMD');
+  wglGetContextGPUIDAMD := dglGetProcAddress('wglGetContextGPUIDAMD');
+  wglCreateAssociatedContextAMD := dglGetProcAddress('wglCreateAssociatedContextAMD');
+  wglCreateAssociatedContextAttribsAMD := dglGetProcAddress('wglCreateAssociatedContextAttribsAMD');
+  wglDeleteAssociatedContextAMD := dglGetProcAddress('wglDeleteAssociatedContextAMD');
+  wglMakeAssociatedContextCurrentAMD := dglGetProcAddress('wglMakeAssociatedContextCurrentAMD');
+  wglGetCurrentAssociatedContextAMD := dglGetProcAddress('wglGetCurrentAssociatedContextAMD');
+  wglBlitContextFramebufferAMD := dglGetProcAddress('wglBlitContextFramebufferAMD');
+end;
+
+procedure Read_WGL_EXT_display_color_table;
+begin
+  wglCreateDisplayColorTableEXT := dglGetProcAddress('wglCreateDisplayColorTableEXT');
+  wglLoadDisplayColorTableEXT := dglGetProcAddress('wglLoadDisplayColorTableEXT');
+  wglBindDisplayColorTableEXT := dglGetProcAddress('wglBindDisplayColorTableEXT');
+  wglDestroyDisplayColorTableEXT := dglGetProcAddress('wglDestroyDisplayColorTableEXT');
+end;
+
+procedure Read_WGL_EXT_extensions_string;
+begin
+  wglGetExtensionsStringEXT := dglGetProcAddress('wglGetExtensionsStringEXT');
+end;
+
+procedure Read_WGL_EXT_make_current_read;
+begin
+  wglMakeContextCurrentEXT := dglGetProcAddress('wglMakeContextCurrentEXT');
+  wglGetCurrentReadDCEXT := dglGetProcAddress('wglGetCurrentReadDCEXT');
+end;
+
+procedure Read_WGL_EXT_pbuffer;
+begin
+  wglCreatePbufferEXT := dglGetProcAddress('wglCreatePbufferEXT');
+  wglGetPbufferDCEXT := dglGetProcAddress('wglGetPbufferDCEXT');
+  wglReleasePbufferDCEXT := dglGetProcAddress('wglReleasePbufferDCEXT');
+  wglDestroyPbufferEXT := dglGetProcAddress('wglDestroyPbufferEXT');
+  wglQueryPbufferEXT := dglGetProcAddress('wglQueryPbufferEXT');
+end;
+
+procedure Read_WGL_EXT_pixel_format;
+begin
+  wglGetPixelFormatAttribivEXT := dglGetProcAddress('wglGetPixelFormatAttribivEXT');
+  wglGetPixelFormatAttribfvEXT := dglGetProcAddress('wglGetPixelFormatAttribfvEXT');
+  wglChoosePixelFormatEXT := dglGetProcAddress('wglChoosePixelFormatEXT');
+end;
+
+procedure Read_WGL_EXT_swap_control;
+begin
+  wglSwapIntervalEXT := dglGetProcAddress('wglSwapIntervalEXT');
+  wglGetSwapIntervalEXT := dglGetProcAddress('wglGetSwapIntervalEXT');
+end;
+
+procedure Read_WGL_I3D_digital_video_control;
+begin
+  wglGetDigitalVideoParametersI3D := dglGetProcAddress('wglGetDigitalVideoParametersI3D');
+  wglSetDigitalVideoParametersI3D := dglGetProcAddress('wglSetDigitalVideoParametersI3D');
+end;
+
+procedure Read_WGL_I3D_gamma;
+begin
+  wglGetGammaTableParametersI3D := dglGetProcAddress('wglGetGammaTableParametersI3D');
+  wglSetGammaTableParametersI3D := dglGetProcAddress('wglSetGammaTableParametersI3D');
+  wglGetGammaTableI3D := dglGetProcAddress('wglGetGammaTableI3D');
+  wglSetGammaTableI3D := dglGetProcAddress('wglSetGammaTableI3D');
+end;
+
+procedure Read_WGL_I3D_genlock;
+begin
+  wglEnableGenlockI3D := dglGetProcAddress('wglEnableGenlockI3D');
+  wglDisableGenlockI3D := dglGetProcAddress('wglDisableGenlockI3D');
+  wglIsEnabledGenlockI3D := dglGetProcAddress('wglIsEnabledGenlockI3D');
+  wglGenlockSourceI3D := dglGetProcAddress('wglGenlockSourceI3D');
+  wglGetGenlockSourceI3D := dglGetProcAddress('wglGetGenlockSourceI3D');
+  wglGenlockSourceEdgeI3D := dglGetProcAddress('wglGenlockSourceEdgeI3D');
+  wglGetGenlockSourceEdgeI3D := dglGetProcAddress('wglGetGenlockSourceEdgeI3D');
+  wglGenlockSampleRateI3D := dglGetProcAddress('wglGenlockSampleRateI3D');
+  wglGetGenlockSampleRateI3D := dglGetProcAddress('wglGetGenlockSampleRateI3D');
+  wglGenlockSourceDelayI3D := dglGetProcAddress('wglGenlockSourceDelayI3D');
+  wglGetGenlockSourceDelayI3D := dglGetProcAddress('wglGetGenlockSourceDelayI3D');
+  wglQueryGenlockMaxSourceDelayI3D := dglGetProcAddress('wglQueryGenlockMaxSourceDelayI3D');
+end;
+
+procedure Read_WGL_I3D_image_buffer;
+begin
+  wglCreateImageBufferI3D := dglGetProcAddress('wglCreateImageBufferI3D');
+  wglDestroyImageBufferI3D := dglGetProcAddress('wglDestroyImageBufferI3D');
+  wglAssociateImageBufferEventsI3D := dglGetProcAddress('wglAssociateImageBufferEventsI3D');
+  wglReleaseImageBufferEventsI3D := dglGetProcAddress('wglReleaseImageBufferEventsI3D');
+end;
+
+procedure Read_WGL_I3D_swap_frame_lock;
+begin
+  wglEnableFrameLockI3D := dglGetProcAddress('wglEnableFrameLockI3D');
+  wglDisableFrameLockI3D := dglGetProcAddress('wglDisableFrameLockI3D');
+  wglIsEnabledFrameLockI3D := dglGetProcAddress('wglIsEnabledFrameLockI3D');
+  wglQueryFrameLockMasterI3D := dglGetProcAddress('wglQueryFrameLockMasterI3D');
+end;
+
+procedure Read_WGL_I3D_swap_frame_usage;
+begin
+  wglGetFrameUsageI3D := dglGetProcAddress('wglGetFrameUsageI3D');
+  wglBeginFrameTrackingI3D := dglGetProcAddress('wglBeginFrameTrackingI3D');
+  wglEndFrameTrackingI3D := dglGetProcAddress('wglEndFrameTrackingI3D');
+  wglQueryFrameTrackingI3D := dglGetProcAddress('wglQueryFrameTrackingI3D');
+end;
+
+procedure Read_WGL_NV_vertex_array_range;
+begin
+  wglAllocateMemoryNV := dglGetProcAddress('wglAllocateMemoryNV');
+  wglFreeMemoryNV := dglGetProcAddress('wglFreeMemoryNV');
+end;
+
+procedure Read_WGL_NV_present_video;
+begin
+  wglEnumerateVideoDevicesNV := dglGetProcAddress('wglEnumerateVideoDevicesNV');
+  wglBindVideoDeviceNV := dglGetProcAddress('wglBindVideoDeviceNV');
+  wglQueryCurrentContextNV := dglGetProcAddress('wglQueryCurrentContextNV');
+end;
+
+procedure Read_WGL_NV_video_output;
+begin
+  wglGetVideoDeviceNV := dglGetProcAddress('wglGetVideoDeviceNV');
+  wglReleaseVideoDeviceNV := dglGetProcAddress('wglReleaseVideoDeviceNV');
+  wglBindVideoImageNV := dglGetProcAddress('wglBindVideoImageNV');
+  wglReleaseVideoImageNV := dglGetProcAddress('wglReleaseVideoImageNV');
+  wglSendPbufferToVideoNV := dglGetProcAddress('wglSendPbufferToVideoNV');
+  wglGetVideoInfoNV := dglGetProcAddress('wglGetVideoInfoNV');
+end;
+
+procedure Read_WGL_NV_swap_group;
+begin
+  wglJoinSwapGroupNV := dglGetProcAddress('wglJoinSwapGroupNV');
+  wglBindSwapBarrierNV := dglGetProcAddress('wglBindSwapBarrierNV');
+  wglQuerySwapGroupNV := dglGetProcAddress('wglQuerySwapGroupNV');
+  wglQueryMaxSwapGroupsNV := dglGetProcAddress('wglQueryMaxSwapGroupsNV');
+  wglQueryFrameCountNV := dglGetProcAddress('wglQueryFrameCountNV');
+  wglResetFrameCountNV := dglGetProcAddress('wglResetFrameCountNV');
+end;
+
+procedure Read_WGL_NV_gpu_affinity;
+begin
+  wglEnumGpusNV := dglGetProcAddress('wglEnumGpusNV');
+  wglEnumGpuDevicesNV := dglGetProcAddress('wglEnumGpuDevicesNV');
+  wglCreateAffinityDCNV := dglGetProcAddress('wglCreateAffinityDCNV');
+  wglEnumGpusFromAffinityDCNV := dglGetProcAddress('wglEnumGpusFromAffinityDCNV');
+  wglDeleteDCNV := dglGetProcAddress('wglDeleteDCNV');
+end;
+
+procedure Read_WGL_NV_video_capture;
+begin
+  wglBindVideoCaptureDeviceNV := dglGetProcAddress('wglBindVideoCaptureDeviceNV');
+  wglEnumerateVideoCaptureDevicesNV := dglGetProcAddress('wglEnumerateVideoCaptureDevicesNV');
+  wglLockVideoCaptureDeviceNV := dglGetProcAddress('wglLockVideoCaptureDeviceNV');
+  wglQueryVideoCaptureDeviceNV := dglGetProcAddress('wglQueryVideoCaptureDeviceNV');
+  wglReleaseVideoCaptureDeviceNV := dglGetProcAddress('wglReleaseVideoCaptureDeviceNV');
+end;
+
+procedure Read_WGL_NV_copy_image;
+begin
+  wglCopyImageSubDataNV := dglGetProcAddress('wglCopyImageSubDataNV');
+end;
+
+procedure Read_WGL_NV_DX_interop;
+begin
+  wglDXSetResourceShareHandleNV := dglGetProcAddress('wglDXSetResourceShareHandleNV');
+  wglDXOpenDeviceNV := dglGetProcAddress('wglDXOpenDeviceNV');
+  wglDXCloseDeviceNV := dglGetProcAddress('wglDXCloseDeviceNV');
+  wglDXRegisterObjectNV := dglGetProcAddress('wglDXRegisterObjectNV');
+  wglDXUnregisterObjectNV := dglGetProcAddress('wglDXUnregisterObjectNV');
+  wglDXObjectAccessNV := dglGetProcAddress('wglDXObjectAccessNV');
+  wglDXLockObjectsNV := dglGetProcAddress('wglDXLockObjectsNV');
+  wglDXUnlockObjectsNV := dglGetProcAddress('wglDXUnlockObjectsNV');
+end;
+
+
+procedure Read_WGL_OML_sync_control;
+begin
+  wglGetSyncValuesOML := dglGetProcAddress('wglGetSyncValuesOML');
+  wglGetMscRateOML := dglGetProcAddress('wglGetMscRateOML');
+  wglSwapBuffersMscOML := dglGetProcAddress('wglSwapBuffersMscOML');
+  wglSwapLayerBuffersMscOML := dglGetProcAddress('wglSwapLayerBuffersMscOML');
+  wglWaitForMscOML := dglGetProcAddress('wglWaitForMscOML');
+  wglWaitForSbcOML := dglGetProcAddress('wglWaitForSbcOML');
+end;
+
+procedure Read_WGL_3DL_stereo_control;
+begin
+  wglSetStereoEmitterState3DL := dglGetProcAddress('wglSetStereoEmitterState3DL');
+end;
+
+procedure Read_WIN_draw_range_elements;
+begin
+  glDrawRangeElementsWIN := dglGetProcAddress('glDrawRangeElementsWIN');
+end;
+
+procedure Read_WIN_swap_hint;
+begin
+  glAddSwapHintRectWIN := dglGetProcAddress('glAddSwapHintRectWIN');
+end;
+{$ENDIF}
+
+
+procedure ReadExtensions;
+begin
+  ReadOpenGLCore;
+  
+  Read_GL_3DFX_tbuffer;
+  Read_GL_APPLE_element_array;
+  Read_GL_APPLE_fence;
+  Read_GL_APPLE_vertex_array_object;
+  Read_GL_APPLE_vertex_array_range;
+  Read_GL_APPLE_texture_range;
+  Read_GL_APPLE_vertex_program_evaluators;
+  Read_GL_APPLE_object_purgeable;
+  Read_GL_ARB_matrix_palette;
+  Read_GL_ARB_multitexture;
+  Read_GL_ARB_point_parameters;
+  Read_GL_ARB_texture_compression;
+  Read_GL_ARB_transpose_matrix;
+  Read_GL_ARB_vertex_blend;
+  Read_GL_ARB_vertex_buffer_object;
+  Read_GL_ARB_vertex_program;
+  Read_GL_ARB_window_pos;
+  Read_GL_ARB_color_buffer_float;
+  Read_GL_ARB_Shader_Objects;
+  Read_GL_ARB_occlusion_query;
+  Read_GL_ARB_draw_instanced;
+  Read_GL_ARB_framebuffer_object;
+  Read_GL_ARB_geometry_shader4;
+  Read_GL_ARB_instanced_arrays;
+  Read_GL_ARB_map_buffer_range;
+  Read_GL_ARB_texture_buffer_object;
+  Read_GL_ARB_vertex_array_object;
+  Read_GL_ARB_uniform_buffer_object;
+  Read_GL_ARB_copy_buffer;
+  Read_GL_ARB_draw_elements_base_vertex;
+  Read_GL_ARB_provoking_vertex;
+  Read_GL_ARB_sync;
+  Read_GL_ARB_texture_multisample;
+  Read_GL_ARB_draw_buffers_blend;
+  Read_GL_ARB_sample_shading;
+  Read_GL_ARB_shading_language_include;
+  Read_GL_ARB_blend_func_extended;
+  Read_GL_ARB_sampler_objects;
+  Read_GL_ARB_timer_query;
+  Read_GL_ARB_vertex_type_2_10_10_10_rev;
+  Read_GL_ARB_draw_indirect;
+  Read_GL_ARB_gpu_shader_fp64;
+  Read_GL_ARB_shader_subroutine;
+  Read_GL_ARB_tessellation_shader;
+  Read_GL_ARB_transform_feedback2;
+  Read_GL_ARB_transform_feedback3;
+  Read_GL_ARB_ES2_compatibility;
+  Read_GL_ARB_get_program_binary;
+  Read_GL_ARB_separate_shader_objects;
+  Read_GL_ARB_vertex_attrib_64bit;
+  Read_GL_ARB_viewport_array;
+  Read_GL_ARB_cl_event;
+  Read_GL_ARB_debug_output;
+  Read_GL_ARB_robustness;
+  //
+  Read_GL_ATI_draw_buffers;
+  Read_GL_ATI_element_array;
+  Read_GL_ATI_envmap_bumpmap;
+  Read_GL_ATI_fragment_shader;
+  Read_GL_ATI_map_object_buffer;
+  Read_GL_ATI_pn_triangles;
+  Read_GL_ATI_separate_stencil;
+  Read_GL_ATI_vertex_array_object;
+  Read_GL_ATI_vertex_attrib_array_object;
+  Read_GL_ATI_vertex_streams;
+  Read_GL_AMD_performance_monitor;
+  Read_GL_AMD_vertex_shader_tesselator;
+  Read_GL_AMD_draw_buffers_blend;
+  Read_GL_AMD_name_gen_delete;
+  Read_GL_AMD_debug_output;
+  Read_GL_AMD_stencil_operation_extended;
+  Read_GL_EXT_blend_color;
+  Read_GL_EXT_blend_func_separate;
+  Read_GL_EXT_blend_minmax;
+  Read_GL_EXT_color_subtable;
+  Read_GL_EXT_compiled_vertex_array;
+  Read_GL_EXT_convolution;
+  Read_GL_EXT_coordinate_frame;
+  Read_GL_EXT_copy_texture;
+  Read_GL_EXT_cull_vertex;
+  Read_GL_EXT_draw_range_elements;
+  Read_GL_EXT_fog_coord;
+  Read_GL_EXT_framebuffer_object;
+  Read_GL_EXT_histogram;
+  Read_GL_EXT_index_func;
+  Read_GL_EXT_index_material;
+  Read_GL_EXT_multi_draw_arrays;
+  Read_GL_EXT_multisample;
+  Read_GL_EXT_paletted_texture;
+  Read_GL_EXT_pixel_transform;
+  Read_GL_EXT_point_parameters;
+  Read_GL_EXT_polygon_offset;
+  Read_GL_EXT_secondary_color;
+  Read_GL_EXT_stencil_two_side;
+  Read_GL_EXT_subtexture;
+  Read_GL_EXT_texture3D;
+  Read_GL_EXT_texture_object;
+  Read_GL_EXT_texture_perturb_normal;
+  Read_GL_EXT_vertex_array;
+  Read_GL_EXT_vertex_shader;
+  Read_GL_EXT_vertex_weighting;
+  Read_GL_EXT_depth_bounds_test;
+  Read_GL_EXT_blend_equation_separate;
+  Read_GL_EXT_stencil_clear_tag;
+  Read_GL_EXT_framebuffer_blit;
+  Read_GL_EXT_framebuffer_multisample;
+  Read_GL_EXT_timer_query;
+  Read_GL_EXT_gpu_program_parameters;
+  Read_GL_EXT_bindable_uniform;
+  Read_GL_EXT_draw_buffers2;
+  Read_GL_EXT_draw_instanced;
+  Read_GL_EXT_geometry_shader4;
+  Read_GL_EXT_gpu_shader4;
+  Read_GL_EXT_texture_array;
+  Read_GL_EXT_texture_buffer_object;
+  Read_GL_EXT_texture_integer;
+  Read_GL_EXT_transform_feedback;
+  Read_GL_EXT_direct_state_access;
+  Read_GL_EXT_separate_shader_objects;
+  Read_GL_EXT_shader_image_load_store;
+  Read_GL_EXT_vertex_attrib_64bit;
+  Read_GL_HP_image_transform;
+  Read_GL_IBM_multimode_draw_arrays;
+  Read_GL_IBM_vertex_array_lists;
+  Read_GL_INGR_blend_func_separate;
+  Read_GL_INTEL_parallel_arrays;
+  Read_GL_MESA_resize_buffers;
+  Read_GL_MESA_window_pos;
+  Read_GL_NV_evaluators;
+  Read_GL_NV_fence;
+  Read_GL_NV_fragment_program;
+  Read_GL_NV_half_float;
+  Read_GL_NV_occlusion_query;
+  Read_GL_NV_pixel_data_range;
+  Read_GL_NV_point_sprite;
+  Read_GL_NV_primitive_restart;
+  Read_GL_NV_register_combiners;
+  Read_GL_NV_register_combiners2;
+  Read_GL_NV_vertex_array_range;
+  Read_GL_NV_vertex_program;
+  Read_GL_NV_depth_buffer_float;
+  Read_GL_NV_framebuffer_multisample_coverage;
+  Read_GL_NV_geometry_program4;
+  Read_GL_NV_gpu_program4;
+  Read_GL_NV_parameter_buffer_object;
+  Read_GL_NV_transform_feedback;
+  Read_GL_NV_conditional_render;
+  Read_GL_NV_present_video;
+  Read_GL_NV_explicit_multisample;
+  Read_GL_NV_transform_feedback2;
+  Read_GL_NV_video_capture;
+  Read_GL_NV_copy_image;
+  Read_GL_NV_shader_buffer_load;
+  Read_GL_NV_vertex_buffer_unified_memory;
+  Read_GL_NV_gpu_program5;
+  Read_GL_NV_gpu_shader5;
+  Read_GL_NV_vertex_attrib_integer_64bit;
+  Read_GL_NV_vdpau_interop;
+  Read_GL_NV_texture_barrier;
+  Read_GL_NV_path_rendering;
+  Read_GL_NV_bindless_texture;
+  Read_GL_PGI_misc_hints;
+  Read_GL_SGIS_detail_texture;
+  Read_GL_SGIS_fog_function;
+  Read_GL_SGIS_multisample;
+  Read_GL_SGIS_pixel_texture;
+  Read_GL_SGIS_point_parameters;
+  Read_GL_SGIS_sharpen_texture;
+  Read_GL_SGIS_texture4D;
+  Read_GL_SGIS_texture_color_mask;
+  Read_GL_SGIS_texture_filter4;
+  Read_GL_SGIX_async;
+  Read_GL_SGIX_flush_raster;
+  Read_GL_SGIX_fragment_lighting;
+  Read_GL_SGIX_framezoom;
+  Read_GL_SGIX_igloo_interface;
+  Read_GL_SGIX_instruments;
+  Read_GL_SGIX_list_priority;
+  Read_GL_SGIX_pixel_texture;
+  Read_GL_SGIX_polynomial_ffd;
+  Read_GL_SGIX_reference_plane;
+  Read_GL_SGIX_sprite;
+  Read_GL_SGIX_tag_sample_buffer;
+  Read_GL_SGI_color_table;
+  Read_GL_SUNX_constant_data;
+  Read_GL_SUN_global_alpha;
+  Read_GL_SUN_mesh_array;
+  Read_GL_SUN_triangle_list;
+  Read_GL_SUN_vertex;
+
+{$IFDEF DGL_WIN}
+  Read_WGL_ARB_buffer_region;
+  Read_WGL_ARB_extensions_string;
+  Read_WGL_ARB_make_current_read;
+  Read_WGL_ARB_pbuffer;
+  Read_WGL_ARB_pixel_format;
+  Read_WGL_ARB_pixel_format_float;
+  Read_WGL_ARB_render_texture;
+  Read_WGL_ARB_create_context;
+  Read_WGL_AMD_gpu_association;
+  Read_WGL_EXT_display_color_table;
+  Read_WGL_EXT_extensions_string;
+  Read_WGL_EXT_make_current_read;
+  Read_WGL_EXT_pbuffer;
+  Read_WGL_EXT_pixel_format;
+  Read_WGL_EXT_swap_control;
+  Read_WGL_I3D_digital_video_control;
+  Read_WGL_I3D_gamma;
+  Read_WGL_I3D_genlock;
+  Read_WGL_I3D_image_buffer;
+  Read_WGL_I3D_swap_frame_lock;
+  Read_WGL_I3D_swap_frame_usage;
+  Read_WGL_NV_vertex_array_range;
+  Read_WGL_NV_present_video;
+  Read_WGL_NV_video_output;
+  Read_WGL_NV_swap_group;
+  Read_WGL_NV_gpu_affinity;
+  Read_WGL_NV_video_capture;
+  Read_WGL_NV_copy_image;
+  Read_WGL_NV_DX_interop;
+  Read_WGL_OML_sync_control;
+  Read_WGL_3DL_stereo_control;
+
+  Read_WIN_draw_range_elements;
+  Read_WIN_swap_hint;
+{$ENDIF}
+
+  ExtensionsRead := True;
+end;
+
+// =============================================================================
+//  ReadCoreVersion
+// =============================================================================
+
+procedure ReadCoreVersion;
+var
+  AnsiBuffer: AnsiString;
+  Buffer: String;
+  MajorVersion, MinorVersion: Integer;
+
+  procedure TrimAndSplitVersionString(Buffer: String; var Max, Min: Integer);
+    // Peels out the X.Y form from the given Buffer which must contain a version string like "text Minor.Major.Build text"
+    // at least however "Major.Minor".
+  var
+    Separator: Integer;
+  begin
+    try
+      // There must be at least one dot to separate major and minor version number.
+      Separator := Pos('.', Buffer);
+      // At least one number must be before and one after the dot.
+      if (Separator > 1) and (Separator < Length(Buffer)) and (AnsiChar(Buffer[Separator - 1]) in ['0'..'9']) and
+      (AnsiChar(Buffer[Separator + 1]) in ['0'..'9']) then
+      begin
+        // OK, it's a valid version string. Now remove unnecessary parts.
+        Dec(Separator);
+        // Find last non-numeric character before version number.
+        while (Separator > 0) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
+          Dec(Separator);
+        // Delete leading characters which do not belong to the version string.
+        Delete(Buffer, 1, Separator);
+        Separator := Pos('.', Buffer) + 1;
+        // Find first non-numeric character after version number
+        while (Separator <= Length(Buffer)) and (AnsiChar(Buffer[Separator]) in ['0'..'9']) do
+          Inc(Separator);
+        // delete trailing characters not belonging to the version string
+        Delete(Buffer, Separator, 255);
+        // Now translate the numbers.
+        Separator := Pos('.', Buffer); // This is necessary because the buffer length might have changed.
+        Max := StrToInt(Copy(Buffer, 1, Separator - 1));
+        Min := StrToInt(Copy(Buffer, Separator + 1, 1));
+      end
+      else
+        Abort;
+    except
+      Min := 0;
+      Max := 0;
+    end;
+  end;
+
+
+begin
+  // determine version of implementation
+  // GL
+  if not Assigned(@glGetString) then
+    glGetString := dglGetProcAddress('glGetString');
+
+  AnsiBuffer := glGetString(GL_VERSION);
+  Buffer := String(AnsiBuffer);
+
+  TrimAndSplitVersionString(Buffer, MajorVersion, MinorVersion);
+
+  GL_VERSION_1_0 := True;
+  GL_VERSION_1_1 := False;
+  GL_VERSION_1_2 := False;
+  GL_VERSION_1_3 := False;
+  GL_VERSION_1_4 := False;
+  GL_VERSION_1_5 := False;
+  GL_VERSION_2_0 := False;
+  GL_VERSION_2_1 := False;
+  GL_VERSION_3_0 := False;
+  GL_VERSION_3_1 := False;
+  GL_VERSION_3_2 := False;
+  GL_VERSION_3_3 := False;
+  GL_VERSION_4_0 := False;
+  GL_VERSION_4_1 := False;
+  GL_VERSION_4_2 := False;
+  GL_VERSION_4_3 := False;
+  GL_VERSION_4_4 := False;
+
+  if MajorVersion = 1 then
+  begin
+    if MinorVersion >= 1 then
+      GL_VERSION_1_1 := True;
+    if MinorVersion >= 2 then
+      GL_VERSION_1_2 := True;
+    if MinorVersion >= 3 then
+      GL_VERSION_1_3 := True;
+    if MinorVersion >= 4 then
+      GL_VERSION_1_4 := True;
+    if MinorVersion >= 5 then
+      GL_VERSION_1_5 := True;
+  end;
+
+  if MajorVersion >= 2 then
+  begin
+    GL_VERSION_1_1 := True;
+    GL_VERSION_1_2 := True;
+    GL_VERSION_1_3 := True;
+    GL_VERSION_1_4 := True;
+    GL_VERSION_1_5 := True;
+    GL_VERSION_2_0 := True;
+
+    if MinorVersion >= 1 then
+      GL_VERSION_2_1 := True;
+  end;
+
+  if MajorVersion >= 3 then
+  begin
+    GL_VERSION_2_1 := True;
+    GL_VERSION_3_0 := True;
+    
+    if MinorVersion >= 1 then
+      GL_VERSION_3_1 := True;
+    if MinorVersion >= 2 then
+      GL_VERSION_3_2 := True;
+    if MinorVersion >= 3 then
+      GL_VERSION_3_3 := True;
+  end;
+
+  if MajorVersion >= 4 then
+  begin
+    GL_VERSION_3_1 := True;
+    GL_VERSION_3_2 := True;
+    GL_VERSION_3_3 := True;
+    GL_VERSION_4_0 := True;
+
+    if MinorVersion >= 1 then
+      GL_VERSION_4_1 := True;
+    if MinorVersion >= 2 then
+      GL_VERSION_4_2 := True;
+    if MinorVersion >= 3 then
+      GL_VERSION_4_3 := True;
+    if MinorVersion >= 4 then
+      GL_VERSION_4_4 := True;
+  end;
+
+  // GLU
+  GLU_VERSION_1_1 := False;
+  GLU_VERSION_1_2 := False;
+  GLU_VERSION_1_3 := False;
+
+  if Assigned(gluGetString) then begin
+    AnsiBuffer := gluGetString(GLU_VERSION);
+    Buffer := String(AnsiBuffer);
+
+    TrimAndSplitVersionString(Buffer, Majorversion, MinorVersion);
+
+    GLU_VERSION_1_1 := True;
+
+    if MinorVersion >= 2 then
+      GLU_VERSION_1_2 := True;
+
+    if MinorVersion >= 3 then
+      GLU_VERSION_1_3 := True;
+  end;
+end;
+
+
+// =============================================================================
+//  ReadImplementationProperties
+// =============================================================================
+
+procedure ReadImplementationProperties;
+var
+  Buffer: Ansistring;
+begin
+  ReadCoreVersion;
+
+  // Check all extensions
+  Buffer := Int_GetExtensionString;
+
+  // === 3DFX ====================================================================
+  GL_3DFX_multisample := Int_CheckExtension(Buffer, 'GL_3DFX_multisample');
+  GL_3DFX_tbuffer := Int_CheckExtension(Buffer, 'GL_3DFX_tbuffer');
+  GL_3DFX_texture_compression_FXT1 := Int_CheckExtension(Buffer, 'GL_3DFX_texture_compression_FXT1');
+
+  // === APPLE ===================================================================
+  GL_APPLE_client_storage := Int_CheckExtension(Buffer, 'GL_APPLE_client_storage');
+  GL_APPLE_element_array := Int_CheckExtension(Buffer, 'GL_APPLE_element_array');
+  GL_APPLE_fence := Int_CheckExtension(Buffer, 'GL_APPLE_fence');
+  GL_APPLE_specular_vector := Int_CheckExtension(Buffer, 'GL_APPLE_specular_vector');
+  GL_APPLE_transform_hint := Int_CheckExtension(Buffer, 'GL_APPLE_transform_hint');
+  GL_APPLE_vertex_array_object := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_object');
+  GL_APPLE_vertex_array_range := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_array_range');
+  GL_APPLE_ycbcr_422 := Int_CheckExtension(Buffer, 'GL_APPLE_ycbcr_422');
+  GL_APPLE_texture_range := Int_CheckExtension(Buffer, 'GL_APPLE_texture_range');
+  GL_APPLE_float_pixels := Int_CheckExtension(Buffer, 'GL_APPLE_float_pixels');
+  GL_APPLE_vertex_program_evaluators := Int_CheckExtension(Buffer, 'GL_APPLE_vertex_program_evaluators');
+  GL_APPLE_aux_depth_stencil := Int_CheckExtension(Buffer, 'GL_APPLE_aux_depth_stencil');
+  GL_APPLE_object_purgeable := Int_CheckExtension(Buffer, 'GL_APPLE_object_purgeable');
+  GL_APPLE_row_bytes := Int_CheckExtension(Buffer, 'GL_APPLE_row_bytes');
+  GL_APPLE_rgb_422 := Int_CheckExtension(Buffer, 'GL_APPLE_rgb_422');
+
+  // === ARB =====================================================================
+  GL_ARB_depth_texture := Int_CheckExtension(Buffer, 'GL_ARB_depth_texture');
+  GL_ARB_fragment_program := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program');
+  GL_ARB_imaging := Int_CheckExtension(Buffer, 'GL_ARB_imaging');
+  GL_ARB_matrix_palette := Int_CheckExtension(Buffer, 'GL_ARB_matrix_palette');
+  GL_ARB_multisample := Int_CheckExtension(Buffer, 'GL_ARB_multisample');
+  GL_ARB_multitexture := Int_CheckExtension(Buffer, 'GL_ARB_multitexture');
+  GL_ARB_point_parameters := Int_CheckExtension(Buffer, 'GL_ARB_point_parameters');
+  GL_ARB_shadow := Int_CheckExtension(Buffer, 'GL_ARB_shadow');
+  GL_ARB_shadow_ambient := Int_CheckExtension(Buffer, 'GL_ARB_shadow_ambient');
+  GL_ARB_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_ARB_texture_border_clamp');
+  GL_ARB_texture_compression := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression');
+  GL_ARB_texture_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map');
+  GL_ARB_texture_env_add := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_add');
+  GL_ARB_texture_env_combine := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_combine');
+  GL_ARB_texture_env_crossbar := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_crossbar');
+  GL_ARB_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_ARB_texture_env_dot3');
+  GL_ARB_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirrored_repeat');
+  GL_ARB_transpose_matrix := Int_CheckExtension(Buffer, 'GL_ARB_transpose_matrix');
+  GL_ARB_vertex_blend := Int_CheckExtension(Buffer, 'GL_ARB_vertex_blend');
+  GL_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_buffer_object');
+  GL_ARB_vertex_program := Int_CheckExtension(Buffer, 'GL_ARB_vertex_program');
+  GL_ARB_window_pos := Int_CheckExtension(Buffer, 'GL_ARB_window_pos');
+  GL_ARB_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_shader_objects');
+  GL_ARB_vertex_shader := Int_CheckExtension(Buffer, 'GL_ARB_vertex_shader');
+  GL_ARB_fragment_shader := Int_CheckExtension(Buffer, 'GL_ARB_fragment_shader');
+  GL_ARB_occlusion_query := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query');
+  GL_ARB_shading_language_100 := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_100');
+  GL_ARB_point_sprite := Int_CheckExtension(Buffer, 'GL_ARB_point_sprite');
+  GL_ARB_texture_non_power_of_two := Int_CheckExtension(Buffer, 'GL_ARB_texture_non_power_of_two');
+  GL_ARB_fragment_program_shadow := Int_CheckExtension(Buffer, 'GL_ARB_fragment_program_shadow');
+  GL_ARB_draw_buffers := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers');
+  GL_ARB_texture_rectangle := Int_CheckExtension(Buffer, 'GL_ARB_texture_rectangle');
+  GL_ARB_color_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_color_buffer_float');
+  GL_ARB_half_float_pixel := Int_CheckExtension(Buffer, 'GL_ARB_half_float_pixel');
+  GL_ARB_texture_float := Int_CheckExtension(Buffer, 'GL_ARB_texture_float');
+  GL_ARB_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_pixel_buffer_object');
+  GL_ARB_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_ARB_depth_buffer_float');
+  GL_ARB_draw_instanced := Int_CheckExtension(Buffer, 'GL_ARB_draw_instanced');
+  GL_ARB_framebuffer_object := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_object');
+  GL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_sRGB');
+  GL_ARB_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_ARB_geometry_shader4');
+  GL_ARB_half_float_vertex := Int_CheckExtension(Buffer, 'GL_ARB_half_float_vertex');
+  GL_ARB_instanced_arrays := Int_CheckExtension(Buffer, 'GL_ARB_instanced_arrays');
+  GL_ARB_map_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_range');
+  GL_ARB_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object');
+  GL_ARB_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_rgtc');
+  GL_ARB_texture_rg := Int_CheckExtension(Buffer, 'GL_ARB_texture_rg');
+  GL_ARB_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_object');
+  GL_ARB_uniform_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_uniform_buffer_object');
+  GL_ARB_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_compatibility');
+  GL_ARB_copy_buffer := Int_CheckExtension(Buffer, 'GL_ARB_copy_buffer');
+  GL_ARB_shader_texture_lod := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_lod');
+  GL_ARB_depth_clamp := Int_CheckExtension(Buffer, 'GL_ARB_depth_clamp');
+  GL_ARB_draw_elements_base_vertex := Int_CheckExtension(Buffer, 'GL_ARB_draw_elements_base_vertex');
+  GL_ARB_fragment_coord_conventions := Int_CheckExtension(Buffer, 'GL_ARB_fragment_coord_conventions');
+  GL_ARB_provoking_vertex := Int_CheckExtension(Buffer, 'GL_ARB_provoking_vertex');
+  GL_ARB_seamless_cube_map := Int_CheckExtension(Buffer, 'GL_ARB_seamless_cube_map');
+  GL_ARB_sync := Int_CheckExtension(Buffer, 'GL_ARB_sync');
+  GL_ARB_texture_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_multisample');
+  GL_ARB_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_ARB_vertex_array_bgra');
+  GL_ARB_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_ARB_draw_buffers_blend');
+  GL_ARB_sample_shading := Int_CheckExtension(Buffer, 'GL_ARB_sample_shading');
+  GL_ARB_texture_cube_map_array := Int_CheckExtension(Buffer, 'GL_ARB_texture_cube_map_array');
+  GL_ARB_texture_gather := Int_CheckExtension(Buffer, 'GL_ARB_texture_gather');
+  GL_ARB_texture_query_lod := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_lod');
+  GL_ARB_shading_language_include := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_include');
+  GL_ARB_texture_compression_bptc := Int_CheckExtension(Buffer, 'GL_ARB_texture_compression_bptc');
+  GL_ARB_blend_func_extended := Int_CheckExtension(Buffer, 'GL_ARB_blend_func_extended');
+  GL_ARB_explicit_attrib_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_attrib_location');
+  GL_ARB_occlusion_query2 := Int_CheckExtension(Buffer, 'GL_ARB_occlusion_query2');
+  GL_ARB_sampler_objects := Int_CheckExtension(Buffer, 'GL_ARB_sampler_objects');
+  GL_ARB_shader_bit_encoding := Int_CheckExtension(Buffer, 'GL_ARB_shader_bit_encoding');
+  GL_ARB_texture_rgb10_a2ui := Int_CheckExtension(Buffer, 'GL_ARB_texture_rgb10_a2ui');
+  GL_ARB_texture_swizzle := Int_CheckExtension(Buffer, 'GL_ARB_texture_swizzle');
+  GL_ARB_timer_query := Int_CheckExtension(Buffer, 'GL_ARB_timer_query');
+  GL_ARB_vertex_type_2_10_10_10_rev := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_2_10_10_10_rev');
+  GL_ARB_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_draw_indirect');
+  GL_ARB_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader5');
+  GL_ARB_gpu_shader_fp64 := Int_CheckExtension(Buffer, 'GL_ARB_gpu_shader_fp64');
+  GL_ARB_shader_subroutine := Int_CheckExtension(Buffer, 'GL_ARB_shader_subroutine');
+  GL_ARB_tessellation_shader := Int_CheckExtension(Buffer, 'GL_ARB_tessellation_shader');
+  GL_ARB_texture_buffer_object_rgb32 := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_object_rgb32');
+  GL_ARB_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback2');
+  GL_ARB_transform_feedback3 := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback3');
+  GL_ARB_ES2_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES2_compatibility');
+  GL_ARB_get_program_binary := Int_CheckExtension(Buffer, 'GL_ARB_get_program_binary');
+  GL_ARB_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_ARB_separate_shader_objects');
+  GL_ARB_shader_precision := Int_CheckExtension(Buffer, 'GL_ARB_shader_precision');
+  GL_ARB_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_64bit');
+  GL_ARB_viewport_array := Int_CheckExtension(Buffer, 'GL_ARB_viewport_array');
+
+  // GL 4.2
+    GL_ARB_base_instance := Int_CheckExtension(Buffer, 'GL_ARB_base_instance');
+    GL_ARB_shading_language_420pack := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_420pack');
+    GL_ARB_transform_feedback_instanced := Int_CheckExtension(Buffer, 'GL_ARB_transform_feedback_instanced');
+    GL_ARB_compressed_texture_pixel_storage := Int_CheckExtension(Buffer, 'GL_ARB_compressed_texture_pixel_storage');
+    GL_ARB_conservative_depth := Int_CheckExtension(Buffer, 'GL_ARB_conservative_depth');
+    GL_ARB_internalformat_query := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query');
+    GL_ARB_map_buffer_alignment := Int_CheckExtension(Buffer, 'GL_ARB_map_buffer_alignment');
+    GL_ARB_shader_atomic_counters := Int_CheckExtension(Buffer, 'GL_ARB_shader_atomic_counters');
+    GL_ARB_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_load_store');
+    GL_ARB_shading_language_packing := Int_CheckExtension(Buffer, 'GL_ARB_shading_language_packing');
+    GL_ARB_texture_storage := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage');
+  // END GL 4.2
+
+  // GL 4.3
+    GL_ARB_arrays_of_arrays := Int_CheckExtension(Buffer, 'GL_ARB_arrays_of_arrays');
+    GL_ARB_fragment_layer_viewport := Int_CheckExtension(Buffer, 'GL_ARB_fragment_layer_viewport');
+    GL_ARB_shader_image_size := Int_CheckExtension(Buffer, 'GL_ARB_shader_image_size');
+    GL_ARB_ES3_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES3_compatibility');
+    GL_ARB_clear_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_clear_buffer_object');
+    GL_ARB_compute_shader := Int_CheckExtension(Buffer, 'GL_ARB_compute_shader');
+    GL_ARB_copy_image := Int_CheckExtension(Buffer, 'GL_ARB_copy_image');
+    GL_KHR_debug := Int_CheckExtension(Buffer, 'GL_KHR_debug');
+    GL_ARB_explicit_uniform_location := Int_CheckExtension(Buffer, 'GL_ARB_explicit_uniform_location');
+    GL_ARB_framebuffer_no_attachments := Int_CheckExtension(Buffer, 'GL_ARB_framebuffer_no_attachments');
+    GL_ARB_internalformat_query2 := Int_CheckExtension(Buffer, 'GL_ARB_internalformat_query2');
+    GL_ARB_invalidate_subdata := Int_CheckExtension(Buffer, 'GL_ARB_invalidate_subdata');
+    GL_ARB_multi_draw_indirect := Int_CheckExtension(Buffer, 'GL_ARB_multi_draw_indirect');
+    GL_ARB_program_interface_query := Int_CheckExtension(Buffer, 'GL_ARB_program_interface_query');
+    GL_ARB_robust_buffer_access_behavior := Int_CheckExtension(Buffer, 'GL_ARB_robust_buffer_access_behavior');
+    GL_ARB_shader_storage_buffer_object := Int_CheckExtension(Buffer, 'GL_ARB_shader_storage_buffer_object');
+    GL_ARB_stencil_texturing := Int_CheckExtension(Buffer, 'GL_ARB_stencil_texturing');
+    GL_ARB_texture_buffer_range := Int_CheckExtension(Buffer, 'GL_ARB_texture_buffer_range');
+    GL_ARB_texture_query_levels := Int_CheckExtension(Buffer, 'GL_ARB_texture_query_levels');
+    GL_ARB_texture_storage_multisample := Int_CheckExtension(Buffer, 'GL_ARB_texture_storage_multisample');
+    GL_ARB_texture_view := Int_CheckExtension(Buffer, 'GL_ARB_texture_view');
+    GL_ARB_vertex_attrib_binding := Int_CheckExtension(Buffer, 'GL_ARB_vertex_attrib_binding');
+    GL_ARB_cl_event := Int_CheckExtension(Buffer, 'GL_ARB_cl_event');
+    GL_ARB_debug_output := Int_CheckExtension(Buffer, 'GL_ARB_debug_output');
+    GL_ARB_robustness := Int_CheckExtension(Buffer, 'GL_ARB_robustness');
+    GL_ARB_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_ARB_shader_stencil_export');
+  // END GL 4.3
+
+  // GL 4.4
+    GL_ARB_buffer_storage               := Int_CheckExtension(Buffer, 'GL_ARB_buffer_storage');
+    GL_ARB_clear_texture                := Int_CheckExtension(Buffer, 'GL_ARB_clear_texture');
+    GL_ARB_enhanced_layouts             := Int_CheckExtension(Buffer, 'GL_ARB_enhanced_layouts');
+    GL_ARB_multi_bind                   := Int_CheckExtension(Buffer, 'GL_ARB_multi_bind');
+    GL_ARB_query_buffer_object          := Int_CheckExtension(Buffer, 'GL_ARB_query_buffer_object');
+    GL_ARB_texture_mirror_clamp_to_edge := Int_CheckExtension(Buffer, 'GL_ARB_texture_mirror_clamp_to_edge');
+    GL_ARB_texture_stencil8             := Int_CheckExtension(Buffer, 'GL_ARB_texture_stencil8');
+    GL_ARB_vertex_type_10f_11f_11f_rev  := Int_CheckExtension(Buffer, 'GL_ARB_vertex_type_10f_11f_11f_rev');
+  // END GL 4.4
+
+  // === ATI/AMD ================================================================
+  GL_ATI_draw_buffers := Int_CheckExtension(Buffer, 'GL_ATI_draw_buffers');
+  GL_ATI_element_array := Int_CheckExtension(Buffer, 'GL_ATI_element_array');
+  GL_ATI_envmap_bumpmap := Int_CheckExtension(Buffer, 'GL_ATI_envmap_bumpmap');
+  GL_ATI_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_fragment_shader');
+  GL_ATI_map_object_buffer := Int_CheckExtension(Buffer, 'GL_ATI_map_object_buffer');
+  GL_ATI_pn_triangles := Int_CheckExtension(Buffer, 'GL_ATI_pn_triangles');
+  GL_ATI_separate_stencil := Int_CheckExtension(Buffer, 'GL_ATI_separate_stencil');
+  GL_ATI_text_fragment_shader := Int_CheckExtension(Buffer, 'GL_ATI_text_fragment_shader');
+  GL_ATI_texture_env_combine3 := Int_CheckExtension(Buffer, 'GL_ATI_texture_env_combine3');
+  GL_ATI_texture_float := Int_CheckExtension(Buffer, 'GL_ATI_texture_float');
+  GL_ATI_texture_mirror_once := Int_CheckExtension(Buffer, 'GL_ATI_texture_mirror_once');
+  GL_ATI_vertex_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_array_object');
+  GL_ATI_vertex_attrib_array_object := Int_CheckExtension(Buffer, 'GL_ATI_vertex_attrib_array_object');
+  GL_ATI_vertex_streams := Int_CheckExtension(Buffer, 'GL_ATI_vertex_streams');
+  GL_ATI_meminfo := Int_CheckExtension(Buffer, 'GL_ATI_meminfo');
+  GL_AMD_performance_monitor := Int_CheckExtension(Buffer, 'GL_AMD_performance_monitor');
+  GL_AMD_texture_texture4 := Int_CheckExtension(Buffer, 'GL_AMD_texture_texture4');
+  GL_AMD_vertex_shader_tesselator := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_tesselator');
+  GL_AMD_draw_buffers_blend := Int_CheckExtension(Buffer, 'GL_AMD_draw_buffers_blend');
+  GL_AMD_shader_stencil_export := Int_CheckExtension(Buffer, 'GL_AMD_shader_stencil_export');
+  GL_AMD_seamless_cubemap_per_texture := Int_CheckExtension(Buffer, 'GL_AMD_seamless_cubemap_per_texture');
+  GL_AMD_conservative_depth := Int_CheckExtension(Buffer, 'GL_AMD_conservative_depth');
+  GL_AMD_name_gen_delete := Int_CheckExtension(Buffer, 'GL_AMD_name_gen_delete');
+  GL_AMD_debug_output := Int_CheckExtension(Buffer, 'GL_AMD_debug_output');
+  GL_AMD_transform_feedback3_lines_triangles := Int_CheckExtension(Buffer, 'GL_AMD_transform_feedback3_lines_triangles');
+  GL_AMD_depth_clamp_separate := Int_CheckExtension(Buffer, 'GL_AMD_depth_clamp_separate');
+  // 4.3
+  GL_AMD_pinned_memory := Int_CheckExtension(Buffer, 'GL_AMD_pinned_memory');
+  GL_AMD_stencil_operation_extended := Int_CheckExtension(Buffer, 'GL_AMD_stencil_operation_extended');
+  GL_AMD_vertex_shader_viewport_index := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_viewport_index');
+  GL_AMD_vertex_shader_layer := Int_CheckExtension(Buffer, 'GL_AMD_vertex_shader_layer');
+       GL_AMD_query_buffer_object := Int_CheckExtension(Buffer, 'GL_AMD_query_buffer_object');
+
+  // === EXT =====================================================================
+  GL_EXT_422_pixels := Int_CheckExtension(Buffer, 'GL_EXT_422_pixels');
+  GL_EXT_abgr := Int_CheckExtension(Buffer, 'GL_EXT_abgr');
+  GL_EXT_bgra := Int_CheckExtension(Buffer, 'GL_EXT_bgra');
+  GL_EXT_blend_color := Int_CheckExtension(Buffer, 'GL_EXT_blend_color');
+  GL_EXT_blend_func_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_func_separate');
+  GL_EXT_blend_logic_op := Int_CheckExtension(Buffer, 'GL_EXT_blend_logic_op');
+  GL_EXT_blend_minmax := Int_CheckExtension(Buffer, 'GL_EXT_blend_minmax');
+  GL_EXT_blend_subtract := Int_CheckExtension(Buffer, 'GL_EXT_blend_subtract');
+  GL_EXT_clip_volume_hint := Int_CheckExtension(Buffer, 'GL_EXT_clip_volume_hint');
+  GL_EXT_cmyka := Int_CheckExtension(Buffer, 'GL_EXT_cmyka');
+  GL_EXT_color_matrix := Int_CheckExtension(Buffer, 'GL_EXT_color_matrix');
+  GL_EXT_color_subtable := Int_CheckExtension(Buffer, 'GL_EXT_color_subtable');
+  GL_EXT_compiled_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_compiled_vertex_array');
+  GL_EXT_convolution := Int_CheckExtension(Buffer, 'GL_EXT_convolution');
+  GL_EXT_coordinate_frame := Int_CheckExtension(Buffer, 'GL_EXT_coordinate_frame');
+  GL_EXT_copy_texture := Int_CheckExtension(Buffer, 'GL_EXT_copy_texture');
+  GL_EXT_cull_vertex := Int_CheckExtension(Buffer, 'GL_EXT_cull_vertex');
+  GL_EXT_draw_range_elements := Int_CheckExtension(Buffer, 'GL_EXT_draw_range_elements');
+  GL_EXT_fog_coord := Int_CheckExtension(Buffer, 'GL_EXT_fog_coord');
+  GL_EXT_framebuffer_object := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_object');
+  GL_EXT_histogram := Int_CheckExtension(Buffer, 'GL_EXT_histogram');
+  GL_EXT_index_array_formats := Int_CheckExtension(Buffer, 'GL_EXT_index_array_formats');
+  GL_EXT_index_func := Int_CheckExtension(Buffer, 'GL_EXT_index_func');
+  GL_EXT_index_material := Int_CheckExtension(Buffer, 'GL_EXT_index_material');
+  GL_EXT_index_texture := Int_CheckExtension(Buffer, 'GL_EXT_index_texture');
+  GL_EXT_light_texture := Int_CheckExtension(Buffer, 'GL_EXT_light_texture');
+  GL_EXT_misc_attribute := Int_CheckExtension(Buffer, 'GL_EXT_misc_attribute');
+  GL_EXT_multi_draw_arrays := Int_CheckExtension(Buffer, 'GL_EXT_multi_draw_arrays');
+  GL_EXT_multisample := Int_CheckExtension(Buffer, 'GL_EXT_multisample');
+  GL_EXT_packed_pixels := Int_CheckExtension(Buffer, 'GL_EXT_packed_pixels');
+  GL_EXT_paletted_texture := Int_CheckExtension(Buffer, 'GL_EXT_paletted_texture');
+  GL_EXT_pixel_transform := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform');
+  GL_EXT_pixel_transform_color_table := Int_CheckExtension(Buffer, 'GL_EXT_pixel_transform_color_table');
+  GL_EXT_point_parameters := Int_CheckExtension(Buffer, 'GL_EXT_point_parameters');
+  GL_EXT_polygon_offset := Int_CheckExtension(Buffer, 'GL_EXT_polygon_offset');
+  GL_EXT_rescale_normal := Int_CheckExtension(Buffer, 'GL_EXT_rescale_normal');
+  GL_EXT_secondary_color := Int_CheckExtension(Buffer, 'GL_EXT_secondary_color');
+  GL_EXT_separate_specular_color := Int_CheckExtension(Buffer, 'GL_EXT_separate_specular_color');
+  GL_EXT_shadow_funcs := Int_CheckExtension(Buffer, 'GL_EXT_shadow_funcs');
+  GL_EXT_shared_texture_palette := Int_CheckExtension(Buffer, 'GL_EXT_shared_texture_palette');
+  GL_EXT_stencil_two_side := Int_CheckExtension(Buffer, 'GL_EXT_stencil_two_side');
+  GL_EXT_stencil_wrap := Int_CheckExtension(Buffer, 'GL_EXT_stencil_wrap');
+  GL_EXT_subtexture := Int_CheckExtension(Buffer, 'GL_EXT_subtexture');
+  GL_EXT_texture := Int_CheckExtension(Buffer, 'GL_EXT_texture');
+  GL_EXT_texture3D := Int_CheckExtension(Buffer, 'GL_EXT_texture3D');
+  GL_EXT_texture_compression_s3tc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_s3tc');
+  GL_EXT_texture_cube_map := Int_CheckExtension(Buffer, 'GL_EXT_texture_cube_map');
+  GL_EXT_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_edge_clamp');
+  GL_EXT_texture_env_add := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_add');
+  GL_EXT_texture_env_combine := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_combine');
+  GL_EXT_texture_env_dot3 := Int_CheckExtension(Buffer, 'GL_EXT_texture_env_dot3');
+  GL_EXT_texture_filter_anisotropic := Int_CheckExtension(Buffer, 'GL_EXT_texture_filter_anisotropic');
+  GL_EXT_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_EXT_texture_lod_bias');
+  GL_EXT_texture_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_object');
+  GL_EXT_texture_perturb_normal := Int_CheckExtension(Buffer, 'GL_EXT_texture_perturb_normal');
+  GL_EXT_texture_rectangle := Int_CheckExtension(Buffer, 'GL_EXT_texture_rectangle');
+  GL_EXT_vertex_array := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array');
+  GL_EXT_vertex_shader := Int_CheckExtension(Buffer, 'GL_EXT_vertex_shader');
+  GL_EXT_vertex_weighting := Int_CheckExtension(Buffer, 'GL_EXT_vertex_weighting');
+  GL_EXT_depth_bounds_test := Int_CheckExtension(Buffer, 'GL_EXT_depth_bounds_test');
+  GL_EXT_texture_mirror_clamp := Int_CheckExtension(Buffer, 'GL_EXT_texture_mirror_clamp');
+  GL_EXT_blend_equation_separate := Int_CheckExtension(Buffer, 'GL_EXT_blend_equation_separate');
+  GL_EXT_pixel_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_pixel_buffer_object');
+  GL_EXT_texture_compression_dxt1 := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_dxt1');
+  GL_EXT_stencil_clear_tag := Int_CheckExtension(Buffer, 'GL_EXT_stencil_clear_tag');
+  GL_EXT_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_EXT_packed_depth_stencil');
+  GL_EXT_texture_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB');
+  GL_EXT_framebuffer_blit := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_blit');
+  GL_EXT_framebuffer_multisample := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_multisample');
+  GL_EXT_timer_query := Int_CheckExtension(Buffer, 'GL_EXT_timer_query');
+  GL_EXT_gpu_program_parameters := Int_CheckExtension(Buffer, 'GL_EXT_gpu_program_parameters');
+  GL_EXT_bindable_uniform := Int_CheckExtension(Buffer, 'GL_EXT_bindable_uniform');
+  GL_EXT_draw_buffers2 := Int_CheckExtension(Buffer, 'GL_EXT_draw_buffers2');
+  GL_EXT_draw_instanced := Int_CheckExtension(Buffer, 'GL_EXT_draw_instanced');
+  GL_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GL_EXT_framebuffer_sRGB');
+  GL_EXT_geometry_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_geometry_shader4');
+  GL_EXT_gpu_shader4 := Int_CheckExtension(Buffer, 'GL_EXT_gpu_shader4');
+  GL_EXT_packed_float := Int_CheckExtension(Buffer, 'GL_EXT_packed_float');
+  GL_EXT_texture_array := Int_CheckExtension(Buffer, 'GL_EXT_texture_array');
+  GL_EXT_texture_buffer_object := Int_CheckExtension(Buffer, 'GL_EXT_texture_buffer_object');
+  GL_EXT_texture_compression_latc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_latc');
+  GL_EXT_texture_compression_rgtc := Int_CheckExtension(Buffer, 'GL_EXT_texture_compression_rgtc');
+  GL_EXT_texture_integer := Int_CheckExtension(Buffer, 'GL_EXT_texture_integer');
+  GL_EXT_texture_shared_exponent := Int_CheckExtension(Buffer, 'GL_EXT_texture_shared_exponent');
+  GL_EXT_transform_feedback := Int_CheckExtension(Buffer, 'GL_EXT_transform_feedback');
+  GL_EXT_direct_state_access := Int_CheckExtension(Buffer, 'GL_EXT_direct_state_access');
+  GL_EXT_vertex_array_bgra := Int_CheckExtension(Buffer, 'GL_EXT_vertex_array_bgra');
+  GL_EXT_texture_swizzle := Int_CheckExtension(Buffer, 'GL_EXT_texture_swizzle');
+  GL_EXT_provoking_vertex := Int_CheckExtension(Buffer, 'GL_EXT_provoking_vertex');
+  GL_EXT_texture_snorm := Int_CheckExtension(Buffer, 'GL_EXT_texture_snorm');
+  GL_EXT_separate_shader_objects := Int_CheckExtension(Buffer, 'GL_EXT_separate_shader_objects');
+  GL_EXT_shader_image_load_store := Int_CheckExtension(Buffer, 'GL_EXT_shader_image_load_store');
+  GL_EXT_vertex_attrib_64bit := Int_CheckExtension(Buffer, 'GL_EXT_vertex_attrib_64bit');
+  GL_EXT_texture_sRGB_decode := Int_CheckExtension(Buffer, 'GL_EXT_texture_sRGB_decode');
+  
+  // === HP ======================================================================
+  GL_HP_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_HP_convolution_border_modes');
+  GL_HP_image_transform := Int_CheckExtension(Buffer, 'GL_HP_image_transform');
+  GL_HP_occlusion_test := Int_CheckExtension(Buffer, 'GL_HP_occlusion_test');
+  GL_HP_texture_lighting := Int_CheckExtension(Buffer, 'GL_HP_texture_lighting');
+
+  // === IBM =====================================================================
+  GL_IBM_cull_vertex := Int_CheckExtension(Buffer, 'GL_IBM_cull_vertex');
+  GL_IBM_multimode_draw_arrays := Int_CheckExtension(Buffer, 'GL_IBM_multimode_draw_arrays');
+  GL_IBM_rasterpos_clip := Int_CheckExtension(Buffer, 'GL_IBM_rasterpos_clip');
+  GL_IBM_texture_mirrored_repeat := Int_CheckExtension(Buffer, 'GL_IBM_texture_mirrored_repeat');
+  GL_IBM_vertex_array_lists := Int_CheckExtension(Buffer, 'GL_IBM_vertex_array_lists');
+
+  // === INGR ====================================================================
+  GL_INGR_blend_func_separate := Int_CheckExtension(Buffer, 'GL_INGR_blend_func_separate');
+  GL_INGR_color_clamp := Int_CheckExtension(Buffer, 'GL_INGR_color_clamp');
+  GL_INGR_interlace_read := Int_CheckExtension(Buffer, 'GL_INGR_interlace_read');
+  GL_INGR_palette_buffer := Int_CheckExtension(Buffer, 'GL_INGR_palette_buffer');
+
+  // === INTEL ===================================================================
+  GL_INTEL_parallel_arrays := Int_CheckExtension(Buffer, 'GL_INTEL_parallel_arrays');
+  GL_INTEL_texture_scissor := Int_CheckExtension(Buffer, 'GL_INTEL_texture_scissor');
+
+  // === MESA ====================================================================
+  GL_MESA_resize_buffers := Int_CheckExtension(Buffer, 'GL_MESA_resize_buffers');
+  GL_MESA_window_pos := Int_CheckExtension(Buffer, 'GL_MESA_window_pos');
+
+  // === NVIDIA ==================================================================
+  GL_NV_blend_square := Int_CheckExtension(Buffer, 'GL_NV_blend_square');
+  GL_NV_copy_depth_to_color := Int_CheckExtension(Buffer, 'GL_NV_copy_depth_to_color');
+  GL_NV_depth_clamp := Int_CheckExtension(Buffer, 'GL_NV_depth_clamp');
+  GL_NV_evaluators := Int_CheckExtension(Buffer, 'GL_NV_evaluators');
+  GL_NV_fence := Int_CheckExtension(Buffer, 'GL_NV_fence');
+  GL_NV_float_buffer := Int_CheckExtension(Buffer, 'GL_NV_float_buffer');
+  GL_NV_fog_distance := Int_CheckExtension(Buffer, 'GL_NV_fog_distance');
+  GL_NV_fragment_program := Int_CheckExtension(Buffer, 'GL_NV_fragment_program');
+  GL_NV_half_float := Int_CheckExtension(Buffer, 'GL_NV_half_float');
+  GL_NV_light_max_exponent := Int_CheckExtension(Buffer, 'GL_NV_light_max_exponent');
+  GL_NV_multisample_filter_hint := Int_CheckExtension(Buffer, 'GL_NV_multisample_filter_hint');
+  GL_NV_occlusion_query := Int_CheckExtension(Buffer, 'GL_NV_occlusion_query');
+  GL_NV_packed_depth_stencil := Int_CheckExtension(Buffer, 'GL_NV_packed_depth_stencil');
+  GL_NV_pixel_data_range := Int_CheckExtension(Buffer, 'GL_NV_pixel_data_range');
+  GL_NV_point_sprite := Int_CheckExtension(Buffer, 'GL_NV_point_sprite');
+  GL_NV_primitive_restart := Int_CheckExtension(Buffer, 'GL_NV_primitive_restart');
+  GL_NV_register_combiners := Int_CheckExtension(Buffer, 'GL_NV_register_combiners');
+  GL_NV_register_combiners2 := Int_CheckExtension(Buffer, 'GL_NV_register_combiners2');
+  GL_NV_texgen_emboss := Int_CheckExtension(Buffer, 'GL_NV_texgen_emboss');
+  GL_NV_texgen_reflection := Int_CheckExtension(Buffer, 'GL_NV_texgen_reflection');
+  GL_NV_texture_compression_vtc := Int_CheckExtension(Buffer, 'GL_NV_texture_compression_vtc');
+  GL_NV_texture_env_combine4 := Int_CheckExtension(Buffer, 'GL_NV_texture_env_combine4');
+  GL_NV_texture_expand_normal := Int_CheckExtension(Buffer, 'GL_NV_texture_expand_normal');
+  GL_NV_texture_rectangle := Int_CheckExtension(Buffer, 'GL_NV_texture_rectangle');
+  GL_NV_texture_shader := Int_CheckExtension(Buffer, 'GL_NV_texture_shader');
+  GL_NV_texture_shader2 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader2');
+  GL_NV_texture_shader3 := Int_CheckExtension(Buffer, 'GL_NV_texture_shader3');
+  GL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range');
+  GL_NV_vertex_array_range2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_array_range2');
+  GL_NV_vertex_program := Int_CheckExtension(Buffer, 'GL_NV_vertex_program');
+  GL_NV_vertex_program1_1 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program1_1');
+  GL_NV_vertex_program2 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2');
+  GL_NV_fragment_program_option := Int_CheckExtension(Buffer, 'GL_NV_fragment_program_option');
+  GL_NV_fragment_program2 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program2');
+  GL_NV_vertex_program2_option := Int_CheckExtension(Buffer, 'GL_NV_vertex_program2_option');
+  GL_NV_vertex_program3 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program3');
+  GL_NV_depth_buffer_float := Int_CheckExtension(Buffer, 'GL_NV_depth_buffer_float');
+  GL_NV_fragment_program4 := Int_CheckExtension(Buffer, 'GL_NV_fragment_program4');
+  GL_NV_framebuffer_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_framebuffer_multisample_coverage');
+  GL_NV_geometry_program4 := Int_CheckExtension(Buffer, 'GL_NV_geometry_program4');
+  GL_NV_gpu_program4 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program4');
+  GL_NV_parameter_buffer_object := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object');
+  GL_NV_transform_feedback := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback');
+  GL_NV_vertex_program4 := Int_CheckExtension(Buffer, 'GL_NV_vertex_program4');
+  GL_NV_conditional_render := Int_CheckExtension(Buffer, 'GL_NV_conditional_render');
+  GL_NV_present_video := Int_CheckExtension(Buffer, 'GL_NV_present_video');
+  GL_NV_explicit_multisample := Int_CheckExtension(Buffer, 'GL_NV_explicit_multisample');
+  GL_NV_transform_feedback2 := Int_CheckExtension(Buffer, 'GL_NV_transform_feedback2');
+  GL_NV_video_capture := Int_CheckExtension(Buffer, 'GL_NV_video_capture');
+  GL_NV_copy_image := Int_CheckExtension(Buffer, 'GL_NV_copy_image');
+  GL_NV_parameter_buffer_object2 := Int_CheckExtension(Buffer, 'GL_NV_parameter_buffer_object2');
+  GL_NV_shader_buffer_load := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_load');
+  GL_NV_vertex_buffer_unified_memory := Int_CheckExtension(Buffer, 'GL_NV_vertex_buffer_unified_memory');
+  GL_NV_gpu_program5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_program5');
+  GL_NV_gpu_shader5 := Int_CheckExtension(Buffer, 'GL_NV_gpu_shader5');
+  GL_NV_shader_buffer_store := Int_CheckExtension(Buffer, 'GL_NV_shader_buffer_store');
+  GL_NV_tessellation_program5 := Int_CheckExtension(Buffer, 'GL_NV_tessellation_program5');
+  GL_NV_vertex_attrib_integer_64bit := Int_CheckExtension(Buffer, 'GL_NV_vertex_attrib_integer_64bit');
+  GL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'GL_NV_multisample_coverage');
+  GL_NV_vdpau_interop := Int_CheckExtension(Buffer, 'GL_NV_vdpau_interop');
+  GL_NV_texture_barrier := Int_CheckExtension(Buffer, 'GL_NV_texture_barrier');
+  // 4.3
+       GL_NV_path_rendering := Int_CheckExtension(Buffer, 'GL_NV_path_rendering');
+  GL_NV_bindless_texture := Int_CheckExtension(Buffer, 'GL_NV_bindless_texture');
+       GL_NV_shader_atomic_float := Int_CheckExtension(Buffer, 'GL_NV_shader_atomic_float');
+
+  // === OML =====================================================================
+  GL_OML_interlace := Int_CheckExtension(Buffer, 'GL_OML_interlace');
+  GL_OML_resample := Int_CheckExtension(Buffer, 'GL_OML_resample');
+  GL_OML_subsample := Int_CheckExtension(Buffer, 'GL_OML_subsample');
+
+  // === PGI =====================================================================
+  GL_PGI_misc_hints := Int_CheckExtension(Buffer, 'GL_PGI_misc_hints');
+  GL_PGI_vertex_hints := Int_CheckExtension(Buffer, 'GL_PGI_vertex_hints');
+
+  // === REND ====================================================================
+  GL_REND_screen_coordinates := Int_CheckExtension(Buffer, 'GL_REND_screen_coordinates');
+
+  // === S3 ======================================================================
+  GL_S3_s3tc := Int_CheckExtension(Buffer, 'GL_S3_s3tc');
+
+  // === SGIS ====================================================================
+  GL_SGIS_detail_texture := Int_CheckExtension(Buffer, 'GL_SGIS_detail_texture');
+  GL_SGIS_fog_function := Int_CheckExtension(Buffer, 'GL_SGIS_fog_function');
+  GL_SGIS_generate_mipmap := Int_CheckExtension(Buffer, 'GL_SGIS_generate_mipmap');
+  GL_SGIS_multisample := Int_CheckExtension(Buffer, 'GL_SGIS_multisample');
+  GL_SGIS_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIS_pixel_texture');
+  GL_SGIS_point_line_texgen := Int_CheckExtension(Buffer, 'GL_SGIS_point_line_texgen');
+  GL_SGIS_point_parameters := Int_CheckExtension(Buffer, 'GL_SGIS_point_parameters');
+  GL_SGIS_sharpen_texture := Int_CheckExtension(Buffer, 'GL_SGIS_sharpen_texture');
+  GL_SGIS_texture4D := Int_CheckExtension(Buffer, 'GL_SGIS_texture4D');
+  GL_SGIS_texture_border_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_border_clamp');
+  GL_SGIS_texture_color_mask := Int_CheckExtension(Buffer, 'GL_SGIS_texture_color_mask');
+  GL_SGIS_texture_edge_clamp := Int_CheckExtension(Buffer, 'GL_SGIS_texture_edge_clamp');
+  GL_SGIS_texture_filter4 := Int_CheckExtension(Buffer, 'GL_SGIS_texture_filter4');
+  GL_SGIS_texture_lod := Int_CheckExtension(Buffer, 'GL_SGIS_texture_lod');
+  GL_SGIS_texture_select := Int_CheckExtension(Buffer, 'GL_SGIS_texture_select');
+
+  // === SGIX ====================================================================
+  GL_FfdMaskSGIX := Int_CheckExtension(Buffer, 'GL_FfdMaskSGIX');
+  GL_SGIX_async := Int_CheckExtension(Buffer, 'GL_SGIX_async');
+  GL_SGIX_async_histogram := Int_CheckExtension(Buffer, 'GL_SGIX_async_histogram');
+  GL_SGIX_async_pixel := Int_CheckExtension(Buffer, 'GL_SGIX_async_pixel');
+  GL_SGIX_blend_alpha_minmax := Int_CheckExtension(Buffer, 'GL_SGIX_blend_alpha_minmax');
+  GL_SGIX_calligraphic_fragment := Int_CheckExtension(Buffer, 'GL_SGIX_calligraphic_fragment');
+  GL_SGIX_clipmap := Int_CheckExtension(Buffer, 'GL_SGIX_clipmap');
+  GL_SGIX_convolution_accuracy := Int_CheckExtension(Buffer, 'GL_SGIX_convolution_accuracy');
+  GL_SGIX_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGIX_depth_pass_instrument');
+  GL_SGIX_depth_texture := Int_CheckExtension(Buffer, 'GL_SGIX_depth_texture');
+  GL_SGIX_flush_raster := Int_CheckExtension(Buffer, 'GL_SGIX_flush_raster');
+  GL_SGIX_fog_offset := Int_CheckExtension(Buffer, 'GL_SGIX_fog_offset');
+  GL_SGIX_fog_scale := Int_CheckExtension(Buffer, 'GL_SGIX_fog_scale');
+  GL_SGIX_fragment_lighting := Int_CheckExtension(Buffer, 'GL_SGIX_fragment_lighting');
+  GL_SGIX_framezoom := Int_CheckExtension(Buffer, 'GL_SGIX_framezoom');
+  GL_SGIX_igloo_interface := Int_CheckExtension(Buffer, 'GL_SGIX_igloo_interface');
+  GL_SGIX_impact_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_impact_pixel_texture');
+  GL_SGIX_instruments := Int_CheckExtension(Buffer, 'GL_SGIX_instruments');
+  GL_SGIX_interlace := Int_CheckExtension(Buffer, 'GL_SGIX_interlace');
+  GL_SGIX_ir_instrument1 := Int_CheckExtension(Buffer, 'GL_SGIX_ir_instrument1');
+  GL_SGIX_list_priority := Int_CheckExtension(Buffer, 'GL_SGIX_list_priority');
+  GL_SGIX_pixel_texture := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_texture');
+  GL_SGIX_pixel_tiles := Int_CheckExtension(Buffer, 'GL_SGIX_pixel_tiles');
+  GL_SGIX_polynomial_ffd := Int_CheckExtension(Buffer, 'GL_SGIX_polynomial_ffd');
+  GL_SGIX_reference_plane := Int_CheckExtension(Buffer, 'GL_SGIX_reference_plane');
+  GL_SGIX_resample := Int_CheckExtension(Buffer, 'GL_SGIX_resample');
+  GL_SGIX_scalebias_hint := Int_CheckExtension(Buffer, 'GL_SGIX_scalebias_hint');
+  GL_SGIX_shadow := Int_CheckExtension(Buffer, 'GL_SGIX_shadow');
+  GL_SGIX_shadow_ambient := Int_CheckExtension(Buffer, 'GL_SGIX_shadow_ambient');
+  GL_SGIX_sprite := Int_CheckExtension(Buffer, 'GL_SGIX_sprite');
+  GL_SGIX_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_subsample');
+  GL_SGIX_tag_sample_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_tag_sample_buffer');
+  GL_SGIX_texture_add_env := Int_CheckExtension(Buffer, 'GL_SGIX_texture_add_env');
+  GL_SGIX_texture_coordinate_clamp := Int_CheckExtension(Buffer, 'GL_SGIX_texture_coordinate_clamp');
+  GL_SGIX_texture_lod_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_lod_bias');
+  GL_SGIX_texture_multi_buffer := Int_CheckExtension(Buffer, 'GL_SGIX_texture_multi_buffer');
+  GL_SGIX_texture_scale_bias := Int_CheckExtension(Buffer, 'GL_SGIX_texture_scale_bias');
+  GL_SGIX_texture_select := Int_CheckExtension(Buffer, 'GL_SGIX_texture_select');
+  GL_SGIX_vertex_preclip := Int_CheckExtension(Buffer, 'GL_SGIX_vertex_preclip');
+  GL_SGIX_ycrcb := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb');
+  GL_SGIX_ycrcb_subsample := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcb_subsample');
+  GL_SGIX_ycrcba := Int_CheckExtension(Buffer, 'GL_SGIX_ycrcba');
+
+  // === SGI =====================================================================
+  GL_SGI_color_matrix := Int_CheckExtension(Buffer, 'GL_SGI_color_matrix');
+  GL_SGI_color_table := Int_CheckExtension(Buffer, 'GL_SGI_color_table');
+  GL_SGI_depth_pass_instrument := Int_CheckExtension(Buffer, 'GL_SGI_depth_pass_instrument');
+  GL_SGI_texture_color_table := Int_CheckExtension(Buffer, 'GL_SGI_texture_color_table');
+
+  // === SUN =====================================================================
+  GL_SUNX_constant_data := Int_CheckExtension(Buffer, 'GL_SUNX_constant_data');
+  GL_SUN_convolution_border_modes := Int_CheckExtension(Buffer, 'GL_SUN_convolution_border_modes');
+  GL_SUN_global_alpha := Int_CheckExtension(Buffer, 'GL_SUN_global_alpha');
+  GL_SUN_mesh_array := Int_CheckExtension(Buffer, 'GL_SUN_mesh_array');
+  GL_SUN_slice_accum := Int_CheckExtension(Buffer, 'GL_SUN_slice_accum');
+  GL_SUN_triangle_list := Int_CheckExtension(Buffer, 'GL_SUN_triangle_list');
+  GL_SUN_vertex := Int_CheckExtension(Buffer, 'GL_SUN_vertex');
+
+  // === WIN =====================================================================
+  GL_WIN_phong_shading := Int_CheckExtension(Buffer, 'GL_WIN_phong_shading');
+  GL_WIN_specular_fog := Int_CheckExtension(Buffer, 'GL_WIN_specular_fog');
+
+  {$IFDEF DGL_WIN}
+  // === WGL =====================================================================
+  WGL_3DFX_multisample := Int_CheckExtension(Buffer, 'WGL_3DFX_multisample');
+  WGL_ARB_buffer_region := Int_CheckExtension(Buffer, 'WGL_ARB_buffer_region');
+  WGL_ARB_extensions_string := Int_CheckExtension(Buffer, 'WGL_ARB_extensions_string');
+  WGL_ARB_make_current_read := Int_CheckExtension(Buffer, 'WGL_ARB_make_current_read');
+  WGL_ARB_multisample := Int_CheckExtension(Buffer, 'WGL_ARB_multisample');
+  WGL_ARB_pbuffer := Int_CheckExtension(Buffer, 'WGL_ARB_pbuffer');
+  WGL_ARB_pixel_format := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format');
+  WGL_ARB_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ARB_pixel_format_float');
+  WGL_ARB_render_texture := Int_CheckExtension(Buffer, 'WGL_ARB_render_texture');
+  WGL_ARB_create_context := Int_CheckExtension(Buffer, 'WGL_ARB_create_context');
+  WGL_ARB_create_context_profile := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_profile');
+  WGL_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'WGL_ARB_framebuffer_sRGB');
+  WGL_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'WGL_ARB_create_context_robustness');
+  WGL_ATI_pixel_format_float := Int_CheckExtension(Buffer, 'WGL_ATI_pixel_format_float');
+  WGL_AMD_gpu_association := Int_CheckExtension(Buffer, 'WGL_AMD_gpu_association');
+  WGL_EXT_depth_float := Int_CheckExtension(Buffer, 'WGL_EXT_depth_float');
+  WGL_EXT_display_color_table := Int_CheckExtension(Buffer, 'WGL_EXT_display_color_table');
+  WGL_EXT_extensions_string := Int_CheckExtension(Buffer, 'WGL_EXT_extensions_string');
+  WGL_EXT_make_current_read := Int_CheckExtension(Buffer, 'WGL_EXT_make_current_read');
+  WGL_EXT_multisample := Int_CheckExtension(Buffer, 'WGL_EXT_multisample');
+  WGL_EXT_pbuffer := Int_CheckExtension(Buffer, 'WGL_EXT_pbuffer');
+  WGL_EXT_pixel_format := Int_CheckExtension(Buffer, 'WGL_EXT_pixel_format');
+  WGL_EXT_swap_control := Int_CheckExtension(Buffer, 'WGL_EXT_swap_control');
+  WGL_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'WGL_EXT_create_context_es2_profile');
+  WGL_I3D_digital_video_control := Int_CheckExtension(Buffer, 'WGL_I3D_digital_video_control');
+  WGL_I3D_gamma := Int_CheckExtension(Buffer, 'WGL_I3D_gamma');
+  WGL_I3D_genlock := Int_CheckExtension(Buffer, 'WGL_I3D_genlock');
+  WGL_I3D_image_buffer := Int_CheckExtension(Buffer, 'WGL_I3D_image_buffer');
+  WGL_I3D_swap_frame_lock := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_lock');
+  WGL_I3D_swap_frame_usage := Int_CheckExtension(Buffer, 'WGL_I3D_swap_frame_usage');
+  WGL_NV_float_buffer := Int_CheckExtension(Buffer, 'WGL_NV_float_buffer');
+  WGL_NV_render_depth_texture := Int_CheckExtension(Buffer, 'WGL_NV_render_depth_texture');
+  WGL_NV_render_texture_rectangle := Int_CheckExtension(Buffer, 'WGL_NV_render_texture_rectangle');
+  WGL_NV_vertex_array_range := Int_CheckExtension(Buffer, 'WGL_NV_vertex_array_range');
+  WGL_NV_present_video := Int_CheckExtension(Buffer, 'WGL_NV_present_video');
+  WGL_NV_video_output := Int_CheckExtension(Buffer, 'WGL_NV_video_output');
+  WGL_NV_swap_group := Int_CheckExtension(Buffer, 'WGL_NV_swap_group');
+  WGL_NV_gpu_affinity := Int_CheckExtension(Buffer, 'WGL_NV_gpu_affinity');
+  WGL_NV_video_capture := Int_CheckExtension(Buffer, 'WGL_NV_video_capture');
+  WGL_NV_copy_image := Int_CheckExtension(Buffer, 'WGL_NV_copy_image');
+  WGL_NV_multisample_coverage := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage');
+  WGL_NV_DX_interop := Int_CheckExtension(Buffer, 'WGL_NV_multisample_coverage');
+  WGL_OML_sync_control := Int_CheckExtension(Buffer, 'WGL_OML_sync_control');
+  WGL_3DL_stereo_control := Int_CheckExtension(Buffer, 'WGL_3DL_stereo_control');
+
+  WIN_draw_range_elements := Int_CheckExtension(Buffer, 'WIN_draw_range_elements');
+  WIN_swap_hint := Int_CheckExtension(Buffer, 'WIN_swap_hint');
+  {$ENDIF}
+
+  {$IFDEF DGL_LINUX}
+  // === GLX =====================================================================
+  GLX_ARB_multisample := Int_CheckExtension(Buffer, 'GLX_ARB_multisample');
+  GLX_ARB_fbconfig_float := Int_CheckExtension(Buffer, 'GLX_ARB_fbconfig_float');
+  GLX_ARB_get_proc_address := Int_CheckExtension(Buffer, 'GLX_ARB_get_proc_address');
+  GLX_ARB_create_context := Int_CheckExtension(Buffer, 'GLX_ARB_create_context');
+  GLX_ARB_create_context_profile := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_profile');
+  GLX_ARB_vertex_buffer_object := Int_CheckExtension(Buffer, 'GLX_ARB_vertex_buffer_object');
+  GLX_ARB_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_ARB_framebuffer_sRGB');
+  GLX_ARB_create_context_robustness := Int_CheckExtension(Buffer, 'GLX_ARB_create_context_robustness');
+  GLX_EXT_visual_info := Int_CheckExtension(Buffer, 'GLX_EXT_visual_info');
+  GLX_EXT_visual_rating := Int_CheckExtension(Buffer, 'GLX_EXT_visual_rating');
+  GLX_EXT_import_context := Int_CheckExtension(Buffer, 'GLX_EXT_import_context');
+  GLX_EXT_fbconfig_packed_float := Int_CheckExtension(Buffer, 'GLX_EXT_fbconfig_packed_float');
+  GLX_EXT_framebuffer_sRGB := Int_CheckExtension(Buffer, 'GLX_EXT_framebuffer_sRGB');
+  GLX_EXT_texture_from_pixmap := Int_CheckExtension(Buffer, 'GLX_EXT_texture_from_pixmap');
+  GLX_EXT_swap_control := Int_CheckExtension(Buffer, 'GLX_EXT_swap_control');
+  GLX_EXT_create_context_es2_profile := Int_CheckExtension(Buffer, 'GLX_EXT_create_context_es2_profile');
+  {$ENDIF}
+  ImplementationRead := True;
+end;
+
+{$IFDEF DGL_WIN}
+// =============================================================================
+// RaiseLastOSError
+// =============================================================================
+// Needed for compatibility with older Delphiversions
+// =============================================================================
+
+procedure RaiseLastOSError;
+begin
+{$IFDEF FPC}
+  raise Exception.Create('RaiseLastOSError!'); // To-Do: find a better solution
+{$ELSE}
+  {$IFDEF DELPHI6_AND_DOWN} // If Delphi 6 or later
+    SysUtils.RaiseLastWin32Error;
+  {$ELSE}
+    SysUtils.RaiseLastOSError;
+  {$ENDIF}
+{$ENDIF}
+end;
+
+// =============================================================================
+// CreateRenderingContext
+// =============================================================================
+
+function CreateRenderingContext(DC: HDC; Options: TRCOptions; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
+const
+  OBJ_MEMDC = 10;
+  OBJ_ENHMETADC = 12;
+  OBJ_METADC = 4;
+  PFD_DOUBLEBUFFER = $00000001;
+  PFD_STEREO = $00000002;
+  PFD_DRAW_TO_WINDOW = $00000004;
+  PFD_DRAW_TO_BITMAP = $00000008;
+  PFD_SUPPORT_GDI = $00000010;
+  PFD_SUPPORT_OPENGL = $00000020;
+  PFD_TYPE_RGBA = 0;
+  PFD_MAIN_PLANE = 0;
+  PFD_OVERLAY_PLANE = 1;
+  PFD_UNDERLAY_PLANE = LongWord(-1);
+  MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
+var
+  PFDescriptor: TPixelFormatDescriptor;
+  PixelFormat: Integer;
+  AType: DWORD;
+begin
+  if GL_LibHandle = nil then
+    InitOpenGL;
+
+  FillChar(PFDescriptor, SizeOf(PFDescriptor), 0);
+
+  with PFDescriptor do
+  begin
+    nSize := SizeOf(PFDescriptor);
+    nVersion := 1;
+    dwFlags := PFD_SUPPORT_OPENGL;
+
+    AType := GetObjectType(DC);
+
+    if AType = 0 then
+      RaiseLastOSError;
+
+    if AType in MemoryDCs then
+      dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
+    else
+      dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
+
+    if opDoubleBuffered in Options then
+      dwFlags := dwFlags or PFD_DOUBLEBUFFER;
+
+    if opGDI in Options then
+      dwFlags := dwFlags or PFD_SUPPORT_GDI;
+
+    if opStereo in Options then
+      dwFlags := dwFlags or PFD_STEREO;
+
+    iPixelType := PFD_TYPE_RGBA;
+    cColorBits := ColorBits;
+    cDepthBits := zBits;
+    cStencilBits := StencilBits;
+    cAccumBits := AccumBits;
+    cAuxBuffers := AuxBuffers;
+
+    if Layer = 0 then
+      iLayerType := PFD_MAIN_PLANE
+    else
+    if Layer > 0 then
+      iLayerType := PFD_OVERLAY_PLANE
+    else
+      iLayerType := Byte(PFD_UNDERLAY_PLANE);
+  end;
+
+  PixelFormat := ChoosePixelFormat(DC, @PFDescriptor);
+
+  if PixelFormat = 0 then
+    RaiseLastOSError;
+
+  if GetPixelFormat(DC) <> PixelFormat then
+    if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
+      RaiseLastOSError;
+
+  DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor);
+
+  Result := wglCreateContext(DC);
+
+  if Result = 0 then
+    RaiseLastOSError
+  else
+    LastPixelFormat := 0;
+end;
+
+// =============================================================================
+// CreateRenderingContextVersion
+// =============================================================================
+//  Creates a context for the more recent OpenGL versions (3.0) and up
+//  For that we first need to get a normal GL context for getting the
+//  function pointer to wglCreateContextAttribsARB first
+// =============================================================================
+function CreateRenderingContextVersion(DC: HDC; Options: TRCOptions; MajorVersion, MinorVersion : Integer; ForwardCompatible : Boolean; ColorBits, ZBits, StencilBits, AccumBits, AuxBuffers: Integer; Layer: Integer): HGLRC;
+const
+  OBJ_MEMDC          = 10;
+  OBJ_ENHMETADC      = 12;
+  OBJ_METADC         = 4;
+  PFD_DOUBLEBUFFER   = $00000001;
+  PFD_STEREO         = $00000002;
+  PFD_DRAW_TO_WINDOW = $00000004;
+  PFD_DRAW_TO_BITMAP = $00000008;
+  PFD_SUPPORT_GDI    = $00000010;
+  PFD_SUPPORT_OPENGL = $00000020;
+  PFD_TYPE_RGBA      = 0;
+  PFD_MAIN_PLANE     = 0;
+  PFD_OVERLAY_PLANE  = 1;
+  PFD_UNDERLAY_PLANE = LongWord(-1);
+  MemoryDCs          = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
+var
+  PFDescriptor : TPixelFormatDescriptor;
+  PixelFormat  : Integer;
+  AType        : DWORD;
+  LegacyRC     : HGLRC;
+  Attribs      : array of Integer;
+begin
+  if GL_LibHandle = nil then
+       InitOpenGL;
+
+  if not Assigned(GL_LibHandle) then
+       raise Exception.Create('GL_LibHandle is NIL. Could not load OpenGL library!');
+
+  FillChar(PFDescriptor, SizeOf(PFDescriptor), 0);
+
+  with PFDescriptor do
+    begin
+      nSize    := SizeOf(PFDescriptor);
+      nVersion := 1;
+      dwFlags  := PFD_SUPPORT_OPENGL;
+      AType    := GetObjectType(DC);
+
+      if AType = 0 then
+       RaiseLastOSError;
+
+      if AType in MemoryDCs then
+       dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
+      else
+       dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
+
+      if opDoubleBuffered in Options then
+       dwFlags := dwFlags or PFD_DOUBLEBUFFER;
+
+      if opGDI in Options then
+       dwFlags := dwFlags or PFD_SUPPORT_GDI;
+
+      if opStereo in Options then
+       dwFlags := dwFlags or PFD_STEREO;
+
+      iPixelType   := PFD_TYPE_RGBA;
+      cColorBits   := ColorBits;
+      cDepthBits   := zBits;
+      cStencilBits := StencilBits;
+      cAccumBits   := AccumBits;
+      cAuxBuffers  := AuxBuffers;
+
+      if Layer = 0 then
+        iLayerType := PFD_MAIN_PLANE
+      else
+        if Layer > 0 then
+          iLayerType := PFD_OVERLAY_PLANE
+        else
+          iLayerType := Byte(PFD_UNDERLAY_PLANE);
+    end;
+
+  PixelFormat := ChoosePixelFormat(DC, @PFDescriptor);
+
+  if PixelFormat = 0 then
+       RaiseLastOSError;
+
+  if GetPixelFormat(DC) <> PixelFormat then
+       if not SetPixelFormat(DC, PixelFormat, @PFDescriptor) then
+               RaiseLastOSError;
+
+  DescribePixelFormat(DC, PixelFormat, SizeOf(PFDescriptor), PFDescriptor);
+
+  // Create legacy render context first for we need function pointers to
+  // create new OpenGL render contexts
+  LegacyRC := wglCreateContext(DC);
+  wglMakeCurrent(DC, LegacyRC);
+
+  // Set attributes to describe our requested context
+  SetLength(Attribs, 5);
+  Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB;
+  Attribs[1] := MajorVersion;
+  Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB;
+  Attribs[3] := MinorVersion;
+
+  // Add context flag for forward compatible context
+  //  Forward compatible means no more support for legacy functions like
+  //  immediate mode (glvertex, glrotate, gltranslate, etc.)
+  if ForwardCompatible then
+    begin
+      SetLength(Attribs, Length(Attribs)+2);
+      Attribs[4] := WGL_CONTEXT_FLAGS_ARB;
+      Attribs[5] := WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+    end;
+
+  // Attribute flags must be finalized with a zero
+  Attribs[High(Attribs)] := 0;
+
+  // Get function pointer for new context creation function
+  wglCreateContextAttribsARB := wglGetProcAddress('wglCreateContextAttribsARB');
+
+  if not Assigned(wglCreateContextAttribsARB) then
+    begin
+      raise Exception.Create('Could not get function pointer adress for wglCreateContextAttribsARB - OpenGL 3.x and above not supported!');
+      wglDeleteContext(LegacyRC);
+      exit;
+    end;
+
+  // Create context
+  Result := wglCreateContextAttribsARB(DC, 0, @Attribs[0]);
+
+  if Result = 0 then
+    begin
+      raise Exception.Create('Could not create the desired OpenGL rendering context!');
+      wglDeleteContext(LegacyRC);
+      exit;
+    end;
+
+  wglDeleteContext(LegacyRC);
+
+  if Result = 0 then
+       RaiseLastOSError
+  else
+       LastPixelFormat := 0;
+end;
+
+// =============================================================================
+// DestroyRenderingContext
+// =============================================================================
+
+procedure DestroyRenderingContext(RC: HGLRC);
+begin
+  wglDeleteContext(RC);
+end;
+
+
+// =============================================================================
+// ActivateRenderingContext
+// =============================================================================
+
+procedure ActivateRenderingContext(DC: HDC; RC: HGLRC; loadext: boolean = true);
+begin
+  Assert((DC <> 0), 'DC must not be 0');
+  Assert((RC <> 0), 'RC must not be 0');
+
+  wglMakeCurrent(DC, RC);
+
+  {$ifdef DGL_TINY_HEADER}
+  ReadCoreVersion;
+  {$else}
+  ReadImplementationProperties;
+
+  if (loadext) then
+    ReadExtensions;
+  {$endif}
+end;
+
+// =============================================================================
+// DeactivateRenderingContext
+// =============================================================================
+
+procedure DeactivateRenderingContext;
+begin
+  wglMakeCurrent(0, 0);
+end;
+{$ENDIF}
+
+
+initialization
+
+{$IFDEF CPU386}
+  Set8087CW($133F);
+{$ENDIF}
+
+finalization
+
+end.