From 67e88d1eef98c13eb468a8341481ecb7a18364e6 Mon Sep 17 00:00:00 2001 From: saschawillems Date: Thu, 8 May 2014 21:03:26 +0200 Subject: [PATCH 1/1] OpenGL 4.3 --- dglOpenGL.html | 185 + dglOpenGL.pas | 20073 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 20258 insertions(+) create mode 100644 dglOpenGL.html create mode 100644 dglOpenGL.pas diff --git a/dglOpenGL.html b/dglOpenGL.html new file mode 100644 index 0000000..fa3ce8a --- /dev/null +++ b/dglOpenGL.html @@ -0,0 +1,185 @@ + + + + Delphi/Free Pascal OpenGL Community - OpenGL Header + + + + + + +
+

Content

+

Description
+ How to use
+ Support
+ Credits
+ Copyright

+
+ +
+ +

Description

+

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. +

+

+
+ +
+

Note

+

OpenGL-Header is for Borland Delphi 4 and above (tested with Delphi 7) and FreePascal.
+ 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.

+
+ +
+ +

How to use

+

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 :

+ + 
+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;
+

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 :

+ 
+procedure MyDeInit;
+begin
+  DeactivateRenderingContext; // Deactivates the current context
+  wglDeleteContext(myRC);
+  ReleaseDC(Handle, myDC);
+end;
+
+ +
+ +

Creating a versioned rendering context

+

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) : + 

+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;
+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! + +

+
+ + +
+ +

Support

+

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 :
+ English support
+ German support

+
+ +
+ +

Credits

+
+

Converted and maintained by DGL's GL2.0-Team :

+

Sascha Willems (http://www.delphigl.de)
+ Steffen Xonna (Lossy eX, http://www.dev-center.de)
+

+

Additional input :

+

Andrey Gruzdev for the Mac OS X patch for XE2 / FPC + Lars Middendorf +Martin Waldegger (Mars)
+ Nico Michaelis (Delphic) for the Linux version of the header (see here)
+ Benjamin Rosseaux (BeRo) for expanding the header for use with Free Pascal
+ And thanks to all who helps us to make the header better

+
+
+ +
+ +

Copyright

+

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.

+
+ +
+ Copyright © 2003-2014 DGL-OpenGL-Portteam - All Rights Reserved +
+ + + + + diff --git a/dglOpenGL.pas b/dglOpenGL.pas new file mode 100644 index 0000000..13386b6 --- /dev/null +++ b/dglOpenGL.pas @@ -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. -- 2.1.4