{ ============================================================================ OpenGL 4.4 - Headertranslation Version 4.4 Date : 2013/07/22 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) ============================================================================== 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_CONSTANT_COLOR = $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: GLint; 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; // GLX_EXT_swap_control TglXSwapIntervalEXT = procedure (dpy: PDisplay; drawable: GLXDrawable; interval: 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; // GLX_EXT_swap_control glXSwapIntervalEXT: TglXSwapIntervalEXT; {$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 := {%H-}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({%H-}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({%H-}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 : GLint; 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'); // GLX_EXT_swap_control glXSwapIntervalEXT := dglGetProcAddress('glXSwapIntervalEXT'); {$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; out 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{%H-}, 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{%H-}, 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.