--- /dev/null
+{ ============================================================================
+
+ 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.
projects / LazOpenGLCore.git / commitdiff