Merge remote-tracking branch 'glBitmap.DGL/unstable'

diff --git a/dglOpenGL.pas b/dglOpenGL.pas
new file mode 100644 (file)
index 0000000..52499fc
--- /dev/null
+++ b/dglOpenGL.pas
@@ -0,0 +1,20329 @@
+{ ============================================================================
+
+       OpenGL 4.5 - Headertranslation
+       Version 4.5
+
+       Supported environments and targets :
+        - (Win32) Delphi 4 and up
+        - (Win32, Win64) Delphi XE2
+        - (Win32, Win64, Linux, MacOSX) FreePascal (1.9.3 and up)
+
+==============================================================================
+
+       Copyright (C) DGL-OpenGL-Portteam
+       All Rights Reserved
+
+       Obtained through:
+       Bitbucket source repository - https://bitbucket.org/saschawillems/dglopengl
+       Delphi OpenGL Community(DGL) - www.delphigl.com
+
+       Converted and maintained by DGL's OpenGL-Portteam :
+         - 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 : see readme.md
+
+
+============================================================================== }
+
+{$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;
+  PGLintptr = ^GLintptr;
+  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_compute_variable_group_size
+  TglDispatchComputeGroupSizeARB = procedure (num_groups_x : GLuint; num_groups_y : GLuint; num_groups_z : GLuint; group_size_x : GLuint; group_size_y : GLuint; group_size_z : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // 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}
+
+  // GL_KHR_debug (4.3)
+  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,
+  GL_VERSION_4_5,
+  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,
+
+
+  // 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,
+
+
+  // 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,
+  GL_ARB_bindless_texture,
+  GL_ARB_sparse_texture,
+
+  // GL 4.5
+  GL_ARB_clip_control,
+  GL_ARB_cull_distance,
+  GL_ARB_ES3_1_compatibility,
+  GL_ARB_conditional_render_inverted,
+  GL_KHR_context_flush_control,
+  GL_ARB_derivative_control,
+  GL_ARB_direct_state_access,
+  GL_ARB_get_texture_sub_image,
+  GL_KHR_robustness,
+  GL_KHR_blend_equation_advanced,
+  GL_KHR_blend_equation_advanced_coherent,
+  GL_KHR_robust_buffer_access_behavior,
+  GL_ARB_shader_texture_image_samples,
+  GL_ARB_texture_barrier,
+
+  GL_ARB_cl_event,
+  GL_ARB_compute_variable_group_size,
+  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,
+
+  // WGL
+  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,
+  WGL_ARB_context_flush_control,
+  WIN_draw_range_elements,
+  WIN_swap_hint,
+
+  // GLX
+  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_ARB_context_flush_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_RGB_RAW_422_APPLE = $8A51;
+
+  // 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_sparse_buffer
+  GL_SPARSE_STORAGE_BIT_ARB = $0400;
+  GL_SPARSE_BUFFER_PAGE_SIZE_ARB = $82F8;
+
+  // 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_compute_variable_group_size
+  GL_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = $9344;
+  GL_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = $90EB;
+  GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = $9345;
+  GL_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = $91BF;
+
+  // 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_SPARSE_TEXTURE
+  GL_TEXTURE_SPARSE_ARB = $91A6;
+  GL_VIRTUAL_PAGE_SIZE_INDEX_ARB = $91A7;
+  GL_NUM_VIRTUAL_PAGE_SIZES_ARB = $91A8;
+  GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = $91A9;
+  GL_NUM_SPARSE_LEVELS_ARB = $91AA;
+  GL_VIRTUAL_PAGE_SIZE_X_ARB = $9195;
+  GL_VIRTUAL_PAGE_SIZE_Y_ARB = $9196;
+  GL_VIRTUAL_PAGE_SIZE_Z_ARB = $9197;
+  GL_MAX_SPARSE_TEXTURE_SIZE_ARB = $9198;
+  GL_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = $9199;
+  GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = $919A;
+  GL_MIN_SPARSE_LEVEL_ARB = $919B;
+
+  // 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_feedback_overflow_query
+  GL_TRANSFORM_FEEDBACK_OVERFLOW_ARB = $82EC;
+  GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = $82ED;
+
+  // 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_KHR_texture_compression_astc_hdr
+  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;
+
+  // 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;
+
+  // GL 4.5
+  GL_CONTEXT_LOST                   = $0507;
+  GL_NEGATIVE_ONE_TO_ONE            = $935E;
+  GL_ZERO_TO_ONE                    = $935F;
+  GL_CLIP_ORIGIN                    = $935C;
+  GL_CLIP_DEPTH_MODE                = $935D;
+  GL_QUERY_WAIT_INVERTED            = $8E17;
+  GL_QUERY_NO_WAIT_INVERTED         = $8E18;
+  GL_QUERY_BY_REGION_WAIT_INVERTED  = $8E19;
+  GL_QUERY_BY_REGION_NO_WAIT_INVERTED = $8E1A;
+  GL_MAX_CULL_DISTANCES             = $82F9;
+  GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = $82FA;
+  GL_TEXTURE_TARGET                 = $1006;
+  GL_QUERY_TARGET                   = $82EA;
+  GL_TEXTURE_BINDING                = $82EB;
+  GL_GUILTY_CONTEXT_RESET           = $8253;
+  GL_INNOCENT_CONTEXT_RESET         = $8254;
+  GL_UNKNOWN_CONTEXT_RESET          = $8255;
+  GL_RESET_NOTIFICATION_STRATEGY    = $8256;
+  GL_LOSE_CONTEXT_ON_RESET          = $8252;
+  GL_NO_RESET_NOTIFICATION          = $8261;
+  GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT = $00000004;
+  GL_CONTEXT_RELEASE_BEHAVIOR       = $82FB;
+  GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = $82FC;
+
+  // 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_KHR_blend_equation_advanced
+  GL_MULTIPLY_KHR = $9294;
+  GL_SCREEN_KHR = $9295;
+  GL_OVERLAY_KHR = $9296;
+  GL_DARKEN_KHR = $9297;
+  GL_LIGHTEN_KHR = $9298;
+  GL_COLORDODGE_KHR = $9299;
+  GL_COLORBURN_KHR = $929A;
+  GL_HARDLIGHT_KHR = $929B;
+  GL_SOFTLIGHT_KHR = $929C;
+  GL_DIFFERENCE_KHR = $929E;
+  GL_EXCLUSION_KHR = $92A0;
+  GL_HSL_HUE_KHR = $92AD;
+  GL_HSL_SATURATION_KHR = $92AE;
+  GL_HSL_COLOR_KHR = $92AF;
+  GL_HSL_LUMINOSITY_KHR = $92B0;
+
+  // GL_KHR_blend_equation_advanced_coherent
+  GL_BLEND_ADVANCED_COHERENT_KHR = $9285;
+
+  // GL_KHR_robustness
+  GL_CONTEXT_ROBUST_ACCESS = $90F3;
+
+  // 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_pipeline_statistics_query
+  GL_VERTICES_SUBMITTED_ARB         = $82EE;
+  GL_PRIMITIVES_SUBMITTED_ARB       = $82EF;
+  GL_VERTEX_SHADER_INVOCATIONS_ARB  = $82F0;
+  GL_TESS_CONTROL_SHADER_PATCHES_ARB = $82F1;
+  GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = $82F2;
+  GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = $82F3;
+  GL_FRAGMENT_SHADER_INVOCATIONS_ARB = $82F4;
+  GL_COMPUTE_SHADER_INVOCATIONS_ARB = $82F5;
+  GL_CLIPPING_INPUT_PRIMITIVES_ARB  = $82F6;
+  GL_CLIPPING_OUTPUT_PRIMITIVES_ARB = $82F7;
+
+  // 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_context_flush_control
+  WGL_CONTEXT_RELEASE_BEHAVIOR_ARB = $2097;
+  WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0;
+  WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = $2098;
+
+  // 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_robustness_application_isolation
+  WGL_CONTEXT_RESET_ISOLATION_BIT_ARB = $00000008;
+
+  // 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_robustness_application_isolation
+  GLX_CONTEXT_RESET_ISOLATION_BIT_ARB = $00000008;
+
+  // GLX_ARB_fbconfig_float
+  GLX_RGBA_FLOAT_TYPE_ARB = $20B9;
+  GLX_RGBA_FLOAT_BIT_ARB = $00000004;
+
+  // GLX_ARB_context_flush_control
+  GLX_CONTEXT_RELEASE_BEHAVIOR_ARB = $2097;
+  GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB = 0;
+  GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB = $2098;
+
+  // 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; length: PGLSizei; infoLog: PGLChar); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetShaderiv = procedure(shaderObj: GLhandle; pname: GLenum; params: PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetShaderInfoLog = procedure(shaderObj: GLHandle; maxLength: glsizei; length: PGLSizei; 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
+  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}
+  TglTexPageCommitmentARB = procedure(target : glenum; level : glint; xoffset : glint; yoffset : glint; zoffset : glint; width : glsizei; height : glsizei; depth : glsizei; resident : glboolean);  {$IFDEF DGL_WIN} stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL 4.5
+  TglClipControl = procedure(origin : GLenum; depth : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateTransformFeedbacks = procedure(n : GLsizei; ids : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformFeedbackBufferBase = procedure (xfb : GLuint; index : GLuint; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTransformFeedbackBufferRange = procedure (xfb : GLuint; index : GLuint; buffer : GLuint; offset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTransformFeedbackiv = procedure (xfb : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTransformFeedbacki_v = procedure (xfb : GLuint; pname : GLenum; index : GLuint; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTransformFeedbacki64_v = procedure (xfb : GLuint; pname : GLenum; index : GLuint; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateBuffers = procedure (n : GLsizei; buffers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedBufferStorage = procedure (buffer : GLuint; size : GLsizei; const data : PGLVoid; flags : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedBufferData = procedure (buffer : GLuint; size : GLsizei; const data : PGLVoid; usage : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedBufferSubData = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyNamedBufferSubData = procedure (readBuffer : GLuint; writeBuffer : GLuint; readOffset : GLintptr; writeOffset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedBufferData = procedure (buffer : GLuint; internalformat : GLenum; format : GLenum; _type : GLenum; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedBufferSubData = procedure (buffer : GLuint; internalformat : GLenum; offset : GLintptr; size : GLsizei; format : GLenum; _type : GLenum; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapNamedBuffer = function(buffer : GLuint; access : GLenum) : PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMapNamedBufferRange = function(buffer : GLuint; offset : GLintptr; length : GLsizei; access : GLbitfield) : PGLvoid; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUnmapNamedBuffer = function(buffer : GLuint) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglFlushMappedNamedBufferRange = procedure (buffer : GLuint; offset : GLintptr; length : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferParameteriv = procedure (buffer : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferParameteri64v = procedure (buffer : GLuint; pname : GLenum; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferPointerv = procedure (buffer : GLuint; pname : GLenum; params : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedBufferSubData = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; data : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateFramebuffers = procedure (n : GLsizei; framebuffers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferRenderbuffer = procedure (framebuffer : GLuint; attachment : GLenum ; renderbuffertarget : GLEnum; renderbuffer : GLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferParameteri = procedure (framebuffer : GLuint; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTexture = procedure (framebuffer : GLuint; attachment : GLenum; texture : GLuint; level : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferTextureLayer = procedure (framebuffer : GLuint; attachment : GLenum; texture : GLuint; level : GLint; layer : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferDrawBuffer = procedure (framebuffer : GLuint; buf : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferDrawBuffers = procedure (framebuffer : GLuint; n : GLsizei; bufs : PGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedFramebufferReadBuffer = procedure (framebuffer : GLuint; src : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInvalidateNamedFramebufferData = procedure (framebuffer : GLuint; numAttachments : GLSizei; attachments : PGLEnum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglInvalidateNamedFramebufferSubData = procedure (framebuffer : GLuint; numAttachments : GLSizei; attachments : PGLEnum; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedFramebufferiv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedFramebufferuiv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedFramebufferfv = procedure (framebuffer : GLuint; buffer : GLenum; drawbuffer : GLint; value : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglClearNamedFramebufferfi = procedure (framebuffer : GLuint; buffer : GLenum; const depth : GLfloat; stencil : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBlitNamedFramebuffer = procedure (readFramebuffer : GLuint; drawFramebuffer : GLuint; 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}
+  TglCheckNamedFramebufferStatus = function(framebuffer : GLuint; target : GLenum) : GLenum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedFramebufferParameteriv = procedure (framebuffer : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedFramebufferAttachmentParameteriv = procedure (framebuffer : GLuint; attachment : GLenum; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateRenderbuffers = procedure (n : GLsizei; renderbuffers : PGLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedRenderbufferStorage = procedure (renderbuffer : GLUInt; internalformat : GLenum ; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedRenderbufferStorageMultisample = procedure (renderbuffer : GLUInt; samples : GLSizei; internalformat : GLenum ; width : GLSizei; height : GLSizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetNamedRenderbufferParameteriv = procedure (renderbuffer : GLUInt; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateTextures = procedure (target : GLenum ; n : GLsizei; textures : PGLUInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureBuffer = procedure (texture : GLuint; internalformat : GLenum; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureBufferRange = procedure (texture : GLuint; internalformat : GLenum; buffer : GLuint; offset : GLintptr; size : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage1D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage2D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage3D = procedure (texture : GLuint; levels : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage2DMultisample = procedure (texture : GLuint; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureStorage3DMultisample = procedure (texture : GLuint; samples : GLsizei; internalformat : GLenum; width : GLsizei; height : GLsizei; depth : GLsizei; fixedsamplelocations : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureSubImage1D = procedure (texture : GLuint; level : GLint; xoffset : GLint; width : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureSubImage2D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; width : GLsizei; height : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureSubImage3D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureSubImage1D = procedure (texture : GLuint; level : GLint; xoffset : GLint; width : GLsizei; format : GLenum; imageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureSubImage2D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; width : GLsizei; height : GLsizei; format : GLenum; mageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCompressedTextureSubImage3D = procedure (texture : GLuint; level : GLint; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; imageSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureSubImage1D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; x : GLint; y : GLint; width : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureSubImage2D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCopyTextureSubImage3D = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; x : GLint; y : GLint; width : GLsizei; height : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterf = procedure (texture : GLuint; pname : GLenum; param : GLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterfv = procedure (texture : GLuint; pname : GLenum; const param : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameteri = procedure (texture : GLuint; pname : GLenum; param : GLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterIiv = procedure (texture : GLuint; pname : GLenum; const params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameterIuiv = procedure (texture : GLuint; pname : GLenum; const params : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureParameteriv = procedure (texture : GLuint; pname : GLenum; const param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenerateTextureMipmap = procedure(texture : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindTextureUnit = procedure (_unit : GLuint; texture : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureImage = procedure (texture : GLuint; level : GLint ; format : GLenum; _type : GLenum; bufSize : GLsizei; pixels : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCompressedTextureImage = procedure (texture : GLuint; level : GLint; bufSize : GLSizei; pixels : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureLevelParameterfv = procedure (texture : GLuint; level : GLint; pname : GLenum; params : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureLevelParameteriv = procedure (texture : GLuint; level : GLint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameterfv = procedure (texture : GLuint; pname : GLenum; params : PGLFloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameterIiv = procedure (texture : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameterIuiv = procedure (texture : GLuint; pname : GLenum; params : PGLInt); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureParameteriv = procedure (texture : GLuint; pname : GLenum; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateVertexArrays = procedure (n : GLsizei; arrays : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisableVertexArrayAttrib = procedure (vaobj : GLuint; index : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglEnableVertexArrayAttrib = procedure (vaobj : GLuint; index : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayElementBuffer = procedure (vaobj : GLuint; buffer : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexBuffer = procedure (vaobj : GLuint; bindingindex : GLuint; buffer : GLuint; offset : GLintptr; stride : GLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayVertexBuffers = procedure (vaobj : GLuint; first : GLuint; count : GLsizei; const buffers : PGLuint; const offsets : PGLintptr; const strides : PGLsizei); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayAttribBinding = procedure (vaobj : GLuint; attribindex : GLuint; bindingindex : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayAttribFormat = procedure(vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; normalized : GLboolean; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayAttribIFormat = procedure (vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayAttribLFormat = procedure (vaobj : GLuint; attribindex : GLuint; size : GLint; _type : GLenum; relativeoffset : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexArrayBindingDivisor = procedure (vaobj : GLuint; bindingindex : GLuint; divisor : GLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexArrayiv = procedure (vaobj : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexArrayIndexediv = procedure (vaobj : GLuint; index : GLuint; pname : GLenum; param : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexArrayIndexed64iv = procedure (vaobj : GLuint; index : GLuint; pname : GLenum; param : PGLint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateSamplers = procedure (n : GLsizei; samplers : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateProgramPipelines = procedure (n : GLsizei; pipelines : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglCreateQueries = procedure (target : GLenum; n : GLsizei; ids : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMemoryBarrierByRegion = procedure (barriers : GLbitfield); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureSubImage = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; format : GLenum; _type : GLenum; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCompressedTextureSubImage = procedure (texture : GLuint; level : GLint ; xoffset : GLint; yoffset : GLint; zoffset : GLint; width : GLsizei; height : GLsizei; depth : GLsizei; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetGraphicsResetStatus = function : GLEnum; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnCompressedTexImage = procedure (target : GLenum; lod : GLint; bufSize : GLsizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnTexImage = procedure (target : GLenum; level : GLint; format : GLenum; _type : GLenum; bufSize : GLSizei; pixels : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformdv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformfv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformiv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnUniformuiv = procedure (_program : GLuint; location : GLint; bufSize : GLsizei; params : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReadnPixels = procedure (x : GLint; y : GLint; width : GLsizei; height : GLsizei; format : GLenum; _type : GLenum; bufSize : GLsizei; data : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMapdv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLdouble); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMapfv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMapiv = procedure (target : GLenum; query : GLenum; bufSize : GLsizei; v : PGLint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPixelMapfv = procedure (map : GLenum; bufSize : GLsizei; values : PGLfloat); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPixelMapuiv = procedure (map : GLenum; bufSize : GLsizei; values : PGLuint); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPixelMapusv = procedure (map : GLenum; bufSize : GLsizei; values : PGLushort); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnPolygonStipple = procedure (bufSize : GLsizei; pattern : PGLubyte); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnColorTable = procedure (target : GLenum; format : GLenum; _type : GLenum; bufSize : GLsizei; table : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnConvolutionFilter = procedure (target : GLenum; format : GLenum; _type : GLenum; bufSize : GLsizei; image : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnSeparableFilter = procedure (target : GLenum; format : GLenum; _type : GLenum; rowBufSize : GLsizei; row : PGLvoid; columnBufSize : GLsizei; column : PGLvoid; span : PGLVoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnHistogram = procedure (target : GLenum; reset : GLboolean; format : GLenum; _type : GLenum; bufSize : GLsizei; values : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetnMinmax = procedure (target : GLenum; reset : GLboolean; format : GLenum; _type : GLenum; bufSize : GLsizei; values : PGLvoid); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTextureBarrier = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_ARB_sparse_buffer
+  TglBufferPageCommitmentARB = procedure (target : GLenum; offset : GLintptr; size : GLsizei; commit : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedBufferPageCommitmentEXT = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; commit : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglNamedBufferPageCommitmentARB = procedure (buffer : GLuint; offset : GLintptr; size : GLsizei; commit : GLboolean); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // GL_KHR_blend_equation_advanced
+  TglBlendBarrierKHR = procedure; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  // 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}
+
+  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_ARB_bindless_texture
+
+  TglGetTextureHandleARB = function (texture : GLuint) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTextureSamplerHandleARB = function (texture : GLuint; sampler : GLuint) : GLUInt64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeTextureHandleResidentARB = procedure (handle : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeTextureHandleNonResidentARB = procedure (handle : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetImageHandleARB = function (texture : GLuint; level : GLint; layered : GLboolean; layer : GLint; format : GLenum) : GLuint64; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeImageHandleResidentARB = procedure (handle : GLuint64; access : GLenum); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglMakeImageHandleNonResidentARB = procedure (handle : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformHandleui64ARB = procedure (location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglUniformHandleui64vARB = procedure (location : GLint; count : GLsizei; const value : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformHandleui64ARB = procedure (program_ : GLuint; location : GLint; value : GLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglProgramUniformHandleui64vARB = procedure (program_ : GLuint; location : GLint; count : GLsizei; const values : PGLuint64); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsTextureHandleResidentARB = function (handle : GLuint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglIsImageHandleResidentARB = function (handle : GLuint64) : GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL1ui64ARB = procedure (index : GLuint; x : GLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglVertexAttribL1ui64vARB = procedure (index : GLuint; const v : PGLuint64EXT); {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetVertexAttribLui64vARB = procedure (index : GLuint; pname : GLenum; params : PGLuint64EXT ); {$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;
+
+  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;
+    glTexPageCommitmentARB : TglTexPageCommitmentARB;
+
+  // GL 4.5
+  glClipControl : TglClipControl;
+  glCreateTransformFeedbacks : TglCreateTransformFeedbacks;
+  glTransformFeedbackBufferBase : TglTransformFeedbackBufferBase;
+  glTransformFeedbackBufferRange : TglTransformFeedbackBufferRange;
+  glGetTransformFeedbackiv : TglGetTransformFeedbackiv;
+  glGetTransformFeedbacki_v : TglGetTransformFeedbacki_v;
+  glGetTransformFeedbacki64_v : TglGetTransformFeedbacki64_v;
+  glCreateBuffers : TglCreateBuffers;
+  glNamedBufferStorage : TglNamedBufferStorage;
+  glNamedBufferData : TglNamedBufferData;
+  glNamedBufferSubData : TglNamedBufferSubData;
+  glCopyNamedBufferSubData : TglCopyNamedBufferSubData;
+  glClearNamedBufferData : TglClearNamedBufferData;
+  glClearNamedBufferSubData : TglClearNamedBufferSubData;
+  glMapNamedBuffer : TglMapNamedBuffer;
+  glMapNamedBufferRange : TglMapNamedBufferRange;
+  glUnmapNamedBuffer : TglUnmapNamedBuffer;
+  glFlushMappedNamedBufferRange : TglFlushMappedNamedBufferRange;
+  glGetNamedBufferParameteriv : TglGetNamedBufferParameteriv;
+  glGetNamedBufferParameteri64v : TglGetNamedBufferParameteri64v;
+  glGetNamedBufferPointerv : TglGetNamedBufferPointerv;
+  glGetNamedBufferSubData : TglGetNamedBufferSubData;
+  glCreateFramebuffers : TglCreateFramebuffers;
+  glNamedFramebufferRenderbuffer : TglNamedFramebufferRenderbuffer;
+  glNamedFramebufferParameteri : TglNamedFramebufferParameteri;
+  glNamedFramebufferTexture : TglNamedFramebufferTexture;
+  glNamedFramebufferTextureLayer : TglNamedFramebufferTextureLayer;
+  glNamedFramebufferDrawBuffer : TglNamedFramebufferDrawBuffer;
+  glNamedFramebufferDrawBuffers : TglNamedFramebufferDrawBuffers;
+  glNamedFramebufferReadBuffer : TglNamedFramebufferReadBuffer;
+  glInvalidateNamedFramebufferData : TglInvalidateNamedFramebufferData;
+  glInvalidateNamedFramebufferSubData : TglInvalidateNamedFramebufferSubData;
+  glClearNamedFramebufferiv : TglClearNamedFramebufferiv;
+  glClearNamedFramebufferuiv : TglClearNamedFramebufferuiv;
+  glClearNamedFramebufferfv : TglClearNamedFramebufferfv;
+  glClearNamedFramebufferfi : TglClearNamedFramebufferfi;
+  glBlitNamedFramebuffer : TglBlitNamedFramebuffer;
+  glCheckNamedFramebufferStatus : TglCheckNamedFramebufferStatus;
+  glGetNamedFramebufferParameteriv : TglGetNamedFramebufferParameteriv;
+  glGetNamedFramebufferAttachmentParameteriv : TglGetNamedFramebufferAttachmentParameteriv;
+  glCreateRenderbuffers : TglCreateRenderbuffers;
+  glNamedRenderbufferStorage : TglNamedRenderbufferStorage;
+  glNamedRenderbufferStorageMultisample : TglNamedRenderbufferStorageMultisample;
+  glGetNamedRenderbufferParameteriv : TglGetNamedRenderbufferParameteriv;
+  glCreateTextures : TglCreateTextures;
+  glTextureBuffer : TglTextureBuffer;
+  glTextureBufferRange : TglTextureBufferRange;
+  glTextureStorage1D : TglTextureStorage1D;
+  glTextureStorage2D : TglTextureStorage2D;
+  glTextureStorage3D : TglTextureStorage3D;
+  glTextureStorage2DMultisample : TglTextureStorage2DMultisample;
+  glTextureStorage3DMultisample : TglTextureStorage3DMultisample;
+  glTextureSubImage1D : TglTextureSubImage1D;
+  glTextureSubImage2D : TglTextureSubImage2D;
+  glTextureSubImage3D : TglTextureSubImage3D;
+  glCompressedTextureSubImage1D : TglCompressedTextureSubImage1D;
+  glCompressedTextureSubImage2D : TglCompressedTextureSubImage2D;
+  glCompressedTextureSubImage3D : TglCompressedTextureSubImage3D;
+  glCopyTextureSubImage1D : TglCopyTextureSubImage1D;
+  glCopyTextureSubImage2D : TglCopyTextureSubImage2D;
+  glCopyTextureSubImage3D : TglCopyTextureSubImage3D;
+  glTextureParameterf : TglTextureParameterf;
+  glTextureParameterfv : TglTextureParameterfv;
+  glTextureParameteri : TglTextureParameteri;
+  glTextureParameterIiv : TglTextureParameterIiv;
+  glTextureParameterIuiv : TglTextureParameterIuiv;
+  glTextureParameteriv : TglTextureParameteriv;
+  glGenerateTextureMipmap : TglGenerateTextureMipmap;
+  glBindTextureUnit : TglBindTextureUnit;
+  glGetTextureImage : TglGetTextureImage;
+  glGetCompressedTextureImage : TglGetCompressedTextureImage;
+  glGetTextureLevelParameterfv : TglGetTextureLevelParameterfv;
+  glGetTextureLevelParameteriv : TglGetTextureLevelParameteriv;
+  glGetTextureParameterfv : TglGetTextureParameterfv;
+  glGetTextureParameterIiv : TglGetTextureParameterIiv;
+  glGetTextureParameterIuiv : TglGetTextureParameterIuiv;
+  glGetTextureParameteriv : TglGetTextureParameteriv;
+  glCreateVertexArrays : TglCreateVertexArrays;
+  glDisableVertexArrayAttrib : TglDisableVertexArrayAttrib;
+  glEnableVertexArrayAttrib : TglEnableVertexArrayAttrib;
+  glVertexArrayElementBuffer : TglVertexArrayElementBuffer;
+  glVertexArrayVertexBuffer : TglVertexArrayVertexBuffer;
+  glVertexArrayVertexBuffers : TglVertexArrayVertexBuffers;
+  glVertexArrayAttribBinding : TglVertexArrayAttribBinding;
+  glVertexArrayAttribFormat : TglVertexArrayAttribFormat;
+  glVertexArrayAttribIFormat : TglVertexArrayAttribIFormat;
+  glVertexArrayAttribLFormat : TglVertexArrayAttribLFormat;
+  glVertexArrayBindingDivisor : TglVertexArrayBindingDivisor;
+  glGetVertexArrayiv : TglGetVertexArrayiv;
+  glGetVertexArrayIndexediv : TglGetVertexArrayIndexediv;
+  glGetVertexArrayIndexed64iv : TglGetVertexArrayIndexed64iv;
+  glCreateSamplers : TglCreateSamplers;
+  glCreateProgramPipelines : TglCreateProgramPipelines;
+  glCreateQueries : TglCreateQueries;
+  glMemoryBarrierByRegion : TglMemoryBarrierByRegion;
+  glGetTextureSubImage : TglGetTextureSubImage;
+  glGetCompressedTextureSubImage : TglGetCompressedTextureSubImage;
+  glGetGraphicsResetStatus : TglGetGraphicsResetStatus;
+  glGetnCompressedTexImage : TglGetnCompressedTexImage;
+  glGetnTexImage : TglGetnTexImage;
+  glGetnUniformdv : TglGetnUniformdv;
+  glGetnUniformfv : TglGetnUniformfv;
+  glGetnUniformiv : TglGetnUniformiv;
+  glGetnUniformuiv : TglGetnUniformuiv;
+  glReadnPixels : TglReadnPixels;
+  glGetnMapdv : TglGetnMapdv;
+  glGetnMapfv : TglGetnMapfv;
+  glGetnMapiv : TglGetnMapiv;
+  glGetnPixelMapfv : TglGetnPixelMapfv;
+  glGetnPixelMapuiv : TglGetnPixelMapuiv;
+  glGetnPixelMapusv : TglGetnPixelMapusv;
+  glGetnPolygonStipple : TglGetnPolygonStipple;
+  glGetnColorTable : TglGetnColorTable;
+  glGetnConvolutionFilter : TglGetnConvolutionFilter;
+  glGetnSeparableFilter : TglGetnSeparableFilter;
+  glGetnHistogram : TglGetnHistogram;
+  glGetnMinmax : TglGetnMinmax;
+  glTextureBarrier : TglTextureBarrier;
+
+  // GL_ARB_sparse_buffer
+  glBufferPageCommitmentARB : TglBufferPageCommitmentARB;
+  glNamedBufferPageCommitmentEXT : TglNamedBufferPageCommitmentEXT;
+  glNamedBufferPageCommitmentARB : TglNamedBufferPageCommitmentARB;
+
+  // GL_KHR_blend_equation_advanced
+  glBlendBarrierKHR : TglBlendBarrierKHR;
+
+  // GL_ARB_cl_event
+  glCreateSyncFromCLeventARB: TglCreateSyncFromCLeventARB;
+
+  // GL_ARB_debug_output
+  glDebugMessageControlARB: TglDebugMessageControlARB;
+  glDebugMessageInsertARB: TglDebugMessageInsertARB;
+  glDebugMessageCallbackARB: TglDebugMessageCallbackARB;
+  glGetDebugMessageLogARB: TglGetDebugMessageLogARB;
+
+  // GL_ARB_compute_variable_group_size
+  glDispatchComputeGroupSizeARB : TglDispatchComputeGroupSizeARB;
+
+  // 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_ARB_bindless_texture
+  glGetTextureHandleARB : TglGetTextureHandleARB;
+  glGetTextureSamplerHandleARB : TglGetTextureSamplerHandleARB;
+  glMakeTextureHandleResidentARB : TglMakeTextureHandleResidentARB;
+  glMakeTextureHandleNonResidentARB : TglMakeTextureHandleNonResidentARB;
+  glGetImageHandleARB : TglGetImageHandleARB;
+  glMakeImageHandleResidentARB : TglMakeImageHandleResidentARB;
+  glMakeImageHandleNonResidentARB : TglMakeImageHandleNonResidentARB;
+  glUniformHandleui64ARB : TglUniformHandleui64ARB;
+  glUniformHandleui64vARB : TglUniformHandleui64vARB;
+  glProgramUniformHandleui64ARB : TglProgramUniformHandleui64ARB;
+  glProgramUniformHandleui64vARB : TglProgramUniformHandleui64vARB;
+  glIsTextureHandleResidentARB : TglIsTextureHandleResidentARB;
+  glIsImageHandleResidentARB : TglIsImageHandleResidentARB;
+  glVertexAttribL1ui64ARB : TglVertexAttribL1ui64ARB;
+  glVertexAttribL1ui64vARB : TglVertexAttribL1ui64vARB;
+  glGetVertexAttribLui64vARB : TglGetVertexAttribLui64vARB;
+
+  // 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;
+
+  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;
+
+
+procedure Read_GL_4_4;
+procedure Read_GL_4_5;
+
+//
+procedure Read_GL_ARB_cl_event;
+procedure Read_GL_ARB_compute_variable_group_size;
+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;
+
+
+  {$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');
+
+      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;
+
+  //  Note (Due to Khronos' change in header convetions, no more single read_ functions) starting with GL 4.4
+  Read_GL_4_4;
+  Read_GL_4_5;
+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_sparse_texture;
+begin
+  glTexPageCommitmentARB := dglGetProcAddress('glTexPageCommitmentARB');
+end;
+
+procedure Read_GL_ARB_sparse_buffer;
+begin
+  glBufferPageCommitmentARB := dglGetProcAddress('glBufferPageCommitmentARB');
+  glNamedBufferPageCommitmentEXT := dglGetProcAddress('glNamedBufferPageCommitmentEXT');
+  glNamedBufferPageCommitmentARB := dglGetProcAddress('glNamedBufferPageCommitmentARB');
+end;
+
+procedure Read_GL_KHR_blend_equation_advanced;
+begin
+  glBlendBarrierKHR := dglGetProcAddress('glBlendBarrierKHR');
+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_4_5;
+begin
+  glClipControl:= dglGetProcAddress('glClipControl');
+  glCreateTransformFeedbacks:= dglGetProcAddress('glCreateTransformFeedbacks');
+  glTransformFeedbackBufferBase:= dglGetProcAddress('glTransformFeedbackBufferBase');
+  glTransformFeedbackBufferRange:= dglGetProcAddress('glTransformFeedbackBufferRange');
+  glGetTransformFeedbackiv:= dglGetProcAddress('glGetTransformFeedbackiv');
+  glGetTransformFeedbacki_v:= dglGetProcAddress('glGetTransformFeedbacki_v');
+  glGetTransformFeedbacki64_v:= dglGetProcAddress('glGetTransformFeedbacki64_v');
+  glCreateBuffers:= dglGetProcAddress('glCreateBuffers');
+  glNamedBufferStorage:= dglGetProcAddress('glNamedBufferStorage');
+  glNamedBufferData:= dglGetProcAddress('glNamedBufferData');
+  glNamedBufferSubData:= dglGetProcAddress('glNamedBufferSubData');
+  glCopyNamedBufferSubData:= dglGetProcAddress('glCopyNamedBufferSubData');
+  glClearNamedBufferData:= dglGetProcAddress('glClearNamedBufferData');
+  glClearNamedBufferSubData:= dglGetProcAddress('glClearNamedBufferSubData');
+  glMapNamedBuffer:= dglGetProcAddress('glMapNamedBuffer');
+  glMapNamedBufferRange:= dglGetProcAddress('glMapNamedBufferRange');
+  glUnmapNamedBuffer:= dglGetProcAddress('glUnmapNamedBuffer');
+  glFlushMappedNamedBufferRange:= dglGetProcAddress('glFlushMappedNamedBufferRange');
+  glGetNamedBufferParameteriv:= dglGetProcAddress('glGetNamedBufferParameteriv');
+  glGetNamedBufferParameteri64v:= dglGetProcAddress('glGetNamedBufferParameteri64v');
+  glGetNamedBufferPointerv:= dglGetProcAddress('glGetNamedBufferPointerv');
+  glGetNamedBufferSubData:= dglGetProcAddress('glGetNamedBufferSubData');
+  glCreateFramebuffers:= dglGetProcAddress('glCreateFramebuffers');
+  glNamedFramebufferRenderbuffer:= dglGetProcAddress('glNamedFramebufferRenderbuffer');
+  glNamedFramebufferParameteri:= dglGetProcAddress('glNamedFramebufferParameteri');
+  glNamedFramebufferTexture:= dglGetProcAddress('glNamedFramebufferTexture');
+  glNamedFramebufferTextureLayer:= dglGetProcAddress('glNamedFramebufferTextureLayer');
+  glNamedFramebufferDrawBuffer:= dglGetProcAddress('glNamedFramebufferDrawBuffer');
+  glNamedFramebufferDrawBuffers:= dglGetProcAddress('glNamedFramebufferDrawBuffers');
+  glNamedFramebufferReadBuffer:= dglGetProcAddress('glNamedFramebufferReadBuffer');
+  glInvalidateNamedFramebufferData:= dglGetProcAddress('glInvalidateNamedFramebufferData');
+  glInvalidateNamedFramebufferSubData:= dglGetProcAddress('glInvalidateNamedFramebufferSubData');
+  glClearNamedFramebufferiv:= dglGetProcAddress('glClearNamedFramebufferiv');
+  glClearNamedFramebufferuiv:= dglGetProcAddress('glClearNamedFramebufferuiv');
+  glClearNamedFramebufferfv:= dglGetProcAddress('glClearNamedFramebufferfv');
+  glClearNamedFramebufferfi:= dglGetProcAddress('glClearNamedFramebufferfi');
+  glBlitNamedFramebuffer:= dglGetProcAddress('glBlitNamedFramebuffer');
+  glCheckNamedFramebufferStatus:= dglGetProcAddress('glCheckNamedFramebufferStatus');
+  glGetNamedFramebufferParameteriv:= dglGetProcAddress('glGetNamedFramebufferParameteriv');
+  glGetNamedFramebufferAttachmentParameteriv:= dglGetProcAddress('glGetNamedFramebufferAttachmentParameteriv');
+  glCreateRenderbuffers:= dglGetProcAddress('glCreateRenderbuffers');
+  glNamedRenderbufferStorage:= dglGetProcAddress('glNamedRenderbufferStorage');
+  glNamedRenderbufferStorageMultisample:= dglGetProcAddress('glNamedRenderbufferStorageMultisample');
+  glGetNamedRenderbufferParameteriv:= dglGetProcAddress('glGetNamedRenderbufferParameteriv');
+  glCreateTextures:= dglGetProcAddress('glCreateTextures');
+  glTextureBuffer:= dglGetProcAddress('glTextureBuffer');
+  glTextureBufferRange:= dglGetProcAddress('glTextureBufferRange');
+  glTextureStorage1D:= dglGetProcAddress('glTextureStorage1D');
+  glTextureStorage2D:= dglGetProcAddress('glTextureStorage2D');
+  glTextureStorage3D:= dglGetProcAddress('glTextureStorage3D');
+  glTextureStorage2DMultisample:= dglGetProcAddress('glTextureStorage2DMultisample');
+  glTextureStorage3DMultisample:= dglGetProcAddress('glTextureStorage3DMultisample');
+  glTextureSubImage1D:= dglGetProcAddress('glTextureSubImage1D');
+  glTextureSubImage2D:= dglGetProcAddress('glTextureSubImage2D');
+  glTextureSubImage3D:= dglGetProcAddress('glTextureSubImage3D');
+  glCompressedTextureSubImage1D:= dglGetProcAddress('glCompressedTextureSubImage1D');
+  glCompressedTextureSubImage2D:= dglGetProcAddress('glCompressedTextureSubImage2D');
+  glCompressedTextureSubImage3D:= dglGetProcAddress('glCompressedTextureSubImage3D');
+  glCopyTextureSubImage1D:= dglGetProcAddress('glCopyTextureSubImage1D');
+  glCopyTextureSubImage2D:= dglGetProcAddress('glCopyTextureSubImage2D');
+  glCopyTextureSubImage3D:= dglGetProcAddress('glCopyTextureSubImage3D');
+  glTextureParameterf:= dglGetProcAddress('glTextureParameterf');
+  glTextureParameterfv:= dglGetProcAddress('glTextureParameterfv');
+  glTextureParameteri:= dglGetProcAddress('glTextureParameteri');
+  glTextureParameterIiv:= dglGetProcAddress('glTextureParameterIiv');
+  glTextureParameterIuiv:= dglGetProcAddress('glTextureParameterIuiv');
+  glTextureParameteriv:= dglGetProcAddress('glTextureParameteriv');
+  glGenerateTextureMipmap:= dglGetProcAddress('glGenerateTextureMipmap');
+  glBindTextureUnit:= dglGetProcAddress('glBindTextureUnit');
+  glGetTextureImage:= dglGetProcAddress('glGetTextureImage');
+  glGetCompressedTextureImage:= dglGetProcAddress('glGetCompressedTextureImage');
+  glGetTextureLevelParameterfv:= dglGetProcAddress('glGetTextureLevelParameterfv');
+  glGetTextureLevelParameteriv:= dglGetProcAddress('glGetTextureLevelParameteriv');
+  glGetTextureParameterfv:= dglGetProcAddress('glGetTextureParameterfv');
+  glGetTextureParameterIiv:= dglGetProcAddress('glGetTextureParameterIiv');
+  glGetTextureParameterIuiv:= dglGetProcAddress('glGetTextureParameterIuiv');
+  glGetTextureParameteriv:= dglGetProcAddress('glGetTextureParameteriv');
+  glCreateVertexArrays:= dglGetProcAddress('glCreateVertexArrays');
+  glDisableVertexArrayAttrib:= dglGetProcAddress('glDisableVertexArrayAttrib');
+  glEnableVertexArrayAttrib:= dglGetProcAddress('glEnableVertexArrayAttrib');
+  glVertexArrayElementBuffer:= dglGetProcAddress('glVertexArrayElementBuffer');
+  glVertexArrayVertexBuffer:= dglGetProcAddress('glVertexArrayVertexBuffer');
+  glVertexArrayVertexBuffers:= dglGetProcAddress('glVertexArrayVertexBuffers');
+  glVertexArrayAttribBinding:= dglGetProcAddress('glVertexArrayAttribBinding');
+  glVertexArrayAttribFormat:= dglGetProcAddress('glVertexArrayAttribFormat');
+  glVertexArrayAttribIFormat:= dglGetProcAddress('glVertexArrayAttribIFormat');
+  glVertexArrayAttribLFormat:= dglGetProcAddress('glVertexArrayAttribLFormat');
+  glVertexArrayBindingDivisor:= dglGetProcAddress('glVertexArrayBindingDivisor');
+  glGetVertexArrayiv:= dglGetProcAddress('glGetVertexArrayiv');
+  glGetVertexArrayIndexediv:= dglGetProcAddress('glGetVertexArrayIndexediv');
+  glGetVertexArrayIndexed64iv:= dglGetProcAddress('glGetVertexArrayIndexed64iv');
+  glCreateSamplers:= dglGetProcAddress('glCreateSamplers');
+  glCreateProgramPipelines:= dglGetProcAddress('glCreateProgramPipelines');
+  glCreateQueries:= dglGetProcAddress('glCreateQueries');
+  glMemoryBarrierByRegion:= dglGetProcAddress('glMemoryBarrierByRegion');
+  glGetTextureSubImage:= dglGetProcAddress('glGetTextureSubImage');
+  glGetCompressedTextureSubImage:= dglGetProcAddress('glGetCompressedTextureSubImage');
+  glGetGraphicsResetStatus:= dglGetProcAddress('glGetGraphicsResetStatus');
+  glGetnCompressedTexImage:= dglGetProcAddress('glGetnCompressedTexImage');
+  glGetnTexImage:= dglGetProcAddress('glGetnTexImage');
+  glGetnUniformdv:= dglGetProcAddress('glGetnUniformdv');
+  glGetnUniformfv:= dglGetProcAddress('glGetnUniformfv');
+  glGetnUniformiv:= dglGetProcAddress('glGetnUniformiv');
+  glGetnUniformuiv:= dglGetProcAddress('glGetnUniformuiv');
+  glReadnPixels:= dglGetProcAddress('glReadnPixels');
+  glGetnMapdv:= dglGetProcAddress('glGetnMapdv');
+  glGetnMapfv:= dglGetProcAddress('glGetnMapfv');
+  glGetnMapiv:= dglGetProcAddress('glGetnMapiv');
+  glGetnPixelMapfv:= dglGetProcAddress('glGetnPixelMapfv');
+  glGetnPixelMapuiv:= dglGetProcAddress('glGetnPixelMapuiv');
+  glGetnPixelMapusv:= dglGetProcAddress('glGetnPixelMapusv');
+  glGetnPolygonStipple:= dglGetProcAddress('glGetnPolygonStipple');
+  glGetnColorTable:= dglGetProcAddress('glGetnColorTable');
+  glGetnConvolutionFilter:= dglGetProcAddress('glGetnConvolutionFilter');
+  glGetnSeparableFilter:= dglGetProcAddress('glGetnSeparableFilter');
+  glGetnHistogram:= dglGetProcAddress('glGetnHistogram');
+  glGetnMinmax:= dglGetProcAddress('glGetnMinmax');
+  glTextureBarrier:= dglGetProcAddress('glTextureBarrier');
+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_bindless_texture;
+begin
+  glGetTextureHandleARB := dglGetProcAddress('TglGetTextureHandleARB');
+  glGetTextureSamplerHandleARB := dglGetProcAddress('TglGetTextureSamplerHandleARB');
+  glMakeTextureHandleResidentARB := dglGetProcAddress('TglMakeTextureHandleResidentARB');
+  glMakeTextureHandleNonResidentARB := dglGetProcAddress('TglMakeTextureHandleNonResidentARB');
+  glGetImageHandleARB := dglGetProcAddress('TglGetImageHandleARB');
+  glMakeImageHandleResidentARB := dglGetProcAddress('TglMakeImageHandleResidentARB');
+  glMakeImageHandleNonResidentARB := dglGetProcAddress('TglMakeImageHandleNonResidentARB');
+  glUniformHandleui64ARB := dglGetProcAddress('TglUniformHandleui64ARB');
+  glUniformHandleui64vARB := dglGetProcAddress('TglUniformHandleui64vARB');
+  glProgramUniformHandleui64ARB := dglGetProcAddress('TglProgramUniformHandleui64ARB');
+  glProgramUniformHandleui64vARB := dglGetProcAddress('TglProgramUniformHandleui64vARB');
+  glIsTextureHandleResidentARB := dglGetProcAddress('TglIsTextureHandleResidentARB');
+  glIsImageHandleResidentARB := dglGetProcAddress('TglIsImageHandleResidentARB');
+  glVertexAttribL1ui64ARB := dglGetProcAddress('TglVertexAttribL1ui64ARB');
+  glVertexAttribL1ui64vARB := dglGetProcAddress('TglVertexAttribL1ui64vARB');
+  glGetVertexAttribLui64vARB := dglGetProcAddress('TglGetVertexAttribLui64vARB');
+end;
+
+procedure Read_GL_ARB_cl_event;
+begin
+  glCreateSyncFromCLeventARB := dglGetProcAddress('glCreateSyncFromCLeventARB');
+end;
+
+procedure Read_GL_ARB_compute_variable_group_size;
+begin
+  glDispatchComputeGroupSizeARB := dglGetProcAddress('glDispatchComputeGroupSizeARB');
+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_sparse_texture;
+  Read_GL_ARB_sparse_buffer;
+  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_compute_variable_group_size;
+  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_KHR_blend_equation_advanced;
+  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;
+  GL_VERSION_4_5 := 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;
+    if MinorVersion >= 4 then
+      GL_VERSION_4_5:= 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_sparse_texture := Int_CheckExtension(Buffer, 'GL_ARB_sparse_texture');
+  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_ARB_compute_variable_group_size := Int_CheckExtension(Buffer, 'GL_ARB_compute_variable_group_size');
+
+  // 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');
+
+  // 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');
+
+  // 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');
+  GL_ARB_bindless_texture := Int_CheckExtension(Buffer, 'GL_ARB_bindless_texture');
+  GL_ARB_sparse_texture        := Int_CheckExtension(Buffer, 'GL_ARB_sparse_texture');
+
+  // GL 4.5
+  GL_ARB_clip_control := Int_CheckExtension(Buffer, 'GL_ARB_clip_control');
+  GL_ARB_cull_distance := Int_CheckExtension(Buffer, 'GL_ARB_cull_distance');
+  GL_ARB_ES3_1_compatibility := Int_CheckExtension(Buffer, 'GL_ARB_ES3_1_compatibility');
+  GL_ARB_conditional_render_inverted := Int_CheckExtension(Buffer, 'GL_ARB_conditional_render_inverted');
+  GL_KHR_context_flush_control := Int_CheckExtension(Buffer, 'GL_KHR_context_flush_control');
+  GL_ARB_derivative_control := Int_CheckExtension(Buffer, 'GL_ARB_derivative_control');
+  GL_ARB_direct_state_access := Int_CheckExtension(Buffer, 'GL_ARB_direct_state_access');
+  GL_ARB_get_texture_sub_image := Int_CheckExtension(Buffer, 'GL_ARB_get_texture_sub_image');
+  GL_KHR_robustness := Int_CheckExtension(Buffer, 'GL_KHR_robustness');
+  GL_ARB_shader_texture_image_samples := Int_CheckExtension(Buffer, 'GL_ARB_shader_texture_image_samples');
+  GL_ARB_texture_barrier := Int_CheckExtension(Buffer, 'GL_ARB_texture_barrier');
+
+  // 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');
+
+  // Khronos
+  // 4.5
+  GL_KHR_blend_equation_advanced := Int_CheckExtension(Buffer, 'GL_KHR_blend_equation_advanced');
+  GL_KHR_blend_equation_advanced_coherent := Int_CheckExtension(Buffer, 'GL_KHR_blend_equation_advanced_coherent');
+  GL_KHR_robustness := Int_CheckExtension(Buffer, 'GL_KHR_robustness');
+  GL_KHR_robust_buffer_access_behavior := Int_CheckExtension(Buffer, 'GL_KHR_robust_buffer_access_behavior');
+
+  // 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');
+  WGL_ARB_context_flush_control := Int_CheckExtension(Buffer, 'WGL_ARB_context_flush_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');
+  GLX_ARB_context_flush_control := Int_CheckExtension(Buffer, 'GLX_ARB_context_flush_control');
+  {$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.
+

diff --git a/glBitmap.pas b/glBitmap.pas
deleted file mode 100644 (file)
index 4ee797b..0000000
--- a/glBitmap.pas
+++ /dev/null
@@ -1,9096 +0,0 @@
-{***********************************************************
-glBitmap by Steffen Xonna aka Lossy eX (2003-2008)
-http://www.opengl24.de/index.php?cat=header&file=glbitmap
-
-modified by Delphi OpenGL Community (http://delphigl.com/) (2013)
-
-------------------------------------------------------------
-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
-------------------------------------------------------------
-Version 3.0.1
-------------------------------------------------------------
-History
-20-11-2013
-- refactoring of the complete library
-21-03-2010
-- The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi
-  then it's your problem if that isn't true. This prevents the unit for incompatibility
-  with newer versions of Delphi.
-- Problems with D2009+ resolved (Thanks noeska and all i forgot)
-- GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson)
-10-08-2008
-- AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson)
-- Additional Datapointer for functioninterface now has the name CustomData
-24-07-2008
-- AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson)
-- If you load an texture from an file the property Filename will be set to the name of the file
-- Three new properties to attach custom data to the Texture objects
-  - CustomName  (free for use string)
-  - CustomNameW (free for use widestring)
-  - CustomDataPointer (free for use pointer to attach other objects or complex structures)
-27-05-2008
-- RLE TGAs loaded much faster
-26-05-2008
-- fixed some problem with reading RLE TGAs.
-21-05-2008
-- function clone now only copys data if it's assigned and now it also copies the ID
-- it seems that lazarus dont like comments in comments.
-01-05-2008
-- It's possible to set the id of the texture
-- define GLB_NO_NATIVE_GL deactivated by default
-27-04-2008
-- Now supports the following libraries
-  - SDL and SDL_image
-  - libPNG
-  - libJPEG
-- Linux compatibillity via free pascal compatibility (delphi sources optional)
-- BMPs now loaded manuel
-- Large restructuring
-- Property DataPtr now has the name Data
-- Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR
-- Unused Depth removed
-- Function FreeData to freeing image data added
-24-10-2007
-- ImageID flag of TGAs was ignored. (Thanks Zwoetzen)
-15-11-2006
-- Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER)
-- Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel
-- Function ReadOpenGLExtension is now only intern
-29-06-2006
-- pngimage now disabled by default like all other versions.
-26-06-2006
-- Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi)
-22-06-2006
-- Fixed some Problem with Delphi 5
-- Now uses the newest version of pngimage. Makes saving pngs much easier.
-22-03-2006
-- Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi)
-09-03-2006
-- Internal Format ifDepth8 added
-- function GrabScreen now supports all uncompressed formats
-31-01-2006
-- AddAlphaFromglBitmap implemented
-29-12-2005
-- LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID)
-28-12-2005
-- Width, Height and Depth internal changed to TglBitmapPixelPosition.
-  property Width, Height, Depth are still existing and new property Dimension are avail
-11-12-2005
-- Added native OpenGL Support. Breaking the dglOpenGL "barrier".
-19-10-2005
-- Added function GrabScreen to class TglBitmap2D
-18-10-2005
-- Added support to Save images
-- Added function Clone to Clone Instance
-11-10-2005
-- Functions now works with Cardinals for each channel. Up to 32 Bits per channel.
-  Usefull for Future
-- Several speed optimizations
-09-10-2005
-- Internal structure change. Loading of TGA, PNG and DDS improved.
-  Data, format and size will now set directly with SetDataPtr.
-- AddFunc now works with all Types of Images and Formats
-- Some Funtions moved to Baseclass TglBitmap
-06-10-2005
-- Added Support to decompress DXT3 and DXT5 compressed Images.
-- Added Mapping to convert data from one format into an other.
-05-10-2005
-- Added method ConvertTo in Class TglBitmap2D. Method allows to convert every
-  supported Input format (supported by GetPixel) into any uncompresed Format
-- Added Support to decompress DXT1 compressed Images.
-- SwapColors replaced by ConvertTo
-04-10-2005
-- Added Support for compressed DDSs
-- Added new internal formats (DXT1, DXT3, DXT5)
-29-09-2005
-- Parameter Components renamed to InternalFormat
-23-09-2005
-- Some AllocMem replaced with GetMem (little speed change)
-- better exception handling. Better protection from memory leaks.
-22-09-2005
-- Added support for Direct Draw Surfaces (.DDS) (uncompressed images only)
-- Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5)
-07-09-2005
-- Added support for Grayscale textures
-- Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8)
-10-07-2005
-- Added support for GL_VERSION_2_0
-- Added support for GL_EXT_texture_filter_anisotropic
-04-07-2005
-- Function FillWithColor fills the Image with one Color
-- Function LoadNormalMap added
-30-06-2005
-- ToNormalMap allows to Create an NormalMap from the Alphachannel
-- ToNormalMap now supports Sobel (nmSobel) function.
-29-06-2005
-- support for RLE Compressed RGB TGAs added
-28-06-2005
-- Class TglBitmapNormalMap added to support Normalmap generation
-- Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures.
-  3 Filters are supported. (4 Samples, 3x3 and 5x5)
-16-06-2005
-- Method LoadCubeMapClass removed
-- LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures
-- virtual abstract method GenTexture in class TglBitmap now is protected
-12-06-2005
-- now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal
-10-06-2005
-- little enhancement for IsPowerOfTwo
-- TglBitmap1D.GenTexture now tests NPOT Textures
-06-06-2005
-- some little name changes. All properties or function with Texture in name are
-  now without texture in name. We have allways texture so we dosn't name it.
-03-06-2005
-- GenTexture now tests if texture is NPOT and NPOT-Texture are supported or
-  TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception.
-02-06-2005
-- added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle
-25-04-2005
-- Function Unbind added
-- call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture.
-21-04-2005
-- class TglBitmapCubeMap added (allows to Create Cubemaps)
-29-03-2005
-- Added Support for PNG Images. (http://pngdelphi.sourceforge.net/)
-  To Enable png's use the define pngimage
-22-03-2005
-- New Functioninterface added
-- Function GetPixel added
-27-11-2004
-- Property BuildMipMaps renamed to MipMap
-21-11-2004
-- property Name removed.
-- BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap
-22-05-2004
-- property name added. Only used in glForms!
-26-11-2003
-- property FreeDataAfterGenTexture is now available as default (default = true)
-- BuildMipmaps now implemented in TglBitmap1D (i've forgotten it)
-- function MoveMemory replaced with function Move (little speed change)
-- several calculations stored in variables (little speed change)
-29-09-2003
-- property BuildMipsMaps added (default = true)
-  if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps
-- property FreeDataAfterGenTexture added (default = true)
-  if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated.
-- parameter DisableOtherTextureUnits of Bind removed
-- parameter FreeDataAfterGeneration of GenTextures removed
-12-09-2003
-- TglBitmap dosn't delete data if class was destroyed (fixed)
-09-09-2003
-- Bind now enables TextureUnits (by params)
-- GenTextures can leave data (by param)
-- LoadTextures now optimal
-03-09-2003
-- Performance optimization in AddFunc
-- procedure Bind moved to subclasses
-- Added new Class TglBitmap1D to support real OpenGL 1D Textures
-19-08-2003
-- Texturefilter and texturewrap now also as defaults
-  Minfilter = GL_LINEAR_MIPMAP_LINEAR
-  Magfilter = GL_LINEAR
-  Wrap(str) = GL_CLAMP_TO_EDGE
-- Added new format tfCompressed to create a compressed texture.
-- propertys IsCompressed, TextureSize and IsResident added
-  IsCompressed and TextureSize only contains data from level 0
-18-08-2003
-- Added function AddFunc to add PerPixelEffects to Image
-- LoadFromFunc now based on AddFunc
-- Invert now based on AddFunc
-- SwapColors now based on AddFunc
-16-08-2003
-- Added function FlipHorz
-15-08-2003
-- Added function LaodFromFunc to create images with function
-- Added function FlipVert
-- Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported
-29-07-2003
-- Added Alphafunctions to calculate alpha per function
-- Added Alpha from ColorKey using alphafunctions
-28-07-2003
-- First full functionally Version of glBitmap
-- Support for 24Bit and 32Bit TGA Pictures added
-25-07-2003
-- begin of programming
-***********************************************************}
-unit glBitmap;
-
-// Please uncomment the defines below to configure the glBitmap to your preferences.
-// If you have configured the unit you can uncomment the warning above.
-{$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Preferences ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// activate to enable build-in OpenGL support with statically linked methods
-// use dglOpenGL.pas if not enabled
-{.$DEFINE GLB_NATIVE_OGL_STATIC}
-
-// activate to enable build-in OpenGL support with dynamically linked methods
-// use dglOpenGL.pas if not enabled
-{.$DEFINE GLB_NATIVE_OGL_DYNAMIC}
-
-
-// activate to enable the support for SDL_surfaces
-{.$DEFINE GLB_SDL}
-
-// activate  to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap)
-{.$DEFINE GLB_DELPHI}
-
-// activate to enable the support for TLazIntfImage from Lazarus
-{.$DEFINE GLB_LAZARUS}
-
-
-
-// activate to enable the support of SDL_image to load files. (READ ONLY)
-// If you enable SDL_image all other libraries will be ignored!
-{.$DEFINE GLB_SDL_IMAGE}
-
-
-
-// activate to enable Lazarus TPortableNetworkGraphic support
-// if you enable this pngImage and libPNG will be ignored
-{.$DEFINE GLB_LAZ_PNG}
-
-// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/
-// if you enable pngimage the libPNG will be ignored
-{.$DEFINE GLB_PNGIMAGE}
-
-// activate to use the libPNG -> http://www.libpng.org/
-// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng
-{.$DEFINE GLB_LIB_PNG}
-
-
-
-// activate to enable Lazarus TJPEGImage support
-// if you enable this delphi jpegs and libJPEG will be ignored
-{.$DEFINE GLB_LAZ_JPEG}
-
-// if you enable delphi jpegs the libJPEG will be ignored
-{.$DEFINE GLB_DELPHI_JPEG}
-
-// activate to use the libJPEG -> http://www.ijg.org/
-// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg
-{.$DEFINE GLB_LIB_JPEG}
-
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// PRIVATE: do not change anything! //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Delphi Versions
-{$IFDEF fpc}
-  {$MODE Delphi}
-
-  {$IFDEF CPUI386}
-    {$DEFINE CPU386}
-    {$ASMMODE INTEL}
-  {$ENDIF}
-
-  {$IFNDEF WINDOWS}
-    {$linklib c}
-  {$ENDIF}
-{$ENDIF}
-
-// Operation System
-{$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)}
-  {$DEFINE GLB_WIN}
-{$ELSEIF DEFINED(LINUX)}
-  {$DEFINE GLB_LINUX}
-{$IFEND}
-
-// native OpenGL Support
-{$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
-  {$DEFINE GLB_NATIVE_OGL}
-{$IFEND}
-
-// checking define combinations
-//SDL Image
-{$IFDEF GLB_SDL_IMAGE}
-  {$IFNDEF GLB_SDL}
-    {$MESSAGE warn 'SDL_image won''t work without SDL. SDL will be activated.'}
-    {$DEFINE GLB_SDL}
-  {$ENDIF}
-
-  {$IFDEF GLB_LAZ_PNG}
-    {$MESSAGE warn 'The Lazarus TPortableNetworkGraphics will be ignored because you are using SDL_image.'}
-    {$undef GLB_LAZ_PNG}
-  {$ENDIF}
-
-  {$IFDEF GLB_PNGIMAGE}
-    {$MESSAGE warn 'The unit pngimage will be ignored because you are using SDL_image.'}
-    {$undef GLB_PNGIMAGE}
-  {$ENDIF}
-
-  {$IFDEF GLB_LAZ_JPEG}
-    {$MESSAGE warn 'The Lazarus TJPEGImage will be ignored because you are using SDL_image.'}
-    {$undef GLB_LAZ_JPEG}
-  {$ENDIF}
-
-  {$IFDEF GLB_DELPHI_JPEG}
-    {$MESSAGE warn 'The unit JPEG will be ignored because you are using SDL_image.'}
-    {$undef GLB_DELPHI_JPEG}
-  {$ENDIF}
-
-  {$IFDEF GLB_LIB_PNG}
-    {$MESSAGE warn 'The library libPNG will be ignored because you are using SDL_image.'}
-    {$undef GLB_LIB_PNG}
-  {$ENDIF}
-
-  {$IFDEF GLB_LIB_JPEG}
-    {$MESSAGE warn 'The library libJPEG will be ignored because you are using SDL_image.'}
-    {$undef GLB_LIB_JPEG}
-  {$ENDIF}
-
-  {$DEFINE GLB_SUPPORT_PNG_READ}
-  {$DEFINE GLB_SUPPORT_JPEG_READ}
-{$ENDIF}
-
-// Lazarus TPortableNetworkGraphic
-{$IFDEF GLB_LAZ_PNG}
-  {$IFNDEF GLB_LAZARUS}
-    {$MESSAGE warn 'Lazarus TPortableNetworkGraphic won''t work without Lazarus. Lazarus will be activated.'}
-    {$DEFINE GLB_LAZARUS}
-  {$ENDIF}
-
-  {$IFDEF GLB_PNGIMAGE}
-    {$MESSAGE warn 'The pngimage will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
-    {$undef GLB_PNGIMAGE}
-  {$ENDIF}
-
-  {$IFDEF GLB_LIB_PNG}
-    {$MESSAGE warn 'The library libPNG will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
-    {$undef GLB_LIB_PNG}
-  {$ENDIF}
-
-  {$DEFINE GLB_SUPPORT_PNG_READ}
-  {$DEFINE GLB_SUPPORT_PNG_WRITE}
-{$ENDIF}
-
-// PNG Image
-{$IFDEF GLB_PNGIMAGE}
-  {$IFDEF GLB_LIB_PNG}
-    {$MESSAGE warn 'The library libPNG will be ignored if you are using pngimage.'}
-    {$undef GLB_LIB_PNG}
-  {$ENDIF}
-
-  {$DEFINE GLB_SUPPORT_PNG_READ}
-  {$DEFINE GLB_SUPPORT_PNG_WRITE}
-{$ENDIF}
-
-// libPNG
-{$IFDEF GLB_LIB_PNG}
-  {$DEFINE GLB_SUPPORT_PNG_READ}
-  {$DEFINE GLB_SUPPORT_PNG_WRITE}
-{$ENDIF}
-
-// Lazarus TJPEGImage
-{$IFDEF GLB_LAZ_JPEG}
-  {$IFNDEF GLB_LAZARUS}
-    {$MESSAGE warn 'Lazarus TJPEGImage won''t work without Lazarus. Lazarus will be activated.'}
-    {$DEFINE GLB_LAZARUS}
-  {$ENDIF}
-
-  {$IFDEF GLB_DELPHI_JPEG}
-    {$MESSAGE warn 'The Delphi JPEGImage will be ignored if you are using the Lazarus TJPEGImage.'}
-    {$undef GLB_DELPHI_JPEG}
-  {$ENDIF}
-
-  {$IFDEF GLB_LIB_JPEG}
-    {$MESSAGE warn 'The library libJPEG will be ignored if you are using the Lazarus TJPEGImage.'}
-    {$undef GLB_LIB_JPEG}
-  {$ENDIF}
-
-  {$DEFINE GLB_SUPPORT_JPEG_READ}
-  {$DEFINE GLB_SUPPORT_JPEG_WRITE}
-{$ENDIF}
-
-// JPEG Image
-{$IFDEF GLB_DELPHI_JPEG}
-  {$IFDEF GLB_LIB_JPEG}
-    {$MESSAGE warn 'The library libJPEG will be ignored if you are using the unit JPEG.'}
-    {$undef GLB_LIB_JPEG}
-  {$ENDIF}
-
-  {$DEFINE GLB_SUPPORT_JPEG_READ}
-  {$DEFINE GLB_SUPPORT_JPEG_WRITE}
-{$ENDIF}
-
-// libJPEG
-{$IFDEF GLB_LIB_JPEG}
-  {$DEFINE GLB_SUPPORT_JPEG_READ}
-  {$DEFINE GLB_SUPPORT_JPEG_WRITE}
-{$ENDIF}
-
-// native OpenGL
-{$IF DEFINED(GLB_NATIVE_OGL_STATIC) AND DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
-  {$MESSAGE warn 'GLB_NATIVE_OGL_STATIC will be ignored because you enabled GLB_NATIVE_OGL_DYNAMIC'}
-{$IFEND}
-
-// general options
-{$EXTENDEDSYNTAX ON}
-{$LONGSTRINGS ON}
-{$ALIGN ON}
-{$IFNDEF FPC}
-  {$OPTIMIZATION ON}
-{$ENDIF}
-
-interface
-
-uses
-  {$IFNDEF GLB_NATIVE_OGL}      dglOpenGL,                          {$ENDIF}
-  {$IF DEFINED(GLB_WIN) AND
-       (DEFINED(GLB_NATIVE_OGL) OR
-        DEFINED(GLB_DELPHI))}   windows,                            {$IFEND}
-
-  {$IFDEF GLB_SDL}              SDL,                                {$ENDIF}
-  {$IFDEF GLB_LAZARUS}          IntfGraphics, GraphType, Graphics,  {$ENDIF}
-  {$IFDEF GLB_DELPHI}           Dialogs, Graphics, Types,           {$ENDIF}
-
-  {$IFDEF GLB_SDL_IMAGE}        SDL_image,                          {$ENDIF}
-  {$IFDEF GLB_PNGIMAGE}         pngimage,                           {$ENDIF}
-  {$IFDEF GLB_LIB_PNG}          libPNG,                             {$ENDIF}
-  {$IFDEF GLB_DELPHI_JPEG}      JPEG,                               {$ENDIF}
-  {$IFDEF GLB_LIB_JPEG}         libJPEG,                            {$ENDIF}
-
-  Classes, SysUtils;
-
-{$IFDEF GLB_NATIVE_OGL}
-const
-  GL_TRUE   = 1;
-  GL_FALSE  = 0;
-
-  GL_ZERO = 0;
-  GL_ONE  = 1;
-
-  GL_VERSION    = $1F02;
-  GL_EXTENSIONS = $1F03;
-
-  GL_TEXTURE_1D         = $0DE0;
-  GL_TEXTURE_2D         = $0DE1;
-  GL_TEXTURE_RECTANGLE  = $84F5;
-
-  GL_NORMAL_MAP                   = $8511;
-  GL_TEXTURE_CUBE_MAP             = $8513;
-  GL_REFLECTION_MAP               = $8512;
-  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_TEXTURE_WIDTH            = $1000;
-  GL_TEXTURE_HEIGHT           = $1001;
-  GL_TEXTURE_INTERNAL_FORMAT  = $1003;
-  GL_TEXTURE_SWIZZLE_RGBA     = $8E46;
-
-  GL_S = $2000;
-  GL_T = $2001;
-  GL_R = $2002;
-  GL_Q = $2003;
-
-  GL_TEXTURE_GEN_S = $0C60;
-  GL_TEXTURE_GEN_T = $0C61;
-  GL_TEXTURE_GEN_R = $0C62;
-  GL_TEXTURE_GEN_Q = $0C63;
-
-  GL_RED    = $1903;
-  GL_GREEN  = $1904;
-  GL_BLUE   = $1905;
-
-  GL_ALPHA    = $1906;
-  GL_ALPHA4   = $803B;
-  GL_ALPHA8   = $803C;
-  GL_ALPHA12  = $803D;
-  GL_ALPHA16  = $803E;
-
-  GL_LUMINANCE    = $1909;
-  GL_LUMINANCE4   = $803F;
-  GL_LUMINANCE8   = $8040;
-  GL_LUMINANCE12  = $8041;
-  GL_LUMINANCE16  = $8042;
-
-  GL_LUMINANCE_ALPHA      = $190A;
-  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_RGB      = $1907;
-  GL_BGR      = $80E0;
-  GL_R3_G3_B2 = $2A10;
-  GL_RGB4     = $804F;
-  GL_RGB5     = $8050;
-  GL_RGB565   = $8D62;
-  GL_RGB8     = $8051;
-  GL_RGB10    = $8052;
-  GL_RGB12    = $8053;
-  GL_RGB16    = $8054;
-
-  GL_RGBA     = $1908;
-  GL_BGRA     = $80E1;
-  GL_RGBA2    = $8055;
-  GL_RGBA4    = $8056;
-  GL_RGB5_A1  = $8057;
-  GL_RGBA8    = $8058;
-  GL_RGB10_A2 = $8059;
-  GL_RGBA12   = $805A;
-  GL_RGBA16   = $805B;
-
-  GL_DEPTH_COMPONENT    = $1902;
-  GL_DEPTH_COMPONENT16  = $81A5;
-  GL_DEPTH_COMPONENT24  = $81A6;
-  GL_DEPTH_COMPONENT32  = $81A7;
-
-  GL_COMPRESSED_RGB                 = $84ED;
-  GL_COMPRESSED_RGBA                = $84EE;
-  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_UNSIGNED_BYTE            = $1401;
-  GL_UNSIGNED_BYTE_3_3_2      = $8032;
-  GL_UNSIGNED_BYTE_2_3_3_REV  = $8362;
-
-  GL_UNSIGNED_SHORT             = $1403;
-  GL_UNSIGNED_SHORT_5_6_5       = $8363;
-  GL_UNSIGNED_SHORT_4_4_4_4     = $8033;
-  GL_UNSIGNED_SHORT_5_5_5_1     = $8034;
-  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                 = $1405;
-  GL_UNSIGNED_INT_8_8_8_8         = $8035;
-  GL_UNSIGNED_INT_10_10_10_2      = $8036;
-  GL_UNSIGNED_INT_8_8_8_8_REV     = $8367;
-  GL_UNSIGNED_INT_2_10_10_10_REV  = $8368;
-
-  { Texture Filter }
-  GL_TEXTURE_MAG_FILTER     = $2800;
-  GL_TEXTURE_MIN_FILTER     = $2801;
-  GL_NEAREST                = $2600;
-  GL_NEAREST_MIPMAP_NEAREST = $2700;
-  GL_NEAREST_MIPMAP_LINEAR  = $2702;
-  GL_LINEAR                 = $2601;
-  GL_LINEAR_MIPMAP_NEAREST  = $2701;
-  GL_LINEAR_MIPMAP_LINEAR   = $2703;
-
-  { Texture Wrap }
-  GL_TEXTURE_WRAP_S   = $2802;
-  GL_TEXTURE_WRAP_T   = $2803;
-  GL_TEXTURE_WRAP_R   = $8072;
-  GL_CLAMP            = $2900;
-  GL_REPEAT           = $2901;
-  GL_CLAMP_TO_EDGE    = $812F;
-  GL_CLAMP_TO_BORDER  = $812D;
-  GL_MIRRORED_REPEAT  = $8370;
-
-  { Other }
-  GL_GENERATE_MIPMAP      = $8191;
-  GL_TEXTURE_BORDER_COLOR = $1004;
-  GL_MAX_TEXTURE_SIZE     = $0D33;
-  GL_PACK_ALIGNMENT       = $0D05;
-  GL_UNPACK_ALIGNMENT     = $0CF5;
-
-  GL_TEXTURE_MAX_ANISOTROPY_EXT     = $84FE;
-  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
-  GL_MAX_CUBE_MAP_TEXTURE_SIZE      = $851C;
-  GL_TEXTURE_GEN_MODE               = $2500;
-
-{$IF DEFINED(GLB_WIN)}
-  libglu    = 'glu32.dll';
-  libopengl = 'opengl32.dll';
-{$ELSEIF DEFINED(GLB_LINUX)}
-  libglu    = 'libGLU.so.1';
-  libopengl = 'libGL.so.1';
-{$IFEND}
-
-type
-  GLboolean = BYTEBOOL;
-  GLint     = Integer;
-  GLsizei   = Integer;
-  GLuint    = Cardinal;
-  GLfloat   = Single;
-  GLenum    = Cardinal;
-
-  PGLvoid    = Pointer;
-  PGLboolean = ^GLboolean;
-  PGLint     = ^GLint;
-  PGLuint    = ^GLuint;
-  PGLfloat   = ^GLfloat;
-
-  TglCompressedTexImage1D  = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-{$IF DEFINED(GLB_WIN)}
-  TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall;
-{$ELSEIF DEFINED(GLB_LINUX)}
-  TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl;
-  TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
-{$IFEND}
-
-{$IF DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
-  TglEnable  = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglDisable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-  TglGetString   = function(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-  TglTexParameteri          = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglTexParameteriv         = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglTexParameterfv         = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGetTexParameteriv      = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGetTexParameterfv      = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-  TglTexGeni        = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGenTextures    = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglBindTexture    = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-  TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglReadPixels          = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglPixelStorei         = procedure(pname: GLenum; param: GLint); {$IFDEF GLB_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 GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-  TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-  TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
-
-{$ELSEIF DEFINED(GLB_NATIVE_OGL_STATIC)}
-  procedure glEnable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glDisable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-
-  function glGetString(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-
-  procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-
-  procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-
-  function  glAreTexturesResident(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glReadPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glPixelStorei(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-
-  procedure glTexImage1D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glTexImage2D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-  procedure glGetTexImage(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
-
-  function gluBuild1DMipmaps(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
-  function gluBuild2DMipmaps(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
-{$IFEND}
-
-var
-  GL_VERSION_1_2,
-  GL_VERSION_1_3,
-  GL_VERSION_1_4,
-  GL_VERSION_2_0,
-  GL_VERSION_3_3,
-
-  GL_SGIS_generate_mipmap,
-
-  GL_ARB_texture_border_clamp,
-  GL_ARB_texture_mirrored_repeat,
-  GL_ARB_texture_rectangle,
-  GL_ARB_texture_non_power_of_two,
-  GL_ARB_texture_swizzle,
-  GL_ARB_texture_cube_map,
-
-  GL_IBM_texture_mirrored_repeat,
-
-  GL_NV_texture_rectangle,
-
-  GL_EXT_texture_edge_clamp,
-  GL_EXT_texture_rectangle,
-  GL_EXT_texture_swizzle,
-  GL_EXT_texture_cube_map,
-  GL_EXT_texture_filter_anisotropic: Boolean;
-
-  glCompressedTexImage1D: TglCompressedTexImage1D;
-  glCompressedTexImage2D: TglCompressedTexImage2D;
-  glGetCompressedTexImage: TglGetCompressedTexImage;
-
-{$IF DEFINED(GLB_WIN)}
-  wglGetProcAddress: TwglGetProcAddress;
-{$ELSEIF DEFINED(GLB_LINUX)}
-  glXGetProcAddress: TglXGetProcAddress;
-  glXGetProcAddressARB: TglXGetProcAddress;
-{$IFEND}
-
-{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
-  glEnable: TglEnable;
-  glDisable: TglDisable;
-
-  glGetString: TglGetString;
-  glGetIntegerv: TglGetIntegerv;
-
-  glTexParameteri: TglTexParameteri;
-  glTexParameteriv: TglTexParameteriv;
-  glTexParameterfv: TglTexParameterfv;
-  glGetTexParameteriv: TglGetTexParameteriv;
-  glGetTexParameterfv: TglGetTexParameterfv;
-  glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
-  glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
-
-  glTexGeni: TglTexGeni;
-  glGenTextures: TglGenTextures;
-  glBindTexture: TglBindTexture;
-  glDeleteTextures: TglDeleteTextures;
-
-  glAreTexturesResident: TglAreTexturesResident;
-  glReadPixels: TglReadPixels;
-  glPixelStorei: TglPixelStorei;
-
-  glTexImage1D: TglTexImage1D;
-  glTexImage2D: TglTexImage2D;
-  glGetTexImage: TglGetTexImage;
-
-  gluBuild1DMipmaps: TgluBuild1DMipmaps;
-  gluBuild2DMipmaps: TgluBuild2DMipmaps;
-{$ENDIF}
-{$ENDIF}
-
-type
-////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmapFormat = (
-    tfEmpty = 0, //must be smallest value!
-
-    tfAlpha4,
-    tfAlpha8,
-    tfAlpha16,
-
-    tfLuminance4,
-    tfLuminance8,
-    tfLuminance16,
-
-    tfLuminance4Alpha4,
-    tfLuminance6Alpha2,
-    tfLuminance8Alpha8,
-    tfLuminance12Alpha4,
-    tfLuminance16Alpha16,
-
-    tfR3G3B2,
-    tfRGBX4,
-    tfXRGB4,
-    tfR5G6B5,
-    tfRGB5X1,
-    tfX1RGB5,
-    tfRGB8,
-    tfRGBX8,
-    tfXRGB8,
-    tfRGB10X2,
-    tfX2RGB10,
-    tfRGB16,
-
-    tfRGBA4,
-    tfARGB4,
-    tfRGB5A1,
-    tfA1RGB5,
-    tfRGBA8,
-    tfARGB8,
-    tfRGB10A2,
-    tfA2RGB10,
-    tfRGBA16,
-
-    tfBGRX4,
-    tfXBGR4,
-    tfB5G6R5,
-    tfBGR5X1,
-    tfX1BGR5,
-    tfBGR8,
-    tfBGRX8,
-    tfXBGR8,
-    tfBGR10X2,
-    tfX2BGR10,
-    tfBGR16,
-
-    tfBGRA4,
-    tfABGR4,
-    tfBGR5A1,
-    tfA1BGR5,
-    tfBGRA8,
-    tfABGR8,
-    tfBGR10A2,
-    tfA2BGR10,
-    tfBGRA16,
-
-    tfDepth16,
-    tfDepth24,
-    tfDepth32,
-
-    tfS3tcDtx1RGBA,
-    tfS3tcDtx3RGBA,
-    tfS3tcDtx5RGBA
-  );
-
-  TglBitmapFileType = (
-     {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG,  {$ENDIF}
-     {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF}
-     ftDDS,
-     ftTGA,
-     ftBMP);
-   TglBitmapFileTypes = set of TglBitmapFileType;
-
-   TglBitmapMipMap = (
-     mmNone,
-     mmMipmap,
-     mmMipmapGlu);
-
-   TglBitmapNormalMapFunc = (
-     nm4Samples,
-     nmSobel,
-     nm3x3,
-     nm5x5);
-
- ////////////////////////////////////////////////////////////////////////////////////////////////////
-   EglBitmap                  = class(Exception);
-   EglBitmapNotSupported      = class(Exception);
-   EglBitmapSizeToLarge       = class(EglBitmap);
-   EglBitmapNonPowerOfTwo     = class(EglBitmap);
-   EglBitmapUnsupportedFormat = class(EglBitmap)
-   public
-     constructor Create(const aFormat: TglBitmapFormat); overload;
-     constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
-   end;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmapColorRec = packed record
-  case Integer of
-    0: (r, g, b, a: Cardinal);
-    1: (arr: array[0..3] of Cardinal);
-  end;
-
-  TglBitmapPixelData = packed record
-    Data, Range: TglBitmapColorRec;
-    Format: TglBitmapFormat;
-  end;
-  PglBitmapPixelData = ^TglBitmapPixelData;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmapPixelPositionFields = set of (ffX, ffY);
-  TglBitmapPixelPosition = record
-    Fields : TglBitmapPixelPositionFields;
-    X : Word;
-    Y : Word;
-  end;
-
-  TglBitmapFormatDescriptor = class(TObject)
-  protected
-    function GetIsCompressed: Boolean; virtual; abstract;
-    function GetHasRed:       Boolean; virtual; abstract;
-    function GetHasGreen:     Boolean; virtual; abstract;
-    function GetHasBlue:      Boolean; virtual; abstract;
-    function GetHasAlpha:     Boolean; virtual; abstract;
-
-    function GetRGBInverted:  TglBitmapFormat; virtual; abstract;
-    function GetWithAlpha:    TglBitmapFormat; virtual; abstract;
-    function GetWithoutAlpha: TglBitmapFormat; virtual; abstract;
-    function GetOpenGLFormat: TglBitmapFormat; virtual; abstract;
-    function GetUncompressed: TglBitmapFormat; virtual; abstract;
-
-    function GetglDataFormat:     GLenum;  virtual; abstract;
-    function GetglFormat:         GLenum;  virtual; abstract;
-    function GetglInternalFormat: GLenum;  virtual; abstract;
-  public
-    property IsCompressed: Boolean read GetIsCompressed;
-    property HasRed:       Boolean read GetHasRed;
-    property HasGreen:     Boolean read GetHasGreen;
-    property HasBlue:      Boolean read GetHasBlue;
-    property HasAlpha:     Boolean read GetHasAlpha;
-
-    property RGBInverted:  TglBitmapFormat read GetRGBInverted;
-    property WithAlpha:    TglBitmapFormat read GetWithAlpha;
-    property WithoutAlpha: TglBitmapFormat read GetWithoutAlpha;
-    property OpenGLFormat: TglBitmapFormat read GetOpenGLFormat;
-    property Uncompressed: TglBitmapFormat read GetUncompressed;
-
-    property glFormat:         GLenum  read GetglFormat;
-    property glInternalFormat: GLenum  read GetglInternalFormat;
-    property glDataFormat:     GLenum  read GetglDataFormat;
-  public
-    class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
-  end;
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmap = class;
-  TglBitmapFunctionRec = record
-    Sender:   TglBitmap;
-    Size:     TglBitmapPixelPosition;
-    Position: TglBitmapPixelPosition;
-    Source:   TglBitmapPixelData;
-    Dest:     TglBitmapPixelData;
-    Args:     Pointer;
-  end;
-  TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmap = class
-  private
-    function GetFormatDesc: TglBitmapFormatDescriptor;
-  protected
-    fID: GLuint;
-    fTarget: GLuint;
-    fAnisotropic: Integer;
-    fDeleteTextureOnFree: Boolean;
-    fFreeDataOnDestroy: Boolean;
-    fFreeDataAfterGenTexture: Boolean;
-    fData: PByte;
-    fIsResident: GLboolean;
-    fBorderColor: array[0..3] of Single;
-
-    fDimension: TglBitmapPixelPosition;
-    fMipMap: TglBitmapMipMap;
-    fFormat: TglBitmapFormat;
-
-    // Mapping
-    fPixelSize: Integer;
-    fRowSize: Integer;
-
-    // Filtering
-    fFilterMin: GLenum;
-    fFilterMag: GLenum;
-
-    // TexturWarp
-    fWrapS: GLenum;
-    fWrapT: GLenum;
-    fWrapR: GLenum;
-
-    //Swizzle
-    fSwizzle: array[0..3] of GLenum;
-
-    // CustomData
-    fFilename: String;
-    fCustomName: String;
-    fCustomNameW: WideString;
-    fCustomData: Pointer;
-
-    //Getter
-    function GetWidth:  Integer; virtual;
-    function GetHeight: Integer; virtual;
-
-    function GetFileWidth:  Integer; virtual;
-    function GetFileHeight: Integer; virtual;
-
-    //Setter
-    procedure SetCustomData(const aValue: Pointer);
-    procedure SetCustomName(const aValue: String);
-    procedure SetCustomNameW(const aValue: WideString);
-    procedure SetFreeDataOnDestroy(const aValue: Boolean);
-    procedure SetDeleteTextureOnFree(const aValue: Boolean);
-    procedure SetFormat(const aValue: TglBitmapFormat);
-    procedure SetFreeDataAfterGenTexture(const aValue: Boolean);
-    procedure SetID(const aValue: Cardinal);
-    procedure SetMipMap(const aValue: TglBitmapMipMap);
-    procedure SetTarget(const aValue: Cardinal);
-    procedure SetAnisotropic(const aValue: Integer);
-
-    procedure CreateID;
-    procedure SetupParameters(out aBuildWithGlu: Boolean);
-    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
-      const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;  //be careful, aData could be freed by this method
-    procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;
-
-    function FlipHorz: Boolean; virtual;
-    function FlipVert: Boolean; virtual;
-
-    property Width:  Integer read GetWidth;
-    property Height: Integer read GetHeight;
-
-    property FileWidth:  Integer read GetFileWidth;
-    property FileHeight: Integer read GetFileHeight;
-  public
-    //Properties
-    property ID:           Cardinal        read fID          write SetID;
-    property Target:       Cardinal        read fTarget      write SetTarget;
-    property Format:       TglBitmapFormat read fFormat      write SetFormat;
-    property MipMap:       TglBitmapMipMap read fMipMap      write SetMipMap;
-    property Anisotropic:  Integer         read fAnisotropic write SetAnisotropic;
-
-    property FormatDesc:   TglBitmapFormatDescriptor read GetFormatDesc;
-
-    property Filename:    String     read fFilename;
-    property CustomName:  String     read fCustomName  write SetCustomName;
-    property CustomNameW: WideString read fCustomNameW write SetCustomNameW;
-    property CustomData:  Pointer    read fCustomData  write SetCustomData;
-
-    property DeleteTextureOnFree:     Boolean read fDeleteTextureOnFree     write SetDeleteTextureOnFree;
-    property FreeDataOnDestroy:       Boolean read fFreeDataOnDestroy       write SetFreeDataOnDestroy;
-    property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture;
-
-    property Dimension:  TglBitmapPixelPosition  read fDimension;
-    property Data:       PByte                   read fData;
-    property IsResident: GLboolean               read fIsResident;
-
-    procedure AfterConstruction; override;
-    procedure BeforeDestruction; override;
-
-    procedure PrepareResType(var aResource: String; var aResType: PChar);
-
-    //Load
-    procedure LoadFromFile(const aFilename: String);
-    procedure LoadFromStream(const aStream: TStream); virtual;
-    procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction;
-      const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);
-    procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);
-    procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
-
-    //Save
-    procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType);
-    procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
-
-    //Convert
-    function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;
-    function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
-      const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;
-  public
-    //Alpha & Co
-    {$IFDEF GLB_SDL}
-    function AssignToSurface(out aSurface: PSDL_Surface): Boolean;
-    function AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
-    function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
-    function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil;
-      const aArgs: Pointer = nil): Boolean;
-    {$ENDIF}
-
-    {$IFDEF GLB_DELPHI}
-    function AssignToBitmap(const aBitmap: TBitmap): Boolean;
-    function AssignFromBitmap(const aBitmap: TBitmap): Boolean;
-    function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
-    function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil;
-      const aArgs: Pointer = nil): Boolean;
-    {$ENDIF}
-
-    {$IFDEF GLB_LAZARUS}
-    function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-    function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
-    function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-    function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil;
-      const aArgs: Pointer = nil): Boolean;
-    {$ENDIF}
-
-    function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil;
-      const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-    function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar;
-      const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-
-    function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;
-    function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-    function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-    function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-
-    function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;
-    function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;
-    function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;
-
-    function AddAlphaFromValue(const aAlpha: Byte): Boolean;
-    function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
-    function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
-
-    function RemoveAlpha: Boolean; virtual;
-  public
-    //Common
-    function Clone: TglBitmap;
-    function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;
-    procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false);
-    procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
-    procedure FreeData;
-
-    //ColorFill
-    procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);
-    procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);
-    procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1);
-
-    //TexParameters
-    procedure SetFilter(const aMin, aMag: GLenum);
-    procedure SetWrap(
-      const S: GLenum = GL_CLAMP_TO_EDGE;
-      const T: GLenum = GL_CLAMP_TO_EDGE;
-      const R: GLenum = GL_CLAMP_TO_EDGE);
-    procedure SetSwizzle(const r, g, b, a: GLenum);
-
-    procedure Bind(const aEnableTextureUnit: Boolean = true); virtual;
-    procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;
-
-    //Constructors
-    constructor Create; overload;
-    constructor Create(const aFileName: String); overload;
-    constructor Create(const aStream: TStream); overload;
-    constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;
-    constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;
-    constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;
-    constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
-  private
-    {$IFDEF GLB_SUPPORT_PNG_READ}  function  LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF}
-    {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF}
-
-    {$IFDEF GLB_SUPPORT_JPEG_READ}  function  LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF}
-    {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF}
-
-    function LoadBMP(const aStream: TStream): Boolean; virtual;
-    procedure SaveBMP(const aStream: TStream); virtual;
-
-    function LoadTGA(const aStream: TStream): Boolean; virtual;
-    procedure SaveTGA(const aStream: TStream); virtual;
-
-    function LoadDDS(const aStream: TStream): Boolean; virtual;
-    procedure SaveDDS(const aStream: TStream); virtual;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmap1D = class(TglBitmap)
-  protected
-    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
-      const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
-    procedure UploadData(const aBuildWithGlu: Boolean);
-  public
-    property Width;
-    procedure AfterConstruction; override;
-    function FlipHorz: Boolean; override;
-    procedure GenTexture(const aTestTextureSize: Boolean = true); override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmap2D = class(TglBitmap)
-  protected
-    fLines: array of PByte;
-    function GetScanline(const aIndex: Integer): Pointer;
-    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
-      const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
-    procedure UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean);
-  public
-    property Width;
-    property Height;
-    property Scanline[const aIndex: Integer]: Pointer read GetScanline;
-
-    procedure AfterConstruction; override;
-
-    procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);
-    procedure GetDataFromTexture;
-    procedure GenTexture(const aTestTextureSize: Boolean = true); override;
-
-    function FlipHorz: Boolean; override;
-    function FlipVert: Boolean; override;
-
-    procedure ToNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3;
-      const aScale: Single = 2; const aUseAlpha: Boolean = false);
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmapCubeMap = class(TglBitmap2D)
-  protected
-    fGenMode: Integer;
-    procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce;
-  public
-    procedure AfterConstruction; override;
-    procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true);
-    procedure Bind(const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true); reintroduce; virtual;
-    procedure Unbind(const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true); reintroduce; virtual;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TglBitmapNormalMap = class(TglBitmapCubeMap)
-  public
-    procedure AfterConstruction; override;
-    procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true);
-  end;
-
-const
-  NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0);
-
-procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
-procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
-procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
-procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
-procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
-procedure glBitmapSetDefaultWrap(
-  const S: Cardinal = GL_CLAMP_TO_EDGE;
-  const T: Cardinal = GL_CLAMP_TO_EDGE;
-  const R: Cardinal = GL_CLAMP_TO_EDGE);
-
-function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
-function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
-function glBitmapGetDefaultMipmap: TglBitmapMipMap;
-function glBitmapGetDefaultFormat: TglBitmapFormat;
-procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
-procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
-
-function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
-function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec;
-function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean;
-
-var
-  glBitmapDefaultDeleteTextureOnFree: Boolean;
-  glBitmapDefaultFreeDataAfterGenTextures: Boolean;
-  glBitmapDefaultFormat: TglBitmapFormat;
-  glBitmapDefaultMipmap: TglBitmapMipMap;
-  glBitmapDefaultFilterMin: Cardinal;
-  glBitmapDefaultFilterMag: Cardinal;
-  glBitmapDefaultWrapS: Cardinal;
-  glBitmapDefaultWrapT: Cardinal;
-  glBitmapDefaultWrapR: Cardinal;
-  glDefaultSwizzle: array[0..3] of GLenum;
-
-{$IFDEF GLB_DELPHI}
-function CreateGrayPalette: HPALETTE;
-{$ENDIF}
-
-implementation
-
-uses
-  Math, syncobjs, typinfo
-  {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND};
-
-type
-{$IFNDEF fpc}
-  QWord   = System.UInt64;
-  PQWord  = ^QWord;
-
-  PtrInt  = Longint;
-  PtrUInt = DWord;
-{$ENDIF}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-  TShiftRec = packed record
-  case Integer of
-    0: (r, g, b, a: Byte);
-    1: (arr: array[0..3] of Byte);
-  end;
-
-  TFormatDescriptor = class(TglBitmapFormatDescriptor)
-  private
-    function GetRedMask: QWord;
-    function GetGreenMask: QWord;
-    function GetBlueMask: QWord;
-    function GetAlphaMask: QWord;
-  protected
-    fFormat: TglBitmapFormat;
-    fWithAlpha: TglBitmapFormat;
-    fWithoutAlpha: TglBitmapFormat;
-    fOpenGLFormat: TglBitmapFormat;
-    fRGBInverted: TglBitmapFormat;
-    fUncompressed: TglBitmapFormat;
-
-    fPixelSize: Single;
-    fIsCompressed: Boolean;
-
-    fRange: TglBitmapColorRec;
-    fShift: TShiftRec;
-
-    fglFormat:         GLenum;
-    fglInternalFormat: GLenum;
-    fglDataFormat:     GLenum;
-
-    function GetIsCompressed: Boolean; override;
-    function GetHasRed: Boolean; override;
-    function GetHasGreen: Boolean; override;
-    function GetHasBlue: Boolean; override;
-    function GetHasAlpha: Boolean; override;
-
-    function GetRGBInverted:  TglBitmapFormat; override;
-    function GetWithAlpha:    TglBitmapFormat; override;
-    function GetWithoutAlpha: TglBitmapFormat; override;
-    function GetOpenGLFormat: TglBitmapFormat; override;
-    function GetUncompressed: TglBitmapFormat; override;
-
-    function GetglFormat: GLenum; override;
-    function GetglInternalFormat: GLenum; override;
-    function GetglDataFormat: GLenum; override;
-
-    function GetComponents: Integer; virtual;
-  public
-    property Format:       TglBitmapFormat read fFormat;
-    property Components:   Integer         read GetComponents;
-    property PixelSize:    Single          read fPixelSize;
-
-    property Range: TglBitmapColorRec read fRange;
-    property Shift: TShiftRec         read fShift;
-
-    property RedMask:   QWord read GetRedMask;
-    property GreenMask: QWord read GetGreenMask;
-    property BlueMask:  QWord read GetBlueMask;
-    property AlphaMask: QWord read GetAlphaMask;
-
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract;
-
-    function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual;
-    function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
-
-    function CreateMappingData: Pointer; virtual;
-    procedure FreeMappingData(var aMappingData: Pointer); virtual;
-
-    function IsEmpty:  Boolean; virtual;
-    function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; virtual;
-
-    procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual;
-
-    constructor Create; virtual;
-  public
-    class procedure Init;
-    class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
-    class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
-    class procedure Clear;
-    class procedure Finalize;
-  end;
-  TFormatDescriptorClass = class of TFormatDescriptor;
-
-  TfdEmpty = class(TFormatDescriptor);
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TfdAlpha_UB1 = class(TFormatDescriptor) //1* unsigned byte
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdLuminance_UB1 = class(TFormatDescriptor) //1* unsigned byte
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdUniversal_UB1 = class(TFormatDescriptor) //1* unsigned byte
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //2* unsigned byte
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdRGB_UB3 = class(TFormatDescriptor) //3* unsigned byte
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdBGR_UB3 = class(TFormatDescriptor) //3* unsigned byte (inverse)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TfdAlpha_US1 = class(TFormatDescriptor) //1* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdLuminance_US1 = class(TFormatDescriptor) //1* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdUniversal_US1 = class(TFormatDescriptor) //1* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdDepth_US1 = class(TFormatDescriptor) //1* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //2* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdRGB_US3 = class(TFormatDescriptor) //3* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdBGR_US3 = class(TFormatDescriptor) //3* unsigned short (inverse)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdRGBA_US4 = class(TfdRGB_US3) //4* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdARGB_US4 = class(TfdRGB_US3) //4* unsigned short
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdBGRA_US4 = class(TfdBGR_US3) //4* unsigned short (inverse)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdABGR_US4 = class(TfdBGR_US3) //4* unsigned short (inverse)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TfdUniversal_UI1 = class(TFormatDescriptor) //1* unsigned int
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-  TfdDepth_UI1 = class(TFormatDescriptor) //1* unsigned int
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TfdAlpha4 = class(TfdAlpha_UB1)
-    constructor Create; override;
-  end;
-
-  TfdAlpha8 = class(TfdAlpha_UB1)
-    constructor Create; override;
-  end;
-
-  TfdAlpha16 = class(TfdAlpha_US1)
-    constructor Create; override;
-  end;
-
-  TfdLuminance4 = class(TfdLuminance_UB1)
-    constructor Create; override;
-  end;
-
-  TfdLuminance8 = class(TfdLuminance_UB1)
-    constructor Create; override;
-  end;
-
-  TfdLuminance16 = class(TfdLuminance_US1)
-    constructor Create; override;
-  end;
-
-  TfdLuminance4Alpha4 = class(TfdLuminanceAlpha_UB2)
-    constructor Create; override;
-  end;
-
-  TfdLuminance6Alpha2 = class(TfdLuminanceAlpha_UB2)
-    constructor Create; override;
-  end;
-
-  TfdLuminance8Alpha8 = class(TfdLuminanceAlpha_UB2)
-    constructor Create; override;
-  end;
-
-  TfdLuminance12Alpha4 = class(TfdLuminanceAlpha_US2)
-    constructor Create; override;
-  end;
-
-  TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2)
-    constructor Create; override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TfdR3G3B2 = class(TfdUniversal_UB1)
-    constructor Create; override;
-  end;
-
-  TfdRGBX4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdXRGB4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdR5G6B5 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdRGB5X1 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdX1RGB5 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdRGB8 = class(TfdRGB_UB3)
-    constructor Create; override;
-  end;
-
-  TfdRGBX8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdXRGB8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdRGB10X2 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdX2RGB10 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdRGB16 = class(TfdRGB_US3)
-    constructor Create; override;
-  end;
-
-  TfdRGBA4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdARGB4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdRGB5A1 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdA1RGB5 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdRGBA8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdARGB8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdRGB10A2 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdA2RGB10 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdRGBA16 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TfdBGRX4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdXBGR4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdB5G6R5 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdBGR5X1 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdX1BGR5 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdBGR8 = class(TfdBGR_UB3)
-    constructor Create; override;
-  end;
-
-  TfdBGRX8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdXBGR8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdBGR10X2 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdX2BGR10 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdBGR16 = class(TfdBGR_US3)
-    constructor Create; override;
-  end;
-
-  TfdBGRA4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdABGR4 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdBGR5A1 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdA1BGR5 = class(TfdUniversal_US1)
-    constructor Create; override;
-  end;
-
-  TfdBGRA8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdABGR8 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdBGR10A2 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdA2BGR10 = class(TfdUniversal_UI1)
-    constructor Create; override;
-  end;
-
-  TfdBGRA16 = class(TfdBGRA_US4)
-    constructor Create; override;
-  end;
-
-  TfdDepth16 = class(TfdDepth_US1)
-    constructor Create; override;
-  end;
-
-  TfdDepth24 = class(TfdDepth_UI1)
-    constructor Create; override;
-  end;
-
-  TfdDepth32 = class(TfdDepth_UI1)
-    constructor Create; override;
-  end;
-
-  TfdS3tcDtx1RGBA = class(TFormatDescriptor)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-    constructor Create; override;
-  end;
-
-  TfdS3tcDtx3RGBA = class(TFormatDescriptor)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-    constructor Create; override;
-  end;
-
-  TfdS3tcDtx5RGBA = class(TFormatDescriptor)
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-    constructor Create; override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TbmpBitfieldFormat = class(TFormatDescriptor)
-  private
-    procedure SetRedMask  (const aValue: QWord);
-    procedure SetGreenMask(const aValue: QWord);
-    procedure SetBlueMask (const aValue: QWord);
-    procedure SetAlphaMask(const aValue: QWord);
-
-    procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte);
-  public
-    property RedMask:   QWord read GetRedMask   write SetRedMask;
-    property GreenMask: QWord read GetGreenMask write SetGreenMask;
-    property BlueMask:  QWord read GetBlueMask  write SetBlueMask;
-    property AlphaMask: QWord read GetAlphaMask write SetAlphaMask;
-
-    property PixelSize: Single read fPixelSize write fPixelSize;
-
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-  TbmpColorTableEnty = packed record
-    b, g, r, a: Byte;
-  end;
-  TbmpColorTable = array of TbmpColorTableEnty;
-  TbmpColorTableFormat = class(TFormatDescriptor)
-  private
-    fColorTable: TbmpColorTable;
-  public
-    property PixelSize:  Single            read fPixelSize  write fPixelSize;
-    property ColorTable: TbmpColorTable    read fColorTable write fColorTable;
-    property Range:      TglBitmapColorRec read fRange      write fRange;
-    property Shift:      TShiftRec         read fShift      write fShift;
-    property Format:     TglBitmapFormat   read fFormat     write fFormat;
-
-    procedure CreateColorTable;
-
-    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
-    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
-    destructor Destroy; override;
-  end;
-
-const
-  LUMINANCE_WEIGHT_R = 0.30;
-  LUMINANCE_WEIGHT_G = 0.59;
-  LUMINANCE_WEIGHT_B = 0.11;
-
-  ALPHA_WEIGHT_R = 0.30;
-  ALPHA_WEIGHT_G = 0.59;
-  ALPHA_WEIGHT_B = 0.11;
-
-  DEPTH_WEIGHT_R = 0.333333333;
-  DEPTH_WEIGHT_G = 0.333333333;
-  DEPTH_WEIGHT_B = 0.333333333;
-
-  UNSUPPORTED_FORMAT = 'the given format isn''t supported by this function.';
-
-  FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = (
-    TfdEmpty,
-
-    TfdAlpha4,
-    TfdAlpha8,
-    TfdAlpha16,
-
-    TfdLuminance4,
-    TfdLuminance8,
-    TfdLuminance16,
-
-    TfdLuminance4Alpha4,
-    TfdLuminance6Alpha2,
-    TfdLuminance8Alpha8,
-    TfdLuminance12Alpha4,
-    TfdLuminance16Alpha16,
-
-    TfdR3G3B2,
-    TfdRGBX4,
-    TfdXRGB4,
-    TfdR5G6B5,
-    TfdRGB5X1,
-    TfdX1RGB5,
-    TfdRGB8,
-    TfdRGBX8,
-    TfdXRGB8,
-    TfdRGB10X2,
-    TfdX2RGB10,
-    TfdRGB16,
-
-    TfdRGBA4,
-    TfdARGB4,
-    TfdRGB5A1,
-    TfdA1RGB5,
-    TfdRGBA8,
-    TfdARGB8,
-    TfdRGB10A2,
-    TfdA2RGB10,
-    TfdRGBA16,
-
-    TfdBGRX4,
-    TfdXBGR4,
-    TfdB5G6R5,
-    TfdBGR5X1,
-    TfdX1BGR5,
-    TfdBGR8,
-    TfdBGRX8,
-    TfdXBGR8,
-    TfdBGR10X2,
-    TfdX2BGR10,
-    TfdBGR16,
-
-    TfdBGRA4,
-    TfdABGR4,
-    TfdBGR5A1,
-    TfdA1BGR5,
-    TfdBGRA8,
-    TfdABGR8,
-    TfdBGR10A2,
-    TfdA2BGR10,
-    TfdBGRA16,
-
-    TfdDepth16,
-    TfdDepth24,
-    TfdDepth32,
-
-    TfdS3tcDtx1RGBA,
-    TfdS3tcDtx3RGBA,
-    TfdS3tcDtx5RGBA
-  );
-
-var
-  FormatDescriptorCS: TCriticalSection;
-  FormatDescriptors: array[TglBitmapFormat] of TFormatDescriptor;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat);
-begin
-  inherited Create('unsupported format: ' + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor EglBitmapUnsupportedFormat.Create(const aMsg: String; const aFormat: TglBitmapFormat);
-begin
-  inherited Create(aMsg + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition;
-begin
-  result.Fields := [];
-
-  if X >= 0 then
-    result.Fields := result.Fields + [ffX];
-  if Y >= 0 then
-    result.Fields := result.Fields + [ffY];
-
-  result.X := Max(0, X);
-  result.Y := Max(0, Y);
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec;
-begin
-  result.r := r;
-  result.g := g;
-  result.b := b;
-  result.a := a;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean;
-var
-  i: Integer;
-begin
-  result := false;
-  for i := 0 to high(r1.arr) do
-    if (r1.arr[i] <> r2.arr[i]) then
-      exit;
-  result := true;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapShiftRec(const r, g, b, a: Byte): TShiftRec;
-begin
-  result.r := r;
-  result.g := g;
-  result.b := b;
-  result.a := a;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function FormatGetSupportedFiles(const aFormat: TglBitmapFormat): TglBitmapFileTypes;
-begin
-  result := [];
-
-  if (aFormat in [
-        //4 bbp
-        tfLuminance4,
-
-        //8bpp
-        tfR3G3B2, tfLuminance8,
-
-        //16bpp
-        tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
-        tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4,
-
-        //24bpp
-        tfBGR8, tfRGB8,
-
-        //32bpp
-        tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8,
-        tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8]) then
-    result := result + [ftBMP];
-
-  if (aFormat in [
-        //8 bpp
-        tfLuminance8, tfAlpha8,
-
-        //16 bpp
-        tfLuminance16, tfLuminance8Alpha8,
-        tfRGB5X1, tfX1RGB5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
-        tfBGR5X1, tfX1BGR5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4,
-
-        //24 bpp
-        tfRGB8, tfBGR8,
-
-        //32 bpp
-        tfRGB10A2, tfRGBA8, tfBGR10A2, tfBGRA8]) then
-    result := result + [ftTGA];
-
-  if (aFormat in [
-        //8 bpp
-        tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2,
-        tfR3G3B2,
-
-        //16 bpp
-        tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4,
-        tfRGBX4, tfXRGB4, tfR5G6B5, tfRGB5X1, tfX1RGB5, tfRGBA4, tfARGB4, tfRGB5A1, tfA1RGB5,
-        tfBGRX4, tfXBGR4, tfB5G6R5, tfBGR5X1, tfX1BGR5, tfBGRA4, tfABGR4, tfBGR5A1, tfA1BGR5,
-
-        //24 bpp
-        tfRGB8, tfBGR8,
-
-        //32 bbp
-        tfLuminance16Alpha16,
-        tfRGBA8, tfRGB10A2,
-        tfBGRA8, tfBGR10A2,
-
-        //compressed
-        tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then
-    result := result + [ftDDS];
-
-  {$IFDEF GLB_SUPPORT_PNG_WRITE}
-  if aFormat in [
-      tfAlpha8, tfLuminance8, tfLuminance8Alpha8,
-      tfRGB8, tfRGBA8,
-      tfBGR8, tfBGRA8] then
-    result := result + [ftPNG];
-  {$ENDIF}
-
-  {$IFDEF GLB_SUPPORT_JPEG_WRITE}
-  if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] then
-    result := result + [ftJPEG];
-  {$ENDIF}
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function IsPowerOfTwo(aNumber: Integer): Boolean;
-begin
-  while (aNumber and 1) = 0 do
-    aNumber := aNumber shr 1;
-  result := aNumber = 1;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function GetTopMostBit(aBitSet: QWord): Integer;
-begin
-  result := 0;
-  while aBitSet > 0 do begin
-    inc(result);
-    aBitSet := aBitSet shr 1;
-  end;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function CountSetBits(aBitSet: QWord): Integer;
-begin
-  result := 0;
-  while aBitSet > 0 do begin
-    if (aBitSet and 1) = 1 then
-      inc(result);
-    aBitSet := aBitSet shr 1;
-  end;
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function LuminanceWeight(const aPixel: TglBitmapPixelData): Cardinal;
-begin
-  result := Trunc(
-    LUMINANCE_WEIGHT_R * aPixel.Data.r +
-    LUMINANCE_WEIGHT_G * aPixel.Data.g +
-    LUMINANCE_WEIGHT_B * aPixel.Data.b);
-end;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function DepthWeight(const aPixel: TglBitmapPixelData): Cardinal;
-begin
-  result := Trunc(
-    DEPTH_WEIGHT_R * aPixel.Data.r +
-    DEPTH_WEIGHT_G * aPixel.Data.g +
-    DEPTH_WEIGHT_B * aPixel.Data.b);
-end;
-
-{$IFDEF GLB_NATIVE_OGL}
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//OpenGLInitialization///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-var
-  GL_LibHandle: Pointer = nil;
-
-function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer;
-begin
-  if not Assigned(aLibHandle) then
-    aLibHandle := GL_LibHandle;
-
-{$IF DEFINED(GLB_WIN)}
-  result := GetProcAddress({%H-}HMODULE(aLibHandle), aProcName);
-  if Assigned(result) then
-    exit;
-
-  if Assigned(wglGetProcAddress) then
-    result := wglGetProcAddress(aProcName);
-{$ELSEIF DEFINED(GLB_LINUX)}
-  if Assigned(glXGetProcAddress) then begin
-    result := glXGetProcAddress(aProcName);
-    if Assigned(result) then
-      exit;
-  end;
-
-  if Assigned(glXGetProcAddressARB) then begin
-    result := glXGetProcAddressARB(aProcName);
-    if Assigned(result) then
-      exit;
-  end;
-
-  result := dlsym(aLibHandle, aProcName);
-{$IFEND}
-  if not Assigned(result) and aRaiseOnErr then
-    raise EglBitmap.Create('unable to load procedure form library: ' + aProcName);
-end;
-
-{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
-var
-  GLU_LibHandle: Pointer = nil;
-  OpenGLInitialized: Boolean;
-  InitOpenGLCS: TCriticalSection;
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glbInitOpenGL;
-
-  ////////////////////////////////////////////////////////////////////////////////
-  function glbLoadLibrary(const aName: PChar): Pointer;
-  begin
-    {$IF DEFINED(GLB_WIN)}
-    result := {%H-}Pointer(LoadLibrary(aName));
-    {$ELSEIF DEFINED(GLB_LINUX)}
-    result := dlopen(Name, RTLD_LAZY);
-    {$ELSE}
-    result := nil;
-    {$IFEND}
-  end;
-
-  ////////////////////////////////////////////////////////////////////////////////
-  function glbFreeLibrary(const aLibHandle: Pointer): Boolean;
-  begin
-    result := false;
-    if not Assigned(aLibHandle) then
-      exit;
-
-    {$IF DEFINED(GLB_WIN)}
-    Result := FreeLibrary({%H-}HINST(aLibHandle));
-    {$ELSEIF DEFINED(GLB_LINUX)}
-    Result := dlclose(aLibHandle) = 0;
-    {$IFEND}
-  end;
-
-begin
-  if Assigned(GL_LibHandle) then
-    glbFreeLibrary(GL_LibHandle);
-
-  if Assigned(GLU_LibHandle) then
-    glbFreeLibrary(GLU_LibHandle);
-
-  GL_LibHandle := glbLoadLibrary(libopengl);
-  if not Assigned(GL_LibHandle) then
-    raise EglBitmap.Create('unable to load library: ' + libopengl);
-
-  GLU_LibHandle := glbLoadLibrary(libglu);
-  if not Assigned(GLU_LibHandle) then
-    raise EglBitmap.Create('unable to load library: ' + libglu);
-
-{$IF DEFINED(GLB_WIN)}
-  wglGetProcAddress    := glbGetProcAddress('wglGetProcAddress');
-{$ELSEIF DEFINED(GLB_LINUX)}
-  glXGetProcAddress    := glbGetProcAddress('glXGetProcAddress');
-  glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB');
-{$IFEND}
-
-  glEnable := glbGetProcAddress('glEnable');
-  glDisable := glbGetProcAddress('glDisable');
-  glGetString := glbGetProcAddress('glGetString');
-  glGetIntegerv := glbGetProcAddress('glGetIntegerv');
-  glTexParameteri := glbGetProcAddress('glTexParameteri');
-  glTexParameteriv := glbGetProcAddress('glTexParameteriv');
-  glTexParameterfv := glbGetProcAddress('glTexParameterfv');
-  glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv');
-  glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv');
-  glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv');
-  glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv');
-  glTexGeni := glbGetProcAddress('glTexGeni');
-  glGenTextures := glbGetProcAddress('glGenTextures');
-  glBindTexture := glbGetProcAddress('glBindTexture');
-  glDeleteTextures := glbGetProcAddress('glDeleteTextures');
-  glAreTexturesResident := glbGetProcAddress('glAreTexturesResident');
-  glReadPixels := glbGetProcAddress('glReadPixels');
-  glPixelStorei := glbGetProcAddress('glPixelStorei');
-  glTexImage1D := glbGetProcAddress('glTexImage1D');
-  glTexImage2D := glbGetProcAddress('glTexImage2D');
-  glGetTexImage := glbGetProcAddress('glGetTexImage');
-
-  gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle);
-  gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle);
-end;
-{$ENDIF}
-
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glbReadOpenGLExtensions;
-var
-  Buffer: AnsiString;
-  MajorVersion, MinorVersion: Integer;
-
-  ///////////////////////////////////////////////////////////////////////////////////////////
-  procedure TrimVersionString(aBuffer: AnsiString; out aMajor, aMinor: Integer);
-  var
-    Separator: Integer;
-  begin
-    aMinor := 0;
-    aMajor := 0;
-
-    Separator := Pos(AnsiString('.'), aBuffer);
-    if (Separator > 1) and (Separator < Length(aBuffer)) and
-       (aBuffer[Separator - 1] in ['0'..'9']) and
-       (aBuffer[Separator + 1] in ['0'..'9']) then begin
-
-      Dec(Separator);
-      while (Separator > 0) and (aBuffer[Separator] in ['0'..'9']) do
-        Dec(Separator);
-
-      Delete(aBuffer, 1, Separator);
-      Separator := Pos(AnsiString('.'), aBuffer) + 1;
-
-      while (Separator <= Length(aBuffer)) and (AnsiChar(aBuffer[Separator]) in ['0'..'9']) do
-        Inc(Separator);
-
-      Delete(aBuffer, Separator, 255);
-      Separator := Pos(AnsiString('.'), aBuffer);
-
-      aMajor := StrToInt(Copy(String(aBuffer), 1, Separator - 1));
-      aMinor := StrToInt(Copy(String(aBuffer), Separator + 1, 1));
-    end;
-  end;
-
-  ///////////////////////////////////////////////////////////////////////////////////////////
-  function CheckExtension(const Extension: AnsiString): Boolean;
-  var
-    ExtPos: Integer;
-  begin
-    ExtPos := Pos(Extension, Buffer);
-    result := ExtPos > 0;
-    if result then
-      result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']);
-  end;
-
-  ///////////////////////////////////////////////////////////////////////////////////////////
-  function CheckVersion(const aMajor, aMinor: Integer): Boolean;
-  begin
-    result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor));
-  end;
-
-begin
-{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
-  InitOpenGLCS.Enter;
-  try
-    if not OpenGLInitialized then begin
-      glbInitOpenGL;
-      OpenGLInitialized := true;
-    end;
-  finally
-    InitOpenGLCS.Leave;
-  end;
-{$ENDIF}
-
-  // Version
-  Buffer := glGetString(GL_VERSION);
-  TrimVersionString(Buffer, MajorVersion, MinorVersion);
-
-  GL_VERSION_1_2 := CheckVersion(1, 2);
-  GL_VERSION_1_3 := CheckVersion(1, 3);
-  GL_VERSION_1_4 := CheckVersion(1, 4);
-  GL_VERSION_2_0 := CheckVersion(2, 0);
-  GL_VERSION_3_3 := CheckVersion(3, 3);
-
-  // Extensions
-  Buffer := glGetString(GL_EXTENSIONS);
-  GL_ARB_texture_border_clamp       := CheckExtension('GL_ARB_texture_border_clamp');
-  GL_ARB_texture_non_power_of_two   := CheckExtension('GL_ARB_texture_non_power_of_two');
-  GL_ARB_texture_swizzle            := CheckExtension('GL_ARB_texture_swizzle');
-  GL_ARB_texture_cube_map           := CheckExtension('GL_ARB_texture_cube_map');
-  GL_ARB_texture_rectangle          := CheckExtension('GL_ARB_texture_rectangle');
-  GL_ARB_texture_mirrored_repeat    := CheckExtension('GL_ARB_texture_mirrored_repeat');
-  GL_EXT_texture_edge_clamp         := CheckExtension('GL_EXT_texture_edge_clamp');
-  GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');
-  GL_EXT_texture_rectangle          := CheckExtension('GL_EXT_texture_rectangle');
-  GL_EXT_texture_swizzle            := CheckExtension('GL_EXT_texture_swizzle');
-  GL_EXT_texture_cube_map           := CheckExtension('GL_EXT_texture_cube_map');
-  GL_NV_texture_rectangle           := CheckExtension('GL_NV_texture_rectangle');
-  GL_IBM_texture_mirrored_repeat    := CheckExtension('GL_IBM_texture_mirrored_repeat');
-  GL_SGIS_generate_mipmap           := CheckExtension('GL_SGIS_generate_mipmap');
-
-  if GL_VERSION_1_3 then begin
-    glCompressedTexImage1D  := glbGetProcAddress('glCompressedTexImage1D');
-    glCompressedTexImage2D  := glbGetProcAddress('glCompressedTexImage2D');
-    glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage');
-  end else begin
-    glCompressedTexImage1D  := glbGetProcAddress('glCompressedTexImage1DARB',  nil, false);
-    glCompressedTexImage2D  := glbGetProcAddress('glCompressedTexImage2DARB',  nil, false);
-    glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB', nil, false);
-  end;
-end;
-{$ENDIF}
-
-{$IFDEF GLB_SDL_IMAGE}
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
-begin
-  result := TStream(context^.unknown.data1).Seek(offset, whence);
-end;
-
-function glBitmapRWread(context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer): Integer; cdecl;
-begin
-  result := TStream(context^.unknown.data1).Read(Ptr^, size * maxnum);
-end;
-
-function glBitmapRWwrite(context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer): Integer; cdecl;
-begin
-  result := TStream(context^.unknown.data1).Write(Ptr^, size * num);
-end;
-
-function glBitmapRWclose(context: PSDL_RWops): Integer; cdecl;
-begin
-  result := 0;
-end;
-
-function glBitmapCreateRWops(Stream: TStream): PSDL_RWops;
-begin
-  result := SDL_AllocRW;
-
-  if result = nil then
-    raise EglBitmapException.Create('glBitmapCreateRWops - SDL_AllocRW failed.');
-
-  result^.seek := glBitmapRWseek;
-  result^.read := glBitmapRWread;
-  result^.write := glBitmapRWwrite;
-  result^.close := glBitmapRWclose;
-  result^.unknown.data1 := Stream;
-end;
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
-begin
-  glBitmapDefaultDeleteTextureOnFree := aDeleteTextureOnFree;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
-begin
-  glBitmapDefaultFreeDataAfterGenTextures := aFreeData;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
-begin
-  glBitmapDefaultMipmap := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
-begin
-  glBitmapDefaultFormat := aFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
-begin
-  glBitmapDefaultFilterMin := aMin;
-  glBitmapDefaultFilterMag := aMag;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultWrap(const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
-begin
-  glBitmapDefaultWrapS := S;
-  glBitmapDefaultWrapT := T;
-  glBitmapDefaultWrapR := R;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
-begin
-  glDefaultSwizzle[0] := r;
-  glDefaultSwizzle[1] := g;
-  glDefaultSwizzle[2] := b;
-  glDefaultSwizzle[3] := a;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
-begin
-  result := glBitmapDefaultDeleteTextureOnFree;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
-begin
-  result := glBitmapDefaultFreeDataAfterGenTextures;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultMipmap: TglBitmapMipMap;
-begin
-  result := glBitmapDefaultMipmap;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmapGetDefaultFormat: TglBitmapFormat;
-begin
-  result := glBitmapDefaultFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultFilter(var aMin, aMag: GLenum);
-begin
-  aMin := glBitmapDefaultFilterMin;
-  aMag := glBitmapDefaultFilterMag;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum);
-begin
-  S := glBitmapDefaultWrapS;
-  T := glBitmapDefaultWrapT;
-  R := glBitmapDefaultWrapR;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
-begin
-  r := glDefaultSwizzle[0];
-  g := glDefaultSwizzle[1];
-  b := glDefaultSwizzle[2];
-  a := glDefaultSwizzle[3];
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetRedMask: QWord;
-begin
-  result := fRange.r shl fShift.r;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetGreenMask: QWord;
-begin
-  result := fRange.g shl fShift.g;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetBlueMask: QWord;
-begin
-  result := fRange.b shl fShift.b;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetAlphaMask: QWord;
-begin
-  result := fRange.a shl fShift.a;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetIsCompressed: Boolean;
-begin
-  result := fIsCompressed;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetHasRed: Boolean;
-begin
-  result := (fRange.r > 0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetHasGreen: Boolean;
-begin
-  result := (fRange.g > 0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetHasBlue: Boolean;
-begin
-  result := (fRange.b > 0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetHasAlpha: Boolean;
-begin
-  result := (fRange.a > 0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetRGBInverted: TglBitmapFormat;
-begin
-  result := fRGBInverted;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetWithAlpha: TglBitmapFormat;
-begin
-  result := fWithAlpha;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetWithoutAlpha: TglBitmapFormat;
-begin
-  result := fWithoutAlpha;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetOpenGLFormat: TglBitmapFormat;
-begin
-  result := fOpenGLFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetUncompressed: TglBitmapFormat;
-begin
-  result := fUncompressed;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetglFormat: GLenum;
-begin
-  result := fglFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetglInternalFormat: GLenum;
-begin
-  result := fglInternalFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetglDataFormat: GLenum;
-begin
-  result := fglDataFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetComponents: Integer;
-var
-  i: Integer;
-begin
-  result := 0;
-  for i := 0 to 3 do
-    if (fRange.arr[i] > 0) then
-      inc(result);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer;
-var
-  w, h: Integer;
-begin
-  if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin
-    w := Max(1, aSize.X);
-    h := Max(1, aSize.Y);
-    result := GetSize(w, h);
-  end else
-    result := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer;
-begin
-  result := 0;
-  if (aWidth <= 0) or (aHeight <= 0) then
-    exit;
-  result := Ceil(aWidth * aHeight * fPixelSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.CreateMappingData: Pointer;
-begin
-  result := nil;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TFormatDescriptor.FreeMappingData(var aMappingData: Pointer);
-begin
-  //DUMMY
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.IsEmpty: Boolean;
-begin
-  result := (fFormat = tfEmpty);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean;
-begin
-  result := false;
-  if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then
-    raise EglBitmap.Create('FormatCheckFormat - All Masks are 0');
-  if (aRedMask   <> RedMask) then
-    exit;
-  if (aGreenMask <> GreenMask) then
-    exit;
-  if (aBlueMask  <> BlueMask) then
-    exit;
-  if (aAlphaMask <> AlphaMask) then
-    exit;
-  result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData);
-begin
-  FillChar(aPixel{%H-}, SizeOf(aPixel), 0);
-  aPixel.Data   := fRange;
-  aPixel.Range  := fRange;
-  aPixel.Format := fFormat;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TFormatDescriptor.Create;
-begin
-  inherited Create;
-
-  fFormat       := tfEmpty;
-  fWithAlpha    := tfEmpty;
-  fWithoutAlpha := tfEmpty;
-  fOpenGLFormat := tfEmpty;
-  fRGBInverted  := tfEmpty;
-  fUncompressed := tfEmpty;
-
-  fPixelSize    := 0.0;
-  fIsCompressed := false;
-
-  fglFormat         := 0;
-  fglInternalFormat := 0;
-  fglDataFormat     := 0;
-
-  FillChar(fRange, 0, SizeOf(fRange));
-  FillChar(fShift, 0, SizeOf(fShift));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdAlpha_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdAlpha_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  aData^ := aPixel.Data.a;
-  inc(aData);
-end;
-
-procedure TfdAlpha_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := 0;
-  aPixel.Data.g := 0;
-  aPixel.Data.b := 0;
-  aPixel.Data.a := aData^;
-  inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminance_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  aData^ := LuminanceWeight(aPixel);
-  inc(aData);
-end;
-
-procedure TfdLuminance_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := aData^;
-  aPixel.Data.g := aData^;
-  aPixel.Data.b := aData^;
-  aPixel.Data.a := 0;
-  inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdUniversal_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  aData^ := 0;
-  for i := 0 to 3 do
-    if (fRange.arr[i] > 0) then
-      aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
-  inc(aData);
-end;
-
-procedure TfdUniversal_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminanceAlpha_UB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  aData^ := aPixel.Data.a;
-  inc(aData);
-end;
-
-procedure TfdLuminanceAlpha_UB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := aData^;
-  inc(aData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdRGB_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGB_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  aData^ := aPixel.Data.b;
-  inc(aData);
-  aData^ := aPixel.Data.g;
-  inc(aData);
-  aData^ := aPixel.Data.r;
-  inc(aData);
-end;
-
-procedure TfdRGB_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.b := aData^;
-  inc(aData);
-  aPixel.Data.g := aData^;
-  inc(aData);
-  aPixel.Data.r := aData^;
-  inc(aData);
-  aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdBGR_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGR_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  aData^ := aPixel.Data.r;
-  inc(aData);
-  aData^ := aPixel.Data.g;
-  inc(aData);
-  aData^ := aPixel.Data.b;
-  inc(aData);
-end;
-
-procedure TfdBGR_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := aData^;
-  inc(aData);
-  aPixel.Data.g := aData^;
-  inc(aData);
-  aPixel.Data.b := aData^;
-  inc(aData);
-  aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdAlpha_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdAlpha_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-end;
-
-procedure TfdAlpha_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := 0;
-  aPixel.Data.g := 0;
-  aPixel.Data.b := 0;
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminance_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := LuminanceWeight(aPixel);
-  inc(aData, 2);
-end;
-
-procedure TfdLuminance_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := PWord(aData)^;
-  aPixel.Data.g := PWord(aData)^;
-  aPixel.Data.b := PWord(aData)^;
-  aPixel.Data.a := 0;
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdUniversal_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  PWord(aData)^ := 0;
-  for i := 0 to 3 do
-    if (fRange.arr[i] > 0) then
-      PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
-  inc(aData, 2);
-end;
-
-procedure TfdUniversal_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdDepth_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := DepthWeight(aPixel);
-  inc(aData, 2);
-end;
-
-procedure TfdDepth_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := PWord(aData)^;
-  aPixel.Data.g := PWord(aData)^;
-  aPixel.Data.b := PWord(aData)^;
-  aPixel.Data.a := PWord(aData)^;;
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdLuminanceAlpha_US2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-end;
-
-procedure TfdLuminanceAlpha_US2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdRGB_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGB_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.b;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.g;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.r;
-  inc(aData, 2);
-end;
-
-procedure TfdRGB_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.b := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.g := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.r := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdBGR_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGR_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.r;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.g;
-  inc(aData, 2);
-  PWord(aData)^ := aPixel.Data.b;
-  inc(aData, 2);
-end;
-
-procedure TfdBGR_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.g := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.b := PWord(aData)^;
-  inc(aData, 2);
-  aPixel.Data.a := 0;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdRGBA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-  inherited Map(aPixel, aData, aMapData);
-end;
-
-procedure TfdRGBA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
-  inherited Unmap(aData, aPixel, aMapData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdARGB_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdARGB_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-end;
-
-procedure TfdARGB_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdBGRA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdBGRA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-  inherited Map(aPixel, aData, aMapData);
-end;
-
-procedure TfdBGRA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
-  inherited Unmap(aData, aPixel, aMapData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdABGR_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdABGR_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  inherited Map(aPixel, aData, aMapData);
-  PWord(aData)^ := aPixel.Data.a;
-  inc(aData, 2);
-end;
-
-procedure TfdABGR_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  inherited Unmap(aData, aPixel, aMapData);
-  aPixel.Data.a := PWord(aData)^;
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdUniversal_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdUniversal_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  PCardinal(aData)^ := 0;
-  for i := 0 to 3 do
-    if (fRange.arr[i] > 0) then
-      PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
-  inc(aData, 4);
-end;
-
-procedure TfdUniversal_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  i: Integer;
-begin
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData, 2);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdDepth_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  PCardinal(aData)^ := DepthWeight(aPixel);
-  inc(aData, 4);
-end;
-
-procedure TfdDepth_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  aPixel.Data.r := PCardinal(aData)^;
-  aPixel.Data.g := PCardinal(aData)^;
-  aPixel.Data.b := PCardinal(aData)^;
-  aPixel.Data.a := 0;
-  inc(aData, 4);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TfdAlpha4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fFormat           := tfAlpha4;
-  fWithAlpha        := tfAlpha4;
-  fOpenGLFormat     := tfAlpha4;
-  fRange.a          := $FF;
-  fglFormat         := GL_ALPHA;
-  fglInternalFormat := GL_ALPHA4;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdAlpha8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fFormat           := tfAlpha8;
-  fWithAlpha        := tfAlpha8;
-  fOpenGLFormat     := tfAlpha8;
-  fRange.a          := $FF;
-  fglFormat         := GL_ALPHA;
-  fglInternalFormat := GL_ALPHA8;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdAlpha16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfAlpha16;
-  fWithAlpha        := tfAlpha16;
-  fOpenGLFormat     := tfAlpha16;
-  fRange.a          := $FFFF;
-  fglFormat         := GL_ALPHA;
-  fglInternalFormat := GL_ALPHA16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdLuminance4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fFormat           := tfLuminance4;
-  fWithAlpha        := tfLuminance4Alpha4;
-  fWithoutAlpha     := tfLuminance4;
-  fOpenGLFormat     := tfLuminance4;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE4;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdLuminance8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fFormat           := tfLuminance8;
-  fWithAlpha        := tfLuminance8Alpha8;
-  fWithoutAlpha     := tfLuminance8;
-  fOpenGLFormat     := tfLuminance8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE8;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdLuminance16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfLuminance16;
-  fWithAlpha        := tfLuminance16Alpha16;
-  fWithoutAlpha     := tfLuminance16;
-  fOpenGLFormat     := tfLuminance16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fglFormat         := GL_LUMINANCE;
-  fglInternalFormat := GL_LUMINANCE16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdLuminance4Alpha4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfLuminance4Alpha4;
-  fWithAlpha        := tfLuminance4Alpha4;
-  fWithoutAlpha     := tfLuminance4;
-  fOpenGLFormat     := tfLuminance4Alpha4;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $FF;
-  fShift.r          := 0;
-  fShift.g          := 0;
-  fShift.b          := 0;
-  fShift.a          := 8;
-  fglFormat         := GL_LUMINANCE_ALPHA;
-  fglInternalFormat := GL_LUMINANCE4_ALPHA4;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdLuminance6Alpha2.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfLuminance6Alpha2;
-  fWithAlpha        := tfLuminance6Alpha2;
-  fWithoutAlpha     := tfLuminance8;
-  fOpenGLFormat     := tfLuminance6Alpha2;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $FF;
-  fShift.r          := 0;
-  fShift.g          := 0;
-  fShift.b          := 0;
-  fShift.a          := 8;
-  fglFormat         := GL_LUMINANCE_ALPHA;
-  fglInternalFormat := GL_LUMINANCE6_ALPHA2;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdLuminance8Alpha8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfLuminance8Alpha8;
-  fWithAlpha        := tfLuminance8Alpha8;
-  fWithoutAlpha     := tfLuminance8;
-  fOpenGLFormat     := tfLuminance8Alpha8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $FF;
-  fShift.r          := 0;
-  fShift.g          := 0;
-  fShift.b          := 0;
-  fShift.a          := 8;
-  fglFormat         := GL_LUMINANCE_ALPHA;
-  fglInternalFormat := GL_LUMINANCE8_ALPHA8;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdLuminance12Alpha4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfLuminance12Alpha4;
-  fWithAlpha        := tfLuminance12Alpha4;
-  fWithoutAlpha     := tfLuminance16;
-  fOpenGLFormat     := tfLuminance12Alpha4;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fShift.r          := 0;
-  fShift.g          := 0;
-  fShift.b          := 0;
-  fShift.a          := 16;
-  fglFormat         := GL_LUMINANCE_ALPHA;
-  fglInternalFormat := GL_LUMINANCE12_ALPHA4;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdLuminance16Alpha16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfLuminance16Alpha16;
-  fWithAlpha        := tfLuminance16Alpha16;
-  fWithoutAlpha     := tfLuminance16;
-  fOpenGLFormat     := tfLuminance16Alpha16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fShift.r          := 0;
-  fShift.g          := 0;
-  fShift.b          := 0;
-  fShift.a          := 16;
-  fglFormat         := GL_LUMINANCE_ALPHA;
-  fglInternalFormat := GL_LUMINANCE16_ALPHA16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdR3G3B2.Create;
-begin
-  inherited Create;
-  fPixelSize        := 1.0;
-  fFormat           := tfR3G3B2;
-  fWithAlpha        := tfRGBA4;
-  fWithoutAlpha     := tfR3G3B2;
-  fOpenGLFormat     := tfR3G3B2;
-  fRGBInverted      := tfEmpty;
-  fRange.r          := $07;
-  fRange.g          := $07;
-  fRange.b          := $04;
-  fShift.r          := 5;
-  fShift.g          := 2;
-  fShift.b          := 0;
-  fglFormat         := GL_RGB;
-  fglInternalFormat := GL_R3_G3_B2;
-  fglDataFormat     := GL_UNSIGNED_BYTE_3_3_2;
-end;
-
-constructor TfdRGBX4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfRGBX4;
-  fWithAlpha        := tfRGBA4;
-  fWithoutAlpha     := tfRGBX4;
-  fOpenGLFormat     := tfRGBX4;
-  fRGBInverted      := tfBGRX4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fRange.a          := $00;
-  fShift.r          := 12;
-  fShift.g          :=  8;
-  fShift.b          :=  4;
-  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
-end;
-
-constructor TfdXRGB4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfXRGB4;
-  fWithAlpha        := tfARGB4;
-  fWithoutAlpha     := tfXRGB4;
-  fOpenGLFormat     := tfXRGB4;
-  fRGBInverted      := tfXBGR4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fShift.r          := 8;
-  fShift.g          := 4;
-  fShift.b          := 0;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGB4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-end;
-
-constructor TfdR5G6B5.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfR5G6B5;
-  fWithAlpha        := tfRGB5A1;
-  fWithoutAlpha     := tfR5G6B5;
-  fOpenGLFormat     := tfR5G6B5;
-  fRGBInverted      := tfB5G6R5;
-  fRange.r          := $1F;
-  fRange.g          := $3F;
-  fRange.b          := $1F;
-  fShift.r          := 11;
-  fShift.g          := 5;
-  fShift.b          := 0;
-  fglFormat         := GL_RGB;
-  fglInternalFormat := GL_RGB565;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5;
-end;
-
-constructor TfdRGB5X1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfRGB5X1;
-  fWithAlpha        := tfRGB5A1;
-  fWithoutAlpha     := tfRGB5X1;
-  fOpenGLFormat     := tfRGB5X1;
-  fRGBInverted      := tfBGR5X1;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fShift.r          := 11;
-  fShift.g          :=  6;
-  fShift.b          :=  1;
-  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB5;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
-end;
-
-constructor TfdX1RGB5.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfX1RGB5;
-  fWithAlpha        := tfA1RGB5;
-  fWithoutAlpha     := tfX1RGB5;
-  fOpenGLFormat     := tfX1RGB5;
-  fRGBInverted      := tfX1BGR5;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fShift.r          := 10;
-  fShift.g          :=  5;
-  fShift.b          :=  0;
-  fglFormat         := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB5;
-  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-end;
-
-constructor TfdRGB8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfRGB8;
-  fWithAlpha        := tfRGBA8;
-  fWithoutAlpha     := tfRGB8;
-  fOpenGLFormat     := tfRGB8;
-  fRGBInverted      := tfBGR8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fShift.r          := 16;
-  fShift.g          :=  8;
-  fShift.b          :=  0;
-  fglFormat         := GL_BGR;    // reverse byte order to match little endianess
-  fglInternalFormat := GL_RGB8;   // as if u interpret the 3 bytes as unsigned integer
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdRGBX8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfRGBX8;
-  fWithAlpha        := tfRGBA8;
-  fWithoutAlpha     := tfRGBX8;
-  fOpenGLFormat     := tfRGB8;
-  fRGBInverted      := tfBGRX8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fShift.r          := 24;
-  fShift.g          := 16;
-  fShift.b          := 8;
-  fglFormat         := GL_RGBA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
-end;
-
-constructor TfdXRGB8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfXRGB8;
-  fWithAlpha        := tfXRGB8;
-  fWithoutAlpha     := tfXRGB8;
-  fOpenGLFormat     := tfRGB8;
-  fRGBInverted      := tfXBGR8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fShift.r          := 16;
-  fShift.g          :=  8;
-  fShift.b          :=  0;
-  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
-end;
-
-constructor TfdRGB10X2.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfRGB10X2;
-  fWithAlpha        := tfRGB10A2;
-  fWithoutAlpha     := tfRGB10X2;
-  fOpenGLFormat     := tfRGB10X2;
-  fRGBInverted      := tfBGR10X2;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fShift.r          := 22;
-  fShift.g          := 12;
-  fShift.b          :=  2;
-  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB10;
-  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
-end;
-
-constructor TfdX2RGB10.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfX2RGB10;
-  fWithAlpha        := tfA2RGB10;
-  fWithoutAlpha     := tfX2RGB10;
-  fOpenGLFormat     := tfX2RGB10;
-  fRGBInverted      := tfX2BGR10;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fShift.r          := 20;
-  fShift.g          := 10;
-  fShift.b          :=  0;
-  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB10;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
-end;
-
-constructor TfdRGB16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 6.0;
-  fFormat           := tfRGB16;
-  fWithAlpha        := tfRGBA16;
-  fWithoutAlpha     := tfRGB16;
-  fOpenGLFormat     := tfRGB16;
-  fRGBInverted      := tfBGR16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fShift.r          := 32;
-  fShift.g          := 16;
-  fShift.b          :=  0;
-  fglFormat         := GL_BGR;     // reverse byte order to match little endianess
-  fglInternalFormat := GL_RGB16;   // as if u interpret the 3 bytes as unsigned integer
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdRGBA4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfRGBA4;
-  fWithAlpha        := tfRGBA4;
-  fWithoutAlpha     := tfRGBX4;
-  fOpenGLFormat     := tfRGBA4;
-  fRGBInverted      := tfBGRA4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fRange.a          := $0F;
-  fShift.r          := 12;
-  fShift.g          :=  8;
-  fShift.b          :=  4;
-  fShift.a          :=  0;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGBA4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
-end;
-
-constructor TfdARGB4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfARGB4;
-  fWithAlpha        := tfARGB4;
-  fWithoutAlpha     := tfXRGB4;
-  fOpenGLFormat     := tfARGB4;
-  fRGBInverted      := tfABGR4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fRange.a          := $0F;
-  fShift.r          :=  8;
-  fShift.g          :=  4;
-  fShift.b          :=  0;
-  fShift.a          := 12;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGBA4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-end;
-
-constructor TfdRGB5A1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfRGB5A1;
-  fWithAlpha        := tfRGB5A1;
-  fWithoutAlpha     := tfRGB5X1;
-  fOpenGLFormat     := tfRGB5A1;
-  fRGBInverted      := tfBGR5A1;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fRange.a          := $01;
-  fShift.r          := 11;
-  fShift.g          :=  6;
-  fShift.b          :=  1;
-  fShift.a          :=  0;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGB5_A1;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
-end;
-
-constructor TfdA1RGB5.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfA1RGB5;
-  fWithAlpha        := tfA1RGB5;
-  fWithoutAlpha     := tfX1RGB5;
-  fOpenGLFormat     := tfA1RGB5;
-  fRGBInverted      := tfA1BGR5;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fRange.a          := $01;
-  fShift.r          := 10;
-  fShift.g          :=  5;
-  fShift.b          :=  0;
-  fShift.a          := 15;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGB5_A1;
-  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-end;
-
-constructor TfdRGBA8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfRGBA8;
-  fWithAlpha        := tfRGBA8;
-  fWithoutAlpha     := tfRGB8;
-  fOpenGLFormat     := tfRGBA8;
-  fRGBInverted      := tfBGRA8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $FF;
-  fShift.r          := 24;
-  fShift.g          := 16;
-  fShift.b          :=  8;
-  fShift.a          :=  0;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGBA8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
-end;
-
-constructor TfdARGB8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfARGB8;
-  fWithAlpha        := tfARGB8;
-  fWithoutAlpha     := tfRGB8;
-  fOpenGLFormat     := tfARGB8;
-  fRGBInverted      := tfABGR8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $FF;
-  fShift.r          := 16;
-  fShift.g          :=  8;
-  fShift.b          :=  0;
-  fShift.a          := 24;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGBA8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
-end;
-
-constructor TfdRGB10A2.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfRGB10A2;
-  fWithAlpha        := tfRGB10A2;
-  fWithoutAlpha     := tfRGB10X2;
-  fOpenGLFormat     := tfRGB10A2;
-  fRGBInverted      := tfBGR10A2;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fRange.a          := $0003;
-  fShift.r          := 22;
-  fShift.g          := 12;
-  fShift.b          :=  2;
-  fShift.a          :=  0;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGB10_A2;
-  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
-end;
-
-constructor TfdA2RGB10.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfA2RGB10;
-  fWithAlpha        := tfA2RGB10;
-  fWithoutAlpha     := tfX2RGB10;
-  fOpenGLFormat     := tfA2RGB10;
-  fRGBInverted      := tfA2BGR10;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fRange.a          := $0003;
-  fShift.r          := 20;
-  fShift.g          := 10;
-  fShift.b          :=  0;
-  fShift.a          := 30;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGB10_A2;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
-end;
-
-constructor TfdRGBA16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 8.0;
-  fFormat           := tfRGBA16;
-  fWithAlpha        := tfRGBA16;
-  fWithoutAlpha     := tfRGB16;
-  fOpenGLFormat     := tfRGBA16;
-  fRGBInverted      := tfBGRA16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fShift.r          := 48;
-  fShift.g          := 32;
-  fShift.b          := 16;
-  fShift.a          :=  0;
-  fglFormat         := GL_BGRA;     // reverse byte order to match little endianess
-  fglInternalFormat := GL_RGBA16;   // as if u interpret the 3 bytes as unsigned integer
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TfdBGRX4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfBGRX4;
-  fWithAlpha        := tfBGRA4;
-  fWithoutAlpha     := tfBGRX4;
-  fOpenGLFormat     := tfBGRX4;
-  fRGBInverted      := tfRGBX4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fShift.r          :=  4;
-  fShift.g          :=  8;
-  fShift.b          := 12;
-  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
-end;
-
-constructor TfdXBGR4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfXBGR4;
-  fWithAlpha        := tfABGR4;
-  fWithoutAlpha     := tfXBGR4;
-  fOpenGLFormat     := tfXBGR4;
-  fRGBInverted      := tfXRGB4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fRange.a          := $0F;
-  fShift.r          := 0;
-  fShift.g          := 4;
-  fShift.b          := 8;
-  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-end;
-
-constructor TfdB5G6R5.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfB5G6R5;
-  fWithAlpha        := tfBGR5A1;
-  fWithoutAlpha     := tfB5G6R5;
-  fOpenGLFormat     := tfB5G6R5;
-  fRGBInverted      := tfR5G6B5;
-  fRange.r          := $1F;
-  fRange.g          := $3F;
-  fRange.b          := $1F;
-  fShift.r          :=  0;
-  fShift.g          :=  5;
-  fShift.b          := 11;
-  fglFormat         := GL_RGB;
-  fglInternalFormat := GL_RGB565;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5_REV;
-end;
-
-constructor TfdBGR5X1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfBGR5X1;
-  fWithAlpha        := tfBGR5A1;
-  fWithoutAlpha     := tfBGR5X1;
-  fOpenGLFormat     := tfBGR5X1;
-  fRGBInverted      := tfRGB5X1;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fShift.r          :=  1;
-  fShift.g          :=  6;
-  fShift.b          := 11;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGB5;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
-end;
-
-constructor TfdX1BGR5.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfX1BGR5;
-  fWithAlpha        := tfA1BGR5;
-  fWithoutAlpha     := tfX1BGR5;
-  fOpenGLFormat     := tfX1BGR5;
-  fRGBInverted      := tfX1RGB5;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fShift.r          :=  0;
-  fShift.g          :=  5;
-  fShift.b          := 10;
-  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB5;
-  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-end;
-
-constructor TfdBGR8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfBGR8;
-  fWithAlpha        := tfBGRA8;
-  fWithoutAlpha     := tfBGR8;
-  fOpenGLFormat     := tfBGR8;
-  fRGBInverted      := tfRGB8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fShift.r          :=  0;
-  fShift.g          :=  8;
-  fShift.b          := 16;
-  fglFormat         := GL_RGB;      // reverse byte order to match little endianess
-  fglInternalFormat := GL_RGB8;     // as if u interpret the 3 bytes as unsigned integer
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-constructor TfdBGRX8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfBGRX8;
-  fWithAlpha        := tfBGRA8;
-  fWithoutAlpha     := tfBGRX8;
-  fOpenGLFormat     := tfBGRX8;
-  fRGBInverted      := tfRGBX8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fShift.r          :=  8;
-  fShift.g          := 16;
-  fShift.b          := 24;
-  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
-end;
-
-constructor TfdXBGR8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfXBGR8;
-  fWithAlpha        := tfABGR8;
-  fWithoutAlpha     := tfXBGR8;
-  fOpenGLFormat     := tfXBGR8;
-  fRGBInverted      := tfXRGB8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fShift.r          :=  0;
-  fShift.g          :=  8;
-  fShift.b          := 16;
-  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
-end;
-
-constructor TfdBGR10X2.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfBGR10X2;
-  fWithAlpha        := tfBGR10A2;
-  fWithoutAlpha     := tfBGR10X2;
-  fOpenGLFormat     := tfBGR10X2;
-  fRGBInverted      := tfRGB10X2;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fShift.r          :=  2;
-  fShift.g          := 12;
-  fShift.b          := 22;
-  fglFormat         := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB10;
-  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
-end;
-
-constructor TfdX2BGR10.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfX2BGR10;
-  fWithAlpha        := tfA2BGR10;
-  fWithoutAlpha     := tfX2BGR10;
-  fOpenGLFormat     := tfX2BGR10;
-  fRGBInverted      := tfX2RGB10;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fShift.r          :=  0;
-  fShift.g          := 10;
-  fShift.b          := 20;
-  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
-  fglInternalFormat := GL_RGB10;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
-end;
-
-constructor TfdBGR16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 6.0;
-  fFormat           := tfBGR16;
-  fWithAlpha        := tfBGRA16;
-  fWithoutAlpha     := tfBGR16;
-  fOpenGLFormat     := tfBGR16;
-  fRGBInverted      := tfRGB16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fShift.r          :=  0;
-  fShift.g          := 16;
-  fShift.b          := 32;
-  fglFormat         := GL_RGB;      // reverse byte order to match little endianess
-  fglInternalFormat := GL_RGB16;    // as if u interpret the 3 bytes as unsigned integer
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdBGRA4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfBGRA4;
-  fWithAlpha        := tfBGRA4;
-  fWithoutAlpha     := tfBGRX4;
-  fOpenGLFormat     := tfBGRA4;
-  fRGBInverted      := tfRGBA4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fRange.a          := $0F;
-  fShift.r          :=  4;
-  fShift.g          :=  8;
-  fShift.b          := 12;
-  fShift.a          :=  0;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGBA4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
-end;
-
-constructor TfdABGR4.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfABGR4;
-  fWithAlpha        := tfABGR4;
-  fWithoutAlpha     := tfXBGR4;
-  fOpenGLFormat     := tfABGR4;
-  fRGBInverted      := tfARGB4;
-  fRange.r          := $0F;
-  fRange.g          := $0F;
-  fRange.b          := $0F;
-  fRange.a          := $0F;
-  fShift.r          :=  0;
-  fShift.g          :=  4;
-  fShift.b          :=  8;
-  fShift.a          := 12;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGBA4;
-  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
-end;
-
-constructor TfdBGR5A1.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfBGR5A1;
-  fWithAlpha        := tfBGR5A1;
-  fWithoutAlpha     := tfBGR5X1;
-  fOpenGLFormat     := tfBGR5A1;
-  fRGBInverted      := tfRGB5A1;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fRange.a          := $01;
-  fShift.r          :=  1;
-  fShift.g          :=  6;
-  fShift.b          := 11;
-  fShift.a          :=  0;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGB5_A1;
-  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
-end;
-
-constructor TfdA1BGR5.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfA1BGR5;
-  fWithAlpha        := tfA1BGR5;
-  fWithoutAlpha     := tfX1BGR5;
-  fOpenGLFormat     := tfA1BGR5;
-  fRGBInverted      := tfA1RGB5;
-  fRange.r          := $1F;
-  fRange.g          := $1F;
-  fRange.b          := $1F;
-  fRange.a          := $01;
-  fShift.r          :=  0;
-  fShift.g          :=  5;
-  fShift.b          := 10;
-  fShift.a          := 15;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGB5_A1;
-  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
-end;
-
-constructor TfdBGRA8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfBGRA8;
-  fWithAlpha        := tfBGRA8;
-  fWithoutAlpha     := tfBGR8;
-  fOpenGLFormat     := tfBGRA8;
-  fRGBInverted      := tfRGBA8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $FF;
-  fShift.r          :=  8;
-  fShift.g          := 16;
-  fShift.b          := 24;
-  fShift.a          :=  0;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGBA8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
-end;
-
-constructor TfdABGR8.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfABGR8;
-  fWithAlpha        := tfABGR8;
-  fWithoutAlpha     := tfBGR8;
-  fOpenGLFormat     := tfABGR8;
-  fRGBInverted      := tfARGB8;
-  fRange.r          := $FF;
-  fRange.g          := $FF;
-  fRange.b          := $FF;
-  fRange.a          := $FF;
-  fShift.r          :=  0;
-  fShift.g          :=  8;
-  fShift.b          := 16;
-  fShift.a          := 24;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGBA8;
-  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
-end;
-
-constructor TfdBGR10A2.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfBGR10A2;
-  fWithAlpha        := tfBGR10A2;
-  fWithoutAlpha     := tfBGR10X2;
-  fOpenGLFormat     := tfBGR10A2;
-  fRGBInverted      := tfRGB10A2;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fRange.a          := $0003;
-  fShift.r          :=  2;
-  fShift.g          := 12;
-  fShift.b          := 22;
-  fShift.a          :=  0;
-  fglFormat         := GL_BGRA;
-  fglInternalFormat := GL_RGB10_A2;
-  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
-end;
-
-constructor TfdA2BGR10.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfA2BGR10;
-  fWithAlpha        := tfA2BGR10;
-  fWithoutAlpha     := tfX2BGR10;
-  fOpenGLFormat     := tfA2BGR10;
-  fRGBInverted      := tfA2RGB10;
-  fRange.r          := $03FF;
-  fRange.g          := $03FF;
-  fRange.b          := $03FF;
-  fRange.a          := $0003;
-  fShift.r          :=  0;
-  fShift.g          := 10;
-  fShift.b          := 20;
-  fShift.a          := 30;
-  fglFormat         := GL_RGBA;
-  fglInternalFormat := GL_RGB10_A2;
-  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
-end;
-
-constructor TfdBGRA16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 8.0;
-  fFormat           := tfBGRA16;
-  fWithAlpha        := tfBGRA16;
-  fWithoutAlpha     := tfBGR16;
-  fOpenGLFormat     := tfBGRA16;
-  fRGBInverted      := tfRGBA16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fShift.r          := 16;
-  fShift.g          := 32;
-  fShift.b          := 48;
-  fShift.a          :=  0;
-  fglFormat         := GL_RGBA;      // reverse byte order to match little endianess
-  fglInternalFormat := GL_RGBA16;    // as if u interpret the 3 bytes as unsigned integer
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdDepth16.Create;
-begin
-  inherited Create;
-  fPixelSize        := 2.0;
-  fFormat           := tfDepth16;
-  fWithoutAlpha     := tfDepth16;
-  fOpenGLFormat     := tfDepth16;
-  fRange.r          := $FFFF;
-  fRange.g          := $FFFF;
-  fRange.b          := $FFFF;
-  fRange.a          := $FFFF;
-  fglFormat         := GL_DEPTH_COMPONENT;
-  fglInternalFormat := GL_DEPTH_COMPONENT16;
-  fglDataFormat     := GL_UNSIGNED_SHORT;
-end;
-
-constructor TfdDepth24.Create;
-begin
-  inherited Create;
-  fPixelSize        := 3.0;
-  fFormat           := tfDepth24;
-  fWithoutAlpha     := tfDepth24;
-  fOpenGLFormat     := tfDepth24;
-  fRange.r          := $FFFFFF;
-  fRange.g          := $FFFFFF;
-  fRange.b          := $FFFFFF;
-  fRange.a          := $FFFFFF;
-  fglFormat         := GL_DEPTH_COMPONENT;
-  fglInternalFormat := GL_DEPTH_COMPONENT24;
-  fglDataFormat     := GL_UNSIGNED_INT;
-end;
-
-constructor TfdDepth32.Create;
-begin
-  inherited Create;
-  fPixelSize        := 4.0;
-  fFormat           := tfDepth32;
-  fWithoutAlpha     := tfDepth32;
-  fOpenGLFormat     := tfDepth32;
-  fRange.r          := $FFFFFFFF;
-  fRange.g          := $FFFFFFFF;
-  fRange.b          := $FFFFFFFF;
-  fRange.a          := $FFFFFFFF;
-  fglFormat         := GL_DEPTH_COMPONENT;
-  fglInternalFormat := GL_DEPTH_COMPONENT32;
-  fglDataFormat     := GL_UNSIGNED_INT;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdS3tcDtx1RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-constructor TfdS3tcDtx1RGBA.Create;
-begin
-  inherited Create;
-  fFormat           := tfS3tcDtx1RGBA;
-  fWithAlpha        := tfS3tcDtx1RGBA;
-  fOpenGLFormat     := tfS3tcDtx1RGBA;
-  fUncompressed     := tfRGB5A1;
-  fPixelSize        := 0.5;
-  fIsCompressed     := true;
-  fglFormat         := GL_COMPRESSED_RGBA;
-  fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdS3tcDtx3RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-constructor TfdS3tcDtx3RGBA.Create;
-begin
-  inherited Create;
-  fFormat           := tfS3tcDtx3RGBA;
-  fWithAlpha        := tfS3tcDtx3RGBA;
-  fOpenGLFormat     := tfS3tcDtx3RGBA;
-  fUncompressed     := tfRGBA8;
-  fPixelSize        := 1.0;
-  fIsCompressed     := true;
-  fglFormat         := GL_COMPRESSED_RGBA;
-  fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TfdS3tcDtx5RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-begin
-  raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-begin
-  raise EglBitmap.Create('mapping for compressed formats is not supported');
-end;
-
-constructor TfdS3tcDtx5RGBA.Create;
-begin
-  inherited Create;
-  fFormat           := tfS3tcDtx3RGBA;
-  fWithAlpha        := tfS3tcDtx3RGBA;
-  fOpenGLFormat     := tfS3tcDtx3RGBA;
-  fUncompressed     := tfRGBA8;
-  fPixelSize        := 1.0;
-  fIsCompressed     := true;
-  fglFormat         := GL_COMPRESSED_RGBA;
-  fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
-  fglDataFormat     := GL_UNSIGNED_BYTE;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TglBitmapFormatDescriptor.GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
-var
-  f: TglBitmapFormat;
-begin
-  for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin
-    result := TFormatDescriptor.Get(f);
-    if (result.glInternalFormat = aInternalFormat) then
-      exit;
-  end;
-  result := TFormatDescriptor.Get(tfEmpty);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class procedure TFormatDescriptor.Init;
-begin
-  if not Assigned(FormatDescriptorCS) then
-    FormatDescriptorCS := TCriticalSection.Create;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TFormatDescriptor.Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
-begin
-  FormatDescriptorCS.Enter;
-  try
-    result := FormatDescriptors[aFormat];
-    if not Assigned(result) then begin
-      result := FORMAT_DESCRIPTOR_CLASSES[aFormat].Create;
-      FormatDescriptors[aFormat] := result;
-    end;
-  finally
-    FormatDescriptorCS.Leave;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
-begin
-  result := Get(Get(aFormat).WithAlpha);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class procedure TFormatDescriptor.Clear;
-var
-  f: TglBitmapFormat;
-begin
-  FormatDescriptorCS.Enter;
-  try
-    for f := low(FormatDescriptors) to high(FormatDescriptors) do
-      FreeAndNil(FormatDescriptors[f]);
-  finally
-    FormatDescriptorCS.Leave;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-class procedure TFormatDescriptor.Finalize;
-begin
-  Clear;
-  FreeAndNil(FormatDescriptorCS);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TBitfieldFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetRedMask(const aValue: QWord);
-begin
-  Update(aValue, fRange.r, fShift.r);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord);
-begin
-  Update(aValue, fRange.g, fShift.g);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord);
-begin
-  Update(aValue, fRange.b, fShift.b);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord);
-begin
-  Update(aValue, fRange.a, fShift.a);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out
-  aShift: Byte);
-begin
-  aShift := 0;
-  aRange := 0;
-  if (aMask = 0) then
-    exit;
-  while (aMask > 0) and ((aMask and 1) = 0) do begin
-    inc(aShift);
-    aMask := aMask shr 1;
-  end;
-  aRange := 1;
-  while (aMask > 0) do begin
-    aRange := aRange shl 1;
-    aMask  := aMask  shr 1;
-  end;
-  dec(aRange);
-
-  fPixelSize := Round(GetTopMostBit(RedMask or GreenMask or BlueMask or AlphaMask) / 8);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  data: QWord;
-  s: Integer;
-begin
-  data :=
-    ((aPixel.Data.r and fRange.r) shl fShift.r) or
-    ((aPixel.Data.g and fRange.g) shl fShift.g) or
-    ((aPixel.Data.b and fRange.b) shl fShift.b) or
-    ((aPixel.Data.a and fRange.a) shl fShift.a);
-  s := Round(fPixelSize);
-  case s of
-    1:           aData^  := data;
-    2:     PWord(aData)^ := data;
-    4: PCardinal(aData)^ := data;
-    8:    PQWord(aData)^ := data;
-  else
-    raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
-  end;
-  inc(aData, s);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  data: QWord;
-  s, i: Integer;
-begin
-  s := Round(fPixelSize);
-  case s of
-    1: data :=           aData^;
-    2: data :=     PWord(aData)^;
-    4: data := PCardinal(aData)^;
-    8: data :=    PQWord(aData)^;
-  else
-    raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
-  end;
-  for i := 0 to 3 do
-    aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i];
-  inc(aData, s);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TColorTableFormat///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.CreateColorTable;
-var
-  i: Integer;
-begin
-  if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
-    raise EglBitmap.Create(UNSUPPORTED_FORMAT);
-
-  if (Format = tfLuminance4) then
-    SetLength(fColorTable, 16)
-  else
-    SetLength(fColorTable, 256);
-
-  case Format of
-    tfLuminance4: begin
-      for i := 0 to High(fColorTable) do begin
-        fColorTable[i].r := 16 * i;
-        fColorTable[i].g := 16 * i;
-        fColorTable[i].b := 16 * i;
-        fColorTable[i].a := 0;
-      end;
-    end;
-
-    tfLuminance8: begin
-      for i := 0 to High(fColorTable) do begin
-        fColorTable[i].r := i;
-        fColorTable[i].g := i;
-        fColorTable[i].b := i;
-        fColorTable[i].a := 0;
-      end;
-    end;
-
-    tfR3G3B2: begin
-      for i := 0 to High(fColorTable) do begin
-        fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255);
-        fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255);
-        fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255);
-        fColorTable[i].a := 0;
-      end;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
-var
-  d: Byte;
-begin
-  if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
-    raise EglBitmap.Create(UNSUPPORTED_FORMAT);
-
-  case Format of
-    tfLuminance4: begin
-      if (aMapData = nil) then
-        aData^ := 0;
-      d := LuminanceWeight(aPixel) and Range.r;
-      aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData)));
-      inc(PByte(aMapData), 4);
-      if ({%H-}PtrUInt(aMapData) >= 8) then begin
-        inc(aData);
-        aMapData := nil;
-      end;
-    end;
-
-    tfLuminance8: begin
-      aData^ := LuminanceWeight(aPixel) and Range.r;
-      inc(aData);
-    end;
-
-    tfR3G3B2: begin
-      aData^ := Round(
-        ((aPixel.Data.r and Range.r) shl Shift.r) or
-        ((aPixel.Data.g and Range.g) shl Shift.g) or
-        ((aPixel.Data.b and Range.b) shl Shift.b));
-      inc(aData);
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-var
-  idx: QWord;
-  s: Integer;
-  bits: Byte;
-  f: Single;
-begin
-  s    := Trunc(fPixelSize);
-  f    := fPixelSize - s;
-  bits := Round(8 * f);
-  case s of
-    0: idx :=          (aData^ shr (8 - bits - {%H-}PtrInt(aMapData))) and ((1 shl bits) - 1);
-    1: idx :=           aData^;
-    2: idx :=     PWord(aData)^;
-    4: idx := PCardinal(aData)^;
-    8: idx :=    PQWord(aData)^;
-  else
-    raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
-  end;
-  if (idx >= Length(fColorTable)) then
-    raise EglBitmap.CreateFmt('invalid color index: %d', [idx]);
-  with fColorTable[idx] do begin
-    aPixel.Data.r := r;
-    aPixel.Data.g := g;
-    aPixel.Data.b := b;
-    aPixel.Data.a := a;
-  end;
-  inc(PByte(aMapData), bits);
-  if ({%H-}PtrUInt(aMapData) >= 8) then begin
-    inc(aData, 1);
-    dec(PByte(aMapData), 8);
-  end;
-  inc(aData, s);
-end;
-
-destructor TbmpColorTableFormat.Destroy;
-begin
-  SetLength(fColorTable, 0);
-  inherited Destroy;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap - Helper//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertPixel(var aPixel: TglBitmapPixelData; const aSourceFD, aDestFD: TFormatDescriptor);
-var
-  i: Integer;
-begin
-  for i := 0 to 3 do begin
-    if (aSourceFD.Range.arr[i] <> aDestFD.Range.arr[i]) then begin
-      if (aSourceFD.Range.arr[i] > 0) then
-        aPixel.Data.arr[i] := Round(aPixel.Data.arr[i] / aSourceFD.Range.arr[i] * aDestFD.Range.arr[i])
-      else
-        aPixel.Data.arr[i] := 0;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertCopyFunc(var aFuncRec: TglBitmapFunctionRec);
-begin
-  with aFuncRec do begin
-    if (Source.Range.r   > 0) then
-      Dest.Data.r := Source.Data.r;
-    if (Source.Range.g > 0) then
-      Dest.Data.g := Source.Data.g;
-    if (Source.Range.b  > 0) then
-      Dest.Data.b := Source.Data.b;
-    if (Source.Range.a > 0) then
-      Dest.Data.a := Source.Data.a;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertCalculateRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
-var
-  i: Integer;
-begin
-  with aFuncRec do begin
-    for i := 0 to 3 do
-      if (Source.Range.arr[i] > 0) then
-        Dest.Data.arr[i] := Round(Dest.Range.arr[i] * Source.Data.arr[i] / Source.Range.arr[i]);
-  end;
-end;
-
-type
-  TShiftData = packed record
-    case Integer of
-      0: (r, g, b, a: SmallInt);
-      1: (arr: array[0..3] of SmallInt);
-  end;
-  PShiftData = ^TShiftData;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapConvertShiftRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
-var
-  i: Integer;
-begin
-  with aFuncRec do
-    for i := 0 to 3 do
-      if (Source.Range.arr[i] > 0) then
-        Dest.Data.arr[i] := Source.Data.arr[i] shr PShiftData(Args)^.arr[i];
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapInvertFunc(var aFuncRec: TglBitmapFunctionRec);
-begin
-  with aFuncRec do begin
-    Dest.Data := Source.Data;
-    if ({%H-}PtrUInt(Args) and $1 > 0) then begin
-      Dest.Data.r := Dest.Data.r xor Dest.Range.r;
-      Dest.Data.g := Dest.Data.g xor Dest.Range.g;
-      Dest.Data.b := Dest.Data.b xor Dest.Range.b;
-    end;
-    if ({%H-}PtrUInt(Args) and $2 > 0) then begin
-      Dest.Data.a := Dest.Data.a xor Dest.Range.a;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapFillWithColorFunc(var aFuncRec: TglBitmapFunctionRec);
-var
-  i: Integer;
-begin
-  with aFuncRec do begin
-    for i := 0 to 3 do
-      Dest.Data.arr[i] := PglBitmapPixelData(Args)^.Data.arr[i];
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-var
-  Temp: Single;
-begin
-  with FuncRec do begin
-    if (FuncRec.Args = nil) then begin //source has no alpha
-      Temp :=
-        Source.Data.r / Source.Range.r * ALPHA_WEIGHT_R +
-        Source.Data.g / Source.Range.g * ALPHA_WEIGHT_G +
-        Source.Data.b / Source.Range.b * ALPHA_WEIGHT_B;
-      Dest.Data.a := Round(Dest.Range.a * Temp);
-    end else
-      Dest.Data.a := Round(Source.Data.a / Source.Range.a * Dest.Range.a);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapColorKeyAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-type
-  PglBitmapPixelData = ^TglBitmapPixelData;
-begin
-  with FuncRec do begin
-    Dest.Data.r := Source.Data.r;
-    Dest.Data.g := Source.Data.g;
-    Dest.Data.b := Source.Data.b;
-
-    with PglBitmapPixelData(Args)^ do
-      if ((Dest.Data.r <= Data.r) and (Dest.Data.r >= Range.r) and
-          (Dest.Data.g <= Data.g) and (Dest.Data.g >= Range.g) and
-          (Dest.Data.b <= Data.b) and (Dest.Data.b >= Range.b)) then
-        Dest.Data.a := 0
-      else
-        Dest.Data.a := Dest.Range.a;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapValueAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-begin
-  with FuncRec do begin
-    Dest.Data.r := Source.Data.r;
-    Dest.Data.g := Source.Data.g;
-    Dest.Data.b := Source.Data.b;
-    Dest.Data.a := PCardinal(Args)^;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure SwapRGB(aData: PByte; aWidth: Integer; const aHasAlpha: Boolean);
-type
-  PRGBPix = ^TRGBPix;
-  TRGBPix = array [0..2] of byte;
-var
-  Temp: Byte;
-begin
-  while aWidth > 0 do begin
-    Temp := PRGBPix(aData)^[0];
-    PRGBPix(aData)^[0] := PRGBPix(aData)^[2];
-    PRGBPix(aData)^[2] := Temp;
-
-    if aHasAlpha then
-      Inc(aData, 4)
-    else
-      Inc(aData, 3);
-    dec(aWidth);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap - PROTECTED///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.GetFormatDesc: TglBitmapFormatDescriptor;
-begin
-  result := TFormatDescriptor.Get(Format);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.GetWidth: Integer;
-begin
-  if (ffX in fDimension.Fields) then
-    result := fDimension.X
-  else
-    result := -1;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.GetHeight: Integer;
-begin
-  if (ffY in fDimension.Fields) then
-    result := fDimension.Y
-  else
-    result := -1;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.GetFileWidth: Integer;
-begin
-  result := Max(1, Width);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.GetFileHeight: Integer;
-begin
-  result := Max(1, Height);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetCustomData(const aValue: Pointer);
-begin
-  if fCustomData = aValue then
-    exit;
-  fCustomData := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetCustomName(const aValue: String);
-begin
-  if fCustomName = aValue then
-    exit;
-  fCustomName := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetCustomNameW(const aValue: WideString);
-begin
-  if fCustomNameW = aValue then
-    exit;
-  fCustomNameW := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetFreeDataOnDestroy(const aValue: Boolean);
-begin
-  if fFreeDataOnDestroy = aValue then
-    exit;
-  fFreeDataOnDestroy := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean);
-begin
-  if fDeleteTextureOnFree = aValue then
-    exit;
-  fDeleteTextureOnFree := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat);
-begin
-  if fFormat = aValue then
-    exit;
-  if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-  SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetFreeDataAfterGenTexture(const aValue: Boolean);
-begin
-  if fFreeDataAfterGenTexture = aValue then
-    exit;
-  fFreeDataAfterGenTexture := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetID(const aValue: Cardinal);
-begin
-  if fID = aValue then
-    exit;
-  fID := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap);
-begin
-  if fMipMap = aValue then
-    exit;
-  fMipMap := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetTarget(const aValue: Cardinal);
-begin
-  if fTarget = aValue then
-    exit;
-  fTarget := aValue;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetAnisotropic(const aValue: Integer);
-var
-  MaxAnisotropic: Integer;
-begin
-  fAnisotropic := aValue;
-  if (ID > 0) then begin
-    if GL_EXT_texture_filter_anisotropic then begin
-      if fAnisotropic > 0 then begin
-        Bind(false);
-        glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAnisotropic);
-        if aValue > MaxAnisotropic then
-          fAnisotropic := MaxAnisotropic;
-        glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, fAnisotropic);
-      end;
-    end else begin
-      fAnisotropic := 0;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.CreateID;
-begin
-  if (ID <> 0) then
-    glDeleteTextures(1, @fID);
-  glGenTextures(1, @fID);
-  Bind(false);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetupParameters(out aBuildWithGlu: Boolean);
-begin
-  // Set Up Parameters
-  SetWrap(fWrapS, fWrapT, fWrapR);
-  SetFilter(fFilterMin, fFilterMag);
-  SetAnisotropic(fAnisotropic);
-  SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);
-
-  if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
-    SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
-
-  // Mip Maps Generation Mode
-  aBuildWithGlu := false;
-  if (MipMap = mmMipmap) then begin
-    if (GL_VERSION_1_4 or GL_SGIS_generate_mipmap) then
-      glTexParameteri(Target, GL_GENERATE_MIPMAP, GL_TRUE)
-    else
-      aBuildWithGlu := true;
-  end else if (MipMap = mmMipmapGlu) then
-    aBuildWithGlu := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
-  const aWidth: Integer; const aHeight: Integer);
-var
-  s: Single;
-begin
-  if (Data <> aData) then begin
-    if (Assigned(Data)) then
-      FreeMem(Data);
-    fData := aData;
-  end;
-
-  if not Assigned(fData) then begin
-    fPixelSize := 0;
-    fRowSize   := 0;
-  end else begin
-    FillChar(fDimension, SizeOf(fDimension), 0);
-    if aWidth <> -1 then begin
-      fDimension.Fields := fDimension.Fields + [ffX];
-      fDimension.X := aWidth;
-    end;
-
-    if aHeight <> -1 then begin
-      fDimension.Fields := fDimension.Fields + [ffY];
-      fDimension.Y := aHeight;
-    end;
-
-    s := TFormatDescriptor.Get(aFormat).PixelSize;
-    fFormat    := aFormat;
-    fPixelSize := Ceil(s);
-    fRowSize   := Ceil(s * aWidth);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.FlipHorz: Boolean;
-begin
-  result := false;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.FlipVert: Boolean;
-begin
-  result := false;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap - PUBLIC//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.AfterConstruction;
-begin
-  inherited AfterConstruction;
-
-  fID         := 0;
-  fTarget     := 0;
-  fIsResident := false;
-
-  fMipMap                  := glBitmapDefaultMipmap;
-  fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture;
-  fDeleteTextureOnFree     := glBitmapGetDefaultDeleteTextureOnFree;
-
-  glBitmapGetDefaultFilter     (fFilterMin, fFilterMag);
-  glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
-  glBitmapGetDefaultSwizzle    (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.BeforeDestruction;
-var
-  NewData: PByte;
-begin
-  if fFreeDataOnDestroy then begin
-    NewData := nil;
-    SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method
-  end;
-  if (fID > 0) and fDeleteTextureOnFree then
-    glDeleteTextures(1, @fID);
-  inherited BeforeDestruction;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.PrepareResType(var aResource: String; var aResType: PChar);
-var
-  TempPos: Integer;
-begin
-  if not Assigned(aResType) then begin
-    TempPos   := Pos('.', aResource);
-    aResType  := PChar(UpperCase(Copy(aResource, TempPos + 1, Length(aResource) - TempPos)));
-    aResource := UpperCase(Copy(aResource, 0, TempPos -1));
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.LoadFromFile(const aFilename: String);
-var
-  fs: TFileStream;
-begin
-  if not FileExists(aFilename) then
-    raise EglBitmap.Create('file does not exist: ' + aFilename);
-  fFilename := aFilename;
-  fs := TFileStream.Create(fFilename, fmOpenRead);
-  try
-    fs.Position := 0;
-    LoadFromStream(fs);
-  finally
-    fs.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.LoadFromStream(const aStream: TStream);
-begin
-  {$IFDEF GLB_SUPPORT_PNG_READ}
-  if not LoadPNG(aStream) then
-  {$ENDIF}
-  {$IFDEF GLB_SUPPORT_JPEG_READ}
-  if not LoadJPEG(aStream) then
-  {$ENDIF}
-  if not LoadDDS(aStream) then
-  if not LoadTGA(aStream) then
-  if not LoadBMP(aStream) then
-    raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction;
-  const aFormat: TglBitmapFormat; const aArgs: Pointer);
-var
-  tmpData: PByte;
-  size: Integer;
-begin
-  size := TFormatDescriptor.Get(aFormat).GetSize(aSize);
-  GetMem(tmpData, size);
-  try
-    FillChar(tmpData^, size, #$FF);
-    SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method
-  except
-    if Assigned(tmpData) then
-      FreeMem(tmpData);
-    raise;
-  end;
-  AddFunc(Self, aFunc, false, aFormat, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar);
-var
-  rs: TResourceStream;
-begin
-  PrepareResType(aResource, aResType);
-  rs := TResourceStream.Create(aInstance, aResource, aResType);
-  try
-    LoadFromStream(rs);
-  finally
-    rs.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
-var
-  rs: TResourceStream;
-begin
-  rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
-  try
-    LoadFromStream(rs);
-  finally
-    rs.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType);
-var
-  fs: TFileStream;
-begin
-  fs := TFileStream.Create(aFileName, fmCreate);
-  try
-    fs.Position := 0;
-    SaveToStream(fs, aFileType);
-  finally
-    fs.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType);
-begin
-  case aFileType of
-    {$IFDEF GLB_SUPPORT_PNG_WRITE}
-    ftPNG:  SavePNG(aStream);
-    {$ENDIF}
-    {$IFDEF GLB_SUPPORT_JPEG_WRITE}
-    ftJPEG: SaveJPEG(aStream);
-    {$ENDIF}
-    ftDDS:  SaveDDS(aStream);
-    ftTGA:  SaveTGA(aStream);
-    ftBMP:  SaveBMP(aStream);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean;
-begin
-  result := AddFunc(Self, aFunc, aCreateTemp, Format, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
-  const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean;
-var
-  DestData, TmpData, SourceData: pByte;
-  TempHeight, TempWidth: Integer;
-  SourceFD, DestFD: TFormatDescriptor;
-  SourceMD, DestMD: Pointer;
-
-  FuncRec: TglBitmapFunctionRec;
-begin
-  Assert(Assigned(Data));
-  Assert(Assigned(aSource));
-  Assert(Assigned(aSource.Data));
-
-  result := false;
-  if Assigned(aSource.Data) and ((aSource.Height > 0) or (aSource.Width > 0)) then begin
-    SourceFD := TFormatDescriptor.Get(aSource.Format);
-    DestFD   := TFormatDescriptor.Get(aFormat);
-
-    if (SourceFD.IsCompressed) then
-      raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format);
-    if (DestFD.IsCompressed) then
-      raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format);
-
-    // inkompatible Formats so CreateTemp
-    if (SourceFD.PixelSize <> DestFD.PixelSize) then
-      aCreateTemp := true;
-
-    // Values
-    TempHeight := Max(1, aSource.Height);
-    TempWidth  := Max(1, aSource.Width);
-
-    FuncRec.Sender := Self;
-    FuncRec.Args   := aArgs;
-
-    TmpData := nil;
-    if aCreateTemp then begin
-      GetMem(TmpData, DestFD.GetSize(TempWidth, TempHeight));
-      DestData := TmpData;
-    end else
-      DestData := Data;
-
-    try
-      SourceFD.PreparePixel(FuncRec.Source);
-      DestFD.PreparePixel  (FuncRec.Dest);
-
-      SourceMD := SourceFD.CreateMappingData;
-      DestMD   := DestFD.CreateMappingData;
-
-      FuncRec.Size            := aSource.Dimension;
-      FuncRec.Position.Fields := FuncRec.Size.Fields;
-
-      try
-        SourceData := aSource.Data;
-        FuncRec.Position.Y := 0;
-        while FuncRec.Position.Y < TempHeight do begin
-          FuncRec.Position.X := 0;
-          while FuncRec.Position.X < TempWidth do begin
-            SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
-            aFunc(FuncRec);
-            DestFD.Map(FuncRec.Dest, DestData, DestMD);
-            inc(FuncRec.Position.X);
-          end;
-          inc(FuncRec.Position.Y);
-        end;
-
-        // Updating Image or InternalFormat
-        if aCreateTemp then
-          SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) //be careful, Data could be freed by this method
-        else if (aFormat <> fFormat) then
-          Format := aFormat;
-
-        result := true;
-      finally
-        SourceFD.FreeMappingData(SourceMD);
-        DestFD.FreeMappingData(DestMD);
-      end;
-    except
-      if aCreateTemp and Assigned(TmpData) then
-        FreeMem(TmpData);
-      raise;
-    end;
-  end;
-end;
-
-{$IFDEF GLB_SDL}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignToSurface(out aSurface: PSDL_Surface): Boolean;
-var
-  Row, RowSize: Integer;
-  SourceData, TmpData: PByte;
-  TempDepth: Integer;
-  FormatDesc: TFormatDescriptor;
-
-  function GetRowPointer(Row: Integer): pByte;
-  begin
-    result := aSurface.pixels;
-    Inc(result, Row * RowSize);
-  end;
-
-begin
-  result := false;
-
-  FormatDesc := TFormatDescriptor.Get(Format);
-  if FormatDesc.IsCompressed then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  if Assigned(Data) then begin
-    case Trunc(FormatDesc.PixelSize) of
-      1: TempDepth :=  8;
-      2: TempDepth := 16;
-      3: TempDepth := 24;
-      4: TempDepth := 32;
-    else
-      raise EglBitmapUnsupportedFormat.Create(Format);
-    end;
-
-    aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
-      FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask);
-    SourceData := Data;
-    RowSize    := FormatDesc.GetSize(FileWidth, 1);
-
-    for Row := 0 to FileHeight-1 do begin
-      TmpData := GetRowPointer(Row);
-      if Assigned(TmpData) then begin
-        Move(SourceData^, TmpData^, RowSize);
-        inc(SourceData, RowSize);
-      end;
-    end;
-    result := true;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
-var
-  pSource, pData, pTempData: PByte;
-  Row, RowSize, TempWidth, TempHeight: Integer;
-  IntFormat: TglBitmapFormat;
-  FormatDesc: TFormatDescriptor;
-
-  function GetRowPointer(Row: Integer): pByte;
-  begin
-    result := aSurface^.pixels;
-    Inc(result, Row * RowSize);
-  end;
-
-begin
-  result := false;
-  if (Assigned(aSurface)) then begin
-    with aSurface^.format^ do begin
-      for IntFormat := High(TglBitmapFormat) to Low(TglBitmapFormat) do begin
-        FormatDesc := TFormatDescriptor.Get(IntFormat);
-        if (FormatDesc.MaskMatch(RMask, GMask, BMask, AMask)) then
-          break;
-      end;
-      if (IntFormat = tfEmpty) then
-        raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.');
-    end;
-
-    TempWidth  := aSurface^.w;
-    TempHeight := aSurface^.h;
-    RowSize := FormatDesc.GetSize(TempWidth, 1);
-    GetMem(pData, TempHeight * RowSize);
-    try
-      pTempData := pData;
-      for Row := 0 to TempHeight -1 do begin
-        pSource := GetRowPointer(Row);
-        if (Assigned(pSource)) then begin
-          Move(pSource^, pTempData^, RowSize);
-          Inc(pTempData, RowSize);
-        end;
-      end;
-      SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
-      result := true;
-    except
-      if Assigned(pData) then
-        FreeMem(pData);
-      raise;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
-var
-  Row, Col, AlphaInterleave: Integer;
-  pSource, pDest: PByte;
-
-  function GetRowPointer(Row: Integer): pByte;
-  begin
-    result := aSurface.pixels;
-    Inc(result, Row * Width);
-  end;
-
-begin
-  result := false;
-  if Assigned(Data) then begin
-    if Format in [tfAlpha8, tfLuminance8Alpha8, tfBGRA8, tfRGBA8] then begin
-      aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0);
-
-      AlphaInterleave := 0;
-      case Format of
-        tfLuminance8Alpha8:
-          AlphaInterleave := 1;
-        tfBGRA8, tfRGBA8:
-          AlphaInterleave := 3;
-      end;
-
-      pSource := Data;
-      for Row := 0 to Height -1 do begin
-        pDest := GetRowPointer(Row);
-        if Assigned(pDest) then begin
-          for Col := 0 to Width -1 do begin
-            Inc(pSource, AlphaInterleave);
-            pDest^ := pSource^;
-            Inc(pDest);
-            Inc(pSource);
-          end;
-        end;
-      end;
-      result := true;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
-var
-  bmp: TglBitmap2D;
-begin
-  bmp := TglBitmap2D.Create;
-  try
-    bmp.AssignFromSurface(aSurface);
-    result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs);
-  finally
-    bmp.Free;
-  end;
-end;
-{$ENDIF}
-
-{$IFDEF GLB_DELPHI}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function CreateGrayPalette: HPALETTE;
-var
-  Idx: Integer;
-  Pal: PLogPalette;
-begin
-  GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256));
-
-  Pal.palVersion := $300;
-  Pal.palNumEntries := 256;
-
-  for Idx := 0 to Pal.palNumEntries - 1 do begin
-    Pal.palPalEntry[Idx].peRed   := Idx;
-    Pal.palPalEntry[Idx].peGreen := Idx;
-    Pal.palPalEntry[Idx].peBlue  := Idx;
-    Pal.palPalEntry[Idx].peFlags := 0;
-  end;
-  Result := CreatePalette(Pal^);
-  FreeMem(Pal);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignToBitmap(const aBitmap: TBitmap): Boolean;
-var
-  Row: Integer;
-  pSource, pData: PByte;
-begin
-  result := false;
-  if Assigned(Data) then begin
-    if Assigned(aBitmap) then begin
-      aBitmap.Width  := Width;
-      aBitmap.Height := Height;
-
-      case Format of
-        tfAlpha8, tfLuminance8: begin
-          aBitmap.PixelFormat := pf8bit;
-          aBitmap.Palette     := CreateGrayPalette;
-        end;
-        tfRGB5A1:
-          aBitmap.PixelFormat := pf15bit;
-        tfR5G6B5:
-          aBitmap.PixelFormat := pf16bit;
-        tfRGB8, tfBGR8:
-          aBitmap.PixelFormat := pf24bit;
-        tfRGBA8, tfBGRA8:
-          aBitmap.PixelFormat := pf32bit;
-      else
-        raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.');
-      end;
-
-      pSource := Data;
-      for Row := 0 to FileHeight -1 do begin
-        pData := aBitmap.Scanline[Row];
-        Move(pSource^, pData^, fRowSize);
-        Inc(pSource, fRowSize);
-        if (Format in [tfRGB8, tfRGBA8]) then        // swap RGB(A) to BGR(A)
-          SwapRGB(pData, FileWidth, Format = tfRGBA8);
-      end;
-      result := true;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignFromBitmap(const aBitmap: TBitmap): Boolean;
-var
-  pSource, pData, pTempData: PByte;
-  Row, RowSize, TempWidth, TempHeight: Integer;
-  IntFormat: TglBitmapFormat;
-begin
-  result := false;
-
-  if (Assigned(aBitmap)) then begin
-    case aBitmap.PixelFormat of
-      pf8bit:
-        IntFormat := tfLuminance8;
-      pf15bit:
-        IntFormat := tfRGB5A1;
-      pf16bit:
-        IntFormat := tfR5G6B5;
-      pf24bit:
-        IntFormat := tfBGR8;
-      pf32bit:
-        IntFormat := tfBGRA8;
-    else
-      raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.');
-    end;
-
-    TempWidth  := aBitmap.Width;
-    TempHeight := aBitmap.Height;
-    RowSize    := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1);
-    GetMem(pData, TempHeight * RowSize);
-    try
-      pTempData := pData;
-      for Row := 0 to TempHeight -1 do begin
-        pSource := aBitmap.Scanline[Row];
-        if (Assigned(pSource)) then begin
-          Move(pSource^, pTempData^, RowSize);
-          Inc(pTempData, RowSize);
-        end;
-      end;
-      SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
-      result := true;
-    except
-      if Assigned(pData) then
-        FreeMem(pData);
-      raise;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
-var
-  Row, Col, AlphaInterleave: Integer;
-  pSource, pDest: PByte;
-begin
-  result := false;
-
-  if Assigned(Data) then begin
-    if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin
-      if Assigned(aBitmap) then begin
-        aBitmap.PixelFormat := pf8bit;
-        aBitmap.Palette     := CreateGrayPalette;
-        aBitmap.Width       := Width;
-        aBitmap.Height      := Height;
-
-        case Format of
-          tfLuminance8Alpha8:
-            AlphaInterleave := 1;
-          tfRGBA8, tfBGRA8:
-            AlphaInterleave := 3;
-          else
-            AlphaInterleave := 0;
-        end;
-
-        // Copy Data
-        pSource := Data;
-
-        for Row := 0 to Height -1 do begin
-          pDest := aBitmap.Scanline[Row];
-          if Assigned(pDest) then begin
-            for Col := 0 to Width -1 do begin
-              Inc(pSource, AlphaInterleave);
-              pDest^ := pSource^;
-              Inc(pDest);
-              Inc(pSource);
-            end;
-          end;
-        end;
-        result := true;
-      end;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
-  tex: TglBitmap2D;
-begin
-  tex := TglBitmap2D.Create;
-  try
-    tex.AssignFromBitmap(ABitmap);
-    result := AddAlphaFromglBitmap(tex, aFunc, aArgs);
-  finally
-    tex.Free;
-  end;
-end;
-{$ENDIF}
-
-{$IFDEF GLB_LAZARUS}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-var
-  rid: TRawImageDescription;
-  FormatDesc: TFormatDescriptor;
-begin
-  result := false;
-  if not Assigned(aImage) or (Format = tfEmpty) then
-    exit;
-  FormatDesc := TFormatDescriptor.Get(Format);
-  if FormatDesc.IsCompressed then
-    exit;
-
-  FillChar(rid{%H-}, SizeOf(rid), 0);
-  if (Format in [
-       tfAlpha4, tfAlpha8, tfAlpha16,
-       tfLuminance4, tfLuminance8, tfLuminance16,
-       tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance16Alpha16]) then
-    rid.Format := ricfGray
-  else
-    rid.Format := ricfRGBA;
-
-  rid.Width        := Width;
-  rid.Height       := Height;
-  rid.Depth        := CountSetBits(FormatDesc.RedMask or FormatDesc.GreenMask or FormatDesc.BlueMask or FormatDesc.AlphaMask);
-  rid.BitOrder     := riboBitsInOrder;
-  rid.ByteOrder    := riboLSBFirst;
-  rid.LineOrder    := riloTopToBottom;
-  rid.LineEnd      := rileTight;
-  rid.BitsPerPixel := Round(8 * FormatDesc.PixelSize);
-  rid.RedPrec      := CountSetBits(FormatDesc.Range.r);
-  rid.GreenPrec    := CountSetBits(FormatDesc.Range.g);
-  rid.BluePrec     := CountSetBits(FormatDesc.Range.b);
-  rid.AlphaPrec    := CountSetBits(FormatDesc.Range.a);
-  rid.RedShift     := FormatDesc.Shift.r;
-  rid.GreenShift   := FormatDesc.Shift.g;
-  rid.BlueShift    := FormatDesc.Shift.b;
-  rid.AlphaShift   := FormatDesc.Shift.a;
-
-  rid.MaskBitsPerPixel  := 0;
-  rid.PaletteColorCount := 0;
-
-  aImage.DataDescription := rid;
-  aImage.CreateData;
-
-  Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension));
-
-  result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
-var
-  f: TglBitmapFormat;
-  FormatDesc: TFormatDescriptor;
-  ImageData: PByte;
-  ImageSize: Integer;
-  CanCopy: Boolean;
-
-  procedure CopyConvert;
-  var
-    bfFormat: TbmpBitfieldFormat;
-    pSourceLine, pDestLine: PByte;
-    pSourceMD, pDestMD: Pointer;
-    x, y: Integer;
-    pixel: TglBitmapPixelData;
-  begin
-    bfFormat  := TbmpBitfieldFormat.Create;
-    with aImage.DataDescription do begin
-      bfFormat.RedMask   := ((1 shl RedPrec)   - 1) shl RedShift;
-      bfFormat.GreenMask := ((1 shl GreenPrec) - 1) shl GreenShift;
-      bfFormat.BlueMask  := ((1 shl BluePrec)  - 1) shl BlueShift;
-      bfFormat.AlphaMask := ((1 shl AlphaPrec) - 1) shl AlphaShift;
-      bfFormat.PixelSize := BitsPerPixel / 8;
-    end;
-    pSourceMD := bfFormat.CreateMappingData;
-    pDestMD   := FormatDesc.CreateMappingData;
-    try
-      for y := 0 to aImage.Height-1 do begin
-        pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine;
-        pDestLine   := ImageData        + y * Round(FormatDesc.PixelSize * aImage.Width);
-        for x := 0 to aImage.Width-1 do begin
-          bfFormat.Unmap(pSourceLine, pixel, pSourceMD);
-          FormatDesc.Map(pixel, pDestLine, pDestMD);
-        end;
-      end;
-    finally
-      FormatDesc.FreeMappingData(pDestMD);
-      bfFormat.FreeMappingData(pSourceMD);
-      bfFormat.Free;
-    end;
-  end;
-
-begin
-  result := false;
-  if not Assigned(aImage) then
-    exit;
-  for f := High(f) downto Low(f) do begin
-    FormatDesc := TFormatDescriptor.Get(f);
-    with aImage.DataDescription do
-      if FormatDesc.MaskMatch(
-        (QWord(1 shl RedPrec  )-1) shl RedShift,
-        (QWord(1 shl GreenPrec)-1) shl GreenShift,
-        (QWord(1 shl BluePrec )-1) shl BlueShift,
-        (QWord(1 shl AlphaPrec)-1) shl AlphaShift) then
-        break;
-  end;
-
-  if (f = tfEmpty) then
-    exit;
-
-  CanCopy :=
-    (Round(FormatDesc.PixelSize * 8)     = aImage.DataDescription.Depth) and
-    (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth);
-
-  ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height);
-  ImageData := GetMem(ImageSize);
-  try
-    if CanCopy then
-      Move(aImage.PixelData^, ImageData^, ImageSize)
-    else
-      CopyConvert;
-    SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method
-  except
-    if Assigned(ImageData) then
-      FreeMem(ImageData);
-    raise;
-  end;
-
-  result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
-var
-  rid: TRawImageDescription;
-  FormatDesc: TFormatDescriptor;
-  Pixel: TglBitmapPixelData;
-  x, y: Integer;
-  srcMD: Pointer;
-  src, dst: PByte;
-begin
-  result := false;
-  if not Assigned(aImage) or (Format = tfEmpty) then
-    exit;
-  FormatDesc := TFormatDescriptor.Get(Format);
-  if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
-    exit;
-
-  FillChar(rid{%H-}, SizeOf(rid), 0);
-  rid.Format       := ricfGray;
-  rid.Width        := Width;
-  rid.Height       := Height;
-  rid.Depth        := CountSetBits(FormatDesc.Range.a);
-  rid.BitOrder     := riboBitsInOrder;
-  rid.ByteOrder    := riboLSBFirst;
-  rid.LineOrder    := riloTopToBottom;
-  rid.LineEnd      := rileTight;
-  rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8);
-  rid.RedPrec      := CountSetBits(FormatDesc.Range.a);
-  rid.GreenPrec    := 0;
-  rid.BluePrec     := 0;
-  rid.AlphaPrec    := 0;
-  rid.RedShift     := 0;
-  rid.GreenShift   := 0;
-  rid.BlueShift    := 0;
-  rid.AlphaShift   := 0;
-
-  rid.MaskBitsPerPixel  := 0;
-  rid.PaletteColorCount := 0;
-
-  aImage.DataDescription := rid;
-  aImage.CreateData;
-
-  srcMD := FormatDesc.CreateMappingData;
-  try
-    FormatDesc.PreparePixel(Pixel);
-    src := Data;
-    dst := aImage.PixelData;
-    for y := 0 to Height-1 do
-      for x := 0 to Width-1 do begin
-        FormatDesc.Unmap(src, Pixel, srcMD);
-        case rid.BitsPerPixel of
-           8: begin
-            dst^ := Pixel.Data.a;
-            inc(dst);
-          end;
-          16: begin
-            PWord(dst)^ := Pixel.Data.a;
-            inc(dst, 2);
-          end;
-          24: begin
-            PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0];
-            PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1];
-            PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2];
-            inc(dst, 3);
-          end;
-          32: begin
-            PCardinal(dst)^ := Pixel.Data.a;
-            inc(dst, 4);
-          end;
-        else
-          raise EglBitmapUnsupportedFormat.Create(Format);
-        end;
-      end;
-  finally
-    FormatDesc.FreeMappingData(srcMD);
-  end;
-  result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
-  tex: TglBitmap2D;
-begin
-  tex := TglBitmap2D.Create;
-  try
-    tex.AssignFromLazIntfImage(aImage);
-    result := AddAlphaFromglBitmap(tex, aFunc, aArgs);
-  finally
-    tex.Free;
-  end;
-end;
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar;
-  const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
-  rs: TResourceStream;
-begin
-  PrepareResType(aResource, aResType);
-  rs := TResourceStream.Create(aInstance, aResource, aResType);
-  try
-    result := AddAlphaFromStream(rs, aFunc, aArgs);
-  finally
-    rs.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar;
-  const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
-  rs: TResourceStream;
-begin
-  rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
-  try
-    result := AddAlphaFromStream(rs, aFunc, aArgs);
-  finally
-    rs.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-begin
-  if TFormatDescriptor.Get(Format).IsCompressed then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-  result := AddFunc(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
-  FS: TFileStream;
-begin
-  FS := TFileStream.Create(aFileName, fmOpenRead);
-  try
-    result := AddAlphaFromStream(FS, aFunc, aArgs);
-  finally
-    FS.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
-  tex: TglBitmap2D;
-begin
-  tex := TglBitmap2D.Create(aStream);
-  try
-    result := AddAlphaFromglBitmap(tex, aFunc, aArgs);
-  finally
-    tex.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
-var
-  DestData, DestData2, SourceData: pByte;
-  TempHeight, TempWidth: Integer;
-  SourceFD, DestFD: TFormatDescriptor;
-  SourceMD, DestMD, DestMD2: Pointer;
-
-  FuncRec: TglBitmapFunctionRec;
-begin
-  result := false;
-
-  Assert(Assigned(Data));
-  Assert(Assigned(aBitmap));
-  Assert(Assigned(aBitmap.Data));
-
-  if ((aBitmap.Width = Width) and (aBitmap.Height = Height)) then begin
-    result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha);
-
-    SourceFD := TFormatDescriptor.Get(aBitmap.Format);
-    DestFD   := TFormatDescriptor.Get(Format);
-
-    if not Assigned(aFunc) then begin
-      aFunc        := glBitmapAlphaFunc;
-      FuncRec.Args := {%H-}Pointer(SourceFD.HasAlpha);
-    end else
-      FuncRec.Args := aArgs;
-
-    // Values
-    TempHeight := aBitmap.FileHeight;
-    TempWidth  := aBitmap.FileWidth;
-
-    FuncRec.Sender          := Self;
-    FuncRec.Size            := Dimension;
-    FuncRec.Position.Fields := FuncRec.Size.Fields;
-
-    DestData   := Data;
-    DestData2  := Data;
-    SourceData := aBitmap.Data;
-
-    // Mapping
-    SourceFD.PreparePixel(FuncRec.Source);
-    DestFD.PreparePixel  (FuncRec.Dest);
-
-    SourceMD := SourceFD.CreateMappingData;
-    DestMD   := DestFD.CreateMappingData;
-    DestMD2  := DestFD.CreateMappingData;
-    try
-      FuncRec.Position.Y := 0;
-      while FuncRec.Position.Y < TempHeight do begin
-        FuncRec.Position.X := 0;
-        while FuncRec.Position.X < TempWidth do begin
-          SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
-          DestFD.Unmap  (DestData,   FuncRec.Dest,   DestMD);
-          aFunc(FuncRec);
-          DestFD.Map(FuncRec.Dest, DestData2, DestMD2);
-          inc(FuncRec.Position.X);
-        end;
-        inc(FuncRec.Position.Y);
-      end;
-    finally
-      SourceFD.FreeMappingData(SourceMD);
-      DestFD.FreeMappingData(DestMD);
-      DestFD.FreeMappingData(DestMD2);
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean;
-begin
-  result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal): Boolean;
-var
-  PixelData: TglBitmapPixelData;
-begin
-  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
-  result := AddAlphaFromColorKeyFloat(
-    aRed   / PixelData.Range.r,
-    aGreen / PixelData.Range.g,
-    aBlue  / PixelData.Range.b,
-    aDeviation / Max(PixelData.Range.r, Max(PixelData.Range.g, PixelData.Range.b)));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single): Boolean;
-var
-  values: array[0..2] of Single;
-  tmp: Cardinal;
-  i: Integer;
-  PixelData: TglBitmapPixelData;
-begin
-  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
-  with PixelData do begin
-    values[0] := aRed;
-    values[1] := aGreen;
-    values[2] := aBlue;
-
-    for i := 0 to 2 do begin
-      tmp          := Trunc(Range.arr[i] * aDeviation);
-      Data.arr[i]  := Min(Range.arr[i], Trunc(Range.arr[i] * values[i] + tmp));
-      Range.arr[i] := Max(0,            Trunc(Range.arr[i] * values[i] - tmp));
-    end;
-    Data.a  := 0;
-    Range.a := 0;
-  end;
-  result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, @PixelData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromValue(const aAlpha: Byte): Boolean;
-begin
-  result := AddAlphaFromValueFloat(aAlpha / $FF);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
-var
-  PixelData: TglBitmapPixelData;
-begin
-  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
-  result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
-var
-  PixelData: TglBitmapPixelData;
-begin
-  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
-  with PixelData do
-    Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha)));
-  result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.RemoveAlpha: Boolean;
-var
-  FormatDesc: TFormatDescriptor;
-begin
-  result := false;
-  FormatDesc := TFormatDescriptor.Get(Format);
-  if Assigned(Data) then begin
-    if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
-      raise EglBitmapUnsupportedFormat.Create(Format);
-    result := ConvertTo(FormatDesc.WithoutAlpha);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.Clone: TglBitmap;
-var
-  Temp: TglBitmap;
-  TempPtr: PByte;
-  Size: Integer;
-begin
-  result := nil;
-  Temp := (ClassType.Create as TglBitmap);
-  try
-    // copy texture data if assigned
-    if Assigned(Data) then begin
-      Size := TFormatDescriptor.Get(Format).GetSize(fDimension);
-      GetMem(TempPtr, Size);
-      try
-        Move(Data^, TempPtr^, Size);
-        Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method
-      except
-        if Assigned(TempPtr) then
-          FreeMem(TempPtr);
-        raise;
-      end;
-    end else begin
-      TempPtr := nil;
-      Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method
-    end;
-
-       // copy properties
-    Temp.fID                      := ID;
-    Temp.fTarget                  := Target;
-    Temp.fFormat                  := Format;
-    Temp.fMipMap                  := MipMap;
-    Temp.fAnisotropic             := Anisotropic;
-    Temp.fBorderColor             := fBorderColor;
-    Temp.fDeleteTextureOnFree     := DeleteTextureOnFree;
-    Temp.fFreeDataAfterGenTexture := FreeDataAfterGenTexture;
-    Temp.fFilterMin               := fFilterMin;
-    Temp.fFilterMag               := fFilterMag;
-    Temp.fWrapS                   := fWrapS;
-    Temp.fWrapT                   := fWrapT;
-    Temp.fWrapR                   := fWrapR;
-    Temp.fFilename                := fFilename;
-    Temp.fCustomName              := fCustomName;
-    Temp.fCustomNameW             := fCustomNameW;
-    Temp.fCustomData              := fCustomData;
-
-    result := Temp;
-  except
-    FreeAndNil(Temp);
-    raise;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.ConvertTo(const aFormat: TglBitmapFormat): Boolean;
-var
-  SourceFD, DestFD: TFormatDescriptor;
-  SourcePD, DestPD: TglBitmapPixelData;
-  ShiftData: TShiftData;
-
-  function DataIsIdentical: Boolean;
-  begin
-    result :=
-      (SourceFD.RedMask   = DestFD.RedMask)   and
-      (SourceFD.GreenMask = DestFD.GreenMask) and
-      (SourceFD.BlueMask  = DestFD.BlueMask)  and
-      (SourceFD.AlphaMask = DestFD.AlphaMask);
-  end;
-
-  function CanCopyDirect: Boolean;
-  begin
-    result :=
-      ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
-      ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
-      ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
-      ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
-  end;
-
-  function CanShift: Boolean;
-  begin
-    result :=
-      ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
-      ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
-      ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
-      ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
-  end;
-
-  function GetShift(aSource, aDest: Cardinal) : ShortInt;
-  begin
-    result := 0;
-    while (aSource > aDest) and (aSource > 0) do begin
-      inc(result);
-      aSource := aSource shr 1;
-    end;
-  end;
-
-begin
-  if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin
-    SourceFD := TFormatDescriptor.Get(Format);
-    DestFD   := TFormatDescriptor.Get(aFormat);
-
-    if DataIsIdentical then begin
-      result := true;
-      Format := aFormat;
-      exit;
-    end;
-
-    SourceFD.PreparePixel(SourcePD);
-    DestFD.PreparePixel  (DestPD);
-
-    if CanCopyDirect then
-      result := AddFunc(Self, glBitmapConvertCopyFunc, false, aFormat)
-    else if CanShift then begin
-      ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r);
-      ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g);
-      ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b);
-      ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a);
-      result := AddFunc(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData);
-    end else
-      result := AddFunc(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat);
-  end else
-    result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean);
-begin
-  if aUseRGB or aUseAlpha then
-    AddFunc(glBitmapInvertFunc, false, {%H-}Pointer(
-      ((Byte(aUseAlpha) and 1) shl 1) or
-       (Byte(aUseRGB)   and 1)      ));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
-begin
-  fBorderColor[0] := aRed;
-  fBorderColor[1] := aGreen;
-  fBorderColor[2] := aBlue;
-  fBorderColor[3] := aAlpha;
-  if (ID > 0) then begin
-    Bind(false);
-    glTexParameterfv(Target, GL_TEXTURE_BORDER_COLOR, @fBorderColor[0]);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.FreeData;
-var
-  TempPtr: PByte;
-begin
-  TempPtr := nil;
-  SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.FillWithColor(const aRed, aGreen, aBlue: Byte;
-  const aAlpha: Byte);
-begin
-  FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal);
-var
-  PixelData: TglBitmapPixelData;
-begin
-  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
-  FillWithColorFloat(
-    aRed   / PixelData.Range.r,
-    aGreen / PixelData.Range.g,
-    aBlue  / PixelData.Range.b,
-    aAlpha / PixelData.Range.a);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single);
-var
-  PixelData: TglBitmapPixelData;
-begin
-  TFormatDescriptor.Get(Format).PreparePixel(PixelData);
-  with PixelData do begin
-    Data.r := Max(0, Min(Range.r, Trunc(Range.r * aRed)));
-    Data.g := Max(0, Min(Range.g, Trunc(Range.g * aGreen)));
-    Data.b := Max(0, Min(Range.b, Trunc(Range.b * aBlue)));
-    Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha)));
-  end;
-  AddFunc(glBitmapFillWithColorFunc, false, @PixelData);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetFilter(const aMin, aMag: GLenum);
-begin
-  //check MIN filter
-  case aMin of
-    GL_NEAREST:
-      fFilterMin := GL_NEAREST;
-    GL_LINEAR:
-      fFilterMin := GL_LINEAR;
-    GL_NEAREST_MIPMAP_NEAREST:
-      fFilterMin := GL_NEAREST_MIPMAP_NEAREST;
-    GL_LINEAR_MIPMAP_NEAREST:
-      fFilterMin := GL_LINEAR_MIPMAP_NEAREST;
-    GL_NEAREST_MIPMAP_LINEAR:
-      fFilterMin := GL_NEAREST_MIPMAP_LINEAR;
-    GL_LINEAR_MIPMAP_LINEAR:
-      fFilterMin := GL_LINEAR_MIPMAP_LINEAR;
-    else
-      raise EglBitmap.Create('SetFilter - Unknow MIN filter.');
-  end;
-
-  //check MAG filter
-  case aMag of
-    GL_NEAREST:
-      fFilterMag := GL_NEAREST;
-    GL_LINEAR:
-      fFilterMag := GL_LINEAR;
-    else
-      raise EglBitmap.Create('SetFilter - Unknow MAG filter.');
-  end;
-
-  //apply filter
-  if (ID > 0) then begin
-    Bind(false);
-    glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag);
-
-    if (MipMap = mmNone) or (Target = GL_TEXTURE_RECTANGLE) then begin
-      case fFilterMin of
-        GL_NEAREST, GL_LINEAR:
-          glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
-        GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR:
-          glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR:
-          glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-      end;
-    end else
-      glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum);
-
-  procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal);
-  begin
-    case aValue of
-      GL_CLAMP:
-        aTarget := GL_CLAMP;
-
-      GL_REPEAT:
-        aTarget := GL_REPEAT;
-
-      GL_CLAMP_TO_EDGE: begin
-        if GL_VERSION_1_2 or GL_EXT_texture_edge_clamp then
-          aTarget := GL_CLAMP_TO_EDGE
-        else
-          aTarget := GL_CLAMP;
-      end;
-
-      GL_CLAMP_TO_BORDER: begin
-        if GL_VERSION_1_3 or GL_ARB_texture_border_clamp then
-          aTarget := GL_CLAMP_TO_BORDER
-        else
-          aTarget := GL_CLAMP;
-      end;
-
-      GL_MIRRORED_REPEAT: begin
-        if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then
-          aTarget := GL_MIRRORED_REPEAT
-        else
-          raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
-      end;
-    else
-      raise EglBitmap.Create('SetWrap - Unknow Texturewrap');
-    end;
-  end;
-
-begin
-  CheckAndSetWrap(S, fWrapS);
-  CheckAndSetWrap(T, fWrapT);
-  CheckAndSetWrap(R, fWrapR);
-
-  if (ID > 0) then begin
-    Bind(false);
-    glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS);
-    glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT);
-    glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum);
-
-  procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer);
-  begin
-    if (aValue = GL_ZERO) or (aValue =   GL_ONE) or (aValue = GL_ALPHA) or
-       (aValue =  GL_RED) or (aValue = GL_GREEN) or (aValue =  GL_BLUE) then
-      fSwizzle[aIndex] := aValue
-    else
-      raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value');
-  end;
-
-begin
-  if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
-    raise EglBitmapNotSupported.Create('texture swizzle is not supported');
-  CheckAndSetValue(r, 0);
-  CheckAndSetValue(g, 1);
-  CheckAndSetValue(b, 2);
-  CheckAndSetValue(a, 3);
-
-  if (ID > 0) then begin
-    Bind(false);
-    glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0]));
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean);
-begin
-  if aEnableTextureUnit then
-    glEnable(Target);
-  if (ID > 0) then
-    glBindTexture(Target, ID);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.Unbind(const aDisableTextureUnit: Boolean);
-begin
-  if aDisableTextureUnit then
-    glDisable(Target);
-  glBindTexture(Target, 0);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create;
-begin
-  if (ClassType = TglBitmap) then
-    raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
-{$IFDEF GLB_NATIVE_OGL}
-  glbReadOpenGLExtensions;
-{$ENDIF}
-  inherited Create;
-  fFormat            := glBitmapGetDefaultFormat;
-  fFreeDataOnDestroy := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create(const aFileName: String);
-begin
-  Create;
-  LoadFromFile(aFileName);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create(const aStream: TStream);
-begin
-  Create;
-  LoadFromStream(aStream);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte);
-var
-  ImageSize: Integer;
-begin
-  Create;
-  if not Assigned(aData) then begin
-    ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize);
-    GetMem(aData, ImageSize);
-    try
-      FillChar(aData^, ImageSize, #$FF);
-      SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method
-    except
-      if Assigned(aData) then
-        FreeMem(aData);
-      raise;
-    end;
-  end else begin
-    SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method
-    fFreeDataOnDestroy := false;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer);
-begin
-  Create;
-  LoadFromFunc(aSize, aFunc, aFormat, aArgs);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar);
-begin
-  Create;
-  LoadFromResource(aInstance, aResource, aResType);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-constructor TglBitmap.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
-begin
-  Create;
-  LoadFromResourceID(aInstance, aResourceID, aResType);
-end;
-
-{$IFDEF GLB_SUPPORT_PNG_READ}
-{$IF DEFINED(GLB_LAZ_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//PNG/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
-const
-  MAGIC_LEN = 8;
-  PNG_MAGIC: String[MAGIC_LEN] = #$89#$50#$4E#$47#$0D#$0A#$1A#$0A;
-var
-  reader: TLazReaderPNG;
-  intf: TLazIntfImage;
-  StreamPos: Int64;
-  magic: String[MAGIC_LEN];
-begin
-  result := true;
-  StreamPos := aStream.Position;
-
-  SetLength(magic, MAGIC_LEN);
-  aStream.Read(magic[1], MAGIC_LEN);
-  aStream.Position := StreamPos;
-  if (magic <> PNG_MAGIC) then begin
-    result := false;
-    exit;
-  end;
-
-  intf   := TLazIntfImage.Create(0, 0);
-  reader := TLazReaderPNG.Create;
-  try try
-    reader.UpdateDescription := true;
-    reader.ImageRead(aStream, intf);
-    AssignFromLazIntfImage(intf);
-  except
-    result := false;
-    aStream.Position := StreamPos;
-    exit;
-  end;
-  finally
-    reader.Free;
-    intf.Free;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
-var
-  Surface: PSDL_Surface;
-  RWops: PSDL_RWops;
-begin
-  result := false;
-  RWops := glBitmapCreateRWops(aStream);
-  try
-    if IMG_isPNG(RWops) > 0 then begin
-      Surface := IMG_LoadPNG_RW(RWops);
-      try
-        AssignFromSurface(Surface);
-        result := true;
-      finally
-        SDL_FreeSurface(Surface);
-      end;
-    end;
-  finally
-    SDL_FreeRW(RWops);
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libPNG_read_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
-begin
-  TStream(png_get_io_ptr(png)).Read(buffer^, size);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
-var
-  StreamPos: Int64;
-  signature: array [0..7] of byte;
-  png: png_structp;
-  png_info: png_infop;
-
-  TempHeight, TempWidth: Integer;
-  Format: TglBitmapFormat;
-
-  png_data: pByte;
-  png_rows: array of pByte;
-  Row, LineSize: Integer;
-begin
-  result := false;
-
-  if not init_libPNG then
-    raise Exception.Create('LoadPNG - unable to initialize libPNG.');
-
-  try
-    // signature
-    StreamPos := aStream.Position;
-    aStream.Read(signature{%H-}, 8);
-    aStream.Position := StreamPos;
-
-    if png_check_sig(@signature, 8) <> 0 then begin
-      // png read struct
-      png := png_create_read_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
-      if png = nil then
-        raise EglBitmapException.Create('LoadPng - couldn''t create read struct.');
-
-      // png info
-      png_info := png_create_info_struct(png);
-      if png_info = nil then begin
-        png_destroy_read_struct(@png, nil, nil);
-        raise EglBitmapException.Create('LoadPng - couldn''t create info struct.');
-      end;
-
-      // set read callback
-      png_set_read_fn(png, aStream, glBitmap_libPNG_read_func);
-
-      // read informations
-      png_read_info(png, png_info);
-
-      // size
-      TempHeight := png_get_image_height(png, png_info);
-      TempWidth := png_get_image_width(png, png_info);
-
-      // format
-      case png_get_color_type(png, png_info) of
-        PNG_COLOR_TYPE_GRAY:
-          Format := tfLuminance8;
-        PNG_COLOR_TYPE_GRAY_ALPHA:
-          Format := tfLuminance8Alpha8;
-        PNG_COLOR_TYPE_RGB:
-          Format := tfRGB8;
-        PNG_COLOR_TYPE_RGB_ALPHA:
-          Format := tfRGBA8;
-        else
-          raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
-      end;
-
-      // cut upper 8 bit from 16 bit formats
-      if png_get_bit_depth(png, png_info) > 8 then
-        png_set_strip_16(png);
-
-      // expand bitdepth smaller than 8
-      if png_get_bit_depth(png, png_info) < 8 then
-        png_set_expand(png);
-
-      // allocating mem for scanlines
-      LineSize := png_get_rowbytes(png, png_info);
-      GetMem(png_data, TempHeight * LineSize);
-      try
-        SetLength(png_rows, TempHeight);
-        for Row := Low(png_rows) to High(png_rows) do begin
-          png_rows[Row] := png_data;
-          Inc(png_rows[Row], Row * LineSize);
-        end;
-
-        // read complete image into scanlines
-        png_read_image(png, @png_rows[0]);
-
-        // read end
-        png_read_end(png, png_info);
-
-        // destroy read struct
-        png_destroy_read_struct(@png, @png_info, nil);
-
-        SetLength(png_rows, 0);
-
-        // set new data
-        SetDataPointer(png_data, Format, TempWidth, TempHeight); //be careful, Data could be freed by this method
-
-        result := true;
-      except
-        if Assigned(png_data) then
-          FreeMem(png_data);
-        raise;
-      end;
-    end;
-  finally
-    quit_libPNG;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_PNGIMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
-var
-  StreamPos: Int64;
-  Png: TPNGObject;
-  Header: String[8];
-  Row, Col, PixSize, LineSize: Integer;
-  NewImage, pSource, pDest, pAlpha: pByte;
-  PngFormat: TglBitmapFormat;
-  FormatDesc: TFormatDescriptor;
-
-const
-  PngHeader: String[8] = #137#80#78#71#13#10#26#10;
-
-begin
-  result := false;
-
-  StreamPos := aStream.Position;
-  aStream.Read(Header[0], SizeOf(Header));
-  aStream.Position := StreamPos;
-
-  {Test if the header matches}
-  if Header = PngHeader then begin
-    Png := TPNGObject.Create;
-    try
-      Png.LoadFromStream(aStream);
-
-      case Png.Header.ColorType of
-        COLOR_GRAYSCALE:
-          PngFormat := tfLuminance8;
-        COLOR_GRAYSCALEALPHA:
-          PngFormat := tfLuminance8Alpha8;
-        COLOR_RGB:
-          PngFormat := tfBGR8;
-        COLOR_RGBALPHA:
-          PngFormat := tfBGRA8;
-        else
-          raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
-      end;
-
-      FormatDesc := TFormatDescriptor.Get(PngFormat);
-      PixSize    := Round(FormatDesc.PixelSize);
-      LineSize   := FormatDesc.GetSize(Png.Header.Width, 1);
-
-      GetMem(NewImage, LineSize * Integer(Png.Header.Height));
-      try
-        pDest := NewImage;
-
-        case Png.Header.ColorType of
-          COLOR_RGB, COLOR_GRAYSCALE:
-            begin
-              for Row := 0 to Png.Height -1 do begin
-                Move (Png.Scanline[Row]^, pDest^, LineSize);
-                Inc(pDest, LineSize);
-              end;
-            end;
-          COLOR_RGBALPHA, COLOR_GRAYSCALEALPHA:
-            begin
-              PixSize := PixSize -1;
-
-              for Row := 0 to Png.Height -1 do begin
-                pSource := Png.Scanline[Row];
-                pAlpha := pByte(Png.AlphaScanline[Row]);
-
-                for Col := 0 to Png.Width -1 do begin
-                  Move (pSource^, pDest^, PixSize);
-                  Inc(pSource, PixSize);
-                  Inc(pDest, PixSize);
-
-                  pDest^ := pAlpha^;
-                  inc(pAlpha);
-                  Inc(pDest);
-                end;
-              end;
-            end;
-          else
-            raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
-        end;
-
-        SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); //be careful, Data could be freed by this method
-
-        result := true;
-      except
-        if Assigned(NewImage) then
-          FreeMem(NewImage);
-        raise;
-      end;
-    finally
-      Png.Free;
-    end;
-  end;
-end;
-{$IFEND}
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_PNG_WRITE}
-{$IFDEF GLB_LIB_PNG}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libPNG_write_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
-begin
-  TStream(png_get_io_ptr(png)).Write(buffer^, size);
-end;
-{$ENDIF}
-
-{$IF DEFINED(GLB_LAZ_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SavePNG(const aStream: TStream);
-var
-  png: TPortableNetworkGraphic;
-  intf: TLazIntfImage;
-  raw: TRawImage;
-begin
-  png  := TPortableNetworkGraphic.Create;
-  intf := TLazIntfImage.Create(0, 0);
-  try
-    if not AssignToLazIntfImage(intf) then
-      raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
-    intf.GetRawImage(raw);
-    png.LoadFromRawImage(raw, false);
-    png.SaveToStream(aStream);
-  finally
-    png.Free;
-    intf.Free;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_PNG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SavePNG(const aStream: TStream);
-var
-  png: png_structp;
-  png_info: png_infop;
-  png_rows: array of pByte;
-  LineSize: Integer;
-  ColorType: Integer;
-  Row: Integer;
-  FormatDesc: TFormatDescriptor;
-begin
-  if not (ftPNG in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  if not init_libPNG then
-    raise Exception.Create('unable to initialize libPNG.');
-
-  try
-    case Format of
-      tfAlpha8, tfLuminance8:
-        ColorType := PNG_COLOR_TYPE_GRAY;
-      tfLuminance8Alpha8:
-        ColorType := PNG_COLOR_TYPE_GRAY_ALPHA;
-      tfBGR8, tfRGB8:
-        ColorType := PNG_COLOR_TYPE_RGB;
-      tfBGRA8, tfRGBA8:
-        ColorType := PNG_COLOR_TYPE_RGBA;
-      else
-        raise EglBitmapUnsupportedFormat.Create(Format);
-    end;
-
-    FormatDesc := TFormatDescriptor.Get(Format);
-    LineSize := FormatDesc.GetSize(Width, 1);
-
-    // creating array for scanline
-    SetLength(png_rows, Height);
-    try
-      for Row := 0 to Height - 1 do begin
-        png_rows[Row] := Data;
-        Inc(png_rows[Row], Row * LineSize)
-      end;
-
-      // write struct
-      png := png_create_write_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
-      if png = nil then
-        raise EglBitmapException.Create('SavePng - couldn''t create write struct.');
-
-      // create png info
-      png_info := png_create_info_struct(png);
-      if png_info = nil then begin
-        png_destroy_write_struct(@png, nil);
-        raise EglBitmapException.Create('SavePng - couldn''t create info struct.');
-      end;
-
-      // set read callback
-      png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil);
-
-      // set compression
-      png_set_compression_level(png, 6);
-
-      if Format in [tfBGR8, tfBGRA8] then
-        png_set_bgr(png);
-
-      png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
-      png_write_info(png, png_info);
-      png_write_image(png, @png_rows[0]);
-      png_write_end(png, png_info);
-      png_destroy_write_struct(@png, @png_info);
-    finally
-      SetLength(png_rows, 0);
-    end;
-  finally
-    quit_libPNG;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_PNGIMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SavePNG(const aStream: TStream);
-var
-  Png: TPNGObject;
-
-  pSource, pDest: pByte;
-  X, Y, PixSize: Integer;
-  ColorType: Cardinal;
-  Alpha: Boolean;
-
-  pTemp: pByte;
-  Temp: Byte;
-begin
-  if not (ftPNG in FormatGetSupportedFiles (Format)) then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  case Format of
-    tfAlpha8, tfLuminance8: begin
-      ColorType := COLOR_GRAYSCALE;
-      PixSize   := 1;
-      Alpha     := false;
-    end;
-    tfLuminance8Alpha8: begin
-      ColorType := COLOR_GRAYSCALEALPHA;
-      PixSize   := 1;
-      Alpha     := true;
-    end;
-    tfBGR8, tfRGB8: begin
-      ColorType := COLOR_RGB;
-      PixSize   := 3;
-      Alpha     := false;
-    end;
-    tfBGRA8, tfRGBA8: begin
-      ColorType := COLOR_RGBALPHA;
-      PixSize   := 3;
-      Alpha     := true
-    end;
-  else
-    raise EglBitmapUnsupportedFormat.Create(Format);
-  end;
-
-  Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height);
-  try
-    // Copy ImageData
-    pSource := Data;
-    for Y := 0 to Height -1 do begin
-      pDest := png.ScanLine[Y];
-      for X := 0 to Width -1 do begin
-        Move(pSource^, pDest^, PixSize);
-        Inc(pDest, PixSize);
-        Inc(pSource, PixSize);
-        if Alpha then begin
-          png.AlphaScanline[Y]^[X] := pSource^;
-          Inc(pSource);
-        end;
-      end;
-
-      // convert RGB line to BGR
-      if Format in [tfRGB8, tfRGBA8] then begin
-        pTemp := png.ScanLine[Y];
-        for X := 0 to Width -1 do begin
-          Temp := pByteArray(pTemp)^[0];
-          pByteArray(pTemp)^[0] := pByteArray(pTemp)^[2];
-          pByteArray(pTemp)^[2] := Temp;
-          Inc(pTemp, 3);
-        end;
-      end;
-    end;
-
-    // Save to Stream
-    Png.CompressionLevel := 6;
-    Png.SaveToStream(aStream);
-  finally
-    FreeAndNil(Png);
-  end;
-end;
-{$IFEND}
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//JPEG////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{$IFDEF GLB_LIB_JPEG}
-type
-  glBitmap_libJPEG_source_mgr_ptr = ^glBitmap_libJPEG_source_mgr;
-  glBitmap_libJPEG_source_mgr = record
-    pub: jpeg_source_mgr;
-
-    SrcStream: TStream;
-    SrcBuffer: array [1..4096] of byte;
-  end;
-
-  glBitmap_libJPEG_dest_mgr_ptr = ^glBitmap_libJPEG_dest_mgr;
-  glBitmap_libJPEG_dest_mgr = record
-    pub: jpeg_destination_mgr;
-
-    DestStream: TStream;
-    DestBuffer: array [1..4096] of byte;
-  end;
-
-procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl;
-begin
-  //DUMMY
-end;
-
-
-procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl;
-begin
-  //DUMMY
-end;
-
-
-procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl;
-begin
-  //DUMMY
-end;
-
-procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl;
-begin
-  //DUMMY
-end;
-
-
-procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl;
-begin
-  //DUMMY
-end;
-
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl;
-var
-  src: glBitmap_libJPEG_source_mgr_ptr;
-  bytes: integer;
-begin
-  src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
-
-  bytes := src^.SrcStream.Read(src^.SrcBuffer[1], 4096);
-       if (bytes <= 0) then begin
-               src^.SrcBuffer[1] := $FF;
-               src^.SrcBuffer[2] := JPEG_EOI;
-               bytes := 2;
-       end;
-
-       src^.pub.next_input_byte := @(src^.SrcBuffer[1]);
-       src^.pub.bytes_in_buffer := bytes;
-
-  result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libJPEG_skip_input_data(cinfo: j_decompress_ptr; num_bytes: Longint); cdecl;
-var
-  src: glBitmap_libJPEG_source_mgr_ptr;
-begin
-  src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
-
-  if num_bytes > 0 then begin
-    // wanted byte isn't in buffer so set stream position and read buffer
-    if num_bytes > src^.pub.bytes_in_buffer then begin
-      src^.SrcStream.Position := src^.SrcStream.Position + num_bytes - src^.pub.bytes_in_buffer;
-      src^.pub.fill_input_buffer(cinfo);
-    end else begin
-      // wanted byte is in buffer so only skip
-               inc(src^.pub.next_input_byte, num_bytes);
-               dec(src^.pub.bytes_in_buffer, num_bytes);
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl;
-var
-  dest: glBitmap_libJPEG_dest_mgr_ptr;
-begin
-  dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
-
-  if dest^.pub.free_in_buffer < Cardinal(Length(dest^.DestBuffer)) then begin
-    // write complete buffer
-    dest^.DestStream.Write(dest^.DestBuffer[1], SizeOf(dest^.DestBuffer));
-
-    // reset buffer
-    dest^.pub.next_output_byte := @dest^.DestBuffer[1];
-    dest^.pub.free_in_buffer := Length(dest^.DestBuffer);
-  end;
-
-  result := true;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmap_libJPEG_term_destination(cinfo: j_compress_ptr); cdecl;
-var
-  Idx: Integer;
-  dest: glBitmap_libJPEG_dest_mgr_ptr;
-begin
-  dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
-
-  for Idx := Low(dest^.DestBuffer) to High(dest^.DestBuffer) do begin
-    // check for endblock
-    if (Idx < High(dest^.DestBuffer)) and (dest^.DestBuffer[Idx] = $FF) and (dest^.DestBuffer[Idx +1] = JPEG_EOI) then begin
-      // write endblock
-      dest^.DestStream.Write(dest^.DestBuffer[Idx], 2);
-
-      // leave
-      break;
-    end else
-      dest^.DestStream.Write(dest^.DestBuffer[Idx], 1);
-  end;
-end;
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_JPEG_READ}
-{$IF DEFINED(GLB_LAZ_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
-const
-  MAGIC_LEN = 2;
-  JPEG_MAGIC: String[MAGIC_LEN] = #$FF#$D8;
-var
-  intf: TLazIntfImage;
-  reader: TFPReaderJPEG;
-  StreamPos: Int64;
-  magic: String[MAGIC_LEN];
-begin
-  result := true;
-  StreamPos := aStream.Position;
-
-  SetLength(magic, MAGIC_LEN);
-  aStream.Read(magic[1], MAGIC_LEN);
-  aStream.Position := StreamPos;
-  if (magic <> JPEG_MAGIC) then begin
-    result := false;
-    exit;
-  end;
-
-  reader := TFPReaderJPEG.Create;
-  intf := TLazIntfImage.Create(0, 0);
-  try try
-    intf.DataDescription := GetDescriptionFromDevice(0, 0, 0);
-    reader.ImageRead(aStream, intf);
-    AssignFromLazIntfImage(intf);
-  except
-    result := false;
-    aStream.Position := StreamPos;
-    exit;
-  end;
-  finally
-    reader.Free;
-    intf.Free;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
-var
-  Surface: PSDL_Surface;
-  RWops: PSDL_RWops;
-begin
-  result := false;
-
-  RWops := glBitmapCreateRWops(aStream);
-  try
-    if IMG_isJPG(RWops) > 0 then begin
-      Surface := IMG_LoadJPG_RW(RWops);
-      try
-        AssignFromSurface(Surface);
-        result := true;
-      finally
-        SDL_FreeSurface(Surface);
-      end;
-    end;
-  finally
-    SDL_FreeRW(RWops);
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
-var
-  StreamPos: Int64;
-  Temp: array[0..1]of Byte;
-
-  jpeg: jpeg_decompress_struct;
-  jpeg_err: jpeg_error_mgr;
-
-  IntFormat: TglBitmapFormat;
-  pImage: pByte;
-  TempHeight, TempWidth: Integer;
-
-  pTemp: pByte;
-  Row: Integer;
-
-  FormatDesc: TFormatDescriptor;
-begin
-  result := false;
-
-  if not init_libJPEG then
-    raise Exception.Create('LoadJPG - unable to initialize libJPEG.');
-
-  try
-    // reading first two bytes to test file and set cursor back to begin
-    StreamPos := aStream.Position;
-    aStream.Read({%H-}Temp[0], 2);
-    aStream.Position := StreamPos;
-
-    // if Bitmap then read file.
-    if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
-      FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00);
-      FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
-
-      // error managment
-      jpeg.err := jpeg_std_error(@jpeg_err);
-      jpeg_err.error_exit     := glBitmap_libJPEG_error_exit;
-      jpeg_err.output_message := glBitmap_libJPEG_output_message;
-
-      // decompression struct
-      jpeg_create_decompress(@jpeg);
-
-      // allocation space for streaming methods
-      jpeg.src := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_source_mgr));
-
-      // seeting up custom functions
-      with glBitmap_libJPEG_source_mgr_ptr(jpeg.src)^ do begin
-        pub.init_source       := glBitmap_libJPEG_init_source;
-        pub.fill_input_buffer := glBitmap_libJPEG_fill_input_buffer;
-        pub.skip_input_data   := glBitmap_libJPEG_skip_input_data;
-        pub.resync_to_restart := jpeg_resync_to_restart; // use default method
-        pub.term_source       := glBitmap_libJPEG_term_source;
-
-        pub.bytes_in_buffer := 0;     // forces fill_input_buffer on first read
-        pub.next_input_byte := nil;   // until buffer loaded
-
-        SrcStream := aStream;
-      end;
-
-      // set global decoding state
-      jpeg.global_state := DSTATE_START;
-
-      // read header of jpeg
-      jpeg_read_header(@jpeg, false);
-
-      // setting output parameter
-      case jpeg.jpeg_color_space of
-        JCS_GRAYSCALE:
-          begin
-            jpeg.out_color_space := JCS_GRAYSCALE;
-            IntFormat := tfLuminance8;
-          end;
-        else
-          jpeg.out_color_space := JCS_RGB;
-          IntFormat := tfRGB8;
-      end;
-
-      // reading image
-      jpeg_start_decompress(@jpeg);
-
-      TempHeight := jpeg.output_height;
-      TempWidth := jpeg.output_width;
-
-      FormatDesc := TFormatDescriptor.Get(IntFormat);
-
-      // creating new image
-      GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight));
-      try
-        pTemp := pImage;
-
-        for Row := 0 to TempHeight -1 do begin
-          jpeg_read_scanlines(@jpeg, @pTemp, 1);
-          Inc(pTemp, FormatDesc.GetSize(TempWidth, 1));
-        end;
-
-        // finish decompression
-        jpeg_finish_decompress(@jpeg);
-
-        // destroy decompression
-        jpeg_destroy_decompress(@jpeg);
-
-        SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
-
-        result := true;
-      except
-        if Assigned(pImage) then
-          FreeMem(pImage);
-        raise;
-      end;
-    end;
-  finally
-    quit_libJPEG;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
-var
-  bmp: TBitmap;
-  jpg: TJPEGImage;
-  StreamPos: Int64;
-  Temp: array[0..1]of Byte;
-begin
-  result := false;
-
-  // reading first two bytes to test file and set cursor back to begin
-  StreamPos := aStream.Position;
-  aStream.Read(Temp[0], 2);
-  aStream.Position := StreamPos;
-
-  // if Bitmap then read file.
-  if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
-    bmp := TBitmap.Create;
-    try
-      jpg := TJPEGImage.Create;
-      try
-        jpg.LoadFromStream(aStream);
-        bmp.Assign(jpg);
-        result := AssignFromBitmap(bmp);
-      finally
-        jpg.Free;
-      end;
-    finally
-      bmp.Free;
-    end;
-  end;
-end;
-{$IFEND}
-{$ENDIF}
-
-{$IFDEF GLB_SUPPORT_JPEG_WRITE}
-{$IF DEFINED(GLB_LAZ_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveJPEG(const aStream: TStream);
-var
-  jpeg: TJPEGImage;
-  intf: TLazIntfImage;
-  raw: TRawImage;
-begin
-  jpeg := TJPEGImage.Create;
-  intf := TLazIntfImage.Create(0, 0);
-  try
-    if not AssignToLazIntfImage(intf) then
-      raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
-    intf.GetRawImage(raw);
-    jpeg.LoadFromRawImage(raw, false);
-    jpeg.SaveToStream(aStream);
-  finally
-    intf.Free;
-    jpeg.Free;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_LIB_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveJPEG(const aStream: TStream);
-var
-  jpeg: jpeg_compress_struct;
-  jpeg_err: jpeg_error_mgr;
-  Row: Integer;
-  pTemp, pTemp2: pByte;
-
-  procedure CopyRow(pDest, pSource: pByte);
-  var
-    X: Integer;
-  begin
-    for X := 0 to Width - 1 do begin
-      pByteArray(pDest)^[0] := pByteArray(pSource)^[2];
-      pByteArray(pDest)^[1] := pByteArray(pSource)^[1];
-      pByteArray(pDest)^[2] := pByteArray(pSource)^[0];
-      Inc(pDest, 3);
-      Inc(pSource, 3);
-    end;
-  end;
-
-begin
-  if not (ftJPEG in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  if not init_libJPEG then
-    raise Exception.Create('SaveJPG - unable to initialize libJPEG.');
-
-  try
-    FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00);
-    FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
-
-    // error managment
-    jpeg.err := jpeg_std_error(@jpeg_err);
-    jpeg_err.error_exit     := glBitmap_libJPEG_error_exit;
-    jpeg_err.output_message := glBitmap_libJPEG_output_message;
-
-    // compression struct
-    jpeg_create_compress(@jpeg);
-
-    // allocation space for streaming methods
-    jpeg.dest := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_dest_mgr));
-
-    // seeting up custom functions
-    with glBitmap_libJPEG_dest_mgr_ptr(jpeg.dest)^ do begin
-      pub.init_destination    := glBitmap_libJPEG_init_destination;
-      pub.empty_output_buffer := glBitmap_libJPEG_empty_output_buffer;
-      pub.term_destination    := glBitmap_libJPEG_term_destination;
-
-      pub.next_output_byte  := @DestBuffer[1];
-      pub.free_in_buffer    := Length(DestBuffer);
-
-      DestStream := aStream;
-    end;
-
-    // very important state
-    jpeg.global_state := CSTATE_START;
-    jpeg.image_width  := Width;
-    jpeg.image_height := Height;
-    case Format of
-      tfAlpha8, tfLuminance8: begin
-        jpeg.input_components := 1;
-        jpeg.in_color_space   := JCS_GRAYSCALE;
-      end;
-      tfRGB8, tfBGR8: begin
-        jpeg.input_components := 3;
-        jpeg.in_color_space   := JCS_RGB;
-      end;
-    end;
-
-    jpeg_set_defaults(@jpeg);
-    jpeg_set_quality(@jpeg, 95, true);
-    jpeg_start_compress(@jpeg, true);
-    pTemp := Data;
-
-    if Format = tfBGR8 then
-      GetMem(pTemp2, fRowSize)
-    else
-      pTemp2 := pTemp;
-
-    try
-      for Row := 0 to jpeg.image_height -1 do begin
-        // prepare row
-        if Format = tfBGR8 then
-          CopyRow(pTemp2, pTemp)
-        else
-          pTemp2 := pTemp;
-
-        // write row
-        jpeg_write_scanlines(@jpeg, @pTemp2, 1);
-        inc(pTemp, fRowSize);
-      end;
-    finally
-      // free memory
-      if Format = tfBGR8 then
-        FreeMem(pTemp2);
-    end;
-    jpeg_finish_compress(@jpeg);
-    jpeg_destroy_compress(@jpeg);
-  finally
-    quit_libJPEG;
-  end;
-end;
-
-{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveJPEG(const aStream: TStream);
-var
-  Bmp: TBitmap;
-  Jpg: TJPEGImage;
-begin
-  if not (ftJPEG in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  Bmp := TBitmap.Create;
-  try
-    Jpg := TJPEGImage.Create;
-    try
-      AssignToBitmap(Bmp);
-      if (Format in [tfAlpha8, tfLuminance8]) then begin
-        Jpg.Grayscale   := true;
-        Jpg.PixelFormat := jf8Bit;
-      end;
-      Jpg.Assign(Bmp);
-      Jpg.SaveToStream(aStream);
-    finally
-      FreeAndNil(Jpg);
-    end;
-  finally
-    FreeAndNil(Bmp);
-  end;
-end;
-{$IFEND}
-{$ENDIF}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//BMP/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const
-  BMP_MAGIC          = $4D42;
-
-  BMP_COMP_RGB       = 0;
-  BMP_COMP_RLE8      = 1;
-  BMP_COMP_RLE4      = 2;
-  BMP_COMP_BITFIELDS = 3;
-
-type
-  TBMPHeader = packed record
-    bfType: Word;
-    bfSize: Cardinal;
-    bfReserved1: Word;
-    bfReserved2: Word;
-    bfOffBits: Cardinal;
-  end;
-
-  TBMPInfo = packed record
-    biSize: Cardinal;
-    biWidth: Longint;
-    biHeight: Longint;
-    biPlanes: Word;
-    biBitCount: Word;
-    biCompression: Cardinal;
-    biSizeImage: Cardinal;
-    biXPelsPerMeter: Longint;
-    biYPelsPerMeter: Longint;
-    biClrUsed: Cardinal;
-    biClrImportant: Cardinal;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
-
-  //////////////////////////////////////////////////////////////////////////////////////////////////
-  function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapColorRec): TglBitmapFormat;
-  begin
-    result := tfEmpty;
-    aStream.Read(aInfo{%H-}, SizeOf(aInfo));
-    FillChar(aMask{%H-}, SizeOf(aMask), 0);
-
-    //Read Compression
-    case aInfo.biCompression of
-      BMP_COMP_RLE4,
-      BMP_COMP_RLE8: begin
-        raise EglBitmap.Create('RLE compression is not supported');
-      end;
-      BMP_COMP_BITFIELDS: begin
-        if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin
-          aStream.Read(aMask.r, SizeOf(aMask.r));
-          aStream.Read(aMask.g, SizeOf(aMask.g));
-          aStream.Read(aMask.b, SizeOf(aMask.b));
-          aStream.Read(aMask.a, SizeOf(aMask.a));
-        end else
-          raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats');
-      end;
-    end;
-
-    //get suitable format
-    case aInfo.biBitCount of
-       8: result := tfLuminance8;
-      16: result := tfX1RGB5;
-      24: result := tfRGB8;
-      32: result := tfXRGB8;
-    end;
-  end;
-
-  function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat;
-  var
-    i, c: Integer;
-    ColorTable: TbmpColorTable;
-  begin
-    result := nil;
-    if (aInfo.biBitCount >= 16) then
-      exit;
-    aFormat := tfLuminance8;
-    c := aInfo.biClrUsed;
-    if (c = 0) then
-      c := 1 shl aInfo.biBitCount;
-    SetLength(ColorTable, c);
-    for i := 0 to c-1 do begin
-      aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty));
-      if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then
-        aFormat := tfRGB8;
-    end;
-
-    result := TbmpColorTableFormat.Create;
-    result.PixelSize  := aInfo.biBitCount / 8;
-    result.ColorTable := ColorTable;
-    result.Range      := glBitmapColorRec($FF, $FF, $FF, $00);
-  end;
-
-  //////////////////////////////////////////////////////////////////////////////////////////////////
-  function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapColorRec;
-    const aInfo: TBMPInfo): TbmpBitfieldFormat;
-  var
-    TmpFormat: TglBitmapFormat;
-    FormatDesc: TFormatDescriptor;
-  begin
-    result := nil;
-    if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin
-      for TmpFormat := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
-        FormatDesc := TFormatDescriptor.Get(TmpFormat);
-        if FormatDesc.MaskMatch(aMask.r, aMask.g, aMask.b, aMask.a) then begin
-          aFormat := FormatDesc.Format;
-          exit;
-        end;
-      end;
-
-      if (aMask.a = 0) and TFormatDescriptor.Get(aFormat).HasAlpha then
-        aFormat := TFormatDescriptor.Get(aFormat).WithoutAlpha;
-      if (aMask.a <> 0) and not TFormatDescriptor.Get(aFormat).HasAlpha then
-        aFormat := TFormatDescriptor.Get(aFormat).WithAlpha;
-
-      result := TbmpBitfieldFormat.Create;
-      result.PixelSize := aInfo.biBitCount / 8;
-      result.RedMask   := aMask.r;
-      result.GreenMask := aMask.g;
-      result.BlueMask  := aMask.b;
-      result.AlphaMask := aMask.a;
-    end;
-  end;
-
-var
-  //simple types
-  StartPos: Int64;
-  ImageSize, rbLineSize, wbLineSize, Padding, i: Integer;
-  PaddingBuff: Cardinal;
-  LineBuf, ImageData, TmpData: PByte;
-  SourceMD, DestMD: Pointer;
-  BmpFormat: TglBitmapFormat;
-
-  //records
-  Mask: TglBitmapColorRec;
-  Header: TBMPHeader;
-  Info: TBMPInfo;
-
-  //classes
-  SpecialFormat: TFormatDescriptor;
-  FormatDesc: TFormatDescriptor;
-
-  //////////////////////////////////////////////////////////////////////////////////////////////////
-  procedure SpecialFormatReadLine(aData: PByte; aLineBuf: PByte);
-  var
-    i: Integer;
-    Pixel: TglBitmapPixelData;
-  begin
-    aStream.Read(aLineBuf^, rbLineSize);
-    SpecialFormat.PreparePixel(Pixel);
-    for i := 0 to Info.biWidth-1 do begin
-      SpecialFormat.Unmap(aLineBuf, Pixel, SourceMD);
-      glBitmapConvertPixel(Pixel, SpecialFormat, FormatDesc);
-      FormatDesc.Map(Pixel, aData, DestMD);
-    end;
-  end;
-
-begin
-  result        := false;
-  BmpFormat     := tfEmpty;
-  SpecialFormat := nil;
-  LineBuf       := nil;
-  SourceMD      := nil;
-  DestMD        := nil;
-
-  // Header
-  StartPos := aStream.Position;
-  aStream.Read(Header{%H-}, SizeOf(Header));
-
-  if Header.bfType = BMP_MAGIC then begin
-    try try
-      BmpFormat        := ReadInfo(Info, Mask);
-      SpecialFormat    := ReadColorTable(BmpFormat, Info);
-      if not Assigned(SpecialFormat) then
-        SpecialFormat  := CheckBitfields(BmpFormat, Mask, Info);
-      aStream.Position := StartPos + Header.bfOffBits;
-
-      if (BmpFormat <> tfEmpty) then begin
-        FormatDesc := TFormatDescriptor.Get(BmpFormat);
-        rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize
-        wbLineSize := Trunc(Info.biWidth * FormatDesc.PixelSize);
-        Padding    := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize;
-
-        //get Memory
-        DestMD    := FormatDesc.CreateMappingData;
-        ImageSize := FormatDesc.GetSize(Info.biWidth, abs(Info.biHeight));
-        GetMem(ImageData, ImageSize);
-        if Assigned(SpecialFormat) then begin
-          GetMem(LineBuf, rbLineSize); //tmp Memory for converting Bitfields
-          SourceMD := SpecialFormat.CreateMappingData;
-        end;
-
-        //read Data
-        try try
-          FillChar(ImageData^, ImageSize, $FF);
-          TmpData := ImageData;
-          if (Info.biHeight > 0) then
-            Inc(TmpData, wbLineSize * (Info.biHeight-1));
-          for i := 0 to Abs(Info.biHeight)-1 do begin
-            if Assigned(SpecialFormat) then
-              SpecialFormatReadLine(TmpData, LineBuf)  //if is special format read and convert data
-            else
-              aStream.Read(TmpData^, wbLineSize);   //else only read data
-            if (Info.biHeight > 0) then
-              dec(TmpData, wbLineSize)
-            else
-              inc(TmpData, wbLineSize);
-            aStream.Read(PaddingBuff{%H-}, Padding);
-          end;
-          SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); //be careful, Data could be freed by this method
-          result := true;
-        finally
-          if Assigned(LineBuf) then
-            FreeMem(LineBuf);
-          if Assigned(SourceMD) then
-            SpecialFormat.FreeMappingData(SourceMD);
-          FormatDesc.FreeMappingData(DestMD);
-        end;
-        except
-          if Assigned(ImageData) then
-            FreeMem(ImageData);
-          raise;
-        end;
-      end else
-        raise EglBitmap.Create('LoadBMP - No suitable format found');
-    except
-      aStream.Position := StartPos;
-      raise;
-    end;
-    finally
-      FreeAndNil(SpecialFormat);
-    end;
-  end
-    else aStream.Position := StartPos;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveBMP(const aStream: TStream);
-var
-  Header: TBMPHeader;
-  Info: TBMPInfo;
-  Converter: TFormatDescriptor;
-  FormatDesc: TFormatDescriptor;
-  SourceFD, DestFD: Pointer;
-  pData, srcData, dstData, ConvertBuffer: pByte;
-
-  Pixel: TglBitmapPixelData;
-  ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx: Integer;
-  RedMask, GreenMask, BlueMask, AlphaMask: Cardinal;
-
-  PaddingBuff: Cardinal;
-
-  function GetLineWidth : Integer;
-  begin
-    result := ((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3;
-  end;
-
-begin
-  if not (ftBMP in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  Converter  := nil;
-  FormatDesc := TFormatDescriptor.Get(Format);
-  ImageSize  := FormatDesc.GetSize(Dimension);
-
-  FillChar(Header{%H-}, SizeOf(Header), 0);
-  Header.bfType      := BMP_MAGIC;
-  Header.bfSize      := SizeOf(Header) + SizeOf(Info) + ImageSize;
-  Header.bfReserved1 := 0;
-  Header.bfReserved2 := 0;
-  Header.bfOffBits   := SizeOf(Header) + SizeOf(Info);
-
-  FillChar(Info{%H-}, SizeOf(Info), 0);
-  Info.biSize        := SizeOf(Info);
-  Info.biWidth       := Width;
-  Info.biHeight      := Height;
-  Info.biPlanes      := 1;
-  Info.biCompression := BMP_COMP_RGB;
-  Info.biSizeImage   := ImageSize;
-
-  try
-    case Format of
-      tfLuminance4: begin
-        Info.biBitCount  := 4;
-        Header.bfSize    := Header.bfSize    + 16 * SizeOf(Cardinal);
-        Header.bfOffBits := Header.bfOffBits + 16 * SizeOf(Cardinal); //16 ColorTable entries
-        Converter := TbmpColorTableFormat.Create;
-        with (Converter as TbmpColorTableFormat) do begin
-          PixelSize := 0.5;
-          Format    := Format;
-          Range     := glBitmapColorRec($F, $F, $F, $0);
-          CreateColorTable;
-        end;
-      end;
-
-      tfR3G3B2, tfLuminance8: begin
-        Info.biBitCount  :=  8;
-        Header.bfSize    := Header.bfSize    + 256 * SizeOf(Cardinal);
-        Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries
-        Converter := TbmpColorTableFormat.Create;
-        with (Converter as TbmpColorTableFormat) do begin
-          PixelSize := 1;
-          Format    := Format;
-          if (Format = tfR3G3B2) then begin
-            Range := glBitmapColorRec($7, $7, $3, $0);
-            Shift := glBitmapShiftRec(0, 3, 6, 0);
-          end else
-            Range := glBitmapColorRec($FF, $FF, $FF, $0);
-          CreateColorTable;
-        end;
-      end;
-
-      tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
-      tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4: begin
-        Info.biBitCount    := 16;
-        Info.biCompression := BMP_COMP_BITFIELDS;
-      end;
-
-      tfBGR8, tfRGB8: begin
-        Info.biBitCount := 24;
-        if (Format = tfRGB8) then
-          Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values
-      end;
-
-      tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8,
-      tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8: begin
-        Info.biBitCount    := 32;
-        Info.biCompression := BMP_COMP_BITFIELDS;
-      end;
-    else
-      raise EglBitmapUnsupportedFormat.Create(Format);
-    end;
-    Info.biXPelsPerMeter := 2835;
-    Info.biYPelsPerMeter := 2835;
-
-    // prepare bitmasks
-    if Info.biCompression = BMP_COMP_BITFIELDS then begin
-      Header.bfSize    := Header.bfSize    + 4 * SizeOf(Cardinal);
-      Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal);
-
-      RedMask    := FormatDesc.RedMask;
-      GreenMask  := FormatDesc.GreenMask;
-      BlueMask   := FormatDesc.BlueMask;
-      AlphaMask  := FormatDesc.AlphaMask;
-    end;
-
-    // headers
-    aStream.Write(Header, SizeOf(Header));
-    aStream.Write(Info, SizeOf(Info));
-
-    // colortable
-    if Assigned(Converter) and (Converter is TbmpColorTableFormat) then
-      with (Converter as TbmpColorTableFormat) do
-        aStream.Write(ColorTable[0].b,
-          SizeOf(TbmpColorTableEnty) * Length(ColorTable));
-
-    // bitmasks
-    if Info.biCompression = BMP_COMP_BITFIELDS then begin
-      aStream.Write(RedMask,   SizeOf(Cardinal));
-      aStream.Write(GreenMask, SizeOf(Cardinal));
-      aStream.Write(BlueMask,  SizeOf(Cardinal));
-      aStream.Write(AlphaMask, SizeOf(Cardinal));
-    end;
-
-    // image data
-    rbLineSize  := Round(Info.biWidth * FormatDesc.PixelSize);
-    wbLineSize  := Round(Info.biWidth * Info.biBitCount / 8);
-    Padding     := GetLineWidth - wbLineSize;
-    PaddingBuff := 0;
-
-    pData := Data;
-    inc(pData, (Height-1) * rbLineSize);
-
-    // prepare row buffer. But only for RGB because RGBA supports color masks
-    // so it's possible to change color within the image.
-    if Assigned(Converter) then begin
-      FormatDesc.PreparePixel(Pixel);
-      GetMem(ConvertBuffer, wbLineSize);
-      SourceFD := FormatDesc.CreateMappingData;
-      DestFD   := Converter.CreateMappingData;
-    end else
-      ConvertBuffer := nil;
-
-    try
-      for LineIdx := 0 to Height - 1 do begin
-        // preparing row
-        if Assigned(Converter) then begin
-          srcData := pData;
-          dstData := ConvertBuffer;
-          for PixelIdx := 0 to Info.biWidth-1 do begin
-            FormatDesc.Unmap(srcData, Pixel, SourceFD);
-            glBitmapConvertPixel(Pixel, FormatDesc, Converter);
-            Converter.Map(Pixel, dstData, DestFD);
-          end;
-          aStream.Write(ConvertBuffer^, wbLineSize);
-        end else begin
-          aStream.Write(pData^, rbLineSize);
-        end;
-        dec(pData, rbLineSize);
-        if (Padding > 0) then
-          aStream.Write(PaddingBuff, Padding);
-      end;
-    finally
-      // destroy row buffer
-      if Assigned(ConvertBuffer) then begin
-        FormatDesc.FreeMappingData(SourceFD);
-        Converter.FreeMappingData(DestFD);
-        FreeMem(ConvertBuffer);
-      end;
-    end;
-  finally
-    if Assigned(Converter) then
-      Converter.Free;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TGA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-type
-  TTGAHeader = packed record
-    ImageID: Byte;
-    ColorMapType: Byte;
-    ImageType: Byte;
-    //ColorMapSpec: Array[0..4] of Byte;
-    ColorMapStart: Word;
-    ColorMapLength: Word;
-    ColorMapEntrySize: Byte;
-    OrigX: Word;
-    OrigY: Word;
-    Width: Word;
-    Height: Word;
-    Bpp: Byte;
-    ImageDesc: Byte;
-  end;
-
-const
-  TGA_UNCOMPRESSED_RGB  =  2;
-  TGA_UNCOMPRESSED_GRAY =  3;
-  TGA_COMPRESSED_RGB    = 10;
-  TGA_COMPRESSED_GRAY   = 11;
-
-  TGA_NONE_COLOR_TABLE  = 0;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadTGA(const aStream: TStream): Boolean;
-var
-  Header: TTGAHeader;
-  ImageData: System.PByte;
-  StartPosition: Int64;
-  PixelSize, LineSize: Integer;
-  tgaFormat: TglBitmapFormat;
-  FormatDesc: TFormatDescriptor;
-  Counter: packed record
-    X, Y: packed record
-      low, high, dir: Integer;
-    end;
-  end;
-
-const
-  CACHE_SIZE = $4000;
-
-  ////////////////////////////////////////////////////////////////////////////////////////
-  procedure ReadUncompressed;
-  var
-    i, j: Integer;
-    buf, tmp1, tmp2: System.PByte;
-  begin
-    buf := nil;
-    if (Counter.X.dir < 0) then
-      GetMem(buf, LineSize);
-    try
-      while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin
-        tmp1 := ImageData;
-        inc(tmp1, (Counter.Y.low * LineSize));          //pointer to LineStart
-        if (Counter.X.dir < 0) then begin               //flip X
-          aStream.Read(buf^, LineSize);
-          tmp2 := buf;
-          inc(tmp2, LineSize - PixelSize);              //pointer to last pixel in line
-          for i := 0 to Header.Width-1 do begin         //for all pixels in line
-            for j := 0 to PixelSize-1 do begin          //for all bytes in pixel
-              tmp1^ := tmp2^;
-              inc(tmp1);
-              inc(tmp2);
-            end;
-            dec(tmp2, 2*PixelSize);                     //move 2 backwards, because j-loop moved 1 forward
-          end;
-        end else
-          aStream.Read(tmp1^, LineSize);
-        inc(Counter.Y.low, Counter.Y.dir);              //move to next line index
-      end;
-    finally
-      if Assigned(buf) then
-        FreeMem(buf);
-    end;
-  end;
-
-  ////////////////////////////////////////////////////////////////////////////////////////
-  procedure ReadCompressed;
-
-    /////////////////////////////////////////////////////////////////
-    var
-      TmpData: System.PByte;
-      LinePixelsRead: Integer;
-    procedure CheckLine;
-    begin
-      if (LinePixelsRead >= Header.Width) then begin
-        LinePixelsRead := 0;
-        inc(Counter.Y.low, Counter.Y.dir);                //next line index
-        TmpData := ImageData;
-        inc(TmpData, Counter.Y.low * LineSize);           //set line
-        if (Counter.X.dir < 0) then                       //if x flipped then
-          inc(TmpData, LineSize - PixelSize);             //set last pixel
-      end;
-    end;
-
-    /////////////////////////////////////////////////////////////////
-    var
-      Cache: PByte;
-      CacheSize, CachePos: Integer;
-    procedure CachedRead(out Buffer; Count: Integer);
-    var
-      BytesRead: Integer;
-    begin
-      if (CachePos + Count > CacheSize) then begin
-        //if buffer overflow save non read bytes
-        BytesRead := 0;
-        if (CacheSize - CachePos > 0) then begin
-          BytesRead := CacheSize - CachePos;
-          Move(PByteArray(Cache)^[CachePos], Buffer{%H-}, BytesRead);
-          inc(CachePos, BytesRead);
-        end;
-
-        //load cache from file
-        CacheSize := Min(CACHE_SIZE, aStream.Size - aStream.Position);
-        aStream.Read(Cache^, CacheSize);
-        CachePos := 0;
-
-        //read rest of requested bytes
-        if (Count - BytesRead > 0) then begin
-          Move(PByteArray(Cache)^[CachePos], TByteArray(Buffer)[BytesRead], Count - BytesRead);
-          inc(CachePos, Count - BytesRead);
-        end;
-      end else begin
-        //if no buffer overflow just read the data
-        Move(PByteArray(Cache)^[CachePos], Buffer, Count);
-        inc(CachePos, Count);
-      end;
-    end;
-
-    procedure PixelToBuffer(const aData: PByte; var aBuffer: PByte);
-    begin
-      case PixelSize of
-        1: begin
-          aBuffer^ := aData^;
-          inc(aBuffer, Counter.X.dir);
-        end;
-        2: begin
-          PWord(aBuffer)^ := PWord(aData)^;
-          inc(aBuffer, 2 * Counter.X.dir);
-        end;
-        3: begin
-          PByteArray(aBuffer)^[0] := PByteArray(aData)^[0];
-          PByteArray(aBuffer)^[1] := PByteArray(aData)^[1];
-          PByteArray(aBuffer)^[2] := PByteArray(aData)^[2];
-          inc(aBuffer, 3 * Counter.X.dir);
-        end;
-        4: begin
-          PCardinal(aBuffer)^ := PCardinal(aData)^;
-          inc(aBuffer, 4 * Counter.X.dir);
-        end;
-      end;
-    end;
-
-  var
-    TotalPixelsToRead, TotalPixelsRead: Integer;
-    Temp: Byte;
-    buf: array [0..3] of Byte; //1 pixel is max 32bit long
-    PixelRepeat: Boolean;
-    PixelsToRead, PixelCount: Integer;
-  begin
-    CacheSize := 0;
-    CachePos  := 0;
-
-    TotalPixelsToRead := Header.Width * Header.Height;
-    TotalPixelsRead   := 0;
-    LinePixelsRead    := 0;
-
-    GetMem(Cache, CACHE_SIZE);
-    try
-      TmpData := ImageData;
-      inc(TmpData, Counter.Y.low * LineSize);           //set line
-      if (Counter.X.dir < 0) then                       //if x flipped then
-        inc(TmpData, LineSize - PixelSize);             //set last pixel
-
-      repeat
-        //read CommandByte
-        CachedRead(Temp, 1);
-        PixelRepeat  := (Temp and $80) > 0;
-        PixelsToRead := (Temp and $7F) + 1;
-        inc(TotalPixelsRead, PixelsToRead);
-
-        if PixelRepeat then
-          CachedRead(buf[0], PixelSize);
-        while (PixelsToRead > 0) do begin
-          CheckLine;
-          PixelCount := Min(Header.Width - LinePixelsRead, PixelsToRead); //max read to EOL or EOF
-          while (PixelCount > 0) do begin
-            if not PixelRepeat then
-              CachedRead(buf[0], PixelSize);
-            PixelToBuffer(@buf[0], TmpData);
-            inc(LinePixelsRead);
-            dec(PixelsToRead);
-            dec(PixelCount);
-          end;
-        end;
-      until (TotalPixelsRead >= TotalPixelsToRead);
-    finally
-      FreeMem(Cache);
-    end;
-  end;
-
-  function IsGrayFormat: Boolean;
-  begin
-    result := Header.ImageType in [TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_GRAY];
-  end;
-
-begin
-  result := false;
-
-  // reading header to test file and set cursor back to begin
-  StartPosition := aStream.Position;
-  aStream.Read(Header{%H-}, SizeOf(Header));
-
-  // no colormapped files
-  if (Header.ColorMapType = TGA_NONE_COLOR_TABLE) and (Header.ImageType in [
-    TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY]) then
-  begin
-    try
-      if Header.ImageID <> 0 then       // skip image ID
-        aStream.Position := aStream.Position + Header.ImageID;
-
-      tgaFormat := tfEmpty;
-      case Header.Bpp of
-         8: if IsGrayFormat then case (Header.ImageDesc and $F) of
-               0: tgaFormat := tfLuminance8;
-               8: tgaFormat := tfAlpha8;
-            end;
-
-        16: if IsGrayFormat then case (Header.ImageDesc and $F) of
-               0: tgaFormat := tfLuminance16;
-               8: tgaFormat := tfLuminance8Alpha8;
-            end else case (Header.ImageDesc and $F) of
-               0: tgaFormat := tfX1RGB5;
-               1: tgaFormat := tfA1RGB5;
-               4: tgaFormat := tfARGB4;
-            end;
-
-        24: if not IsGrayFormat then case (Header.ImageDesc and $F) of
-               0: tgaFormat := tfRGB8;
-            end;
-
-        32: if not IsGrayFormat then case (Header.ImageDesc and $F) of
-               2: tgaFormat := tfA2RGB10;
-               8: tgaFormat := tfARGB8;
-            end;
-      end;
-
-      if (tgaFormat = tfEmpty) then
-        raise EglBitmap.Create('LoadTga - unsupported format');
-
-      FormatDesc := TFormatDescriptor.Get(tgaFormat);
-      PixelSize  := FormatDesc.GetSize(1, 1);
-      LineSize   := FormatDesc.GetSize(Header.Width, 1);
-
-      GetMem(ImageData, LineSize * Header.Height);
-      try
-        //column direction
-        if ((Header.ImageDesc and (1 shl 4)) > 0) then begin
-          Counter.X.low  := Header.Height-1;;
-          Counter.X.high := 0;
-          Counter.X.dir  := -1;
-        end else begin
-          Counter.X.low  := 0;
-          Counter.X.high := Header.Height-1;
-          Counter.X.dir  := 1;
-        end;
-
-        // Row direction
-        if ((Header.ImageDesc and (1 shl 5)) > 0) then begin
-          Counter.Y.low  := 0;
-          Counter.Y.high := Header.Height-1;
-          Counter.Y.dir  := 1;
-        end else begin
-          Counter.Y.low  := Header.Height-1;;
-          Counter.Y.high := 0;
-          Counter.Y.dir  := -1;
-        end;
-
-        // Read Image
-        case Header.ImageType of
-          TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY:
-            ReadUncompressed;
-          TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY:
-            ReadCompressed;
-        end;
-
-        SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); //be careful, Data could be freed by this method
-        result := true;
-      except
-        if Assigned(ImageData) then
-          FreeMem(ImageData);
-        raise;
-      end;
-    finally
-      aStream.Position := StartPosition;
-    end;
-  end
-    else aStream.Position := StartPosition;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveTGA(const aStream: TStream);
-var
-  Header: TTGAHeader;
-  LineSize, Size, x, y: Integer;
-  Pixel: TglBitmapPixelData;
-  LineBuf, SourceData, DestData: PByte;
-  SourceMD, DestMD: Pointer;
-  FormatDesc: TFormatDescriptor;
-  Converter: TFormatDescriptor;
-begin
-  if not (ftTGA in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  //prepare header
-  FillChar(Header{%H-}, SizeOf(Header), 0);
-
-  //set ImageType
-  if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8,
-                 tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8]) then
-    Header.ImageType := TGA_UNCOMPRESSED_GRAY
-  else
-    Header.ImageType := TGA_UNCOMPRESSED_RGB;
-
-  //set BitsPerPixel
-  if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8]) then
-    Header.Bpp := 8
-  else if (Format in [tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8,
-                      tfRGB5X1, tfBGR5X1, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then
-    Header.Bpp := 16
-  else if (Format in [tfBGR8, tfRGB8]) then
-    Header.Bpp := 24
-  else
-    Header.Bpp := 32;
-
-  //set AlphaBitCount
-  case Format of
-    tfRGB5A1, tfBGR5A1:
-      Header.ImageDesc := 1 and $F;
-    tfRGB10A2, tfBGR10A2:
-      Header.ImageDesc := 2 and $F;
-    tfRGBA4, tfBGRA4:
-      Header.ImageDesc := 4 and $F;
-    tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8:
-      Header.ImageDesc := 8 and $F;
-  end;
-
-  Header.Width     := Width;
-  Header.Height    := Height;
-  Header.ImageDesc := Header.ImageDesc or $20; //flip y
-  aStream.Write(Header, SizeOf(Header));
-
-  // convert RGB(A) to BGR(A)
-  Converter  := nil;
-  FormatDesc := TFormatDescriptor.Get(Format);
-  Size       := FormatDesc.GetSize(Dimension);
-  if Format in [tfRGB5X1, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin
-    if (FormatDesc.RGBInverted = tfEmpty) then
-      raise EglBitmap.Create('inverted RGB format is empty');
-    Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted);
-    if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or
-       (Converter.PixelSize <> FormatDesc.PixelSize) then
-      raise EglBitmap.Create('invalid inverted RGB format');
-  end;
-
-  if Assigned(Converter) then begin
-    LineSize := FormatDesc.GetSize(Width, 1);
-    GetMem(LineBuf, LineSize);
-    SourceMD := FormatDesc.CreateMappingData;
-    DestMD   := Converter.CreateMappingData;
-    try
-      SourceData := Data;
-      for y := 0 to Height-1 do begin
-        DestData := LineBuf;
-        for x := 0 to Width-1 do begin
-          FormatDesc.Unmap(SourceData, Pixel, SourceMD);
-          Converter.Map(Pixel, DestData, DestMD);
-        end;
-        aStream.Write(LineBuf^, LineSize);
-      end;
-    finally
-      FreeMem(LineBuf);
-      FormatDesc.FreeMappingData(SourceMD);
-      FormatDesc.FreeMappingData(DestMD);
-    end;
-  end else
-    aStream.Write(Data^, Size);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//DDS/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-const
-  DDS_MAGIC: Cardinal         = $20534444;
-
-  // DDS_header.dwFlags
-  DDSD_CAPS                   = $00000001;
-  DDSD_HEIGHT                 = $00000002;
-  DDSD_WIDTH                  = $00000004;
-  DDSD_PIXELFORMAT            = $00001000;
-
-  // DDS_header.sPixelFormat.dwFlags
-  DDPF_ALPHAPIXELS            = $00000001;
-  DDPF_ALPHA                  = $00000002;
-  DDPF_FOURCC                 = $00000004;
-  DDPF_RGB                    = $00000040;
-  DDPF_LUMINANCE              = $00020000;
-
-  // DDS_header.sCaps.dwCaps1
-  DDSCAPS_TEXTURE             = $00001000;
-
-  // DDS_header.sCaps.dwCaps2
-  DDSCAPS2_CUBEMAP            = $00000200;
-
-  D3DFMT_DXT1                 = $31545844;
-  D3DFMT_DXT3                 = $33545844;
-  D3DFMT_DXT5                 = $35545844;
-
-type
-  TDDSPixelFormat = packed record
-    dwSize: Cardinal;
-    dwFlags: Cardinal;
-    dwFourCC: Cardinal;
-    dwRGBBitCount: Cardinal;
-    dwRBitMask: Cardinal;
-    dwGBitMask: Cardinal;
-    dwBBitMask: Cardinal;
-    dwABitMask: Cardinal;
-  end;
-
-  TDDSCaps = packed record
-    dwCaps1: Cardinal;
-    dwCaps2: Cardinal;
-    dwDDSX: Cardinal;
-    dwReserved: Cardinal;
-  end;
-
-  TDDSHeader = packed record
-    dwSize: Cardinal;
-    dwFlags: Cardinal;
-    dwHeight: Cardinal;
-    dwWidth: Cardinal;
-    dwPitchOrLinearSize: Cardinal;
-    dwDepth: Cardinal;
-    dwMipMapCount: Cardinal;
-    dwReserved: array[0..10] of Cardinal;
-    PixelFormat: TDDSPixelFormat;
-    Caps: TDDSCaps;
-    dwReserved2: Cardinal;
-  end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.LoadDDS(const aStream: TStream): Boolean;
-var
-  Header: TDDSHeader;
-  Converter: TbmpBitfieldFormat;
-
-  function GetDDSFormat: TglBitmapFormat;
-  var
-    fd: TFormatDescriptor;
-    i: Integer;
-    Range: TglBitmapColorRec;
-    match: Boolean;
-  begin
-    result := tfEmpty;
-    with Header.PixelFormat do begin
-      // Compresses
-      if ((dwFlags and DDPF_FOURCC) > 0) then begin
-        case Header.PixelFormat.dwFourCC of
-          D3DFMT_DXT1: result := tfS3tcDtx1RGBA;
-          D3DFMT_DXT3: result := tfS3tcDtx3RGBA;
-          D3DFMT_DXT5: result := tfS3tcDtx5RGBA;
-        end;
-      end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0) then begin
-        // prepare masks
-        if ((dwFlags and DDPF_LUMINANCE) = 0) then begin
-          Range.r := dwRBitMask;
-          Range.g := dwGBitMask;
-          Range.b := dwBBitMask;
-        end else begin
-          Range.r := dwRBitMask;
-          Range.g := dwRBitMask;
-          Range.b := dwRBitMask;
-        end;
-        Range.a := dwABitMask;
-
-        //find matching format
-        for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
-          fd := TFormatDescriptor.Get(result);
-          if fd.MaskMatch(Range.r, Range.g, Range.b, Range.a) and
-             (8 * fd.PixelSize = dwRGBBitCount) then
-            exit;
-        end;
-
-        //find format with same Range
-        for i := 0 to 3 do begin
-          while ((Range.arr[i] and 1) = 0) and (Range.arr[i] > 0) do
-            Range.arr[i] := Range.arr[i] shr 1;
-        end;
-        for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
-          fd := TFormatDescriptor.Get(result);
-          match := true;
-          for i := 0 to 3 do
-            if (fd.Range.arr[i] <> Range.arr[i]) then begin
-              match := false;
-              break;
-            end;
-          if match then
-            break;
-        end;
-
-        //no format with same range found -> use default
-        if (result = tfEmpty) then begin
-          if (dwABitMask > 0) then
-            result := tfRGBA8
-          else
-            result := tfRGB8;
-        end;
-
-        Converter := TbmpBitfieldFormat.Create;
-        Converter.RedMask   := dwRBitMask;
-        Converter.GreenMask := dwGBitMask;
-        Converter.BlueMask  := dwBBitMask;
-        Converter.AlphaMask := dwABitMask;
-        Converter.PixelSize := dwRGBBitCount / 8;
-      end;
-    end;
-  end;
-
-var
-  StreamPos: Int64;
-  x, y, LineSize, RowSize, Magic: Cardinal;
-  NewImage, TmpData, RowData, SrcData: System.PByte;
-  SourceMD, DestMD: Pointer;
-  Pixel: TglBitmapPixelData;
-  ddsFormat: TglBitmapFormat;
-  FormatDesc: TFormatDescriptor;
-
-begin
-  result    := false;
-  Converter := nil;
-  StreamPos := aStream.Position;
-
-  // Magic
-  aStream.Read(Magic{%H-}, sizeof(Magic));
-  if (Magic <> DDS_MAGIC) then begin
-    aStream.Position := StreamPos;
-    exit;
-  end;
-
-  //Header
-  aStream.Read(Header{%H-}, sizeof(Header));
-  if (Header.dwSize <> SizeOf(Header)) or
-     ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <>
-        (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then
-  begin
-    aStream.Position := StreamPos;
-    exit;
-  end;
-
-  if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then
-    raise EglBitmap.Create('LoadDDS - CubeMaps are not supported');
-
-  ddsFormat := GetDDSFormat;
-  try
-    if (ddsFormat = tfEmpty) then
-      raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
-
-    FormatDesc := TFormatDescriptor.Get(ddsFormat);
-    LineSize   := Trunc(Header.dwWidth * FormatDesc.PixelSize);
-    GetMem(NewImage, Header.dwHeight * LineSize);
-    try
-      TmpData := NewImage;
-
-      //Converter needed
-      if Assigned(Converter) then begin
-        RowSize := Round(Header.dwWidth * Header.PixelFormat.dwRGBBitCount / 8);
-        GetMem(RowData, RowSize);
-        SourceMD := Converter.CreateMappingData;
-        DestMD   := FormatDesc.CreateMappingData;
-        try
-          for y := 0 to Header.dwHeight-1 do begin
-            TmpData := NewImage;
-            inc(TmpData, y * LineSize);
-            SrcData := RowData;
-            aStream.Read(SrcData^, RowSize);
-            for x := 0 to Header.dwWidth-1 do begin
-              Converter.Unmap(SrcData, Pixel, SourceMD);
-              glBitmapConvertPixel(Pixel, Converter, FormatDesc);
-              FormatDesc.Map(Pixel, TmpData, DestMD);
-            end;
-          end;
-        finally
-          Converter.FreeMappingData(SourceMD);
-          FormatDesc.FreeMappingData(DestMD);
-          FreeMem(RowData);
-        end;
-      end else
-
-      // Compressed
-      if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin
-        RowSize := Header.dwPitchOrLinearSize div Header.dwWidth;
-        for Y := 0 to Header.dwHeight-1 do begin
-          aStream.Read(TmpData^, RowSize);
-          Inc(TmpData, LineSize);
-        end;
-      end else
-
-      // Uncompressed
-      if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin
-        RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3;
-        for Y := 0 to Header.dwHeight-1 do begin
-          aStream.Read(TmpData^, RowSize);
-          Inc(TmpData, LineSize);
-        end;
-      end else
-        raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
-
-      SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method
-      result := true;
-    except
-      if Assigned(NewImage) then
-        FreeMem(NewImage);
-      raise;
-    end;
-  finally
-    FreeAndNil(Converter);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveDDS(const aStream: TStream);
-var
-  Header: TDDSHeader;
-  FormatDesc: TFormatDescriptor;
-begin
-  if not (ftDDS in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  FormatDesc := TFormatDescriptor.Get(Format);
-
-  // Generell
-  FillChar(Header{%H-}, SizeOf(Header), 0);
-  Header.dwSize  := SizeOf(Header);
-  Header.dwFlags := DDSD_WIDTH or DDSD_HEIGHT or DDSD_CAPS or DDSD_PIXELFORMAT;
-
-  Header.dwWidth  := Max(1, Width);
-  Header.dwHeight := Max(1, Height);
-
-  // Caps
-  Header.Caps.dwCaps1 := DDSCAPS_TEXTURE;
-
-  // Pixelformat
-  Header.PixelFormat.dwSize := sizeof(Header);
-  if (FormatDesc.IsCompressed) then begin
-    Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_FOURCC;
-    case Format of
-      tfS3tcDtx1RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT1;
-      tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3;
-      tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5;
-    end;
-  end else if (Format in [tfAlpha8, tfAlpha16]) then begin
-    Header.PixelFormat.dwFlags       := Header.PixelFormat.dwFlags or DDPF_ALPHA;
-    Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8);
-    Header.PixelFormat.dwABitMask    := FormatDesc.AlphaMask;
-  end else if (FormatDesc.RedMask = FormatDesc.GreenMask) and (FormatDesc.GreenMask = FormatDesc.BlueMask) then begin
-    Header.PixelFormat.dwFlags       := Header.PixelFormat.dwFlags or DDPF_LUMINANCE;
-    Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8);
-    Header.PixelFormat.dwRBitMask    := FormatDesc.RedMask;
-    Header.PixelFormat.dwABitMask    := FormatDesc.AlphaMask;
-  end else begin
-    Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB;
-    Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8);
-    Header.PixelFormat.dwRBitMask    := FormatDesc.RedMask;
-    Header.PixelFormat.dwGBitMask    := FormatDesc.GreenMask;
-    Header.PixelFormat.dwBBitMask    := FormatDesc.BlueMask;
-    Header.PixelFormat.dwABitMask    := FormatDesc.AlphaMask;
-  end;
-
-  if (FormatDesc.HasAlpha) then
-    Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS;
-
-  aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC));
-  aStream.Write(Header, SizeOf(Header));
-  aStream.Write(Data^, FormatDesc.GetSize(Dimension));
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap1D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
-  const aWidth: Integer; const aHeight: Integer);
-var
-  pTemp: pByte;
-  Size: Integer;
-begin
-  if (aHeight > 1) then begin
-    Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1);
-    GetMem(pTemp, Size);
-    try
-      Move(aData^, pTemp^, Size);
-      FreeMem(aData);
-      aData := nil;
-    except
-      FreeMem(pTemp);
-      raise;
-    end;
-  end else
-    pTemp := aData;
-  inherited SetDataPointer(pTemp, aFormat, aWidth);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap1D.FlipHorz: Boolean;
-var
-  Col: Integer;
-  pTempDest, pDest, pSource: PByte;
-begin
-  result := inherited FlipHorz;
-  if Assigned(Data) and not TFormatDescriptor.Get(Format).IsCompressed then begin
-    pSource := Data;
-    GetMem(pDest, fRowSize);
-    try
-      pTempDest := pDest;
-      Inc(pTempDest, fRowSize);
-      for Col := 0 to Width-1 do begin
-        dec(pTempDest, fPixelSize); //dec before, because ptr is behind last byte of data
-        Move(pSource^, pTempDest^, fPixelSize);
-        Inc(pSource, fPixelSize);
-      end;
-      SetDataPointer(pDest, Format, Width); //be careful, Data could be freed by this method
-      result := true;
-    except
-      if Assigned(pDest) then
-        FreeMem(pDest);
-      raise;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap1D.UploadData(const aBuildWithGlu: Boolean);
-var
-  FormatDesc: TFormatDescriptor;
-begin
-  // Upload data
-  FormatDesc := TFormatDescriptor.Get(Format);
-  if FormatDesc.IsCompressed then begin
-    if not Assigned(glCompressedTexImage1D) then
-      raise EglBitmap.Create('compressed formats not supported by video adapter');
-    glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data)
-  end else if aBuildWithGlu then
-    gluBuild1DMipmaps(Target, FormatDesc.glInternalFormat, Width, FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
-  else
-    glTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
-
-  // Free Data
-  if (FreeDataAfterGenTexture) then
-    FreeData;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean);
-var
-  BuildWithGlu, TexRec: Boolean;
-  TexSize: Integer;
-begin
-  if Assigned(Data) then begin
-    // Check Texture Size
-    if (aTestTextureSize) then begin
-      glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
-
-      if (Width > TexSize) then
-        raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
-
-      TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
-                (Target = GL_TEXTURE_RECTANGLE);
-      if not (IsPowerOfTwo(Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
-        raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
-    end;
-
-    CreateId;
-    SetupParameters(BuildWithGlu);
-    UploadData(BuildWithGlu);
-    glAreTexturesResident(1, @fID, @fIsResident);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap1D.AfterConstruction;
-begin
-  inherited;
-  Target := GL_TEXTURE_1D;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap2D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer;
-begin
-  if (aIndex >= Low(fLines)) and (aIndex <= High(fLines)) then
-    result := fLines[aIndex]
-  else
-    result := nil;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
-  const aWidth: Integer; const aHeight: Integer);
-var
-  Idx, LineWidth: Integer;
-begin
-  inherited SetDataPointer(aData, aFormat, aWidth, aHeight);
-
-  if not TFormatDescriptor.Get(aFormat).IsCompressed then begin
-    // Assigning Data
-    if Assigned(Data) then begin
-      SetLength(fLines, GetHeight);
-      LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).PixelSize);
-
-      for Idx := 0 to GetHeight-1 do begin
-        fLines[Idx] := Data;
-        Inc(fLines[Idx], Idx * LineWidth);
-      end;
-    end
-      else SetLength(fLines, 0);
-  end else begin
-    SetLength(fLines, 0);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean);
-var
-  FormatDesc: TFormatDescriptor;
-begin
-  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-  FormatDesc := TFormatDescriptor.Get(Format);
-  if FormatDesc.IsCompressed then begin
-    if not Assigned(glCompressedTexImage2D) then
-      raise EglBitmap.Create('compressed formats not supported by video adapter');
-    glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data)
-  end else if aBuildWithGlu then begin
-    gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height,
-      FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
-  end else begin
-    glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0,
-      FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
-  end;
-
-  // Freigeben
-  if (FreeDataAfterGenTexture) then
-    FreeData;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.AfterConstruction;
-begin
-  inherited;
-  Target := GL_TEXTURE_2D;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);
-var
-  Temp: pByte;
-  Size, w, h: Integer;
-  FormatDesc: TFormatDescriptor;
-begin
-  FormatDesc := TFormatDescriptor.Get(aFormat);
-  if FormatDesc.IsCompressed then
-    raise EglBitmapUnsupportedFormat.Create(aFormat);
-
-  w    := aRight  - aLeft;
-  h    := aBottom - aTop;
-  Size := FormatDesc.GetSize(w, h);
-  GetMem(Temp, Size);
-  try
-    glPixelStorei(GL_PACK_ALIGNMENT, 1);
-    glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
-    SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method
-    FlipVert;
-  except
-    if Assigned(Temp) then
-      FreeMem(Temp);
-    raise;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.GetDataFromTexture;
-var
-  Temp: PByte;
-  TempWidth, TempHeight: Integer;
-  TempIntFormat: GLint;
-  IntFormat: TglBitmapFormat;
-  FormatDesc: TFormatDescriptor;
-begin
-  Bind;
-
-  // Request Data
-  glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_WIDTH,           @TempWidth);
-  glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_HEIGHT,          @TempHeight);
-  glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_INTERNAL_FORMAT, @TempIntFormat);
-
-  IntFormat  := tfEmpty;
-  FormatDesc := (TglBitmapFormatDescriptor.GetByFormat(TempIntFormat) as TFormatDescriptor);
-  IntFormat  := FormatDesc.Format;
-
-  // Getting data from OpenGL
-  FormatDesc := TFormatDescriptor.Get(IntFormat);
-  GetMem(Temp, FormatDesc.GetSize(TempWidth, TempHeight));
-  try
-    if FormatDesc.IsCompressed then begin
-      if not Assigned(glGetCompressedTexImage) then
-        raise EglBitmap.Create('compressed formats not supported by video adapter');
-      glGetCompressedTexImage(Target, 0, Temp)
-    end else
-      glGetTexImage(Target, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
-    SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
-  except
-    if Assigned(Temp) then
-      FreeMem(Temp);
-    raise;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.GenTexture(const aTestTextureSize: Boolean);
-var
-  BuildWithGlu, PotTex, TexRec: Boolean;
-  TexSize: Integer;
-begin
-  if Assigned(Data) then begin
-    // Check Texture Size
-    if (aTestTextureSize) then begin
-      glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
-
-      if ((Height > TexSize) or (Width > TexSize)) then
-        raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
-
-      PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width);
-      TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);
-      if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
-        raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
-    end;
-
-    CreateId;
-    SetupParameters(BuildWithGlu);
-    UploadData(Target, BuildWithGlu);
-    glAreTexturesResident(1, @fID, @fIsResident);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap2D.FlipHorz: Boolean;
-var
-  Col, Row: Integer;
-  TempDestData, DestData, SourceData: PByte;
-  ImgSize: Integer;
-begin
-  result := inherited FlipHorz;
-  if Assigned(Data) then begin
-    SourceData := Data;
-    ImgSize := Height * fRowSize;
-    GetMem(DestData, ImgSize);
-    try
-      TempDestData := DestData;
-      Dec(TempDestData, fRowSize + fPixelSize);
-      for Row := 0 to Height -1 do begin
-        Inc(TempDestData, fRowSize * 2);
-        for Col := 0 to Width -1 do begin
-          Move(SourceData^, TempDestData^, fPixelSize);
-          Inc(SourceData, fPixelSize);
-          Dec(TempDestData, fPixelSize);
-        end;
-      end;
-      SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method
-      result := true;
-    except
-      if Assigned(DestData) then
-        FreeMem(DestData);
-      raise;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap2D.FlipVert: Boolean;
-var
-  Row: Integer;
-  TempDestData, DestData, SourceData: PByte;
-begin
-  result := inherited FlipVert;
-  if Assigned(Data) then begin
-    SourceData := Data;
-    GetMem(DestData, Height * fRowSize);
-    try
-      TempDestData := DestData;
-      Inc(TempDestData, Width * (Height -1) * fPixelSize);
-      for Row := 0 to Height -1 do begin
-        Move(SourceData^, TempDestData^, fRowSize);
-        Dec(TempDestData, fRowSize);
-        Inc(SourceData, fRowSize);
-      end;
-      SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method
-      result := true;
-    except
-      if Assigned(DestData) then
-        FreeMem(DestData);
-      raise;
-    end;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmap2D - ToNormalMap///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-type
-  TMatrixItem = record
-    X, Y: Integer;
-    W: Single;
-  end;
-
-  PglBitmapToNormalMapRec = ^TglBitmapToNormalMapRec;
-  TglBitmapToNormalMapRec = Record
-    Scale: Single;
-    Heights: array of Single;
-    MatrixU : array of TMatrixItem;
-    MatrixV : array of TMatrixItem;
-  end;
-
-const
-  ONE_OVER_255 = 1 / 255;
-
-  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapToNormalMapPrepareFunc(var FuncRec: TglBitmapFunctionRec);
-var
-  Val: Single;
-begin
-  with FuncRec do begin
-    Val :=
-      Source.Data.r * LUMINANCE_WEIGHT_R +
-      Source.Data.g * LUMINANCE_WEIGHT_G +
-      Source.Data.b * LUMINANCE_WEIGHT_B;
-    PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Val * ONE_OVER_255;
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapToNormalMapPrepareAlphaFunc(var FuncRec: TglBitmapFunctionRec);
-begin
-  with FuncRec do
-    PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Source.Data.a * ONE_OVER_255;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapToNormalMapFunc (var FuncRec: TglBitmapFunctionRec);
-type
-  TVec = Array[0..2] of Single;
-var
-  Idx: Integer;
-  du, dv: Double;
-  Len: Single;
-  Vec: TVec;
-
-  function GetHeight(X, Y: Integer): Single;
-  begin
-    with FuncRec do begin
-      X := Max(0, Min(Size.X -1, X));
-      Y := Max(0, Min(Size.Y -1, Y));
-      result := PglBitmapToNormalMapRec(Args)^.Heights[Y * Size.X + X];
-    end;
-  end;
-
-begin
-  with FuncRec do begin
-    with PglBitmapToNormalMapRec(Args)^ do begin
-      du := 0;
-      for Idx := Low(MatrixU) to High(MatrixU) do
-        du := du + GetHeight(Position.X + MatrixU[Idx].X, Position.Y + MatrixU[Idx].Y) * MatrixU[Idx].W;
-
-      dv := 0;
-      for Idx := Low(MatrixU) to High(MatrixU) do
-        dv := dv + GetHeight(Position.X + MatrixV[Idx].X, Position.Y + MatrixV[Idx].Y) * MatrixV[Idx].W;
-
-      Vec[0] := -du * Scale;
-      Vec[1] := -dv * Scale;
-      Vec[2] := 1;
-    end;
-
-    // Normalize
-    Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
-    if Len <> 0 then begin
-      Vec[0] := Vec[0] * Len;
-      Vec[1] := Vec[1] * Len;
-      Vec[2] := Vec[2] * Len;
-    end;
-
-    // Farbe zuweisem
-    Dest.Data.r := Trunc((Vec[0] + 1) * 127.5);
-    Dest.Data.g := Trunc((Vec[1] + 1) * 127.5);
-    Dest.Data.b := Trunc((Vec[2] + 1) * 127.5);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap2D.ToNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean);
-var
-  Rec: TglBitmapToNormalMapRec;
-
-  procedure SetEntry (var Matrix: array of TMatrixItem; Index, X, Y: Integer; W: Single);
-  begin
-    if (Index >= Low(Matrix)) and (Index <= High(Matrix)) then begin
-      Matrix[Index].X := X;
-      Matrix[Index].Y := Y;
-      Matrix[Index].W := W;
-    end;
-  end;
-
-begin
-  if TFormatDescriptor.Get(Format).IsCompressed then
-    raise EglBitmapUnsupportedFormat.Create(Format);
-
-  if aScale > 100 then
-    Rec.Scale := 100
-  else if aScale < -100 then
-    Rec.Scale := -100
-  else
-    Rec.Scale := aScale;
-
-  SetLength(Rec.Heights, Width * Height);
-  try
-    case aFunc of
-      nm4Samples: begin
-        SetLength(Rec.MatrixU, 2);
-        SetEntry(Rec.MatrixU, 0, -1,  0, -0.5);
-        SetEntry(Rec.MatrixU, 1,  1,  0,  0.5);
-
-        SetLength(Rec.MatrixV, 2);
-        SetEntry(Rec.MatrixV, 0,  0,  1,  0.5);
-        SetEntry(Rec.MatrixV, 1,  0, -1, -0.5);
-      end;
-
-      nmSobel: begin
-        SetLength(Rec.MatrixU, 6);
-        SetEntry(Rec.MatrixU, 0, -1,  1, -1.0);
-        SetEntry(Rec.MatrixU, 1, -1,  0, -2.0);
-        SetEntry(Rec.MatrixU, 2, -1, -1, -1.0);
-        SetEntry(Rec.MatrixU, 3,  1,  1,  1.0);
-        SetEntry(Rec.MatrixU, 4,  1,  0,  2.0);
-        SetEntry(Rec.MatrixU, 5,  1, -1,  1.0);
-
-        SetLength(Rec.MatrixV, 6);
-        SetEntry(Rec.MatrixV, 0, -1,  1,  1.0);
-        SetEntry(Rec.MatrixV, 1,  0,  1,  2.0);
-        SetEntry(Rec.MatrixV, 2,  1,  1,  1.0);
-        SetEntry(Rec.MatrixV, 3, -1, -1, -1.0);
-        SetEntry(Rec.MatrixV, 4,  0, -1, -2.0);
-        SetEntry(Rec.MatrixV, 5,  1, -1, -1.0);
-      end;
-
-      nm3x3: begin
-        SetLength(Rec.MatrixU, 6);
-        SetEntry(Rec.MatrixU, 0, -1,  1, -1/6);
-        SetEntry(Rec.MatrixU, 1, -1,  0, -1/6);
-        SetEntry(Rec.MatrixU, 2, -1, -1, -1/6);
-        SetEntry(Rec.MatrixU, 3,  1,  1,  1/6);
-        SetEntry(Rec.MatrixU, 4,  1,  0,  1/6);
-        SetEntry(Rec.MatrixU, 5,  1, -1,  1/6);
-
-        SetLength(Rec.MatrixV, 6);
-        SetEntry(Rec.MatrixV, 0, -1,  1,  1/6);
-        SetEntry(Rec.MatrixV, 1,  0,  1,  1/6);
-        SetEntry(Rec.MatrixV, 2,  1,  1,  1/6);
-        SetEntry(Rec.MatrixV, 3, -1, -1, -1/6);
-        SetEntry(Rec.MatrixV, 4,  0, -1, -1/6);
-        SetEntry(Rec.MatrixV, 5,  1, -1, -1/6);
-      end;
-
-      nm5x5: begin
-        SetLength(Rec.MatrixU, 20);
-        SetEntry(Rec.MatrixU,  0, -2,  2, -1 / 16);
-        SetEntry(Rec.MatrixU,  1, -1,  2, -1 / 10);
-        SetEntry(Rec.MatrixU,  2,  1,  2,  1 / 10);
-        SetEntry(Rec.MatrixU,  3,  2,  2,  1 / 16);
-        SetEntry(Rec.MatrixU,  4, -2,  1, -1 / 10);
-        SetEntry(Rec.MatrixU,  5, -1,  1, -1 /  8);
-        SetEntry(Rec.MatrixU,  6,  1,  1,  1 /  8);
-        SetEntry(Rec.MatrixU,  7,  2,  1,  1 / 10);
-        SetEntry(Rec.MatrixU,  8, -2,  0, -1 / 2.8);
-        SetEntry(Rec.MatrixU,  9, -1,  0, -0.5);
-        SetEntry(Rec.MatrixU, 10,  1,  0,  0.5);
-        SetEntry(Rec.MatrixU, 11,  2,  0,  1 / 2.8);
-        SetEntry(Rec.MatrixU, 12, -2, -1, -1 / 10);
-        SetEntry(Rec.MatrixU, 13, -1, -1, -1 /  8);
-        SetEntry(Rec.MatrixU, 14,  1, -1,  1 /  8);
-        SetEntry(Rec.MatrixU, 15,  2, -1,  1 / 10);
-        SetEntry(Rec.MatrixU, 16, -2, -2, -1 / 16);
-        SetEntry(Rec.MatrixU, 17, -1, -2, -1 / 10);
-        SetEntry(Rec.MatrixU, 18,  1, -2,  1 / 10);
-        SetEntry(Rec.MatrixU, 19,  2, -2,  1 / 16);
-
-        SetLength(Rec.MatrixV, 20);
-        SetEntry(Rec.MatrixV,  0, -2,  2,  1 / 16);
-        SetEntry(Rec.MatrixV,  1, -1,  2,  1 / 10);
-        SetEntry(Rec.MatrixV,  2,  0,  2,  0.25);
-        SetEntry(Rec.MatrixV,  3,  1,  2,  1 / 10);
-        SetEntry(Rec.MatrixV,  4,  2,  2,  1 / 16);
-        SetEntry(Rec.MatrixV,  5, -2,  1,  1 / 10);
-        SetEntry(Rec.MatrixV,  6, -1,  1,  1 /  8);
-        SetEntry(Rec.MatrixV,  7,  0,  1,  0.5);
-        SetEntry(Rec.MatrixV,  8,  1,  1,  1 /  8);
-        SetEntry(Rec.MatrixV,  9,  2,  1,  1 / 16);
-        SetEntry(Rec.MatrixV, 10, -2, -1, -1 / 16);
-        SetEntry(Rec.MatrixV, 11, -1, -1, -1 /  8);
-        SetEntry(Rec.MatrixV, 12,  0, -1, -0.5);
-        SetEntry(Rec.MatrixV, 13,  1, -1, -1 /  8);
-        SetEntry(Rec.MatrixV, 14,  2, -1, -1 / 10);
-        SetEntry(Rec.MatrixV, 15, -2, -2, -1 / 16);
-        SetEntry(Rec.MatrixV, 16, -1, -2, -1 / 10);
-        SetEntry(Rec.MatrixV, 17,  0, -2, -0.25);
-        SetEntry(Rec.MatrixV, 18,  1, -2, -1 / 10);
-        SetEntry(Rec.MatrixV, 19,  2, -2, -1 / 16);
-      end;
-    end;
-
-    // Daten Sammeln
-    if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then
-      AddFunc(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec)
-    else
-      AddFunc(glBitmapToNormalMapPrepareFunc, false, @Rec);
-    AddFunc(glBitmapToNormalMapFunc, false, @Rec);
-  finally
-    SetLength(Rec.Heights, 0);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmapCubeMap////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean);
-begin
-  Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.');
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.AfterConstruction;
-begin
-  inherited;
-
-  if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then
-    raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
-
-  SetWrap;
-  Target   := GL_TEXTURE_CUBE_MAP;
-  fGenMode := GL_REFLECTION_MAP;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean);
-var
-  BuildWithGlu: Boolean;
-  TexSize: Integer;
-begin
-  if (aTestTextureSize) then begin
-    glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize);
-
-    if (Height > TexSize) or (Width > TexSize) then
-      raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
-
-    if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
-      raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.');
-  end;
-
-  if (ID = 0) then
-    CreateID;
-  SetupParameters(BuildWithGlu);
-  UploadData(aCubeTarget, BuildWithGlu);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.Bind(const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean);
-begin
-  inherited Bind (aEnableTextureUnit);
-  if aEnableTexCoordsGen then begin
-    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode);
-    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode);
-    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode);
-    glEnable(GL_TEXTURE_GEN_S);
-    glEnable(GL_TEXTURE_GEN_T);
-    glEnable(GL_TEXTURE_GEN_R);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapCubeMap.Unbind(const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean);
-begin
-  inherited Unbind(aDisableTextureUnit);
-  if aDisableTexCoordsGen then begin
-    glDisable(GL_TEXTURE_GEN_S);
-    glDisable(GL_TEXTURE_GEN_T);
-    glDisable(GL_TEXTURE_GEN_R);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//TglBitmapNormalMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-type
-  TVec = Array[0..2] of Single;
-  TglBitmapNormalMapGetVectorFunc = procedure (out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-
-  PglBitmapNormalMapRec = ^TglBitmapNormalMapRec;
-  TglBitmapNormalMapRec = record
-    HalfSize : Integer;
-    Func: TglBitmapNormalMapGetVectorFunc;
-  end;
-
-  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapPosX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
-  aVec[0] := aHalfSize;
-  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
-  aVec[2] := - (aPosition.X + 0.5 - aHalfSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapNegX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
-  aVec[0] := - aHalfSize;
-  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
-  aVec[2] := aPosition.X + 0.5 - aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapPosY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
-  aVec[0] := aPosition.X + 0.5 - aHalfSize;
-  aVec[1] := aHalfSize;
-  aVec[2] := aPosition.Y + 0.5 - aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapNegY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
-  aVec[0] := aPosition.X + 0.5 - aHalfSize;
-  aVec[1] := - aHalfSize;
-  aVec[2] := - (aPosition.Y + 0.5 - aHalfSize);
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapPosZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
-  aVec[0] := aPosition.X + 0.5 - aHalfSize;
-  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
-  aVec[2] := aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapNegZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
-begin
-  aVec[0] := - (aPosition.X + 0.5 - aHalfSize);
-  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
-  aVec[2] := - aHalfSize;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure glBitmapNormalMapFunc(var FuncRec: TglBitmapFunctionRec);
-var
-  i: Integer;
-  Vec: TVec;
-  Len: Single;
-begin
-  with FuncRec do begin
-    with PglBitmapNormalMapRec(Args)^ do begin
-      Func(Vec, Position, HalfSize);
-
-      // Normalize
-      Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
-      if Len <> 0 then begin
-        Vec[0] := Vec[0] * Len;
-        Vec[1] := Vec[1] * Len;
-        Vec[2] := Vec[2] * Len;
-      end;
-
-      // Scale Vector and AddVectro
-      Vec[0] := Vec[0] * 0.5 + 0.5;
-      Vec[1] := Vec[1] * 0.5 + 0.5;
-      Vec[2] := Vec[2] * 0.5 + 0.5;
-    end;
-
-    // Set Color
-    for i := 0 to 2 do
-      Dest.Data.arr[i] := Round(Vec[i] * 255);
-  end;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapNormalMap.AfterConstruction;
-begin
-  inherited;
-  fGenMode := GL_NORMAL_MAP;
-end;
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean);
-var
-  Rec: TglBitmapNormalMapRec;
-  SizeRec: TglBitmapPixelPosition;
-begin
-  Rec.HalfSize := aSize div 2;
-  FreeDataAfterGenTexture := false;
-
-  SizeRec.Fields := [ffX, ffY];
-  SizeRec.X := aSize;
-  SizeRec.Y := aSize;
-
-  // Positive X
-  Rec.Func := glBitmapNormalMapPosX;
-  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize);
-
-  // Negative X
-  Rec.Func := glBitmapNormalMapNegX;
-  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize);
-
-  // Positive Y
-  Rec.Func := glBitmapNormalMapPosY;
-  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize);
-
-  // Negative Y
-  Rec.Func := glBitmapNormalMapNegY;
-  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize);
-
-  // Positive Z
-  Rec.Func := glBitmapNormalMapPosZ;
-  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize);
-
-  // Negative Z
-  Rec.Func := glBitmapNormalMapNegZ;
-  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
-  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize);
-end;
-
-
-initialization
-  glBitmapSetDefaultFormat (tfEmpty);
-  glBitmapSetDefaultMipmap (mmMipmap);
-  glBitmapSetDefaultFilter (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
-  glBitmapSetDefaultWrap   (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
-  glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA);
-
-  glBitmapSetDefaultFreeDataAfterGenTexture(true);
-  glBitmapSetDefaultDeleteTextureOnFree    (true);
-
-  TFormatDescriptor.Init;
-
-{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
-  OpenGLInitialized := false;
-  InitOpenGLCS := TCriticalSection.Create;
-{$ENDIF}
-
-finalization
-  TFormatDescriptor.Finalize;
-
-{$IFDEF GLB_NATIVE_OGL}
-  if Assigned(GL_LibHandle) then
-    glbFreeLibrary(GL_LibHandle);
-
-{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
-  if Assigned(GLU_LibHandle) then
-    glbFreeLibrary(GLU_LibHandle);
-  FreeAndNil(InitOpenGLCS);
-{$ENDIF}
-{$ENDIF}  
-
-end.

diff --git a/uglcArrayBuffer.pas b/uglcArrayBuffer.pas
new file mode 100644 (file)
index 0000000..8a65b62
--- /dev/null
+++ b/uglcArrayBuffer.pas
@@ -0,0 +1,178 @@
+unit uglcArrayBuffer;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Array Buffer
+  Beispiel:
+    type
+      TVertex = packed record
+        pos: TgluVector3f; // vertex position
+        tex: TgluVector2f; // texture coordinates
+        nor: TgluVector3f; // normal
+      end;
+      PVertex = ^TVertex;
+
+    var
+      vBuffer: TglcArrayBuffer;
+      iBuffer: TglcArrayBuffer;
+      p: Pointer;
+
+    vBuffer := TglcArrayBuffer.Create(TglcBufferTarget.btArrayBuffer);
+    iBuffer := TglcArrayBuffer.Create(TglcBufferTarget.btElementArrayBuffer);
+    try
+      // write vertex data to vertex buffer
+      vBuffer.Bind;
+      vBuffer.BufferData(4, SizeOf(TresMeshVertex), TglcBufferUsage.buStaticDraw, nil);
+      p := vBuffer.MapBuffer(TglcBufferAccess.baWriteOnly);
+      try
+        PVertex(p).pos := gluVertex3f(0.0, 0.0, 0.0);
+        PVertex(p).tex := gluVertex2f(0.0, 0.5);
+        PVertex(p).nor := gluVertex3f(0.0, 1.0, 0.0);
+        inc(p, SizeOf(TVertex));
+        // ... 
+      finally
+        vBuffer.UnmapBuffer;
+        vBuffer.Unbind;
+      end;
+
+      // write indices to index buffer 
+      iBuffer.Bind;
+      iBuffer.BufferData(4, SizeOf(GLuint), TglcBufferUsage.buStaticDraw, nil);
+      p := iBuffer.MapBuffer(TglcBufferAccess.baWriteOnly);
+      try
+        PGLuint(p) := 0;
+        //  ...
+      finally
+        iBuffer.UnmapBuffer;
+        iBuffer.Unbind;
+      end;
+
+      // use array buffers to draw primitive
+      vBuffer.Bind;
+      iBuffer.Bind;
+
+      glEnableClientState(GL_VERTEX_ARRAY);
+      glVertexPointer(3, GL_FLOAT, 8, Pointer(0));
+
+      glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+      glTexCoordPointer(2, GL_FLOAT, 8, Pointer(3));
+
+      glEnableClientState(GL_NORMAL_ARRAY);
+      glNormalPointer(GL_FLOAT, 8, Pointer(5));
+
+      glEnableClientState(GL_INDEX_ARRAY);
+      glIndexPointer(GL_INT, 0, nil);
+
+      glDrawElements(GL_QUADS, iBuffer.DataCount, GL_UNSIGNED_INT, nil);
+
+      glDisableClientState(GL_INDEX_ARRAY);
+      glDisableClientState(GL_VERTEX_ARRAY);
+      glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+      glDisableClientState(GL_NORMAL_ARRAY);
+
+      fIndexBuffer.Unbind;
+      fVertexBuffer.Unbind;
+    finally
+      FreeAndNil(vBuffer);
+      FreeAndNil(iBuffer);
+    end; }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  dglOpenGL, sysutils, uglcTypes;
+
+type
+  EglcArrayBuffer = class(Exception);
+  TglcArrayBuffer = class(TObject)
+  private
+    fID: GLuint;
+    fTarget: TglcBufferTarget;
+    fUsage: TglcBufferUsage;
+  protected
+    fDataCount: Integer;
+    fDataSize: Integer;
+  public
+    property ID:        gluInt           read fID;
+    property Target:    TglcBufferTarget read fTarget;
+    property Usage:     TglcBufferUsage  read fUsage;
+    property DataCount: Integer          read fDataCount;
+    property DataSize:  Integer          read fDataSize;
+
+    procedure BufferData(const aDataCount, aDataSize: Cardinal; const aUsage: TglcBufferUsage; const aData: Pointer);
+    function MapBuffer(const aAccess: TglcBufferAccess): Pointer;
+    procedure UnmapBuffer;
+    procedure Bind;
+    procedure Unbind;
+    constructor Create(const aTarget: TglcBufferTarget);
+    destructor Destroy; override;
+  end;
+
+implementation
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcArrayBuffer///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.BufferData(const aDataCount, aDataSize: Cardinal; const aUsage: TglcBufferUsage; const aData: Pointer);
+begin
+  glGetError(); //clear Errors
+  Bind;
+  fDataCount := aDataCount;
+  fDataSize  := aDataSize;
+  fUsage     := aUsage;
+  glBufferData(GLenum(fTarget), fDataCount * fDataSize, aData, GLenum(fUsage));
+  glcCheckAndRaiseError;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+function TglcArrayBuffer.MapBuffer(const aAccess: TglcBufferAccess): Pointer;
+begin
+  glGetError();
+  result := nil;
+  if (fDataCount * fDataSize) <= 0 then
+    exit;
+  result := glMapBuffer(GLenum(fTarget), GLenum(aAccess));
+  glcCheckAndRaiseError;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.UnmapBuffer;
+begin
+  glUnmapBuffer(GLenum(fTarget));
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.Bind;
+begin
+  glBindBuffer(GLenum(fTarget), fID);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+procedure TglcArrayBuffer.Unbind;
+begin
+  glBindBuffer(GLenum(fTarget), 0);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+constructor TglcArrayBuffer.Create(const aTarget: TglcBufferTarget);
+begin
+  if not GL_ARB_Vertex_Buffer_Object then
+    raise EglcArrayBuffer.Create('Create - VertexBuffer: not supported');
+  inherited Create;
+  glGenBuffers(1, @fID);
+  fDataCount   := 0;
+  fDataSize    := 0;
+  fTarget      := aTarget;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////[c]
+destructor TglcArrayBuffer.Destroy;
+begin
+  glDeleteBuffers(1, @fID);
+  inherited Destroy;
+end;
+
+end.
+

diff --git a/uglcBitmap.pas b/uglcBitmap.pas
new file mode 100644 (file)
index 0000000..996ca54
--- /dev/null
+++ b/uglcBitmap.pas
@@ -0,0 +1,9102 @@
+{***********************************************************
+glBitmap by Steffen Xonna aka Lossy eX (2003-2008)
+http://www.opengl24.de/index.php?cat=header&file=glbitmap
+
+modified by Delphi OpenGL Community (http://delphigl.com/) (2013)
+
+------------------------------------------------------------
+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
+------------------------------------------------------------
+Version 3.0.1
+------------------------------------------------------------
+History
+20-11-2013
+- refactoring of the complete library
+21-03-2010
+- The define GLB_DELPHI dosn't check versions anymore. If you say you are using delphi
+  then it's your problem if that isn't true. This prevents the unit for incompatibility
+  with newer versions of Delphi.
+- Problems with D2009+ resolved (Thanks noeska and all i forgot)
+- GetPixel isn't set if you are loading textures inside the constructor (Thanks Wilson)
+10-08-2008
+- AddAlphaFromglBitmap used the custom pointer instead the imagedatapointer (Thanks Wilson)
+- Additional Datapointer for functioninterface now has the name CustomData
+24-07-2008
+- AssigneAlphaToBitmap overwrites his own palette (Thanks Wilson)
+- If you load an texture from an file the property Filename will be set to the name of the file
+- Three new properties to attach custom data to the Texture objects
+  - CustomName  (free for use string)
+  - CustomNameW (free for use widestring)
+  - CustomDataPointer (free for use pointer to attach other objects or complex structures)
+27-05-2008
+- RLE TGAs loaded much faster
+26-05-2008
+- fixed some problem with reading RLE TGAs.
+21-05-2008
+- function clone now only copys data if it's assigned and now it also copies the ID
+- it seems that lazarus dont like comments in comments.
+01-05-2008
+- It's possible to set the id of the texture
+- define GLB_NO_NATIVE_GL deactivated by default
+27-04-2008
+- Now supports the following libraries
+  - SDL and SDL_image
+  - libPNG
+  - libJPEG
+- Linux compatibillity via free pascal compatibility (delphi sources optional)
+- BMPs now loaded manuel
+- Large restructuring
+- Property DataPtr now has the name Data
+- Functions are more flexible between RGB(A) and BGR(A). RGB can be saved as Bitmap and will be saved as BGR
+- Unused Depth removed
+- Function FreeData to freeing image data added
+24-10-2007
+- ImageID flag of TGAs was ignored. (Thanks Zwoetzen)
+15-11-2006
+- Function SetBorderColor implemented (only used by opengl if wrap is set to GL_CLAMP_TO_BORDER)
+- Function AddAlphaFromValue implemented to use an fixed Value as Alphachannel
+- Function ReadOpenGLExtension is now only intern
+29-06-2006
+- pngimage now disabled by default like all other versions.
+26-06-2006
+- Setting up an anisotropic filter of 0 isnt allowed by nvidia (Thanks Ogridi)
+22-06-2006
+- Fixed some Problem with Delphi 5
+- Now uses the newest version of pngimage. Makes saving pngs much easier.
+22-03-2006
+- Property IsCompressed and Size removed. Not really supported by Spec (Thanks Ogridi)
+09-03-2006
+- Internal Format ifDepth8 added
+- function GrabScreen now supports all uncompressed formats
+31-01-2006
+- AddAlphaFromglBitmap implemented
+29-12-2005
+- LoadFromResource and LoadFromResourceId now needs an Instance and an ResourceType (for ID)
+28-12-2005
+- Width, Height and Depth internal changed to TglBitmapPixelPosition.
+  property Width, Height, Depth are still existing and new property Dimension are avail
+11-12-2005
+- Added native OpenGL Support. Breaking the dglOpenGL "barrier".
+19-10-2005
+- Added function GrabScreen to class TglBitmap2D
+18-10-2005
+- Added support to Save images
+- Added function Clone to Clone Instance
+11-10-2005
+- Functions now works with Cardinals for each channel. Up to 32 Bits per channel.
+  Usefull for Future
+- Several speed optimizations
+09-10-2005
+- Internal structure change. Loading of TGA, PNG and DDS improved.
+  Data, format and size will now set directly with SetDataPtr.
+- AddFunc now works with all Types of Images and Formats
+- Some Funtions moved to Baseclass TglBitmap
+06-10-2005
+- Added Support to decompress DXT3 and DXT5 compressed Images.
+- Added Mapping to convert data from one format into an other.
+05-10-2005
+- Added method ConvertTo in Class TglBitmap2D. Method allows to convert every
+  supported Input format (supported by GetPixel) into any uncompresed Format
+- Added Support to decompress DXT1 compressed Images.
+- SwapColors replaced by ConvertTo
+04-10-2005
+- Added Support for compressed DDSs
+- Added new internal formats (DXT1, DXT3, DXT5)
+29-09-2005
+- Parameter Components renamed to InternalFormat
+23-09-2005
+- Some AllocMem replaced with GetMem (little speed change)
+- better exception handling. Better protection from memory leaks.
+22-09-2005
+- Added support for Direct Draw Surfaces (.DDS) (uncompressed images only)
+- Added new internal formats (RGB8, RGBA8, RGBA4, RGB5A1, RGB10A2, R5G6B5)
+07-09-2005
+- Added support for Grayscale textures
+- Added internal formats (Alpha, Luminance, LuminanceAlpha, BGR8, BGRA8)
+10-07-2005
+- Added support for GL_VERSION_2_0
+- Added support for GL_EXT_texture_filter_anisotropic
+04-07-2005
+- Function FillWithColor fills the Image with one Color
+- Function LoadNormalMap added
+30-06-2005
+- ToNormalMap allows to Create an NormalMap from the Alphachannel
+- ToNormalMap now supports Sobel (nmSobel) function.
+29-06-2005
+- support for RLE Compressed RGB TGAs added
+28-06-2005
+- Class TglBitmapNormalMap added to support Normalmap generation
+- Added function ToNormalMap in class TglBitmap2D to genereate normal maps from textures.
+  3 Filters are supported. (4 Samples, 3x3 and 5x5)
+16-06-2005
+- Method LoadCubeMapClass removed
+- LoadCubeMap returnvalue is now the Texture paramter. Such as LoadTextures
+- virtual abstract method GenTexture in class TglBitmap now is protected
+12-06-2005
+- now support DescriptionFlag in LoadTga. Allows vertical flipped images to be loaded as normal
+10-06-2005
+- little enhancement for IsPowerOfTwo
+- TglBitmap1D.GenTexture now tests NPOT Textures
+06-06-2005
+- some little name changes. All properties or function with Texture in name are
+  now without texture in name. We have allways texture so we dosn't name it.
+03-06-2005
+- GenTexture now tests if texture is NPOT and NPOT-Texture are supported or
+  TextureTarget is GL_TEXTURE_RECTANGLE. Else it raised an exception.
+02-06-2005
+- added support for GL_ARB_texture_rectangle, GL_EXT_texture_rectangle and GL_NV_texture_rectangle
+25-04-2005
+- Function Unbind added
+- call of SetFilter or SetTextureWrap if TextureID exists results in setting properties to opengl texture.
+21-04-2005
+- class TglBitmapCubeMap added (allows to Create Cubemaps)
+29-03-2005
+- Added Support for PNG Images. (http://pngdelphi.sourceforge.net/)
+  To Enable png's use the define pngimage
+22-03-2005
+- New Functioninterface added
+- Function GetPixel added
+27-11-2004
+- Property BuildMipMaps renamed to MipMap
+21-11-2004
+- property Name removed.
+- BuildMipMaps is now a set of 3 values. None, GluBuildMipmaps and SGIS_generate_mipmap
+22-05-2004
+- property name added. Only used in glForms!
+26-11-2003
+- property FreeDataAfterGenTexture is now available as default (default = true)
+- BuildMipmaps now implemented in TglBitmap1D (i've forgotten it)
+- function MoveMemory replaced with function Move (little speed change)
+- several calculations stored in variables (little speed change)
+29-09-2003
+- property BuildMipsMaps added (default = true)
+  if BuildMipMaps isn't set GenTextures uses glTexImage[12]D else it use gluBuild[12]dMipmaps
+- property FreeDataAfterGenTexture added (default = true)
+  if FreeDataAfterGenTexture is set the texturedata were deleted after the texture was generated.
+- parameter DisableOtherTextureUnits of Bind removed
+- parameter FreeDataAfterGeneration of GenTextures removed
+12-09-2003
+- TglBitmap dosn't delete data if class was destroyed (fixed)
+09-09-2003
+- Bind now enables TextureUnits (by params)
+- GenTextures can leave data (by param)
+- LoadTextures now optimal
+03-09-2003
+- Performance optimization in AddFunc
+- procedure Bind moved to subclasses
+- Added new Class TglBitmap1D to support real OpenGL 1D Textures
+19-08-2003
+- Texturefilter and texturewrap now also as defaults
+  Minfilter = GL_LINEAR_MIPMAP_LINEAR
+  Magfilter = GL_LINEAR
+  Wrap(str) = GL_CLAMP_TO_EDGE
+- Added new format tfCompressed to create a compressed texture.
+- propertys IsCompressed, TextureSize and IsResident added
+  IsCompressed and TextureSize only contains data from level 0
+18-08-2003
+- Added function AddFunc to add PerPixelEffects to Image
+- LoadFromFunc now based on AddFunc
+- Invert now based on AddFunc
+- SwapColors now based on AddFunc
+16-08-2003
+- Added function FlipHorz
+15-08-2003
+- Added function LaodFromFunc to create images with function
+- Added function FlipVert
+- Added internal format RGB(A) if GL_EXT_bgra or OpenGL 1.2 isn't supported
+29-07-2003
+- Added Alphafunctions to calculate alpha per function
+- Added Alpha from ColorKey using alphafunctions
+28-07-2003
+- First full functionally Version of glBitmap
+- Support for 24Bit and 32Bit TGA Pictures added
+25-07-2003
+- begin of programming
+***********************************************************}
+unit uglcBitmap;
+
+// Please uncomment the defines below to configure the glBitmap to your preferences.
+// If you have configured the unit you can uncomment the warning above.
+{.$MESSAGE error 'Hey. I''m the glBitmap.pas and i need to be configured. My master tell me your preferences! ;)'}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Preferences ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// activate to enable build-in OpenGL support with statically linked methods
+// use dglOpenGL.pas if not enabled
+{.$DEFINE GLB_NATIVE_OGL_STATIC}
+
+// activate to enable build-in OpenGL support with dynamically linked methods
+// use dglOpenGL.pas if not enabled
+{.$DEFINE GLB_NATIVE_OGL_DYNAMIC}
+
+
+// activate to enable the support for SDL_surfaces
+{.$DEFINE GLB_SDL}
+
+// activate  to enable the support for Delphi (including support for Delphi's (not Lazarus') TBitmap)
+{.$DEFINE GLB_DELPHI}
+
+// activate to enable the support for TLazIntfImage from Lazarus
+{$DEFINE GLB_LAZARUS}
+
+
+
+// activate to enable the support of SDL_image to load files. (READ ONLY)
+// If you enable SDL_image all other libraries will be ignored!
+{.$DEFINE GLB_SDL_IMAGE}
+
+
+
+// activate to enable Lazarus TPortableNetworkGraphic support
+// if you enable this pngImage and libPNG will be ignored
+{$DEFINE GLB_LAZ_PNG}
+
+// activate to enable png support with the unit pngimage -> http://pngdelphi.sourceforge.net/
+// if you enable pngimage the libPNG will be ignored
+{.$DEFINE GLB_PNGIMAGE}
+
+// activate to use the libPNG -> http://www.libpng.org/
+// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libpng
+{.$DEFINE GLB_LIB_PNG}
+
+
+
+// activate to enable Lazarus TJPEGImage support
+// if you enable this delphi jpegs and libJPEG will be ignored
+{$DEFINE GLB_LAZ_JPEG}
+
+// if you enable delphi jpegs the libJPEG will be ignored
+{.$DEFINE GLB_DELPHI_JPEG}
+
+// activate to use the libJPEG -> http://www.ijg.org/
+// You will need an aditional header -> http://www.opengl24.de/index.php?cat=header&file=libjpeg
+{.$DEFINE GLB_LIB_JPEG}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// PRIVATE: do not change anything! //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Delphi Versions
+{$IFDEF fpc}
+  {$MODE Delphi}
+
+  {$IFDEF CPUI386}
+    {$DEFINE CPU386}
+    {$ASMMODE INTEL}
+  {$ENDIF}
+
+  {$IFNDEF WINDOWS}
+    {$linklib c}
+  {$ENDIF}
+{$ENDIF}
+
+// Operation System
+{$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)}
+  {$DEFINE GLB_WIN}
+{$ELSEIF DEFINED(LINUX)}
+  {$DEFINE GLB_LINUX}
+{$IFEND}
+
+// native OpenGL Support
+{$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
+  {$DEFINE GLB_NATIVE_OGL}
+{$IFEND}
+
+// checking define combinations
+//SDL Image
+{$IFDEF GLB_SDL_IMAGE}
+  {$IFNDEF GLB_SDL}
+    {$MESSAGE warn 'SDL_image won''t work without SDL. SDL will be activated.'}
+    {$DEFINE GLB_SDL}
+  {$ENDIF}
+
+  {$IFDEF GLB_LAZ_PNG}
+    {$MESSAGE warn 'The Lazarus TPortableNetworkGraphics will be ignored because you are using SDL_image.'}
+    {$undef GLB_LAZ_PNG}
+  {$ENDIF}
+
+  {$IFDEF GLB_PNGIMAGE}
+    {$MESSAGE warn 'The unit pngimage will be ignored because you are using SDL_image.'}
+    {$undef GLB_PNGIMAGE}
+  {$ENDIF}
+
+  {$IFDEF GLB_LAZ_JPEG}
+    {$MESSAGE warn 'The Lazarus TJPEGImage will be ignored because you are using SDL_image.'}
+    {$undef GLB_LAZ_JPEG}
+  {$ENDIF}
+
+  {$IFDEF GLB_DELPHI_JPEG}
+    {$MESSAGE warn 'The unit JPEG will be ignored because you are using SDL_image.'}
+    {$undef GLB_DELPHI_JPEG}
+  {$ENDIF}
+
+  {$IFDEF GLB_LIB_PNG}
+    {$MESSAGE warn 'The library libPNG will be ignored because you are using SDL_image.'}
+    {$undef GLB_LIB_PNG}
+  {$ENDIF}
+
+  {$IFDEF GLB_LIB_JPEG}
+    {$MESSAGE warn 'The library libJPEG will be ignored because you are using SDL_image.'}
+    {$undef GLB_LIB_JPEG}
+  {$ENDIF}
+
+  {$DEFINE GLB_SUPPORT_PNG_READ}
+  {$DEFINE GLB_SUPPORT_JPEG_READ}
+{$ENDIF}
+
+// Lazarus TPortableNetworkGraphic
+{$IFDEF GLB_LAZ_PNG}
+  {$IFNDEF GLB_LAZARUS}
+    {$MESSAGE warn 'Lazarus TPortableNetworkGraphic won''t work without Lazarus. Lazarus will be activated.'}
+    {$DEFINE GLB_LAZARUS}
+  {$ENDIF}
+
+  {$IFDEF GLB_PNGIMAGE}
+    {$MESSAGE warn 'The pngimage will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
+    {$undef GLB_PNGIMAGE}
+  {$ENDIF}
+
+  {$IFDEF GLB_LIB_PNG}
+    {$MESSAGE warn 'The library libPNG will be ignored if you are using Lazarus TPortableNetworkGraphic.'}
+    {$undef GLB_LIB_PNG}
+  {$ENDIF}
+
+  {$DEFINE GLB_SUPPORT_PNG_READ}
+  {$DEFINE GLB_SUPPORT_PNG_WRITE}
+{$ENDIF}
+
+// PNG Image
+{$IFDEF GLB_PNGIMAGE}
+  {$IFDEF GLB_LIB_PNG}
+    {$MESSAGE warn 'The library libPNG will be ignored if you are using pngimage.'}
+    {$undef GLB_LIB_PNG}
+  {$ENDIF}
+
+  {$DEFINE GLB_SUPPORT_PNG_READ}
+  {$DEFINE GLB_SUPPORT_PNG_WRITE}
+{$ENDIF}
+
+// libPNG
+{$IFDEF GLB_LIB_PNG}
+  {$DEFINE GLB_SUPPORT_PNG_READ}
+  {$DEFINE GLB_SUPPORT_PNG_WRITE}
+{$ENDIF}
+
+// Lazarus TJPEGImage
+{$IFDEF GLB_LAZ_JPEG}
+  {$IFNDEF GLB_LAZARUS}
+    {$MESSAGE warn 'Lazarus TJPEGImage won''t work without Lazarus. Lazarus will be activated.'}
+    {$DEFINE GLB_LAZARUS}
+  {$ENDIF}
+
+  {$IFDEF GLB_DELPHI_JPEG}
+    {$MESSAGE warn 'The Delphi JPEGImage will be ignored if you are using the Lazarus TJPEGImage.'}
+    {$undef GLB_DELPHI_JPEG}
+  {$ENDIF}
+
+  {$IFDEF GLB_LIB_JPEG}
+    {$MESSAGE warn 'The library libJPEG will be ignored if you are using the Lazarus TJPEGImage.'}
+    {$undef GLB_LIB_JPEG}
+  {$ENDIF}
+
+  {$DEFINE GLB_SUPPORT_JPEG_READ}
+  {$DEFINE GLB_SUPPORT_JPEG_WRITE}
+{$ENDIF}
+
+// JPEG Image
+{$IFDEF GLB_DELPHI_JPEG}
+  {$IFDEF GLB_LIB_JPEG}
+    {$MESSAGE warn 'The library libJPEG will be ignored if you are using the unit JPEG.'}
+    {$undef GLB_LIB_JPEG}
+  {$ENDIF}
+
+  {$DEFINE GLB_SUPPORT_JPEG_READ}
+  {$DEFINE GLB_SUPPORT_JPEG_WRITE}
+{$ENDIF}
+
+// libJPEG
+{$IFDEF GLB_LIB_JPEG}
+  {$DEFINE GLB_SUPPORT_JPEG_READ}
+  {$DEFINE GLB_SUPPORT_JPEG_WRITE}
+{$ENDIF}
+
+// native OpenGL
+{$IF DEFINED(GLB_NATIVE_OGL_STATIC) AND DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
+  {$MESSAGE warn 'GLB_NATIVE_OGL_STATIC will be ignored because you enabled GLB_NATIVE_OGL_DYNAMIC'}
+{$IFEND}
+
+// general options
+{$EXTENDEDSYNTAX ON}
+{$LONGSTRINGS ON}
+{$ALIGN ON}
+{$IFNDEF FPC}
+  {$OPTIMIZATION ON}
+{$ENDIF}
+
+interface
+
+uses
+  {$IFNDEF GLB_NATIVE_OGL}      dglOpenGL,                          {$ENDIF}
+  {$IF DEFINED(GLB_WIN) AND
+       (DEFINED(GLB_NATIVE_OGL) OR
+        DEFINED(GLB_DELPHI))}   windows,                            {$IFEND}
+
+  {$IFDEF GLB_SDL}              SDL,                                {$ENDIF}
+  {$IFDEF GLB_LAZARUS}          IntfGraphics, GraphType, Graphics,  {$ENDIF}
+  {$IFDEF GLB_DELPHI}           Dialogs, Graphics, Types,           {$ENDIF}
+
+  {$IFDEF GLB_SDL_IMAGE}        SDL_image,                          {$ENDIF}
+  {$IFDEF GLB_PNGIMAGE}         pngimage,                           {$ENDIF}
+  {$IFDEF GLB_LIB_PNG}          libPNG,                             {$ENDIF}
+  {$IFDEF GLB_DELPHI_JPEG}      JPEG,                               {$ENDIF}
+  {$IFDEF GLB_LIB_JPEG}         libJPEG,                            {$ENDIF}
+
+  Classes, SysUtils;
+
+{$IFDEF GLB_NATIVE_OGL}
+const
+  GL_TRUE   = 1;
+  GL_FALSE  = 0;
+
+  GL_ZERO = 0;
+  GL_ONE  = 1;
+
+  GL_VERSION    = $1F02;
+  GL_EXTENSIONS = $1F03;
+
+  GL_TEXTURE_1D         = $0DE0;
+  GL_TEXTURE_2D         = $0DE1;
+  GL_TEXTURE_RECTANGLE  = $84F5;
+
+  GL_NORMAL_MAP                   = $8511;
+  GL_TEXTURE_CUBE_MAP             = $8513;
+  GL_REFLECTION_MAP               = $8512;
+  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_TEXTURE_WIDTH            = $1000;
+  GL_TEXTURE_HEIGHT           = $1001;
+  GL_TEXTURE_INTERNAL_FORMAT  = $1003;
+  GL_TEXTURE_SWIZZLE_RGBA     = $8E46;
+
+  GL_S = $2000;
+  GL_T = $2001;
+  GL_R = $2002;
+  GL_Q = $2003;
+
+  GL_TEXTURE_GEN_S = $0C60;
+  GL_TEXTURE_GEN_T = $0C61;
+  GL_TEXTURE_GEN_R = $0C62;
+  GL_TEXTURE_GEN_Q = $0C63;
+
+  GL_RED    = $1903;
+  GL_GREEN  = $1904;
+  GL_BLUE   = $1905;
+
+  GL_ALPHA    = $1906;
+  GL_ALPHA4   = $803B;
+  GL_ALPHA8   = $803C;
+  GL_ALPHA12  = $803D;
+  GL_ALPHA16  = $803E;
+
+  GL_LUMINANCE    = $1909;
+  GL_LUMINANCE4   = $803F;
+  GL_LUMINANCE8   = $8040;
+  GL_LUMINANCE12  = $8041;
+  GL_LUMINANCE16  = $8042;
+
+  GL_LUMINANCE_ALPHA      = $190A;
+  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_RGB      = $1907;
+  GL_BGR      = $80E0;
+  GL_R3_G3_B2 = $2A10;
+  GL_RGB4     = $804F;
+  GL_RGB5     = $8050;
+  GL_RGB565   = $8D62;
+  GL_RGB8     = $8051;
+  GL_RGB10    = $8052;
+  GL_RGB12    = $8053;
+  GL_RGB16    = $8054;
+
+  GL_RGBA     = $1908;
+  GL_BGRA     = $80E1;
+  GL_RGBA2    = $8055;
+  GL_RGBA4    = $8056;
+  GL_RGB5_A1  = $8057;
+  GL_RGBA8    = $8058;
+  GL_RGB10_A2 = $8059;
+  GL_RGBA12   = $805A;
+  GL_RGBA16   = $805B;
+
+  GL_DEPTH_COMPONENT    = $1902;
+  GL_DEPTH_COMPONENT16  = $81A5;
+  GL_DEPTH_COMPONENT24  = $81A6;
+  GL_DEPTH_COMPONENT32  = $81A7;
+
+  GL_COMPRESSED_RGB                 = $84ED;
+  GL_COMPRESSED_RGBA                = $84EE;
+  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_UNSIGNED_BYTE            = $1401;
+  GL_UNSIGNED_BYTE_3_3_2      = $8032;
+  GL_UNSIGNED_BYTE_2_3_3_REV  = $8362;
+
+  GL_UNSIGNED_SHORT             = $1403;
+  GL_UNSIGNED_SHORT_5_6_5       = $8363;
+  GL_UNSIGNED_SHORT_4_4_4_4     = $8033;
+  GL_UNSIGNED_SHORT_5_5_5_1     = $8034;
+  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                 = $1405;
+  GL_UNSIGNED_INT_8_8_8_8         = $8035;
+  GL_UNSIGNED_INT_10_10_10_2      = $8036;
+  GL_UNSIGNED_INT_8_8_8_8_REV     = $8367;
+  GL_UNSIGNED_INT_2_10_10_10_REV  = $8368;
+
+  { Texture Filter }
+  GL_TEXTURE_MAG_FILTER     = $2800;
+  GL_TEXTURE_MIN_FILTER     = $2801;
+  GL_NEAREST                = $2600;
+  GL_NEAREST_MIPMAP_NEAREST = $2700;
+  GL_NEAREST_MIPMAP_LINEAR  = $2702;
+  GL_LINEAR                 = $2601;
+  GL_LINEAR_MIPMAP_NEAREST  = $2701;
+  GL_LINEAR_MIPMAP_LINEAR   = $2703;
+
+  { Texture Wrap }
+  GL_TEXTURE_WRAP_S   = $2802;
+  GL_TEXTURE_WRAP_T   = $2803;
+  GL_TEXTURE_WRAP_R   = $8072;
+  GL_CLAMP            = $2900;
+  GL_REPEAT           = $2901;
+  GL_CLAMP_TO_EDGE    = $812F;
+  GL_CLAMP_TO_BORDER  = $812D;
+  GL_MIRRORED_REPEAT  = $8370;
+
+  { Other }
+  GL_GENERATE_MIPMAP      = $8191;
+  GL_TEXTURE_BORDER_COLOR = $1004;
+  GL_MAX_TEXTURE_SIZE     = $0D33;
+  GL_PACK_ALIGNMENT       = $0D05;
+  GL_UNPACK_ALIGNMENT     = $0CF5;
+
+  GL_TEXTURE_MAX_ANISOTROPY_EXT     = $84FE;
+  GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
+  GL_MAX_CUBE_MAP_TEXTURE_SIZE      = $851C;
+  GL_TEXTURE_GEN_MODE               = $2500;
+
+{$IF DEFINED(GLB_WIN)}
+  libglu    = 'glu32.dll';
+  libopengl = 'opengl32.dll';
+{$ELSEIF DEFINED(GLB_LINUX)}
+  libglu    = 'libGLU.so.1';
+  libopengl = 'libGL.so.1';
+{$IFEND}
+
+type
+  GLboolean = BYTEBOOL;
+  GLint     = Integer;
+  GLsizei   = Integer;
+  GLuint    = Cardinal;
+  GLfloat   = Single;
+  GLenum    = Cardinal;
+
+  PGLvoid    = Pointer;
+  PGLboolean = ^GLboolean;
+  PGLint     = ^GLint;
+  PGLuint    = ^GLuint;
+  PGLfloat   = ^GLfloat;
+
+  TglCompressedTexImage1D  = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+{$IF DEFINED(GLB_WIN)}
+  TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall;
+{$ELSEIF DEFINED(GLB_LINUX)}
+  TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl;
+  TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
+{$IFEND}
+
+{$IF DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
+  TglEnable  = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDisable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  TglGetString   = function(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetIntegerv = procedure(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  TglTexParameteri          = procedure(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameteriv         = procedure(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglTexParameterfv         = procedure(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameteriv      = procedure(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexParameterfv      = procedure(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexLevelParameteriv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexLevelParameterfv = procedure(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  TglTexGeni        = procedure(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGenTextures    = procedure(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglBindTexture    = procedure(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglDeleteTextures = procedure(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  TglAreTexturesResident = function(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglReadPixels          = procedure(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglPixelStorei         = procedure(pname: GLenum; param: GLint); {$IFDEF GLB_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 GLB_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 GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TglGetTexImage = procedure(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+  TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+  TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+
+{$ELSEIF DEFINED(GLB_NATIVE_OGL_STATIC)}
+  procedure glEnable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glDisable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+
+  function glGetString(name: GLenum): PAnsiChar; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glGetIntegerv(pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+
+  procedure glTexParameteri(target: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glTexParameteriv(target: GLenum; pname: GLenum; const params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glTexParameterfv(target: GLenum; pname: GLenum; const params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glGetTexParameteriv(target: GLenum; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glGetTexParameterfv(target: GLenum; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glGetTexLevelParameteriv(target: GLenum; level: GLint; pname: GLenum; params: PGLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glGetTexLevelParameterfv(target: GLenum; level: GLint; pname: GLenum; params: PGLfloat); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+
+  procedure glTexGeni(coord: GLenum; pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glGenTextures(n: GLsizei; textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glBindTexture(target: GLenum; texture: GLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glDeleteTextures(n: GLsizei; const textures: PGLuint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+
+  function  glAreTexturesResident(n: GLsizei; const textures: PGLuint; residences: PGLboolean): GLboolean; {$IFDEF DGL_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glReadPixels(x: GLint; y: GLint; width: GLsizei; height: GLsizei; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glPixelStorei(pname: GLenum; param: GLint); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+
+  procedure glTexImage1D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glTexImage2D(target: GLenum; level: GLint; internalformat: GLint; width: GLsizei; height: GLsizei; border: GLint; format: GLenum; _type: GLenum; const pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+  procedure glGetTexImage(target: GLenum; level: GLint; format: GLenum; _type: GLenum; pixels: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
+
+  function gluBuild1DMipmaps(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
+  function gluBuild2DMipmaps(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
+{$IFEND}
+
+var
+  GL_VERSION_1_2,
+  GL_VERSION_1_3,
+  GL_VERSION_1_4,
+  GL_VERSION_2_0,
+  GL_VERSION_3_3,
+
+  GL_SGIS_generate_mipmap,
+
+  GL_ARB_texture_border_clamp,
+  GL_ARB_texture_mirrored_repeat,
+  GL_ARB_texture_rectangle,
+  GL_ARB_texture_non_power_of_two,
+  GL_ARB_texture_swizzle,
+  GL_ARB_texture_cube_map,
+
+  GL_IBM_texture_mirrored_repeat,
+
+  GL_NV_texture_rectangle,
+
+  GL_EXT_texture_edge_clamp,
+  GL_EXT_texture_rectangle,
+  GL_EXT_texture_swizzle,
+  GL_EXT_texture_cube_map,
+  GL_EXT_texture_filter_anisotropic: Boolean;
+
+  glCompressedTexImage1D: TglCompressedTexImage1D;
+  glCompressedTexImage2D: TglCompressedTexImage2D;
+  glGetCompressedTexImage: TglGetCompressedTexImage;
+
+{$IF DEFINED(GLB_WIN)}
+  wglGetProcAddress: TwglGetProcAddress;
+{$ELSEIF DEFINED(GLB_LINUX)}
+  glXGetProcAddress: TglXGetProcAddress;
+  glXGetProcAddressARB: TglXGetProcAddress;
+{$IFEND}
+
+{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
+  glEnable: TglEnable;
+  glDisable: TglDisable;
+
+  glGetString: TglGetString;
+  glGetIntegerv: TglGetIntegerv;
+
+  glTexParameteri: TglTexParameteri;
+  glTexParameteriv: TglTexParameteriv;
+  glTexParameterfv: TglTexParameterfv;
+  glGetTexParameteriv: TglGetTexParameteriv;
+  glGetTexParameterfv: TglGetTexParameterfv;
+  glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
+  glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
+
+  glTexGeni: TglTexGeni;
+  glGenTextures: TglGenTextures;
+  glBindTexture: TglBindTexture;
+  glDeleteTextures: TglDeleteTextures;
+
+  glAreTexturesResident: TglAreTexturesResident;
+  glReadPixels: TglReadPixels;
+  glPixelStorei: TglPixelStorei;
+
+  glTexImage1D: TglTexImage1D;
+  glTexImage2D: TglTexImage2D;
+  glGetTexImage: TglGetTexImage;
+
+  gluBuild1DMipmaps: TgluBuild1DMipmaps;
+  gluBuild2DMipmaps: TgluBuild2DMipmaps;
+{$ENDIF}
+{$ENDIF}
+
+type
+////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmapFormat = (
+    tfEmpty = 0, //must be smallest value!
+
+    tfAlpha4,
+    tfAlpha8,
+    tfAlpha16,
+
+    tfLuminance4,
+    tfLuminance8,
+    tfLuminance16,
+
+    tfLuminance4Alpha4,
+    tfLuminance6Alpha2,
+    tfLuminance8Alpha8,
+    tfLuminance12Alpha4,
+    tfLuminance16Alpha16,
+
+    tfR3G3B2,
+    tfRGBX4,
+    tfXRGB4,
+    tfR5G6B5,
+    tfRGB5X1,
+    tfX1RGB5,
+    tfRGB8,
+    tfRGBX8,
+    tfXRGB8,
+    tfRGB10X2,
+    tfX2RGB10,
+    tfRGB16,
+
+    tfRGBA4,
+    tfARGB4,
+    tfRGB5A1,
+    tfA1RGB5,
+    tfRGBA8,
+    tfARGB8,
+    tfRGB10A2,
+    tfA2RGB10,
+    tfRGBA16,
+
+    tfBGRX4,
+    tfXBGR4,
+    tfB5G6R5,
+    tfBGR5X1,
+    tfX1BGR5,
+    tfBGR8,
+    tfBGRX8,
+    tfXBGR8,
+    tfBGR10X2,
+    tfX2BGR10,
+    tfBGR16,
+
+    tfBGRA4,
+    tfABGR4,
+    tfBGR5A1,
+    tfA1BGR5,
+    tfBGRA8,
+    tfABGR8,
+    tfBGR10A2,
+    tfA2BGR10,
+    tfBGRA16,
+
+    tfDepth16,
+    tfDepth24,
+    tfDepth32,
+
+    tfS3tcDtx1RGBA,
+    tfS3tcDtx3RGBA,
+    tfS3tcDtx5RGBA
+  );
+
+  TglBitmapFileType = (
+     {$IFDEF GLB_SUPPORT_PNG_WRITE} ftPNG,  {$ENDIF}
+     {$IFDEF GLB_SUPPORT_JPEG_WRITE}ftJPEG, {$ENDIF}
+     ftDDS,
+     ftTGA,
+     ftBMP);
+   TglBitmapFileTypes = set of TglBitmapFileType;
+
+   TglBitmapMipMap = (
+     mmNone,
+     mmMipmap,
+     mmMipmapGlu);
+
+   TglBitmapNormalMapFunc = (
+     nm4Samples,
+     nmSobel,
+     nm3x3,
+     nm5x5);
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+   EglBitmap                  = class(Exception);
+   EglBitmapNotSupported      = class(Exception);
+   EglBitmapSizeToLarge       = class(EglBitmap);
+   EglBitmapNonPowerOfTwo     = class(EglBitmap);
+   EglBitmapUnsupportedFormat = class(EglBitmap)
+   public
+     constructor Create(const aFormat: TglBitmapFormat); overload;
+     constructor Create(const aMsg: String; const aFormat: TglBitmapFormat); overload;
+   end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmapColorRec = packed record
+  case Integer of
+    0: (r, g, b, a: Cardinal);
+    1: (arr: array[0..3] of Cardinal);
+  end;
+
+  TglBitmapPixelData = packed record
+    Data, Range: TglBitmapColorRec;
+    Format: TglBitmapFormat;
+  end;
+  PglBitmapPixelData = ^TglBitmapPixelData;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmapPixelPositionFields = set of (ffX, ffY);
+  TglBitmapPixelPosition = record
+    Fields : TglBitmapPixelPositionFields;
+    X : Word;
+    Y : Word;
+  end;
+
+  TglBitmapFormatDescriptor = class(TObject)
+  protected
+    function GetIsCompressed: Boolean; virtual; abstract;
+    function GetHasRed:       Boolean; virtual; abstract;
+    function GetHasGreen:     Boolean; virtual; abstract;
+    function GetHasBlue:      Boolean; virtual; abstract;
+    function GetHasAlpha:     Boolean; virtual; abstract;
+
+    function GetRGBInverted:  TglBitmapFormat; virtual; abstract;
+    function GetWithAlpha:    TglBitmapFormat; virtual; abstract;
+    function GetWithoutAlpha: TglBitmapFormat; virtual; abstract;
+    function GetOpenGLFormat: TglBitmapFormat; virtual; abstract;
+    function GetUncompressed: TglBitmapFormat; virtual; abstract;
+
+    function GetglDataFormat:     GLenum;  virtual; abstract;
+    function GetglFormat:         GLenum;  virtual; abstract;
+    function GetglInternalFormat: GLenum;  virtual; abstract;
+  public
+    property IsCompressed: Boolean read GetIsCompressed;
+    property HasRed:       Boolean read GetHasRed;
+    property HasGreen:     Boolean read GetHasGreen;
+    property HasBlue:      Boolean read GetHasBlue;
+    property HasAlpha:     Boolean read GetHasAlpha;
+
+    property RGBInverted:  TglBitmapFormat read GetRGBInverted;
+    property WithAlpha:    TglBitmapFormat read GetWithAlpha;
+    property WithoutAlpha: TglBitmapFormat read GetWithoutAlpha;
+    property OpenGLFormat: TglBitmapFormat read GetOpenGLFormat;
+    property Uncompressed: TglBitmapFormat read GetUncompressed;
+
+    property glFormat:         GLenum  read GetglFormat;
+    property glInternalFormat: GLenum  read GetglInternalFormat;
+    property glDataFormat:     GLenum  read GetglDataFormat;
+  public
+    class function GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmap = class;
+  TglBitmapFunctionRec = record
+    Sender:   TglBitmap;
+    Size:     TglBitmapPixelPosition;
+    Position: TglBitmapPixelPosition;
+    Source:   TglBitmapPixelData;
+    Dest:     TglBitmapPixelData;
+    Args:     Pointer;
+  end;
+  TglBitmapFunction = procedure(var FuncRec: TglBitmapFunctionRec);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmap = class
+  private
+    function GetFormatDesc: TglBitmapFormatDescriptor;
+  protected
+    fID: GLuint;
+    fTarget: GLuint;
+    fAnisotropic: Integer;
+    fDeleteTextureOnFree: Boolean;
+    fFreeDataOnDestroy: Boolean;
+    fFreeDataAfterGenTexture: Boolean;
+    fData: PByte;
+    fIsResident: GLboolean;
+    fBorderColor: array[0..3] of Single;
+
+    fDimension: TglBitmapPixelPosition;
+    fMipMap: TglBitmapMipMap;
+    fFormat: TglBitmapFormat;
+
+    // Mapping
+    fPixelSize: Integer;
+    fRowSize: Integer;
+
+    // Filtering
+    fFilterMin: GLenum;
+    fFilterMag: GLenum;
+
+    // TexturWarp
+    fWrapS: GLenum;
+    fWrapT: GLenum;
+    fWrapR: GLenum;
+
+    //Swizzle
+    fSwizzle: array[0..3] of GLenum;
+
+    // CustomData
+    fFilename: String;
+    fCustomName: String;
+    fCustomNameW: WideString;
+    fCustomData: Pointer;
+
+    //Getter
+    function GetWidth:  Integer; virtual;
+    function GetHeight: Integer; virtual;
+
+    function GetFileWidth:  Integer; virtual;
+    function GetFileHeight: Integer; virtual;
+
+    //Setter
+    procedure SetCustomData(const aValue: Pointer);
+    procedure SetCustomName(const aValue: String);
+    procedure SetCustomNameW(const aValue: WideString);
+    procedure SetFreeDataOnDestroy(const aValue: Boolean);
+    procedure SetDeleteTextureOnFree(const aValue: Boolean);
+    procedure SetFormat(const aValue: TglBitmapFormat);
+    procedure SetFreeDataAfterGenTexture(const aValue: Boolean);
+    procedure SetID(const aValue: Cardinal);
+    procedure SetMipMap(const aValue: TglBitmapMipMap);
+    procedure SetTarget(const aValue: Cardinal);
+    procedure SetAnisotropic(const aValue: Integer);
+
+    procedure CreateID;
+    procedure SetupParameters(out aBuildWithGlu: Boolean);
+    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+      const aWidth: Integer = -1; const aHeight: Integer = -1); virtual;  //be careful, aData could be freed by this method
+    procedure GenTexture(const aTestTextureSize: Boolean = true); virtual; abstract;
+
+    function FlipHorz: Boolean; virtual;
+    function FlipVert: Boolean; virtual;
+
+    property Width:  Integer read GetWidth;
+    property Height: Integer read GetHeight;
+
+    property FileWidth:  Integer read GetFileWidth;
+    property FileHeight: Integer read GetFileHeight;
+  public
+    //Properties
+    property ID:           Cardinal        read fID          write SetID;
+    property Target:       Cardinal        read fTarget      write SetTarget;
+    property Format:       TglBitmapFormat read fFormat      write SetFormat;
+    property MipMap:       TglBitmapMipMap read fMipMap      write SetMipMap;
+    property Anisotropic:  Integer         read fAnisotropic write SetAnisotropic;
+
+    property FormatDesc:   TglBitmapFormatDescriptor read GetFormatDesc;
+
+    property Filename:    String     read fFilename;
+    property CustomName:  String     read fCustomName  write SetCustomName;
+    property CustomNameW: WideString read fCustomNameW write SetCustomNameW;
+    property CustomData:  Pointer    read fCustomData  write SetCustomData;
+
+    property DeleteTextureOnFree:     Boolean read fDeleteTextureOnFree     write SetDeleteTextureOnFree;
+    property FreeDataOnDestroy:       Boolean read fFreeDataOnDestroy       write SetFreeDataOnDestroy;
+    property FreeDataAfterGenTexture: Boolean read fFreeDataAfterGenTexture write SetFreeDataAfterGenTexture;
+
+    property Dimension:  TglBitmapPixelPosition  read fDimension;
+    property Data:       PByte                   read fData;
+    property IsResident: GLboolean               read fIsResident;
+
+    procedure AfterConstruction; override;
+    procedure BeforeDestruction; override;
+
+    procedure PrepareResType(var aResource: String; var aResType: PChar);
+
+    //Load
+    procedure LoadFromFile(const aFilename: String);
+    procedure LoadFromStream(const aStream: TStream); virtual;
+    procedure LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction;
+      const aFormat: TglBitmapFormat; const aArgs: Pointer = nil);
+    procedure LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil);
+    procedure LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
+
+    //Save
+    procedure SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType);
+    procedure SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType); virtual;
+
+    //Convert
+    function AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer = nil): Boolean; overload;
+    function AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
+      const aFormat: TglBitmapFormat; const aArgs: Pointer = nil): Boolean; overload;
+  public
+    //Alpha & Co
+    {$IFDEF GLB_SDL}
+    function AssignToSurface(out aSurface: PSDL_Surface): Boolean;
+    function AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
+    function AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
+    function AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil;
+      const aArgs: Pointer = nil): Boolean;
+    {$ENDIF}
+
+    {$IFDEF GLB_DELPHI}
+    function AssignToBitmap(const aBitmap: TBitmap): Boolean;
+    function AssignFromBitmap(const aBitmap: TBitmap): Boolean;
+    function AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
+    function AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction = nil;
+      const aArgs: Pointer = nil): Boolean;
+    {$ENDIF}
+
+    {$IFDEF GLB_LAZARUS}
+    function AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+    function AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
+    function AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+    function AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction = nil;
+      const aArgs: Pointer = nil): Boolean;
+    {$ENDIF}
+
+    function AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar = nil;
+      const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+    function AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar;
+      const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+
+    function AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer = nil): Boolean; virtual;
+    function AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+    function AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+    function AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+
+    function AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte = 0): Boolean;
+    function AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal = 0): Boolean;
+    function AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single = 0): Boolean;
+
+    function AddAlphaFromValue(const aAlpha: Byte): Boolean;
+    function AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
+    function AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
+
+    function RemoveAlpha: Boolean; virtual;
+  public
+    //Common
+    function Clone: TglBitmap;
+    function ConvertTo(const aFormat: TglBitmapFormat): Boolean; virtual;
+    procedure Invert(const aUseRGB: Boolean = true; const aUseAlpha: Boolean = false);
+    procedure SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
+    procedure FreeData;
+
+    //ColorFill
+    procedure FillWithColor(const aRed, aGreen, aBlue: Byte; const aAlpha: Byte = 255);
+    procedure FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal = $FFFFFFFF);
+    procedure FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha : Single = 1);
+
+    //TexParameters
+    procedure SetFilter(const aMin, aMag: GLenum);
+    procedure SetWrap(
+      const S: GLenum = GL_CLAMP_TO_EDGE;
+      const T: GLenum = GL_CLAMP_TO_EDGE;
+      const R: GLenum = GL_CLAMP_TO_EDGE);
+    procedure SetSwizzle(const r, g, b, a: GLenum);
+
+    procedure Bind(const aEnableTextureUnit: Boolean = true); virtual;
+    procedure Unbind(const aDisableTextureUnit: Boolean = true); virtual;
+
+    //Constructors
+    constructor Create; overload;
+    constructor Create(const aFileName: String); overload;
+    constructor Create(const aStream: TStream); overload;
+    constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte = nil); overload;
+    constructor Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer = nil); overload;
+    constructor Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar = nil); overload;
+    constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
+  private
+    {$IFDEF GLB_SUPPORT_PNG_READ}  function  LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF}
+    {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF}
+
+    {$IFDEF GLB_SUPPORT_JPEG_READ}  function  LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF}
+    {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF}
+
+    function LoadBMP(const aStream: TStream): Boolean; virtual;
+    procedure SaveBMP(const aStream: TStream); virtual;
+
+    function LoadTGA(const aStream: TStream): Boolean; virtual;
+    procedure SaveTGA(const aStream: TStream); virtual;
+
+    function LoadDDS(const aStream: TStream): Boolean; virtual;
+    procedure SaveDDS(const aStream: TStream); virtual;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmap1D = class(TglBitmap)
+  protected
+    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+      const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
+    procedure UploadData(const aBuildWithGlu: Boolean);
+  public
+    property Width;
+    procedure AfterConstruction; override;
+    function FlipHorz: Boolean; override;
+    procedure GenTexture(const aTestTextureSize: Boolean = true); override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmap2D = class(TglBitmap)
+  protected
+    fLines: array of PByte;
+    function GetScanline(const aIndex: Integer): Pointer;
+    procedure SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+      const aWidth: Integer = - 1; const aHeight: Integer = - 1); override;
+    procedure UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean);
+  public
+    property Width;
+    property Height;
+    property Scanline[const aIndex: Integer]: Pointer read GetScanline;
+
+    procedure AfterConstruction; override;
+
+    procedure GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);
+    procedure GetDataFromTexture;
+    procedure GenTexture(const aTestTextureSize: Boolean = true); override;
+
+    function FlipHorz: Boolean; override;
+    function FlipVert: Boolean; override;
+
+    procedure ToNormalMap(const aFunc: TglBitmapNormalMapFunc = nm3x3;
+      const aScale: Single = 2; const aUseAlpha: Boolean = false);
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmapCubeMap = class(TglBitmap2D)
+  protected
+    fGenMode: Integer;
+    procedure GenTexture(const aTestTextureSize: Boolean = true); reintroduce;
+  public
+    procedure AfterConstruction; override;
+    procedure GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean = true);
+    procedure Bind(const aEnableTexCoordsGen: Boolean = true; const aEnableTextureUnit: Boolean = true); reintroduce; virtual;
+    procedure Unbind(const aDisableTexCoordsGen: Boolean = true; const aDisableTextureUnit: Boolean = true); reintroduce; virtual;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglBitmapNormalMap = class(TglBitmapCubeMap)
+  public
+    procedure AfterConstruction; override;
+    procedure GenerateNormalMap(const aSize: Integer = 32; const aTestTextureSize: Boolean = true);
+  end;
+
+  TglcBitmapFormat    = TglBitmapFormat;
+  TglcBitmap1D        = TglBitmap1D;
+  TglcBitmap2D        = TglBitmap2D;
+  TglcBitmapCubeMap   = TglBitmapCubeMap;
+  TglcBitmapNormalMap = TglBitmapNormalMap;
+  
+const
+  NULL_SIZE: TglBitmapPixelPosition = (Fields: []; X: 0; Y: 0);
+
+procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
+procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
+procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
+procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
+procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
+procedure glBitmapSetDefaultWrap(
+  const S: Cardinal = GL_CLAMP_TO_EDGE;
+  const T: Cardinal = GL_CLAMP_TO_EDGE;
+  const R: Cardinal = GL_CLAMP_TO_EDGE);
+
+function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
+function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
+function glBitmapGetDefaultMipmap: TglBitmapMipMap;
+function glBitmapGetDefaultFormat: TglBitmapFormat;
+procedure glBitmapGetDefaultFilter(var aMin, aMag: Cardinal);
+procedure glBitmapGetDefaultTextureWrap(var S, T, R: Cardinal);
+
+function glBitmapPosition(X: Integer = -1; Y: Integer = -1): TglBitmapPixelPosition;
+function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec;
+function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean;
+
+var
+  glBitmapDefaultDeleteTextureOnFree: Boolean;
+  glBitmapDefaultFreeDataAfterGenTextures: Boolean;
+  glBitmapDefaultFormat: TglBitmapFormat;
+  glBitmapDefaultMipmap: TglBitmapMipMap;
+  glBitmapDefaultFilterMin: Cardinal;
+  glBitmapDefaultFilterMag: Cardinal;
+  glBitmapDefaultWrapS: Cardinal;
+  glBitmapDefaultWrapT: Cardinal;
+  glBitmapDefaultWrapR: Cardinal;
+  glDefaultSwizzle: array[0..3] of GLenum;
+
+{$IFDEF GLB_DELPHI}
+function CreateGrayPalette: HPALETTE;
+{$ENDIF}
+
+implementation
+
+uses
+  Math, syncobjs, typinfo
+  {$IF DEFINED(GLB_SUPPORT_JPEG_READ) AND DEFINED(GLB_LAZ_JPEG)}, FPReadJPEG{$IFEND};
+
+type
+{$IFNDEF fpc}
+  QWord   = System.UInt64;
+  PQWord  = ^QWord;
+
+  PtrInt  = Longint;
+  PtrUInt = DWord;
+{$ENDIF}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+  TShiftRec = packed record
+  case Integer of
+    0: (r, g, b, a: Byte);
+    1: (arr: array[0..3] of Byte);
+  end;
+
+  TFormatDescriptor = class(TglBitmapFormatDescriptor)
+  private
+    function GetRedMask: QWord;
+    function GetGreenMask: QWord;
+    function GetBlueMask: QWord;
+    function GetAlphaMask: QWord;
+  protected
+    fFormat: TglBitmapFormat;
+    fWithAlpha: TglBitmapFormat;
+    fWithoutAlpha: TglBitmapFormat;
+    fOpenGLFormat: TglBitmapFormat;
+    fRGBInverted: TglBitmapFormat;
+    fUncompressed: TglBitmapFormat;
+
+    fPixelSize: Single;
+    fIsCompressed: Boolean;
+
+    fRange: TglBitmapColorRec;
+    fShift: TShiftRec;
+
+    fglFormat:         GLenum;
+    fglInternalFormat: GLenum;
+    fglDataFormat:     GLenum;
+
+    function GetIsCompressed: Boolean; override;
+    function GetHasRed: Boolean; override;
+    function GetHasGreen: Boolean; override;
+    function GetHasBlue: Boolean; override;
+    function GetHasAlpha: Boolean; override;
+
+    function GetRGBInverted:  TglBitmapFormat; override;
+    function GetWithAlpha:    TglBitmapFormat; override;
+    function GetWithoutAlpha: TglBitmapFormat; override;
+    function GetOpenGLFormat: TglBitmapFormat; override;
+    function GetUncompressed: TglBitmapFormat; override;
+
+    function GetglFormat: GLenum; override;
+    function GetglInternalFormat: GLenum; override;
+    function GetglDataFormat: GLenum; override;
+
+    function GetComponents: Integer; virtual;
+  public
+    property Format:       TglBitmapFormat read fFormat;
+    property Components:   Integer         read GetComponents;
+    property PixelSize:    Single          read fPixelSize;
+
+    property Range: TglBitmapColorRec read fRange;
+    property Shift: TShiftRec         read fShift;
+
+    property RedMask:   QWord read GetRedMask;
+    property GreenMask: QWord read GetGreenMask;
+    property BlueMask:  QWord read GetBlueMask;
+    property AlphaMask: QWord read GetAlphaMask;
+
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract;
+
+    function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual;
+    function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
+
+    function CreateMappingData: Pointer; virtual;
+    procedure FreeMappingData(var aMappingData: Pointer); virtual;
+
+    function IsEmpty:  Boolean; virtual;
+    function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; virtual;
+
+    procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual;
+
+    constructor Create; virtual;
+  public
+    class procedure Init;
+    class function Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
+    class function GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
+    class procedure Clear;
+    class procedure Finalize;
+  end;
+  TFormatDescriptorClass = class of TFormatDescriptor;
+
+  TfdEmpty = class(TFormatDescriptor);
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdAlpha_UB1 = class(TFormatDescriptor) //1* unsigned byte
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdLuminance_UB1 = class(TFormatDescriptor) //1* unsigned byte
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdUniversal_UB1 = class(TFormatDescriptor) //1* unsigned byte
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdLuminanceAlpha_UB2 = class(TfdLuminance_UB1) //2* unsigned byte
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdRGB_UB3 = class(TFormatDescriptor) //3* unsigned byte
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdBGR_UB3 = class(TFormatDescriptor) //3* unsigned byte (inverse)
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdAlpha_US1 = class(TFormatDescriptor) //1* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdLuminance_US1 = class(TFormatDescriptor) //1* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdUniversal_US1 = class(TFormatDescriptor) //1* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdDepth_US1 = class(TFormatDescriptor) //1* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdLuminanceAlpha_US2 = class(TfdLuminance_US1) //2* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdRGB_US3 = class(TFormatDescriptor) //3* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdBGR_US3 = class(TFormatDescriptor) //3* unsigned short (inverse)
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdRGBA_US4 = class(TfdRGB_US3) //4* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdARGB_US4 = class(TfdRGB_US3) //4* unsigned short
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdBGRA_US4 = class(TfdBGR_US3) //4* unsigned short (inverse)
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdABGR_US4 = class(TfdBGR_US3) //4* unsigned short (inverse)
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdUniversal_UI1 = class(TFormatDescriptor) //1* unsigned int
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+  TfdDepth_UI1 = class(TFormatDescriptor) //1* unsigned int
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdAlpha4 = class(TfdAlpha_UB1)
+    constructor Create; override;
+  end;
+
+  TfdAlpha8 = class(TfdAlpha_UB1)
+    constructor Create; override;
+  end;
+
+  TfdAlpha16 = class(TfdAlpha_US1)
+    constructor Create; override;
+  end;
+
+  TfdLuminance4 = class(TfdLuminance_UB1)
+    constructor Create; override;
+  end;
+
+  TfdLuminance8 = class(TfdLuminance_UB1)
+    constructor Create; override;
+  end;
+
+  TfdLuminance16 = class(TfdLuminance_US1)
+    constructor Create; override;
+  end;
+
+  TfdLuminance4Alpha4 = class(TfdLuminanceAlpha_UB2)
+    constructor Create; override;
+  end;
+
+  TfdLuminance6Alpha2 = class(TfdLuminanceAlpha_UB2)
+    constructor Create; override;
+  end;
+
+  TfdLuminance8Alpha8 = class(TfdLuminanceAlpha_UB2)
+    constructor Create; override;
+  end;
+
+  TfdLuminance12Alpha4 = class(TfdLuminanceAlpha_US2)
+    constructor Create; override;
+  end;
+
+  TfdLuminance16Alpha16 = class(TfdLuminanceAlpha_US2)
+    constructor Create; override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdR3G3B2 = class(TfdUniversal_UB1)
+    constructor Create; override;
+  end;
+
+  TfdRGBX4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdXRGB4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdR5G6B5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGB5X1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdX1RGB5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGB8 = class(TfdRGB_UB3)
+    constructor Create; override;
+  end;
+
+  TfdRGBX8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdXRGB8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGB10X2 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdX2RGB10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGB16 = class(TfdRGB_US3)
+    constructor Create; override;
+  end;
+
+  TfdRGBA4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdARGB4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGB5A1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdA1RGB5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdRGBA8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdARGB8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGB10A2 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdA2RGB10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdRGBA16 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TfdBGRX4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdXBGR4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdB5G6R5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGR5X1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdX1BGR5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGR8 = class(TfdBGR_UB3)
+    constructor Create; override;
+  end;
+
+  TfdBGRX8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdXBGR8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGR10X2 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdX2BGR10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGR16 = class(TfdBGR_US3)
+    constructor Create; override;
+  end;
+
+  TfdBGRA4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdABGR4 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGR5A1 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdA1BGR5 = class(TfdUniversal_US1)
+    constructor Create; override;
+  end;
+
+  TfdBGRA8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdABGR8 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGR10A2 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdA2BGR10 = class(TfdUniversal_UI1)
+    constructor Create; override;
+  end;
+
+  TfdBGRA16 = class(TfdBGRA_US4)
+    constructor Create; override;
+  end;
+
+  TfdDepth16 = class(TfdDepth_US1)
+    constructor Create; override;
+  end;
+
+  TfdDepth24 = class(TfdDepth_UI1)
+    constructor Create; override;
+  end;
+
+  TfdDepth32 = class(TfdDepth_UI1)
+    constructor Create; override;
+  end;
+
+  TfdS3tcDtx1RGBA = class(TFormatDescriptor)
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+    constructor Create; override;
+  end;
+
+  TfdS3tcDtx3RGBA = class(TFormatDescriptor)
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+    constructor Create; override;
+  end;
+
+  TfdS3tcDtx5RGBA = class(TFormatDescriptor)
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+    constructor Create; override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TbmpBitfieldFormat = class(TFormatDescriptor)
+  private
+    procedure SetRedMask  (const aValue: QWord);
+    procedure SetGreenMask(const aValue: QWord);
+    procedure SetBlueMask (const aValue: QWord);
+    procedure SetAlphaMask(const aValue: QWord);
+
+    procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte);
+  public
+    property RedMask:   QWord read GetRedMask   write SetRedMask;
+    property GreenMask: QWord read GetGreenMask write SetGreenMask;
+    property BlueMask:  QWord read GetBlueMask  write SetBlueMask;
+    property AlphaMask: QWord read GetAlphaMask write SetAlphaMask;
+
+    property PixelSize: Single read fPixelSize write fPixelSize;
+
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TbmpColorTableEnty = packed record
+    b, g, r, a: Byte;
+  end;
+  TbmpColorTable = array of TbmpColorTableEnty;
+  TbmpColorTableFormat = class(TFormatDescriptor)
+  private
+    fColorTable: TbmpColorTable;
+  public
+    property PixelSize:  Single            read fPixelSize  write fPixelSize;
+    property ColorTable: TbmpColorTable    read fColorTable write fColorTable;
+    property Range:      TglBitmapColorRec read fRange      write fRange;
+    property Shift:      TShiftRec         read fShift      write fShift;
+    property Format:     TglBitmapFormat   read fFormat     write fFormat;
+
+    procedure CreateColorTable;
+
+    procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); override;
+    procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); override;
+    destructor Destroy; override;
+  end;
+
+const
+  LUMINANCE_WEIGHT_R = 0.30;
+  LUMINANCE_WEIGHT_G = 0.59;
+  LUMINANCE_WEIGHT_B = 0.11;
+
+  ALPHA_WEIGHT_R = 0.30;
+  ALPHA_WEIGHT_G = 0.59;
+  ALPHA_WEIGHT_B = 0.11;
+
+  DEPTH_WEIGHT_R = 0.333333333;
+  DEPTH_WEIGHT_G = 0.333333333;
+  DEPTH_WEIGHT_B = 0.333333333;
+
+  UNSUPPORTED_FORMAT = 'the given format isn''t supported by this function.';
+
+  FORMAT_DESCRIPTOR_CLASSES: array[TglBitmapFormat] of TFormatDescriptorClass = (
+    TfdEmpty,
+
+    TfdAlpha4,
+    TfdAlpha8,
+    TfdAlpha16,
+
+    TfdLuminance4,
+    TfdLuminance8,
+    TfdLuminance16,
+
+    TfdLuminance4Alpha4,
+    TfdLuminance6Alpha2,
+    TfdLuminance8Alpha8,
+    TfdLuminance12Alpha4,
+    TfdLuminance16Alpha16,
+
+    TfdR3G3B2,
+    TfdRGBX4,
+    TfdXRGB4,
+    TfdR5G6B5,
+    TfdRGB5X1,
+    TfdX1RGB5,
+    TfdRGB8,
+    TfdRGBX8,
+    TfdXRGB8,
+    TfdRGB10X2,
+    TfdX2RGB10,
+    TfdRGB16,
+
+    TfdRGBA4,
+    TfdARGB4,
+    TfdRGB5A1,
+    TfdA1RGB5,
+    TfdRGBA8,
+    TfdARGB8,
+    TfdRGB10A2,
+    TfdA2RGB10,
+    TfdRGBA16,
+
+    TfdBGRX4,
+    TfdXBGR4,
+    TfdB5G6R5,
+    TfdBGR5X1,
+    TfdX1BGR5,
+    TfdBGR8,
+    TfdBGRX8,
+    TfdXBGR8,
+    TfdBGR10X2,
+    TfdX2BGR10,
+    TfdBGR16,
+
+    TfdBGRA4,
+    TfdABGR4,
+    TfdBGR5A1,
+    TfdA1BGR5,
+    TfdBGRA8,
+    TfdABGR8,
+    TfdBGR10A2,
+    TfdA2BGR10,
+    TfdBGRA16,
+
+    TfdDepth16,
+    TfdDepth24,
+    TfdDepth32,
+
+    TfdS3tcDtx1RGBA,
+    TfdS3tcDtx3RGBA,
+    TfdS3tcDtx5RGBA
+  );
+
+var
+  FormatDescriptorCS: TCriticalSection;
+  FormatDescriptors: array[TglBitmapFormat] of TFormatDescriptor;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EglBitmapUnsupportedFormat.Create(const aFormat: TglBitmapFormat);
+begin
+  inherited Create('unsupported format: ' + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EglBitmapUnsupportedFormat.Create(const aMsg: String; const aFormat: TglBitmapFormat);
+begin
+  inherited Create(aMsg + GetEnumName(TypeInfo(TglBitmapFormat), Integer(aFormat)));
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapPosition(X, Y: Integer): TglBitmapPixelPosition;
+begin
+  result.Fields := [];
+
+  if X >= 0 then
+    result.Fields := result.Fields + [ffX];
+  if Y >= 0 then
+    result.Fields := result.Fields + [ffY];
+
+  result.X := Max(0, X);
+  result.Y := Max(0, Y);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapColorRec(const r, g, b, a: Cardinal): TglBitmapColorRec;
+begin
+  result.r := r;
+  result.g := g;
+  result.b := b;
+  result.a := a;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapColorRecCmp(const r1, r2: TglBitmapColorRec): Boolean;
+var
+  i: Integer;
+begin
+  result := false;
+  for i := 0 to high(r1.arr) do
+    if (r1.arr[i] <> r2.arr[i]) then
+      exit;
+  result := true;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapShiftRec(const r, g, b, a: Byte): TShiftRec;
+begin
+  result.r := r;
+  result.g := g;
+  result.b := b;
+  result.a := a;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function FormatGetSupportedFiles(const aFormat: TglBitmapFormat): TglBitmapFileTypes;
+begin
+  result := [];
+
+  if (aFormat in [
+        //4 bbp
+        tfLuminance4,
+
+        //8bpp
+        tfR3G3B2, tfLuminance8,
+
+        //16bpp
+        tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
+        tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4,
+
+        //24bpp
+        tfBGR8, tfRGB8,
+
+        //32bpp
+        tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8,
+        tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8]) then
+    result := result + [ftBMP];
+
+  if (aFormat in [
+        //8 bpp
+        tfLuminance8, tfAlpha8,
+
+        //16 bpp
+        tfLuminance16, tfLuminance8Alpha8,
+        tfRGB5X1, tfX1RGB5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
+        tfBGR5X1, tfX1BGR5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4,
+
+        //24 bpp
+        tfRGB8, tfBGR8,
+
+        //32 bpp
+        tfRGB10A2, tfRGBA8, tfBGR10A2, tfBGRA8]) then
+    result := result + [ftTGA];
+
+  if (aFormat in [
+        //8 bpp
+        tfAlpha8, tfLuminance8, tfLuminance4Alpha4, tfLuminance6Alpha2,
+        tfR3G3B2,
+
+        //16 bpp
+        tfAlpha16, tfLuminance16, tfLuminance8Alpha8, tfLuminance12Alpha4,
+        tfRGBX4, tfXRGB4, tfR5G6B5, tfRGB5X1, tfX1RGB5, tfRGBA4, tfARGB4, tfRGB5A1, tfA1RGB5,
+        tfBGRX4, tfXBGR4, tfB5G6R5, tfBGR5X1, tfX1BGR5, tfBGRA4, tfABGR4, tfBGR5A1, tfA1BGR5,
+
+        //24 bpp
+        tfRGB8, tfBGR8,
+
+        //32 bbp
+        tfLuminance16Alpha16,
+        tfRGBA8, tfRGB10A2,
+        tfBGRA8, tfBGR10A2,
+
+        //compressed
+        tfS3tcDtx1RGBA, tfS3tcDtx3RGBA, tfS3tcDtx5RGBA]) then
+    result := result + [ftDDS];
+
+  {$IFDEF GLB_SUPPORT_PNG_WRITE}
+  if aFormat in [
+      tfAlpha8, tfLuminance8, tfLuminance8Alpha8,
+      tfRGB8, tfRGBA8,
+      tfBGR8, tfBGRA8] then
+    result := result + [ftPNG];
+  {$ENDIF}
+
+  {$IFDEF GLB_SUPPORT_JPEG_WRITE}
+  if aFormat in [tfAlpha8, tfLuminance8, tfRGB8, tfBGR8] then
+    result := result + [ftJPEG];
+  {$ENDIF}
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function IsPowerOfTwo(aNumber: Integer): Boolean;
+begin
+  while (aNumber and 1) = 0 do
+    aNumber := aNumber shr 1;
+  result := aNumber = 1;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function GetTopMostBit(aBitSet: QWord): Integer;
+begin
+  result := 0;
+  while aBitSet > 0 do begin
+    inc(result);
+    aBitSet := aBitSet shr 1;
+  end;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function CountSetBits(aBitSet: QWord): Integer;
+begin
+  result := 0;
+  while aBitSet > 0 do begin
+    if (aBitSet and 1) = 1 then
+      inc(result);
+    aBitSet := aBitSet shr 1;
+  end;
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function LuminanceWeight(const aPixel: TglBitmapPixelData): Cardinal;
+begin
+  result := Trunc(
+    LUMINANCE_WEIGHT_R * aPixel.Data.r +
+    LUMINANCE_WEIGHT_G * aPixel.Data.g +
+    LUMINANCE_WEIGHT_B * aPixel.Data.b);
+end;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function DepthWeight(const aPixel: TglBitmapPixelData): Cardinal;
+begin
+  result := Trunc(
+    DEPTH_WEIGHT_R * aPixel.Data.r +
+    DEPTH_WEIGHT_G * aPixel.Data.g +
+    DEPTH_WEIGHT_B * aPixel.Data.b);
+end;
+
+{$IFDEF GLB_NATIVE_OGL}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//OpenGLInitialization///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+var
+  GL_LibHandle: Pointer = nil;
+
+function glbGetProcAddress(aProcName: PAnsiChar; aLibHandle: Pointer = nil; const aRaiseOnErr: Boolean = true): Pointer;
+begin
+  if not Assigned(aLibHandle) then
+    aLibHandle := GL_LibHandle;
+
+{$IF DEFINED(GLB_WIN)}
+  result := GetProcAddress({%H-}HMODULE(aLibHandle), aProcName);
+  if Assigned(result) then
+    exit;
+
+  if Assigned(wglGetProcAddress) then
+    result := wglGetProcAddress(aProcName);
+{$ELSEIF DEFINED(GLB_LINUX)}
+  if Assigned(glXGetProcAddress) then begin
+    result := glXGetProcAddress(aProcName);
+    if Assigned(result) then
+      exit;
+  end;
+
+  if Assigned(glXGetProcAddressARB) then begin
+    result := glXGetProcAddressARB(aProcName);
+    if Assigned(result) then
+      exit;
+  end;
+
+  result := dlsym(aLibHandle, aProcName);
+{$IFEND}
+  if not Assigned(result) and aRaiseOnErr then
+    raise EglBitmap.Create('unable to load procedure form library: ' + aProcName);
+end;
+
+{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
+var
+  GLU_LibHandle: Pointer = nil;
+  OpenGLInitialized: Boolean;
+  InitOpenGLCS: TCriticalSection;
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glbInitOpenGL;
+
+  ////////////////////////////////////////////////////////////////////////////////
+  function glbLoadLibrary(const aName: PChar): Pointer;
+  begin
+    {$IF DEFINED(GLB_WIN)}
+    result := {%H-}Pointer(LoadLibrary(aName));
+    {$ELSEIF DEFINED(GLB_LINUX)}
+    result := dlopen(Name, RTLD_LAZY);
+    {$ELSE}
+    result := nil;
+    {$IFEND}
+  end;
+
+  ////////////////////////////////////////////////////////////////////////////////
+  function glbFreeLibrary(const aLibHandle: Pointer): Boolean;
+  begin
+    result := false;
+    if not Assigned(aLibHandle) then
+      exit;
+
+    {$IF DEFINED(GLB_WIN)}
+    Result := FreeLibrary({%H-}HINST(aLibHandle));
+    {$ELSEIF DEFINED(GLB_LINUX)}
+    Result := dlclose(aLibHandle) = 0;
+    {$IFEND}
+  end;
+
+begin
+  if Assigned(GL_LibHandle) then
+    glbFreeLibrary(GL_LibHandle);
+
+  if Assigned(GLU_LibHandle) then
+    glbFreeLibrary(GLU_LibHandle);
+
+  GL_LibHandle := glbLoadLibrary(libopengl);
+  if not Assigned(GL_LibHandle) then
+    raise EglBitmap.Create('unable to load library: ' + libopengl);
+
+  GLU_LibHandle := glbLoadLibrary(libglu);
+  if not Assigned(GLU_LibHandle) then
+    raise EglBitmap.Create('unable to load library: ' + libglu);
+
+{$IF DEFINED(GLB_WIN)}
+  wglGetProcAddress    := glbGetProcAddress('wglGetProcAddress');
+{$ELSEIF DEFINED(GLB_LINUX)}
+  glXGetProcAddress    := glbGetProcAddress('glXGetProcAddress');
+  glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB');
+{$IFEND}
+
+  glEnable := glbGetProcAddress('glEnable');
+  glDisable := glbGetProcAddress('glDisable');
+  glGetString := glbGetProcAddress('glGetString');
+  glGetIntegerv := glbGetProcAddress('glGetIntegerv');
+  glTexParameteri := glbGetProcAddress('glTexParameteri');
+  glTexParameteriv := glbGetProcAddress('glTexParameteriv');
+  glTexParameterfv := glbGetProcAddress('glTexParameterfv');
+  glGetTexParameteriv := glbGetProcAddress('glGetTexParameteriv');
+  glGetTexParameterfv := glbGetProcAddress('glGetTexParameterfv');
+  glGetTexLevelParameteriv := glbGetProcAddress('glGetTexLevelParameteriv');
+  glGetTexLevelParameterfv := glbGetProcAddress('glGetTexLevelParameterfv');
+  glTexGeni := glbGetProcAddress('glTexGeni');
+  glGenTextures := glbGetProcAddress('glGenTextures');
+  glBindTexture := glbGetProcAddress('glBindTexture');
+  glDeleteTextures := glbGetProcAddress('glDeleteTextures');
+  glAreTexturesResident := glbGetProcAddress('glAreTexturesResident');
+  glReadPixels := glbGetProcAddress('glReadPixels');
+  glPixelStorei := glbGetProcAddress('glPixelStorei');
+  glTexImage1D := glbGetProcAddress('glTexImage1D');
+  glTexImage2D := glbGetProcAddress('glTexImage2D');
+  glGetTexImage := glbGetProcAddress('glGetTexImage');
+
+  gluBuild1DMipmaps := glbGetProcAddress('gluBuild1DMipmaps', GLU_LibHandle);
+  gluBuild2DMipmaps := glbGetProcAddress('gluBuild2DMipmaps', GLU_LibHandle);
+end;
+{$ENDIF}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glbReadOpenGLExtensions;
+var
+  Buffer: AnsiString;
+  MajorVersion, MinorVersion: Integer;
+
+  ///////////////////////////////////////////////////////////////////////////////////////////
+  procedure TrimVersionString(aBuffer: AnsiString; out aMajor, aMinor: Integer);
+  var
+    Separator: Integer;
+  begin
+    aMinor := 0;
+    aMajor := 0;
+
+    Separator := Pos(AnsiString('.'), aBuffer);
+    if (Separator > 1) and (Separator < Length(aBuffer)) and
+       (aBuffer[Separator - 1] in ['0'..'9']) and
+       (aBuffer[Separator + 1] in ['0'..'9']) then begin
+
+      Dec(Separator);
+      while (Separator > 0) and (aBuffer[Separator] in ['0'..'9']) do
+        Dec(Separator);
+
+      Delete(aBuffer, 1, Separator);
+      Separator := Pos(AnsiString('.'), aBuffer) + 1;
+
+      while (Separator <= Length(aBuffer)) and (AnsiChar(aBuffer[Separator]) in ['0'..'9']) do
+        Inc(Separator);
+
+      Delete(aBuffer, Separator, 255);
+      Separator := Pos(AnsiString('.'), aBuffer);
+
+      aMajor := StrToInt(Copy(String(aBuffer), 1, Separator - 1));
+      aMinor := StrToInt(Copy(String(aBuffer), Separator + 1, 1));
+    end;
+  end;
+
+  ///////////////////////////////////////////////////////////////////////////////////////////
+  function CheckExtension(const Extension: AnsiString): Boolean;
+  var
+    ExtPos: Integer;
+  begin
+    ExtPos := Pos(Extension, Buffer);
+    result := ExtPos > 0;
+    if result then
+      result := ((ExtPos + Length(Extension) - 1) = Length(Buffer)) or not (Buffer[ExtPos + Length(Extension)] in ['_', 'A'..'Z', 'a'..'z']);
+  end;
+
+  ///////////////////////////////////////////////////////////////////////////////////////////
+  function CheckVersion(const aMajor, aMinor: Integer): Boolean;
+  begin
+    result := (MajorVersion > aMajor) or ((MajorVersion = aMajor) and (MinorVersion >= aMinor));
+  end;
+
+begin
+{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
+  InitOpenGLCS.Enter;
+  try
+    if not OpenGLInitialized then begin
+      glbInitOpenGL;
+      OpenGLInitialized := true;
+    end;
+  finally
+    InitOpenGLCS.Leave;
+  end;
+{$ENDIF}
+
+  // Version
+  Buffer := glGetString(GL_VERSION);
+  TrimVersionString(Buffer, MajorVersion, MinorVersion);
+
+  GL_VERSION_1_2 := CheckVersion(1, 2);
+  GL_VERSION_1_3 := CheckVersion(1, 3);
+  GL_VERSION_1_4 := CheckVersion(1, 4);
+  GL_VERSION_2_0 := CheckVersion(2, 0);
+  GL_VERSION_3_3 := CheckVersion(3, 3);
+
+  // Extensions
+  Buffer := glGetString(GL_EXTENSIONS);
+  GL_ARB_texture_border_clamp       := CheckExtension('GL_ARB_texture_border_clamp');
+  GL_ARB_texture_non_power_of_two   := CheckExtension('GL_ARB_texture_non_power_of_two');
+  GL_ARB_texture_swizzle            := CheckExtension('GL_ARB_texture_swizzle');
+  GL_ARB_texture_cube_map           := CheckExtension('GL_ARB_texture_cube_map');
+  GL_ARB_texture_rectangle          := CheckExtension('GL_ARB_texture_rectangle');
+  GL_ARB_texture_mirrored_repeat    := CheckExtension('GL_ARB_texture_mirrored_repeat');
+  GL_EXT_texture_edge_clamp         := CheckExtension('GL_EXT_texture_edge_clamp');
+  GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');
+  GL_EXT_texture_rectangle          := CheckExtension('GL_EXT_texture_rectangle');
+  GL_EXT_texture_swizzle            := CheckExtension('GL_EXT_texture_swizzle');
+  GL_EXT_texture_cube_map           := CheckExtension('GL_EXT_texture_cube_map');
+  GL_NV_texture_rectangle           := CheckExtension('GL_NV_texture_rectangle');
+  GL_IBM_texture_mirrored_repeat    := CheckExtension('GL_IBM_texture_mirrored_repeat');
+  GL_SGIS_generate_mipmap           := CheckExtension('GL_SGIS_generate_mipmap');
+
+  if GL_VERSION_1_3 then begin
+    glCompressedTexImage1D  := glbGetProcAddress('glCompressedTexImage1D');
+    glCompressedTexImage2D  := glbGetProcAddress('glCompressedTexImage2D');
+    glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage');
+  end else begin
+    glCompressedTexImage1D  := glbGetProcAddress('glCompressedTexImage1DARB',  nil, false);
+    glCompressedTexImage2D  := glbGetProcAddress('glCompressedTexImage2DARB',  nil, false);
+    glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB', nil, false);
+  end;
+end;
+{$ENDIF}
+
+{$IFDEF GLB_SDL_IMAGE}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
+begin
+  result := TStream(context^.unknown.data1).Seek(offset, whence);
+end;
+
+function glBitmapRWread(context: PSDL_RWops; Ptr: Pointer; size: Integer; maxnum : Integer): Integer; cdecl;
+begin
+  result := TStream(context^.unknown.data1).Read(Ptr^, size * maxnum);
+end;
+
+function glBitmapRWwrite(context: PSDL_RWops; Ptr: Pointer; size: Integer; num: Integer): Integer; cdecl;
+begin
+  result := TStream(context^.unknown.data1).Write(Ptr^, size * num);
+end;
+
+function glBitmapRWclose(context: PSDL_RWops): Integer; cdecl;
+begin
+  result := 0;
+end;
+
+function glBitmapCreateRWops(Stream: TStream): PSDL_RWops;
+begin
+  result := SDL_AllocRW;
+
+  if result = nil then
+    raise EglBitmapException.Create('glBitmapCreateRWops - SDL_AllocRW failed.');
+
+  result^.seek := glBitmapRWseek;
+  result^.read := glBitmapRWread;
+  result^.write := glBitmapRWwrite;
+  result^.close := glBitmapRWclose;
+  result^.unknown.data1 := Stream;
+end;
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultDeleteTextureOnFree(const aDeleteTextureOnFree: Boolean);
+begin
+  glBitmapDefaultDeleteTextureOnFree := aDeleteTextureOnFree;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFreeDataAfterGenTexture(const aFreeData: Boolean);
+begin
+  glBitmapDefaultFreeDataAfterGenTextures := aFreeData;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultMipmap(const aValue: TglBitmapMipMap);
+begin
+  glBitmapDefaultMipmap := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFormat(const aFormat: TglBitmapFormat);
+begin
+  glBitmapDefaultFormat := aFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultFilter(const aMin, aMag: Integer);
+begin
+  glBitmapDefaultFilterMin := aMin;
+  glBitmapDefaultFilterMag := aMag;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultWrap(const S: Cardinal = GL_CLAMP_TO_EDGE; const T: Cardinal = GL_CLAMP_TO_EDGE; const R: Cardinal = GL_CLAMP_TO_EDGE);
+begin
+  glBitmapDefaultWrapS := S;
+  glBitmapDefaultWrapT := T;
+  glBitmapDefaultWrapR := R;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapSetDefaultSwizzle(const r: GLenum = GL_RED; g: GLenum = GL_GREEN; b: GLenum = GL_BLUE; a: GLenum = GL_ALPHA);
+begin
+  glDefaultSwizzle[0] := r;
+  glDefaultSwizzle[1] := g;
+  glDefaultSwizzle[2] := b;
+  glDefaultSwizzle[3] := a;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultDeleteTextureOnFree: Boolean;
+begin
+  result := glBitmapDefaultDeleteTextureOnFree;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultFreeDataAfterGenTexture: Boolean;
+begin
+  result := glBitmapDefaultFreeDataAfterGenTextures;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultMipmap: TglBitmapMipMap;
+begin
+  result := glBitmapDefaultMipmap;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmapGetDefaultFormat: TglBitmapFormat;
+begin
+  result := glBitmapDefaultFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultFilter(var aMin, aMag: GLenum);
+begin
+  aMin := glBitmapDefaultFilterMin;
+  aMag := glBitmapDefaultFilterMag;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultTextureWrap(var S, T, R: GLenum);
+begin
+  S := glBitmapDefaultWrapS;
+  T := glBitmapDefaultWrapT;
+  R := glBitmapDefaultWrapR;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapGetDefaultSwizzle(var r, g, b, a: GLenum);
+begin
+  r := glDefaultSwizzle[0];
+  g := glDefaultSwizzle[1];
+  b := glDefaultSwizzle[2];
+  a := glDefaultSwizzle[3];
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetRedMask: QWord;
+begin
+  result := fRange.r shl fShift.r;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetGreenMask: QWord;
+begin
+  result := fRange.g shl fShift.g;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetBlueMask: QWord;
+begin
+  result := fRange.b shl fShift.b;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetAlphaMask: QWord;
+begin
+  result := fRange.a shl fShift.a;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetIsCompressed: Boolean;
+begin
+  result := fIsCompressed;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetHasRed: Boolean;
+begin
+  result := (fRange.r > 0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetHasGreen: Boolean;
+begin
+  result := (fRange.g > 0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetHasBlue: Boolean;
+begin
+  result := (fRange.b > 0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetHasAlpha: Boolean;
+begin
+  result := (fRange.a > 0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetRGBInverted: TglBitmapFormat;
+begin
+  result := fRGBInverted;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetWithAlpha: TglBitmapFormat;
+begin
+  result := fWithAlpha;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetWithoutAlpha: TglBitmapFormat;
+begin
+  result := fWithoutAlpha;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetOpenGLFormat: TglBitmapFormat;
+begin
+  result := fOpenGLFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetUncompressed: TglBitmapFormat;
+begin
+  result := fUncompressed;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetglFormat: GLenum;
+begin
+  result := fglFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetglInternalFormat: GLenum;
+begin
+  result := fglInternalFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetglDataFormat: GLenum;
+begin
+  result := fglDataFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetComponents: Integer;
+var
+  i: Integer;
+begin
+  result := 0;
+  for i := 0 to 3 do
+    if (fRange.arr[i] > 0) then
+      inc(result);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetSize(const aSize: TglBitmapPixelPosition): Integer;
+var
+  w, h: Integer;
+begin
+  if (ffX in aSize.Fields) or (ffY in aSize.Fields) then begin
+    w := Max(1, aSize.X);
+    h := Max(1, aSize.Y);
+    result := GetSize(w, h);
+  end else
+    result := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.GetSize(const aWidth, aHeight: Integer): Integer;
+begin
+  result := 0;
+  if (aWidth <= 0) or (aHeight <= 0) then
+    exit;
+  result := Ceil(aWidth * aHeight * fPixelSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.CreateMappingData: Pointer;
+begin
+  result := nil;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TFormatDescriptor.FreeMappingData(var aMappingData: Pointer);
+begin
+  //DUMMY
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.IsEmpty: Boolean;
+begin
+  result := (fFormat = tfEmpty);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean;
+begin
+  result := false;
+  if (aRedMask = 0) and (aGreenMask = 0) and (aBlueMask = 0) and (aAlphaMask = 0) then
+    raise EglBitmap.Create('FormatCheckFormat - All Masks are 0');
+  if (aRedMask   <> RedMask) then
+    exit;
+  if (aGreenMask <> GreenMask) then
+    exit;
+  if (aBlueMask  <> BlueMask) then
+    exit;
+  if (aAlphaMask <> AlphaMask) then
+    exit;
+  result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TFormatDescriptor.PreparePixel(out aPixel: TglBitmapPixelData);
+begin
+  FillChar(aPixel{%H-}, SizeOf(aPixel), 0);
+  aPixel.Data   := fRange;
+  aPixel.Range  := fRange;
+  aPixel.Format := fFormat;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TFormatDescriptor.Create;
+begin
+  inherited Create;
+
+  fFormat       := tfEmpty;
+  fWithAlpha    := tfEmpty;
+  fWithoutAlpha := tfEmpty;
+  fOpenGLFormat := tfEmpty;
+  fRGBInverted  := tfEmpty;
+  fUncompressed := tfEmpty;
+
+  fPixelSize    := 0.0;
+  fIsCompressed := false;
+
+  fglFormat         := 0;
+  fglInternalFormat := 0;
+  fglDataFormat     := 0;
+
+  FillChar(fRange, 0, SizeOf(fRange));
+  FillChar(fShift, 0, SizeOf(fShift));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdAlpha_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdAlpha_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  aData^ := aPixel.Data.a;
+  inc(aData);
+end;
+
+procedure TfdAlpha_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := 0;
+  aPixel.Data.g := 0;
+  aPixel.Data.b := 0;
+  aPixel.Data.a := aData^;
+  inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminance_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  aData^ := LuminanceWeight(aPixel);
+  inc(aData);
+end;
+
+procedure TfdLuminance_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := aData^;
+  aPixel.Data.g := aData^;
+  aPixel.Data.b := aData^;
+  aPixel.Data.a := 0;
+  inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_UB1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdUniversal_UB1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  aData^ := 0;
+  for i := 0 to 3 do
+    if (fRange.arr[i] > 0) then
+      aData^ := aData^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
+  inc(aData);
+end;
+
+procedure TfdUniversal_UB1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  for i := 0 to 3 do
+    aPixel.Data.arr[i] := (aData^ shr fShift.arr[i]) and fRange.arr[i];
+  inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminanceAlpha_UB2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminanceAlpha_UB2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  inherited Map(aPixel, aData, aMapData);
+  aData^ := aPixel.Data.a;
+  inc(aData);
+end;
+
+procedure TfdLuminanceAlpha_UB2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := aData^;
+  inc(aData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGB_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGB_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  aData^ := aPixel.Data.b;
+  inc(aData);
+  aData^ := aPixel.Data.g;
+  inc(aData);
+  aData^ := aPixel.Data.r;
+  inc(aData);
+end;
+
+procedure TfdRGB_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.b := aData^;
+  inc(aData);
+  aPixel.Data.g := aData^;
+  inc(aData);
+  aPixel.Data.r := aData^;
+  inc(aData);
+  aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGR_UB3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGR_UB3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  aData^ := aPixel.Data.r;
+  inc(aData);
+  aData^ := aPixel.Data.g;
+  inc(aData);
+  aData^ := aPixel.Data.b;
+  inc(aData);
+end;
+
+procedure TfdBGR_UB3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := aData^;
+  inc(aData);
+  aPixel.Data.g := aData^;
+  inc(aData);
+  aPixel.Data.b := aData^;
+  inc(aData);
+  aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdAlpha_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdAlpha_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+end;
+
+procedure TfdAlpha_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := 0;
+  aPixel.Data.g := 0;
+  aPixel.Data.b := 0;
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminance_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminance_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := LuminanceWeight(aPixel);
+  inc(aData, 2);
+end;
+
+procedure TfdLuminance_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PWord(aData)^;
+  aPixel.Data.g := PWord(aData)^;
+  aPixel.Data.b := PWord(aData)^;
+  aPixel.Data.a := 0;
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdUniversal_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  PWord(aData)^ := 0;
+  for i := 0 to 3 do
+    if (fRange.arr[i] > 0) then
+      PWord(aData)^ := PWord(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
+  inc(aData, 2);
+end;
+
+procedure TfdUniversal_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  for i := 0 to 3 do
+    aPixel.Data.arr[i] := (PWord(aData)^ shr fShift.arr[i]) and fRange.arr[i];
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdDepth_US1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdDepth_US1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := DepthWeight(aPixel);
+  inc(aData, 2);
+end;
+
+procedure TfdDepth_US1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PWord(aData)^;
+  aPixel.Data.g := PWord(aData)^;
+  aPixel.Data.b := PWord(aData)^;
+  aPixel.Data.a := PWord(aData)^;;
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdLuminanceAlpha_US2///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdLuminanceAlpha_US2.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  inherited Map(aPixel, aData, aMapData);
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+end;
+
+procedure TfdLuminanceAlpha_US2.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGB_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGB_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := aPixel.Data.b;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.g;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.r;
+  inc(aData, 2);
+end;
+
+procedure TfdRGB_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.b := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.g := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.r := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGR_US3//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGR_US3.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := aPixel.Data.r;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.g;
+  inc(aData, 2);
+  PWord(aData)^ := aPixel.Data.b;
+  inc(aData, 2);
+end;
+
+procedure TfdBGR_US3.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.g := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.b := PWord(aData)^;
+  inc(aData, 2);
+  aPixel.Data.a := 0;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdRGBA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdRGBA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+  inherited Map(aPixel, aData, aMapData);
+end;
+
+procedure TfdRGBA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+  inherited Unmap(aData, aPixel, aMapData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdARGB_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdARGB_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  inherited Map(aPixel, aData, aMapData);
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+end;
+
+procedure TfdARGB_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdBGRA_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdBGRA_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+  inherited Map(aPixel, aData, aMapData);
+end;
+
+procedure TfdBGRA_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+  inherited Unmap(aData, aPixel, aMapData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdABGR_US4/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdABGR_US4.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  inherited Map(aPixel, aData, aMapData);
+  PWord(aData)^ := aPixel.Data.a;
+  inc(aData, 2);
+end;
+
+procedure TfdABGR_US4.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  inherited Unmap(aData, aPixel, aMapData);
+  aPixel.Data.a := PWord(aData)^;
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdUniversal_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdUniversal_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  PCardinal(aData)^ := 0;
+  for i := 0 to 3 do
+    if (fRange.arr[i] > 0) then
+      PCardinal(aData)^ := PCardinal(aData)^ or ((aPixel.Data.arr[i] and fRange.arr[i]) shl fShift.arr[i]);
+  inc(aData, 4);
+end;
+
+procedure TfdUniversal_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+  i: Integer;
+begin
+  for i := 0 to 3 do
+    aPixel.Data.arr[i] := (PCardinal(aData)^ shr fShift.arr[i]) and fRange.arr[i];
+  inc(aData, 2);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdDepth_UI1////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdDepth_UI1.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  PCardinal(aData)^ := DepthWeight(aPixel);
+  inc(aData, 4);
+end;
+
+procedure TfdDepth_UI1.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  aPixel.Data.r := PCardinal(aData)^;
+  aPixel.Data.g := PCardinal(aData)^;
+  aPixel.Data.b := PCardinal(aData)^;
+  aPixel.Data.a := 0;
+  inc(aData, 4);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TfdAlpha4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 1.0;
+  fFormat           := tfAlpha4;
+  fWithAlpha        := tfAlpha4;
+  fOpenGLFormat     := tfAlpha4;
+  fRange.a          := $FF;
+  fglFormat         := GL_ALPHA;
+  fglInternalFormat := GL_ALPHA4;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdAlpha8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 1.0;
+  fFormat           := tfAlpha8;
+  fWithAlpha        := tfAlpha8;
+  fOpenGLFormat     := tfAlpha8;
+  fRange.a          := $FF;
+  fglFormat         := GL_ALPHA;
+  fglInternalFormat := GL_ALPHA8;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdAlpha16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfAlpha16;
+  fWithAlpha        := tfAlpha16;
+  fOpenGLFormat     := tfAlpha16;
+  fRange.a          := $FFFF;
+  fglFormat         := GL_ALPHA;
+  fglInternalFormat := GL_ALPHA16;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdLuminance4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 1.0;
+  fFormat           := tfLuminance4;
+  fWithAlpha        := tfLuminance4Alpha4;
+  fWithoutAlpha     := tfLuminance4;
+  fOpenGLFormat     := tfLuminance4;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fglFormat         := GL_LUMINANCE;
+  fglInternalFormat := GL_LUMINANCE4;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdLuminance8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 1.0;
+  fFormat           := tfLuminance8;
+  fWithAlpha        := tfLuminance8Alpha8;
+  fWithoutAlpha     := tfLuminance8;
+  fOpenGLFormat     := tfLuminance8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fglFormat         := GL_LUMINANCE;
+  fglInternalFormat := GL_LUMINANCE8;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdLuminance16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfLuminance16;
+  fWithAlpha        := tfLuminance16Alpha16;
+  fWithoutAlpha     := tfLuminance16;
+  fOpenGLFormat     := tfLuminance16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fglFormat         := GL_LUMINANCE;
+  fglInternalFormat := GL_LUMINANCE16;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdLuminance4Alpha4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfLuminance4Alpha4;
+  fWithAlpha        := tfLuminance4Alpha4;
+  fWithoutAlpha     := tfLuminance4;
+  fOpenGLFormat     := tfLuminance4Alpha4;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 8;
+  fglFormat         := GL_LUMINANCE_ALPHA;
+  fglInternalFormat := GL_LUMINANCE4_ALPHA4;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdLuminance6Alpha2.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfLuminance6Alpha2;
+  fWithAlpha        := tfLuminance6Alpha2;
+  fWithoutAlpha     := tfLuminance8;
+  fOpenGLFormat     := tfLuminance6Alpha2;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 8;
+  fglFormat         := GL_LUMINANCE_ALPHA;
+  fglInternalFormat := GL_LUMINANCE6_ALPHA2;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdLuminance8Alpha8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfLuminance8Alpha8;
+  fWithAlpha        := tfLuminance8Alpha8;
+  fWithoutAlpha     := tfLuminance8;
+  fOpenGLFormat     := tfLuminance8Alpha8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 8;
+  fglFormat         := GL_LUMINANCE_ALPHA;
+  fglInternalFormat := GL_LUMINANCE8_ALPHA8;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdLuminance12Alpha4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfLuminance12Alpha4;
+  fWithAlpha        := tfLuminance12Alpha4;
+  fWithoutAlpha     := tfLuminance16;
+  fOpenGLFormat     := tfLuminance12Alpha4;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 16;
+  fglFormat         := GL_LUMINANCE_ALPHA;
+  fglInternalFormat := GL_LUMINANCE12_ALPHA4;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdLuminance16Alpha16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfLuminance16Alpha16;
+  fWithAlpha        := tfLuminance16Alpha16;
+  fWithoutAlpha     := tfLuminance16;
+  fOpenGLFormat     := tfLuminance16Alpha16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 0;
+  fShift.g          := 0;
+  fShift.b          := 0;
+  fShift.a          := 16;
+  fglFormat         := GL_LUMINANCE_ALPHA;
+  fglInternalFormat := GL_LUMINANCE16_ALPHA16;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdR3G3B2.Create;
+begin
+  inherited Create;
+  fPixelSize        := 1.0;
+  fFormat           := tfR3G3B2;
+  fWithAlpha        := tfRGBA4;
+  fWithoutAlpha     := tfR3G3B2;
+  fOpenGLFormat     := tfR3G3B2;
+  fRGBInverted      := tfEmpty;
+  fRange.r          := $07;
+  fRange.g          := $07;
+  fRange.b          := $04;
+  fShift.r          := 5;
+  fShift.g          := 2;
+  fShift.b          := 0;
+  fglFormat         := GL_RGB;
+  fglInternalFormat := GL_R3_G3_B2;
+  fglDataFormat     := GL_UNSIGNED_BYTE_3_3_2;
+end;
+
+constructor TfdRGBX4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGBX4;
+  fWithAlpha        := tfRGBA4;
+  fWithoutAlpha     := tfRGBX4;
+  fOpenGLFormat     := tfRGBX4;
+  fRGBInverted      := tfBGRX4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $00;
+  fShift.r          := 12;
+  fShift.g          :=  8;
+  fShift.b          :=  4;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
+end;
+
+constructor TfdXRGB4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfXRGB4;
+  fWithAlpha        := tfARGB4;
+  fWithoutAlpha     := tfXRGB4;
+  fOpenGLFormat     := tfXRGB4;
+  fRGBInverted      := tfXBGR4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fShift.r          := 8;
+  fShift.g          := 4;
+  fShift.b          := 0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+end;
+
+constructor TfdR5G6B5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfR5G6B5;
+  fWithAlpha        := tfRGB5A1;
+  fWithoutAlpha     := tfR5G6B5;
+  fOpenGLFormat     := tfR5G6B5;
+  fRGBInverted      := tfB5G6R5;
+  fRange.r          := $1F;
+  fRange.g          := $3F;
+  fRange.b          := $1F;
+  fShift.r          := 11;
+  fShift.g          := 5;
+  fShift.b          := 0;
+  fglFormat         := GL_RGB;
+  fglInternalFormat := GL_RGB565;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5;
+end;
+
+constructor TfdRGB5X1.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGB5X1;
+  fWithAlpha        := tfRGB5A1;
+  fWithoutAlpha     := tfRGB5X1;
+  fOpenGLFormat     := tfRGB5X1;
+  fRGBInverted      := tfBGR5X1;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fShift.r          := 11;
+  fShift.g          :=  6;
+  fShift.b          :=  1;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB5;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+constructor TfdX1RGB5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfX1RGB5;
+  fWithAlpha        := tfA1RGB5;
+  fWithoutAlpha     := tfX1RGB5;
+  fOpenGLFormat     := tfX1RGB5;
+  fRGBInverted      := tfX1BGR5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fShift.r          := 10;
+  fShift.g          :=  5;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB5;
+  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+end;
+
+constructor TfdRGB8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfRGB8;
+  fWithAlpha        := tfRGBA8;
+  fWithoutAlpha     := tfRGB8;
+  fOpenGLFormat     := tfRGB8;
+  fRGBInverted      := tfBGR8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          := 16;
+  fShift.g          :=  8;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGR;    // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB8;   // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdRGBX8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfRGBX8;
+  fWithAlpha        := tfRGBA8;
+  fWithoutAlpha     := tfRGBX8;
+  fOpenGLFormat     := tfRGB8;
+  fRGBInverted      := tfBGRX8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          := 24;
+  fShift.g          := 16;
+  fShift.b          := 8;
+  fglFormat         := GL_RGBA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
+end;
+
+constructor TfdXRGB8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfXRGB8;
+  fWithAlpha        := tfXRGB8;
+  fWithoutAlpha     := tfXRGB8;
+  fOpenGLFormat     := tfRGB8;
+  fRGBInverted      := tfXBGR8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          := 16;
+  fShift.g          :=  8;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
+end;
+
+constructor TfdRGB10X2.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfRGB10X2;
+  fWithAlpha        := tfRGB10A2;
+  fWithoutAlpha     := tfRGB10X2;
+  fOpenGLFormat     := tfRGB10X2;
+  fRGBInverted      := tfBGR10X2;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          := 22;
+  fShift.g          := 12;
+  fShift.b          :=  2;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB10;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
+end;
+
+constructor TfdX2RGB10.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfX2RGB10;
+  fWithAlpha        := tfA2RGB10;
+  fWithoutAlpha     := tfX2RGB10;
+  fOpenGLFormat     := tfX2RGB10;
+  fRGBInverted      := tfX2BGR10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          := 20;
+  fShift.g          := 10;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB10;
+  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+end;
+
+constructor TfdRGB16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 6.0;
+  fFormat           := tfRGB16;
+  fWithAlpha        := tfRGBA16;
+  fWithoutAlpha     := tfRGB16;
+  fOpenGLFormat     := tfRGB16;
+  fRGBInverted      := tfBGR16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fShift.r          := 32;
+  fShift.g          := 16;
+  fShift.b          :=  0;
+  fglFormat         := GL_BGR;     // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB16;   // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdRGBA4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGBA4;
+  fWithAlpha        := tfRGBA4;
+  fWithoutAlpha     := tfRGBX4;
+  fOpenGLFormat     := tfRGBA4;
+  fRGBInverted      := tfBGRA4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          := 12;
+  fShift.g          :=  8;
+  fShift.b          :=  4;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGBA4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
+end;
+
+constructor TfdARGB4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfARGB4;
+  fWithAlpha        := tfARGB4;
+  fWithoutAlpha     := tfXRGB4;
+  fOpenGLFormat     := tfARGB4;
+  fRGBInverted      := tfABGR4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          :=  8;
+  fShift.g          :=  4;
+  fShift.b          :=  0;
+  fShift.a          := 12;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGBA4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+end;
+
+constructor TfdRGB5A1.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfRGB5A1;
+  fWithAlpha        := tfRGB5A1;
+  fWithoutAlpha     := tfRGB5X1;
+  fOpenGLFormat     := tfRGB5A1;
+  fRGBInverted      := tfBGR5A1;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fRange.a          := $01;
+  fShift.r          := 11;
+  fShift.g          :=  6;
+  fShift.b          :=  1;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGB5_A1;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+constructor TfdA1RGB5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfA1RGB5;
+  fWithAlpha        := tfA1RGB5;
+  fWithoutAlpha     := tfX1RGB5;
+  fOpenGLFormat     := tfA1RGB5;
+  fRGBInverted      := tfA1BGR5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fRange.a          := $01;
+  fShift.r          := 10;
+  fShift.g          :=  5;
+  fShift.b          :=  0;
+  fShift.a          := 15;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB5_A1;
+  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+end;
+
+constructor TfdRGBA8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfRGBA8;
+  fWithAlpha        := tfRGBA8;
+  fWithoutAlpha     := tfRGB8;
+  fOpenGLFormat     := tfRGBA8;
+  fRGBInverted      := tfBGRA8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 24;
+  fShift.g          := 16;
+  fShift.b          :=  8;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGBA8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
+end;
+
+constructor TfdARGB8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfARGB8;
+  fWithAlpha        := tfARGB8;
+  fWithoutAlpha     := tfRGB8;
+  fOpenGLFormat     := tfARGB8;
+  fRGBInverted      := tfABGR8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          := 16;
+  fShift.g          :=  8;
+  fShift.b          :=  0;
+  fShift.a          := 24;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGBA8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
+end;
+
+constructor TfdRGB10A2.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfRGB10A2;
+  fWithAlpha        := tfRGB10A2;
+  fWithoutAlpha     := tfRGB10X2;
+  fOpenGLFormat     := tfRGB10A2;
+  fRGBInverted      := tfBGR10A2;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          := 22;
+  fShift.g          := 12;
+  fShift.b          :=  2;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGB10_A2;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
+end;
+
+constructor TfdA2RGB10.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfA2RGB10;
+  fWithAlpha        := tfA2RGB10;
+  fWithoutAlpha     := tfX2RGB10;
+  fOpenGLFormat     := tfA2RGB10;
+  fRGBInverted      := tfA2BGR10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          := 20;
+  fShift.g          := 10;
+  fShift.b          :=  0;
+  fShift.a          := 30;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB10_A2;
+  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+end;
+
+constructor TfdRGBA16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 8.0;
+  fFormat           := tfRGBA16;
+  fWithAlpha        := tfRGBA16;
+  fWithoutAlpha     := tfRGB16;
+  fOpenGLFormat     := tfRGBA16;
+  fRGBInverted      := tfBGRA16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 48;
+  fShift.g          := 32;
+  fShift.b          := 16;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;     // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGBA16;   // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TfdBGRX4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfBGRX4;
+  fWithAlpha        := tfBGRA4;
+  fWithoutAlpha     := tfBGRX4;
+  fOpenGLFormat     := tfBGRX4;
+  fRGBInverted      := tfRGBX4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fShift.r          :=  4;
+  fShift.g          :=  8;
+  fShift.b          := 12;
+  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
+end;
+
+constructor TfdXBGR4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfXBGR4;
+  fWithAlpha        := tfABGR4;
+  fWithoutAlpha     := tfXBGR4;
+  fOpenGLFormat     := tfXBGR4;
+  fRGBInverted      := tfXRGB4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          := 0;
+  fShift.g          := 4;
+  fShift.b          := 8;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+end;
+
+constructor TfdB5G6R5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfB5G6R5;
+  fWithAlpha        := tfBGR5A1;
+  fWithoutAlpha     := tfB5G6R5;
+  fOpenGLFormat     := tfB5G6R5;
+  fRGBInverted      := tfR5G6B5;
+  fRange.r          := $1F;
+  fRange.g          := $3F;
+  fRange.b          := $1F;
+  fShift.r          :=  0;
+  fShift.g          :=  5;
+  fShift.b          := 11;
+  fglFormat         := GL_RGB;
+  fglInternalFormat := GL_RGB565;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_6_5_REV;
+end;
+
+constructor TfdBGR5X1.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfBGR5X1;
+  fWithAlpha        := tfBGR5A1;
+  fWithoutAlpha     := tfBGR5X1;
+  fOpenGLFormat     := tfBGR5X1;
+  fRGBInverted      := tfRGB5X1;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fShift.r          :=  1;
+  fShift.g          :=  6;
+  fShift.b          := 11;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB5;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+constructor TfdX1BGR5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfX1BGR5;
+  fWithAlpha        := tfA1BGR5;
+  fWithoutAlpha     := tfX1BGR5;
+  fOpenGLFormat     := tfX1BGR5;
+  fRGBInverted      := tfX1RGB5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fShift.r          :=  0;
+  fShift.g          :=  5;
+  fShift.b          := 10;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB5;
+  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+end;
+
+constructor TfdBGR8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfBGR8;
+  fWithAlpha        := tfBGRA8;
+  fWithoutAlpha     := tfBGR8;
+  fOpenGLFormat     := tfBGR8;
+  fRGBInverted      := tfRGB8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          :=  0;
+  fShift.g          :=  8;
+  fShift.b          := 16;
+  fglFormat         := GL_RGB;      // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB8;     // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+constructor TfdBGRX8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfBGRX8;
+  fWithAlpha        := tfBGRA8;
+  fWithoutAlpha     := tfBGRX8;
+  fOpenGLFormat     := tfBGRX8;
+  fRGBInverted      := tfRGBX8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          :=  8;
+  fShift.g          := 16;
+  fShift.b          := 24;
+  fglFormat         := GL_BGRA;  //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
+end;
+
+constructor TfdXBGR8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfXBGR8;
+  fWithAlpha        := tfABGR8;
+  fWithoutAlpha     := tfXBGR8;
+  fOpenGLFormat     := tfXBGR8;
+  fRGBInverted      := tfXRGB8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fShift.r          :=  0;
+  fShift.g          :=  8;
+  fShift.b          := 16;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
+end;
+
+constructor TfdBGR10X2.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfBGR10X2;
+  fWithAlpha        := tfBGR10A2;
+  fWithoutAlpha     := tfBGR10X2;
+  fOpenGLFormat     := tfBGR10X2;
+  fRGBInverted      := tfRGB10X2;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          :=  2;
+  fShift.g          := 12;
+  fShift.b          := 22;
+  fglFormat         := GL_BGRA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB10;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
+end;
+
+constructor TfdX2BGR10.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfX2BGR10;
+  fWithAlpha        := tfA2BGR10;
+  fWithoutAlpha     := tfX2BGR10;
+  fOpenGLFormat     := tfX2BGR10;
+  fRGBInverted      := tfX2RGB10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fShift.r          :=  0;
+  fShift.g          := 10;
+  fShift.b          := 20;
+  fglFormat         := GL_RGBA; //GL_INVALID_OPERATION if not GL_BGRA or GL_RGBA
+  fglInternalFormat := GL_RGB10;
+  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+end;
+
+constructor TfdBGR16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 6.0;
+  fFormat           := tfBGR16;
+  fWithAlpha        := tfBGRA16;
+  fWithoutAlpha     := tfBGR16;
+  fOpenGLFormat     := tfBGR16;
+  fRGBInverted      := tfRGB16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fShift.r          :=  0;
+  fShift.g          := 16;
+  fShift.b          := 32;
+  fglFormat         := GL_RGB;      // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGB16;    // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdBGRA4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfBGRA4;
+  fWithAlpha        := tfBGRA4;
+  fWithoutAlpha     := tfBGRX4;
+  fOpenGLFormat     := tfBGRA4;
+  fRGBInverted      := tfRGBA4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          :=  4;
+  fShift.g          :=  8;
+  fShift.b          := 12;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGBA4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4;
+end;
+
+constructor TfdABGR4.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfABGR4;
+  fWithAlpha        := tfABGR4;
+  fWithoutAlpha     := tfXBGR4;
+  fOpenGLFormat     := tfABGR4;
+  fRGBInverted      := tfARGB4;
+  fRange.r          := $0F;
+  fRange.g          := $0F;
+  fRange.b          := $0F;
+  fRange.a          := $0F;
+  fShift.r          :=  0;
+  fShift.g          :=  4;
+  fShift.b          :=  8;
+  fShift.a          := 12;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGBA4;
+  fglDataFormat     := GL_UNSIGNED_SHORT_4_4_4_4_REV;
+end;
+
+constructor TfdBGR5A1.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfBGR5A1;
+  fWithAlpha        := tfBGR5A1;
+  fWithoutAlpha     := tfBGR5X1;
+  fOpenGLFormat     := tfBGR5A1;
+  fRGBInverted      := tfRGB5A1;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fRange.a          := $01;
+  fShift.r          :=  1;
+  fShift.g          :=  6;
+  fShift.b          := 11;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB5_A1;
+  fglDataFormat     := GL_UNSIGNED_SHORT_5_5_5_1;
+end;
+
+constructor TfdA1BGR5.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfA1BGR5;
+  fWithAlpha        := tfA1BGR5;
+  fWithoutAlpha     := tfX1BGR5;
+  fOpenGLFormat     := tfA1BGR5;
+  fRGBInverted      := tfA1RGB5;
+  fRange.r          := $1F;
+  fRange.g          := $1F;
+  fRange.b          := $1F;
+  fRange.a          := $01;
+  fShift.r          :=  0;
+  fShift.g          :=  5;
+  fShift.b          := 10;
+  fShift.a          := 15;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGB5_A1;
+  fglDataFormat     := GL_UNSIGNED_SHORT_1_5_5_5_REV;
+end;
+
+constructor TfdBGRA8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfBGRA8;
+  fWithAlpha        := tfBGRA8;
+  fWithoutAlpha     := tfBGR8;
+  fOpenGLFormat     := tfBGRA8;
+  fRGBInverted      := tfRGBA8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          :=  8;
+  fShift.g          := 16;
+  fShift.b          := 24;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGBA8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8;
+end;
+
+constructor TfdABGR8.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfABGR8;
+  fWithAlpha        := tfABGR8;
+  fWithoutAlpha     := tfBGR8;
+  fOpenGLFormat     := tfABGR8;
+  fRGBInverted      := tfARGB8;
+  fRange.r          := $FF;
+  fRange.g          := $FF;
+  fRange.b          := $FF;
+  fRange.a          := $FF;
+  fShift.r          :=  0;
+  fShift.g          :=  8;
+  fShift.b          := 16;
+  fShift.a          := 24;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGBA8;
+  fglDataFormat     := GL_UNSIGNED_INT_8_8_8_8_REV;
+end;
+
+constructor TfdBGR10A2.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfBGR10A2;
+  fWithAlpha        := tfBGR10A2;
+  fWithoutAlpha     := tfBGR10X2;
+  fOpenGLFormat     := tfBGR10A2;
+  fRGBInverted      := tfRGB10A2;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          :=  2;
+  fShift.g          := 12;
+  fShift.b          := 22;
+  fShift.a          :=  0;
+  fglFormat         := GL_BGRA;
+  fglInternalFormat := GL_RGB10_A2;
+  fglDataFormat     := GL_UNSIGNED_INT_10_10_10_2;
+end;
+
+constructor TfdA2BGR10.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfA2BGR10;
+  fWithAlpha        := tfA2BGR10;
+  fWithoutAlpha     := tfX2BGR10;
+  fOpenGLFormat     := tfA2BGR10;
+  fRGBInverted      := tfA2RGB10;
+  fRange.r          := $03FF;
+  fRange.g          := $03FF;
+  fRange.b          := $03FF;
+  fRange.a          := $0003;
+  fShift.r          :=  0;
+  fShift.g          := 10;
+  fShift.b          := 20;
+  fShift.a          := 30;
+  fglFormat         := GL_RGBA;
+  fglInternalFormat := GL_RGB10_A2;
+  fglDataFormat     := GL_UNSIGNED_INT_2_10_10_10_REV;
+end;
+
+constructor TfdBGRA16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 8.0;
+  fFormat           := tfBGRA16;
+  fWithAlpha        := tfBGRA16;
+  fWithoutAlpha     := tfBGR16;
+  fOpenGLFormat     := tfBGRA16;
+  fRGBInverted      := tfRGBA16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fShift.r          := 16;
+  fShift.g          := 32;
+  fShift.b          := 48;
+  fShift.a          :=  0;
+  fglFormat         := GL_RGBA;      // reverse byte order to match little endianess
+  fglInternalFormat := GL_RGBA16;    // as if u interpret the 3 bytes as unsigned integer
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdDepth16.Create;
+begin
+  inherited Create;
+  fPixelSize        := 2.0;
+  fFormat           := tfDepth16;
+  fWithoutAlpha     := tfDepth16;
+  fOpenGLFormat     := tfDepth16;
+  fRange.r          := $FFFF;
+  fRange.g          := $FFFF;
+  fRange.b          := $FFFF;
+  fRange.a          := $FFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
+  fglInternalFormat := GL_DEPTH_COMPONENT16;
+  fglDataFormat     := GL_UNSIGNED_SHORT;
+end;
+
+constructor TfdDepth24.Create;
+begin
+  inherited Create;
+  fPixelSize        := 3.0;
+  fFormat           := tfDepth24;
+  fWithoutAlpha     := tfDepth24;
+  fOpenGLFormat     := tfDepth24;
+  fRange.r          := $FFFFFF;
+  fRange.g          := $FFFFFF;
+  fRange.b          := $FFFFFF;
+  fRange.a          := $FFFFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
+  fglInternalFormat := GL_DEPTH_COMPONENT24;
+  fglDataFormat     := GL_UNSIGNED_INT;
+end;
+
+constructor TfdDepth32.Create;
+begin
+  inherited Create;
+  fPixelSize        := 4.0;
+  fFormat           := tfDepth32;
+  fWithoutAlpha     := tfDepth32;
+  fOpenGLFormat     := tfDepth32;
+  fRange.r          := $FFFFFFFF;
+  fRange.g          := $FFFFFFFF;
+  fRange.b          := $FFFFFFFF;
+  fRange.a          := $FFFFFFFF;
+  fglFormat         := GL_DEPTH_COMPONENT;
+  fglInternalFormat := GL_DEPTH_COMPONENT32;
+  fglDataFormat     := GL_UNSIGNED_INT;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdS3tcDtx1RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdS3tcDtx1RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx1RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+constructor TfdS3tcDtx1RGBA.Create;
+begin
+  inherited Create;
+  fFormat           := tfS3tcDtx1RGBA;
+  fWithAlpha        := tfS3tcDtx1RGBA;
+  fOpenGLFormat     := tfS3tcDtx1RGBA;
+  fUncompressed     := tfRGB5A1;
+  fPixelSize        := 0.5;
+  fIsCompressed     := true;
+  fglFormat         := GL_COMPRESSED_RGBA;
+  fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdS3tcDtx3RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdS3tcDtx3RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx3RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+constructor TfdS3tcDtx3RGBA.Create;
+begin
+  inherited Create;
+  fFormat           := tfS3tcDtx3RGBA;
+  fWithAlpha        := tfS3tcDtx3RGBA;
+  fOpenGLFormat     := tfS3tcDtx3RGBA;
+  fUncompressed     := tfRGBA8;
+  fPixelSize        := 1.0;
+  fIsCompressed     := true;
+  fglFormat         := GL_COMPRESSED_RGBA;
+  fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TfdS3tcDtx5RGBA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TfdS3tcDtx5RGBA.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+begin
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+procedure TfdS3tcDtx5RGBA.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+begin
+  raise EglBitmap.Create('mapping for compressed formats is not supported');
+end;
+
+constructor TfdS3tcDtx5RGBA.Create;
+begin
+  inherited Create;
+  fFormat           := tfS3tcDtx3RGBA;
+  fWithAlpha        := tfS3tcDtx3RGBA;
+  fOpenGLFormat     := tfS3tcDtx3RGBA;
+  fUncompressed     := tfRGBA8;
+  fPixelSize        := 1.0;
+  fIsCompressed     := true;
+  fglFormat         := GL_COMPRESSED_RGBA;
+  fglInternalFormat := GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+  fglDataFormat     := GL_UNSIGNED_BYTE;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglBitmapFormatDescriptor.GetByFormat(const aInternalFormat: GLenum): TglBitmapFormatDescriptor;
+var
+  f: TglBitmapFormat;
+begin
+  for f := Low(TglBitmapFormat) to High(TglBitmapFormat) do begin
+    result := TFormatDescriptor.Get(f);
+    if (result.glInternalFormat = aInternalFormat) then
+      exit;
+  end;
+  result := TFormatDescriptor.Get(tfEmpty);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TFormatDescriptor.Init;
+begin
+  if not Assigned(FormatDescriptorCS) then
+    FormatDescriptorCS := TCriticalSection.Create;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TFormatDescriptor.Get(const aFormat: TglBitmapFormat): TFormatDescriptor;
+begin
+  FormatDescriptorCS.Enter;
+  try
+    result := FormatDescriptors[aFormat];
+    if not Assigned(result) then begin
+      result := FORMAT_DESCRIPTOR_CLASSES[aFormat].Create;
+      FormatDescriptors[aFormat] := result;
+    end;
+  finally
+    FormatDescriptorCS.Leave;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TFormatDescriptor.GetAlpha(const aFormat: TglBitmapFormat): TFormatDescriptor;
+begin
+  result := Get(Get(aFormat).WithAlpha);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TFormatDescriptor.Clear;
+var
+  f: TglBitmapFormat;
+begin
+  FormatDescriptorCS.Enter;
+  try
+    for f := low(FormatDescriptors) to high(FormatDescriptors) do
+      FreeAndNil(FormatDescriptors[f]);
+  finally
+    FormatDescriptorCS.Leave;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TFormatDescriptor.Finalize;
+begin
+  Clear;
+  FreeAndNil(FormatDescriptorCS);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TBitfieldFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.SetRedMask(const aValue: QWord);
+begin
+  Update(aValue, fRange.r, fShift.r);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord);
+begin
+  Update(aValue, fRange.g, fShift.g);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord);
+begin
+  Update(aValue, fRange.b, fShift.b);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord);
+begin
+  Update(aValue, fRange.a, fShift.a);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out
+  aShift: Byte);
+begin
+  aShift := 0;
+  aRange := 0;
+  if (aMask = 0) then
+    exit;
+  while (aMask > 0) and ((aMask and 1) = 0) do begin
+    inc(aShift);
+    aMask := aMask shr 1;
+  end;
+  aRange := 1;
+  while (aMask > 0) do begin
+    aRange := aRange shl 1;
+    aMask  := aMask  shr 1;
+  end;
+  dec(aRange);
+
+  fPixelSize := Round(GetTopMostBit(RedMask or GreenMask or BlueMask or AlphaMask) / 8);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  data: QWord;
+  s: Integer;
+begin
+  data :=
+    ((aPixel.Data.r and fRange.r) shl fShift.r) or
+    ((aPixel.Data.g and fRange.g) shl fShift.g) or
+    ((aPixel.Data.b and fRange.b) shl fShift.b) or
+    ((aPixel.Data.a and fRange.a) shl fShift.a);
+  s := Round(fPixelSize);
+  case s of
+    1:           aData^  := data;
+    2:     PWord(aData)^ := data;
+    4: PCardinal(aData)^ := data;
+    8:    PQWord(aData)^ := data;
+  else
+    raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
+  end;
+  inc(aData, s);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+  data: QWord;
+  s, i: Integer;
+begin
+  s := Round(fPixelSize);
+  case s of
+    1: data :=           aData^;
+    2: data :=     PWord(aData)^;
+    4: data := PCardinal(aData)^;
+    8: data :=    PQWord(aData)^;
+  else
+    raise EglBitmap.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
+  end;
+  for i := 0 to 3 do
+    aPixel.Data.arr[i] := (data shr fShift.arr[i]) and fRange.arr[i];
+  inc(aData, s);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TColorTableFormat///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.CreateColorTable;
+var
+  i: Integer;
+begin
+  if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
+    raise EglBitmap.Create(UNSUPPORTED_FORMAT);
+
+  if (Format = tfLuminance4) then
+    SetLength(fColorTable, 16)
+  else
+    SetLength(fColorTable, 256);
+
+  case Format of
+    tfLuminance4: begin
+      for i := 0 to High(fColorTable) do begin
+        fColorTable[i].r := 16 * i;
+        fColorTable[i].g := 16 * i;
+        fColorTable[i].b := 16 * i;
+        fColorTable[i].a := 0;
+      end;
+    end;
+
+    tfLuminance8: begin
+      for i := 0 to High(fColorTable) do begin
+        fColorTable[i].r := i;
+        fColorTable[i].g := i;
+        fColorTable[i].b := i;
+        fColorTable[i].a := 0;
+      end;
+    end;
+
+    tfR3G3B2: begin
+      for i := 0 to High(fColorTable) do begin
+        fColorTable[i].r := Round(((i shr Shift.r) and Range.r) / Range.r * 255);
+        fColorTable[i].g := Round(((i shr Shift.g) and Range.g) / Range.g * 255);
+        fColorTable[i].b := Round(((i shr Shift.b) and Range.b) / Range.b * 255);
+        fColorTable[i].a := 0;
+      end;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
+var
+  d: Byte;
+begin
+  if not (Format in [tfLuminance4, tfLuminance8, tfR3G3B2]) then
+    raise EglBitmap.Create(UNSUPPORTED_FORMAT);
+
+  case Format of
+    tfLuminance4: begin
+      if (aMapData = nil) then
+        aData^ := 0;
+      d := LuminanceWeight(aPixel) and Range.r;
+      aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData)));
+      inc(PByte(aMapData), 4);
+      if ({%H-}PtrUInt(aMapData) >= 8) then begin
+        inc(aData);
+        aMapData := nil;
+      end;
+    end;
+
+    tfLuminance8: begin
+      aData^ := LuminanceWeight(aPixel) and Range.r;
+      inc(aData);
+    end;
+
+    tfR3G3B2: begin
+      aData^ := Round(
+        ((aPixel.Data.r and Range.r) shl Shift.r) or
+        ((aPixel.Data.g and Range.g) shl Shift.g) or
+        ((aPixel.Data.b and Range.b) shl Shift.b));
+      inc(aData);
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
+var
+  idx: QWord;
+  s: Integer;
+  bits: Byte;
+  f: Single;
+begin
+  s    := Trunc(fPixelSize);
+  f    := fPixelSize - s;
+  bits := Round(8 * f);
+  case s of
+    0: idx :=          (aData^ shr (8 - bits - {%H-}PtrInt(aMapData))) and ((1 shl bits) - 1);
+    1: idx :=           aData^;
+    2: idx :=     PWord(aData)^;
+    4: idx := PCardinal(aData)^;
+    8: idx :=    PQWord(aData)^;
+  else
+    raise EglBitmap.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
+  end;
+  if (idx >= Length(fColorTable)) then
+    raise EglBitmap.CreateFmt('invalid color index: %d', [idx]);
+  with fColorTable[idx] do begin
+    aPixel.Data.r := r;
+    aPixel.Data.g := g;
+    aPixel.Data.b := b;
+    aPixel.Data.a := a;
+  end;
+  inc(PByte(aMapData), bits);
+  if ({%H-}PtrUInt(aMapData) >= 8) then begin
+    inc(aData, 1);
+    dec(PByte(aMapData), 8);
+  end;
+  inc(aData, s);
+end;
+
+destructor TbmpColorTableFormat.Destroy;
+begin
+  SetLength(fColorTable, 0);
+  inherited Destroy;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap - Helper//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertPixel(var aPixel: TglBitmapPixelData; const aSourceFD, aDestFD: TFormatDescriptor);
+var
+  i: Integer;
+begin
+  for i := 0 to 3 do begin
+    if (aSourceFD.Range.arr[i] <> aDestFD.Range.arr[i]) then begin
+      if (aSourceFD.Range.arr[i] > 0) then
+        aPixel.Data.arr[i] := Round(aPixel.Data.arr[i] / aSourceFD.Range.arr[i] * aDestFD.Range.arr[i])
+      else
+        aPixel.Data.arr[i] := 0;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertCopyFunc(var aFuncRec: TglBitmapFunctionRec);
+begin
+  with aFuncRec do begin
+    if (Source.Range.r   > 0) then
+      Dest.Data.r := Source.Data.r;
+    if (Source.Range.g > 0) then
+      Dest.Data.g := Source.Data.g;
+    if (Source.Range.b  > 0) then
+      Dest.Data.b := Source.Data.b;
+    if (Source.Range.a > 0) then
+      Dest.Data.a := Source.Data.a;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertCalculateRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
+var
+  i: Integer;
+begin
+  with aFuncRec do begin
+    for i := 0 to 3 do
+      if (Source.Range.arr[i] > 0) then
+        Dest.Data.arr[i] := Round(Dest.Range.arr[i] * Source.Data.arr[i] / Source.Range.arr[i]);
+  end;
+end;
+
+type
+  TShiftData = packed record
+    case Integer of
+      0: (r, g, b, a: SmallInt);
+      1: (arr: array[0..3] of SmallInt);
+  end;
+  PShiftData = ^TShiftData;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapConvertShiftRGBAFunc(var aFuncRec: TglBitmapFunctionRec);
+var
+  i: Integer;
+begin
+  with aFuncRec do
+    for i := 0 to 3 do
+      if (Source.Range.arr[i] > 0) then
+        Dest.Data.arr[i] := Source.Data.arr[i] shr PShiftData(Args)^.arr[i];
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapInvertFunc(var aFuncRec: TglBitmapFunctionRec);
+begin
+  with aFuncRec do begin
+    Dest.Data := Source.Data;
+    if ({%H-}PtrUInt(Args) and $1 > 0) then begin
+      Dest.Data.r := Dest.Data.r xor Dest.Range.r;
+      Dest.Data.g := Dest.Data.g xor Dest.Range.g;
+      Dest.Data.b := Dest.Data.b xor Dest.Range.b;
+    end;
+    if ({%H-}PtrUInt(Args) and $2 > 0) then begin
+      Dest.Data.a := Dest.Data.a xor Dest.Range.a;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapFillWithColorFunc(var aFuncRec: TglBitmapFunctionRec);
+var
+  i: Integer;
+begin
+  with aFuncRec do begin
+    for i := 0 to 3 do
+      Dest.Data.arr[i] := PglBitmapPixelData(Args)^.Data.arr[i];
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+var
+  Temp: Single;
+begin
+  with FuncRec do begin
+    if (FuncRec.Args = nil) then begin //source has no alpha
+      Temp :=
+        Source.Data.r / Source.Range.r * ALPHA_WEIGHT_R +
+        Source.Data.g / Source.Range.g * ALPHA_WEIGHT_G +
+        Source.Data.b / Source.Range.b * ALPHA_WEIGHT_B;
+      Dest.Data.a := Round(Dest.Range.a * Temp);
+    end else
+      Dest.Data.a := Round(Source.Data.a / Source.Range.a * Dest.Range.a);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapColorKeyAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+type
+  PglBitmapPixelData = ^TglBitmapPixelData;
+begin
+  with FuncRec do begin
+    Dest.Data.r := Source.Data.r;
+    Dest.Data.g := Source.Data.g;
+    Dest.Data.b := Source.Data.b;
+
+    with PglBitmapPixelData(Args)^ do
+      if ((Dest.Data.r <= Data.r) and (Dest.Data.r >= Range.r) and
+          (Dest.Data.g <= Data.g) and (Dest.Data.g >= Range.g) and
+          (Dest.Data.b <= Data.b) and (Dest.Data.b >= Range.b)) then
+        Dest.Data.a := 0
+      else
+        Dest.Data.a := Dest.Range.a;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapValueAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+begin
+  with FuncRec do begin
+    Dest.Data.r := Source.Data.r;
+    Dest.Data.g := Source.Data.g;
+    Dest.Data.b := Source.Data.b;
+    Dest.Data.a := PCardinal(Args)^;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure SwapRGB(aData: PByte; aWidth: Integer; const aHasAlpha: Boolean);
+type
+  PRGBPix = ^TRGBPix;
+  TRGBPix = array [0..2] of byte;
+var
+  Temp: Byte;
+begin
+  while aWidth > 0 do begin
+    Temp := PRGBPix(aData)^[0];
+    PRGBPix(aData)^[0] := PRGBPix(aData)^[2];
+    PRGBPix(aData)^[2] := Temp;
+
+    if aHasAlpha then
+      Inc(aData, 4)
+    else
+      Inc(aData, 3);
+    dec(aWidth);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap - PROTECTED///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetFormatDesc: TglBitmapFormatDescriptor;
+begin
+  result := TFormatDescriptor.Get(Format);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetWidth: Integer;
+begin
+  if (ffX in fDimension.Fields) then
+    result := fDimension.X
+  else
+    result := -1;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetHeight: Integer;
+begin
+  if (ffY in fDimension.Fields) then
+    result := fDimension.Y
+  else
+    result := -1;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetFileWidth: Integer;
+begin
+  result := Max(1, Width);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.GetFileHeight: Integer;
+begin
+  result := Max(1, Height);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomData(const aValue: Pointer);
+begin
+  if fCustomData = aValue then
+    exit;
+  fCustomData := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomName(const aValue: String);
+begin
+  if fCustomName = aValue then
+    exit;
+  fCustomName := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetCustomNameW(const aValue: WideString);
+begin
+  if fCustomNameW = aValue then
+    exit;
+  fCustomNameW := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetFreeDataOnDestroy(const aValue: Boolean);
+begin
+  if fFreeDataOnDestroy = aValue then
+    exit;
+  fFreeDataOnDestroy := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetDeleteTextureOnFree(const aValue: Boolean);
+begin
+  if fDeleteTextureOnFree = aValue then
+    exit;
+  fDeleteTextureOnFree := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetFormat(const aValue: TglBitmapFormat);
+begin
+  if fFormat = aValue then
+    exit;
+  if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+  SetDataPointer(fData, aValue, Width, Height); //be careful, Data could be freed by this method
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetFreeDataAfterGenTexture(const aValue: Boolean);
+begin
+  if fFreeDataAfterGenTexture = aValue then
+    exit;
+  fFreeDataAfterGenTexture := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetID(const aValue: Cardinal);
+begin
+  if fID = aValue then
+    exit;
+  fID := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetMipMap(const aValue: TglBitmapMipMap);
+begin
+  if fMipMap = aValue then
+    exit;
+  fMipMap := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetTarget(const aValue: Cardinal);
+begin
+  if fTarget = aValue then
+    exit;
+  fTarget := aValue;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetAnisotropic(const aValue: Integer);
+var
+  MaxAnisotropic: Integer;
+begin
+  fAnisotropic := aValue;
+  if (ID > 0) then begin
+    if GL_EXT_texture_filter_anisotropic then begin
+      if fAnisotropic > 0 then begin
+        Bind(false);
+        glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, @MaxAnisotropic);
+        if aValue > MaxAnisotropic then
+          fAnisotropic := MaxAnisotropic;
+        glTexParameteri(Target, GL_TEXTURE_MAX_ANISOTROPY_EXT, fAnisotropic);
+      end;
+    end else begin
+      fAnisotropic := 0;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.CreateID;
+begin
+  if (ID <> 0) then
+    glDeleteTextures(1, @fID);
+  glGenTextures(1, @fID);
+  Bind(false);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetupParameters(out aBuildWithGlu: Boolean);
+begin
+  // Set Up Parameters
+  SetWrap(fWrapS, fWrapT, fWrapR);
+  SetFilter(fFilterMin, fFilterMag);
+  SetAnisotropic(fAnisotropic);
+  SetBorderColor(fBorderColor[0], fBorderColor[1], fBorderColor[2], fBorderColor[3]);
+
+  if (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
+    SetSwizzle(fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
+
+  // Mip Maps Generation Mode
+  aBuildWithGlu := false;
+  if (MipMap = mmMipmap) then begin
+    if (GL_VERSION_1_4 or GL_SGIS_generate_mipmap) then
+      glTexParameteri(Target, GL_GENERATE_MIPMAP, GL_TRUE)
+    else
+      aBuildWithGlu := true;
+  end else if (MipMap = mmMipmapGlu) then
+    aBuildWithGlu := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+  const aWidth: Integer; const aHeight: Integer);
+var
+  s: Single;
+begin
+  if (Data <> aData) then begin
+    if (Assigned(Data)) then
+      FreeMem(Data);
+    fData := aData;
+  end;
+
+  if not Assigned(fData) then begin
+    fPixelSize := 0;
+    fRowSize   := 0;
+  end else begin
+    FillChar(fDimension, SizeOf(fDimension), 0);
+    if aWidth <> -1 then begin
+      fDimension.Fields := fDimension.Fields + [ffX];
+      fDimension.X := aWidth;
+    end;
+
+    if aHeight <> -1 then begin
+      fDimension.Fields := fDimension.Fields + [ffY];
+      fDimension.Y := aHeight;
+    end;
+
+    s := TFormatDescriptor.Get(aFormat).PixelSize;
+    fFormat    := aFormat;
+    fPixelSize := Ceil(s);
+    fRowSize   := Ceil(s * aWidth);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.FlipHorz: Boolean;
+begin
+  result := false;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.FlipVert: Boolean;
+begin
+  result := false;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap - PUBLIC//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.AfterConstruction;
+begin
+  inherited AfterConstruction;
+
+  fID         := 0;
+  fTarget     := 0;
+  fIsResident := false;
+
+  fMipMap                  := glBitmapDefaultMipmap;
+  fFreeDataAfterGenTexture := glBitmapGetDefaultFreeDataAfterGenTexture;
+  fDeleteTextureOnFree     := glBitmapGetDefaultDeleteTextureOnFree;
+
+  glBitmapGetDefaultFilter     (fFilterMin, fFilterMag);
+  glBitmapGetDefaultTextureWrap(fWrapS, fWrapT, fWrapR);
+  glBitmapGetDefaultSwizzle    (fSwizzle[0], fSwizzle[1], fSwizzle[2], fSwizzle[3]);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.BeforeDestruction;
+var
+  NewData: PByte;
+begin
+  if fFreeDataOnDestroy then begin
+    NewData := nil;
+    SetDataPointer(NewData, tfEmpty); //be careful, Data could be freed by this method
+  end;
+  if (fID > 0) and fDeleteTextureOnFree then
+    glDeleteTextures(1, @fID);
+  inherited BeforeDestruction;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.PrepareResType(var aResource: String; var aResType: PChar);
+var
+  TempPos: Integer;
+begin
+  if not Assigned(aResType) then begin
+    TempPos   := Pos('.', aResource);
+    aResType  := PChar(UpperCase(Copy(aResource, TempPos + 1, Length(aResource) - TempPos)));
+    aResource := UpperCase(Copy(aResource, 0, TempPos -1));
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.LoadFromFile(const aFilename: String);
+var
+  fs: TFileStream;
+begin
+  if not FileExists(aFilename) then
+    raise EglBitmap.Create('file does not exist: ' + aFilename);
+  fFilename := aFilename;
+  fs := TFileStream.Create(fFilename, fmOpenRead);
+  try
+    fs.Position := 0;
+    LoadFromStream(fs);
+  finally
+    fs.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.LoadFromStream(const aStream: TStream);
+begin
+  {$IFDEF GLB_SUPPORT_PNG_READ}
+  if not LoadPNG(aStream) then
+  {$ENDIF}
+  {$IFDEF GLB_SUPPORT_JPEG_READ}
+  if not LoadJPEG(aStream) then
+  {$ENDIF}
+  if not LoadDDS(aStream) then
+  if not LoadTGA(aStream) then
+  if not LoadBMP(aStream) then
+    raise EglBitmap.Create('LoadFromStream - Couldn''t load Stream. It''s possible to be an unknow Streamtype.');
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.LoadFromFunc(const aSize: TglBitmapPixelPosition; const aFunc: TglBitmapFunction;
+  const aFormat: TglBitmapFormat; const aArgs: Pointer);
+var
+  tmpData: PByte;
+  size: Integer;
+begin
+  size := TFormatDescriptor.Get(aFormat).GetSize(aSize);
+  GetMem(tmpData, size);
+  try
+    FillChar(tmpData^, size, #$FF);
+    SetDataPointer(tmpData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method
+  except
+    if Assigned(tmpData) then
+      FreeMem(tmpData);
+    raise;
+  end;
+  AddFunc(Self, aFunc, false, aFormat, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.LoadFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar);
+var
+  rs: TResourceStream;
+begin
+  PrepareResType(aResource, aResType);
+  rs := TResourceStream.Create(aInstance, aResource, aResType);
+  try
+    LoadFromStream(rs);
+  finally
+    rs.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.LoadFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
+var
+  rs: TResourceStream;
+begin
+  rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
+  try
+    LoadFromStream(rs);
+  finally
+    rs.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveToFile(const aFileName: String; const aFileType: TglBitmapFileType);
+var
+  fs: TFileStream;
+begin
+  fs := TFileStream.Create(aFileName, fmCreate);
+  try
+    fs.Position := 0;
+    SaveToStream(fs, aFileType);
+  finally
+    fs.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveToStream(const aStream: TStream; const aFileType: TglBitmapFileType);
+begin
+  case aFileType of
+    {$IFDEF GLB_SUPPORT_PNG_WRITE}
+    ftPNG:  SavePNG(aStream);
+    {$ENDIF}
+    {$IFDEF GLB_SUPPORT_JPEG_WRITE}
+    ftJPEG: SaveJPEG(aStream);
+    {$ENDIF}
+    ftDDS:  SaveDDS(aStream);
+    ftTGA:  SaveTGA(aStream);
+    ftBMP:  SaveBMP(aStream);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddFunc(const aFunc: TglBitmapFunction; const aCreateTemp: Boolean; const aArgs: Pointer): Boolean;
+begin
+  result := AddFunc(Self, aFunc, aCreateTemp, Format, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddFunc(const aSource: TglBitmap; const aFunc: TglBitmapFunction; aCreateTemp: Boolean;
+  const aFormat: TglBitmapFormat; const aArgs: Pointer): Boolean;
+var
+  DestData, TmpData, SourceData: pByte;
+  TempHeight, TempWidth: Integer;
+  SourceFD, DestFD: TFormatDescriptor;
+  SourceMD, DestMD: Pointer;
+
+  FuncRec: TglBitmapFunctionRec;
+begin
+  Assert(Assigned(Data));
+  Assert(Assigned(aSource));
+  Assert(Assigned(aSource.Data));
+
+  result := false;
+  if Assigned(aSource.Data) and ((aSource.Height > 0) or (aSource.Width > 0)) then begin
+    SourceFD := TFormatDescriptor.Get(aSource.Format);
+    DestFD   := TFormatDescriptor.Get(aFormat);
+
+    if (SourceFD.IsCompressed) then
+      raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', SourceFD.Format);
+    if (DestFD.IsCompressed) then
+      raise EglBitmapUnsupportedFormat.Create('compressed formats are not supported: ', DestFD.Format);
+
+    // inkompatible Formats so CreateTemp
+    if (SourceFD.PixelSize <> DestFD.PixelSize) then
+      aCreateTemp := true;
+
+    // Values
+    TempHeight := Max(1, aSource.Height);
+    TempWidth  := Max(1, aSource.Width);
+
+    FuncRec.Sender := Self;
+    FuncRec.Args   := aArgs;
+
+    TmpData := nil;
+    if aCreateTemp then begin
+      GetMem(TmpData, DestFD.GetSize(TempWidth, TempHeight));
+      DestData := TmpData;
+    end else
+      DestData := Data;
+
+    try
+      SourceFD.PreparePixel(FuncRec.Source);
+      DestFD.PreparePixel  (FuncRec.Dest);
+
+      SourceMD := SourceFD.CreateMappingData;
+      DestMD   := DestFD.CreateMappingData;
+
+      FuncRec.Size            := aSource.Dimension;
+      FuncRec.Position.Fields := FuncRec.Size.Fields;
+
+      try
+        SourceData := aSource.Data;
+        FuncRec.Position.Y := 0;
+        while FuncRec.Position.Y < TempHeight do begin
+          FuncRec.Position.X := 0;
+          while FuncRec.Position.X < TempWidth do begin
+            SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
+            aFunc(FuncRec);
+            DestFD.Map(FuncRec.Dest, DestData, DestMD);
+            inc(FuncRec.Position.X);
+          end;
+          inc(FuncRec.Position.Y);
+        end;
+
+        // Updating Image or InternalFormat
+        if aCreateTemp then
+          SetDataPointer(TmpData, aFormat, aSource.Width, aSource.Height) //be careful, Data could be freed by this method
+        else if (aFormat <> fFormat) then
+          Format := aFormat;
+
+        result := true;
+      finally
+        SourceFD.FreeMappingData(SourceMD);
+        DestFD.FreeMappingData(DestMD);
+      end;
+    except
+      if aCreateTemp and Assigned(TmpData) then
+        FreeMem(TmpData);
+      raise;
+    end;
+  end;
+end;
+
+{$IFDEF GLB_SDL}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignToSurface(out aSurface: PSDL_Surface): Boolean;
+var
+  Row, RowSize: Integer;
+  SourceData, TmpData: PByte;
+  TempDepth: Integer;
+  FormatDesc: TFormatDescriptor;
+
+  function GetRowPointer(Row: Integer): pByte;
+  begin
+    result := aSurface.pixels;
+    Inc(result, Row * RowSize);
+  end;
+
+begin
+  result := false;
+
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if FormatDesc.IsCompressed then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  if Assigned(Data) then begin
+    case Trunc(FormatDesc.PixelSize) of
+      1: TempDepth :=  8;
+      2: TempDepth := 16;
+      3: TempDepth := 24;
+      4: TempDepth := 32;
+    else
+      raise EglBitmapUnsupportedFormat.Create(Format);
+    end;
+
+    aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
+      FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask);
+    SourceData := Data;
+    RowSize    := FormatDesc.GetSize(FileWidth, 1);
+
+    for Row := 0 to FileHeight-1 do begin
+      TmpData := GetRowPointer(Row);
+      if Assigned(TmpData) then begin
+        Move(SourceData^, TmpData^, RowSize);
+        inc(SourceData, RowSize);
+      end;
+    end;
+    result := true;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
+var
+  pSource, pData, pTempData: PByte;
+  Row, RowSize, TempWidth, TempHeight: Integer;
+  IntFormat: TglBitmapFormat;
+  FormatDesc: TFormatDescriptor;
+
+  function GetRowPointer(Row: Integer): pByte;
+  begin
+    result := aSurface^.pixels;
+    Inc(result, Row * RowSize);
+  end;
+
+begin
+  result := false;
+  if (Assigned(aSurface)) then begin
+    with aSurface^.format^ do begin
+      for IntFormat := High(TglBitmapFormat) to Low(TglBitmapFormat) do begin
+        FormatDesc := TFormatDescriptor.Get(IntFormat);
+        if (FormatDesc.MaskMatch(RMask, GMask, BMask, AMask)) then
+          break;
+      end;
+      if (IntFormat = tfEmpty) then
+        raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.');
+    end;
+
+    TempWidth  := aSurface^.w;
+    TempHeight := aSurface^.h;
+    RowSize := FormatDesc.GetSize(TempWidth, 1);
+    GetMem(pData, TempHeight * RowSize);
+    try
+      pTempData := pData;
+      for Row := 0 to TempHeight -1 do begin
+        pSource := GetRowPointer(Row);
+        if (Assigned(pSource)) then begin
+          Move(pSource^, pTempData^, RowSize);
+          Inc(pTempData, RowSize);
+        end;
+      end;
+      SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
+      result := true;
+    except
+      if Assigned(pData) then
+        FreeMem(pData);
+      raise;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignAlphaToSurface(out aSurface: PSDL_Surface): Boolean;
+var
+  Row, Col, AlphaInterleave: Integer;
+  pSource, pDest: PByte;
+
+  function GetRowPointer(Row: Integer): pByte;
+  begin
+    result := aSurface.pixels;
+    Inc(result, Row * Width);
+  end;
+
+begin
+  result := false;
+  if Assigned(Data) then begin
+    if Format in [tfAlpha8, tfLuminance8Alpha8, tfBGRA8, tfRGBA8] then begin
+      aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 8, $FF, $FF, $FF, 0);
+
+      AlphaInterleave := 0;
+      case Format of
+        tfLuminance8Alpha8:
+          AlphaInterleave := 1;
+        tfBGRA8, tfRGBA8:
+          AlphaInterleave := 3;
+      end;
+
+      pSource := Data;
+      for Row := 0 to Height -1 do begin
+        pDest := GetRowPointer(Row);
+        if Assigned(pDest) then begin
+          for Col := 0 to Width -1 do begin
+            Inc(pSource, AlphaInterleave);
+            pDest^ := pSource^;
+            Inc(pDest);
+            Inc(pSource);
+          end;
+        end;
+      end;
+      result := true;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
+var
+  bmp: TglBitmap2D;
+begin
+  bmp := TglBitmap2D.Create;
+  try
+    bmp.AssignFromSurface(aSurface);
+    result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs);
+  finally
+    bmp.Free;
+  end;
+end;
+{$ENDIF}
+
+{$IFDEF GLB_DELPHI}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function CreateGrayPalette: HPALETTE;
+var
+  Idx: Integer;
+  Pal: PLogPalette;
+begin
+  GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256));
+
+  Pal.palVersion := $300;
+  Pal.palNumEntries := 256;
+
+  for Idx := 0 to Pal.palNumEntries - 1 do begin
+    Pal.palPalEntry[Idx].peRed   := Idx;
+    Pal.palPalEntry[Idx].peGreen := Idx;
+    Pal.palPalEntry[Idx].peBlue  := Idx;
+    Pal.palPalEntry[Idx].peFlags := 0;
+  end;
+  Result := CreatePalette(Pal^);
+  FreeMem(Pal);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignToBitmap(const aBitmap: TBitmap): Boolean;
+var
+  Row: Integer;
+  pSource, pData: PByte;
+begin
+  result := false;
+  if Assigned(Data) then begin
+    if Assigned(aBitmap) then begin
+      aBitmap.Width  := Width;
+      aBitmap.Height := Height;
+
+      case Format of
+        tfAlpha8, tfLuminance8: begin
+          aBitmap.PixelFormat := pf8bit;
+          aBitmap.Palette     := CreateGrayPalette;
+        end;
+        tfRGB5A1:
+          aBitmap.PixelFormat := pf15bit;
+        tfR5G6B5:
+          aBitmap.PixelFormat := pf16bit;
+        tfRGB8, tfBGR8:
+          aBitmap.PixelFormat := pf24bit;
+        tfRGBA8, tfBGRA8:
+          aBitmap.PixelFormat := pf32bit;
+      else
+        raise EglBitmap.Create('AssignToBitmap - Invalid Pixelformat.');
+      end;
+
+      pSource := Data;
+      for Row := 0 to FileHeight -1 do begin
+        pData := aBitmap.Scanline[Row];
+        Move(pSource^, pData^, fRowSize);
+        Inc(pSource, fRowSize);
+        if (Format in [tfRGB8, tfRGBA8]) then        // swap RGB(A) to BGR(A)
+          SwapRGB(pData, FileWidth, Format = tfRGBA8);
+      end;
+      result := true;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignFromBitmap(const aBitmap: TBitmap): Boolean;
+var
+  pSource, pData, pTempData: PByte;
+  Row, RowSize, TempWidth, TempHeight: Integer;
+  IntFormat: TglBitmapFormat;
+begin
+  result := false;
+
+  if (Assigned(aBitmap)) then begin
+    case aBitmap.PixelFormat of
+      pf8bit:
+        IntFormat := tfLuminance8;
+      pf15bit:
+        IntFormat := tfRGB5A1;
+      pf16bit:
+        IntFormat := tfR5G6B5;
+      pf24bit:
+        IntFormat := tfBGR8;
+      pf32bit:
+        IntFormat := tfBGRA8;
+    else
+      raise EglBitmap.Create('AssignFromBitmap - Invalid Pixelformat.');
+    end;
+
+    TempWidth  := aBitmap.Width;
+    TempHeight := aBitmap.Height;
+    RowSize    := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1);
+    GetMem(pData, TempHeight * RowSize);
+    try
+      pTempData := pData;
+      for Row := 0 to TempHeight -1 do begin
+        pSource := aBitmap.Scanline[Row];
+        if (Assigned(pSource)) then begin
+          Move(pSource^, pTempData^, RowSize);
+          Inc(pTempData, RowSize);
+        end;
+      end;
+      SetDataPointer(pData, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
+      result := true;
+    except
+      if Assigned(pData) then
+        FreeMem(pData);
+      raise;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignAlphaToBitmap(const aBitmap: TBitmap): Boolean;
+var
+  Row, Col, AlphaInterleave: Integer;
+  pSource, pDest: PByte;
+begin
+  result := false;
+
+  if Assigned(Data) then begin
+    if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin
+      if Assigned(aBitmap) then begin
+        aBitmap.PixelFormat := pf8bit;
+        aBitmap.Palette     := CreateGrayPalette;
+        aBitmap.Width       := Width;
+        aBitmap.Height      := Height;
+
+        case Format of
+          tfLuminance8Alpha8:
+            AlphaInterleave := 1;
+          tfRGBA8, tfBGRA8:
+            AlphaInterleave := 3;
+          else
+            AlphaInterleave := 0;
+        end;
+
+        // Copy Data
+        pSource := Data;
+
+        for Row := 0 to Height -1 do begin
+          pDest := aBitmap.Scanline[Row];
+          if Assigned(pDest) then begin
+            for Col := 0 to Width -1 do begin
+              Inc(pSource, AlphaInterleave);
+              pDest^ := pSource^;
+              Inc(pDest);
+              Inc(pSource);
+            end;
+          end;
+        end;
+        result := true;
+      end;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+  tex: TglBitmap2D;
+begin
+  tex := TglBitmap2D.Create;
+  try
+    tex.AssignFromBitmap(ABitmap);
+    result := AddAlphaFromglBitmap(tex, aFunc, aArgs);
+  finally
+    tex.Free;
+  end;
+end;
+{$ENDIF}
+
+{$IFDEF GLB_LAZARUS}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+var
+  rid: TRawImageDescription;
+  FormatDesc: TFormatDescriptor;
+begin
+  result := false;
+  if not Assigned(aImage) or (Format = tfEmpty) then
+    exit;
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if FormatDesc.IsCompressed then
+    exit;
+
+  FillChar(rid{%H-}, SizeOf(rid), 0);
+  if (Format in [
+       tfAlpha4, tfAlpha8, tfAlpha16,
+       tfLuminance4, tfLuminance8, tfLuminance16,
+       tfLuminance4Alpha4, tfLuminance8Alpha8, tfLuminance12Alpha4, tfLuminance16Alpha16]) then
+    rid.Format := ricfGray
+  else
+    rid.Format := ricfRGBA;
+
+  rid.Width        := Width;
+  rid.Height       := Height;
+  rid.Depth        := CountSetBits(FormatDesc.RedMask or FormatDesc.GreenMask or FormatDesc.BlueMask or FormatDesc.AlphaMask);
+  rid.BitOrder     := riboBitsInOrder;
+  rid.ByteOrder    := riboLSBFirst;
+  rid.LineOrder    := riloTopToBottom;
+  rid.LineEnd      := rileTight;
+  rid.BitsPerPixel := Round(8 * FormatDesc.PixelSize);
+  rid.RedPrec      := CountSetBits(FormatDesc.Range.r);
+  rid.GreenPrec    := CountSetBits(FormatDesc.Range.g);
+  rid.BluePrec     := CountSetBits(FormatDesc.Range.b);
+  rid.AlphaPrec    := CountSetBits(FormatDesc.Range.a);
+  rid.RedShift     := FormatDesc.Shift.r;
+  rid.GreenShift   := FormatDesc.Shift.g;
+  rid.BlueShift    := FormatDesc.Shift.b;
+  rid.AlphaShift   := FormatDesc.Shift.a;
+
+  rid.MaskBitsPerPixel  := 0;
+  rid.PaletteColorCount := 0;
+
+  aImage.DataDescription := rid;
+  aImage.CreateData;
+
+  Move(Data^, aImage.PixelData^, FormatDesc.GetSize(Dimension));
+
+  result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignFromLazIntfImage(const aImage: TLazIntfImage): Boolean;
+var
+  f: TglBitmapFormat;
+  FormatDesc: TFormatDescriptor;
+  ImageData: PByte;
+  ImageSize: Integer;
+  CanCopy: Boolean;
+
+  procedure CopyConvert;
+  var
+    bfFormat: TbmpBitfieldFormat;
+    pSourceLine, pDestLine: PByte;
+    pSourceMD, pDestMD: Pointer;
+    x, y: Integer;
+    pixel: TglBitmapPixelData;
+  begin
+    bfFormat  := TbmpBitfieldFormat.Create;
+    with aImage.DataDescription do begin
+      bfFormat.RedMask   := ((1 shl RedPrec)   - 1) shl RedShift;
+      bfFormat.GreenMask := ((1 shl GreenPrec) - 1) shl GreenShift;
+      bfFormat.BlueMask  := ((1 shl BluePrec)  - 1) shl BlueShift;
+      bfFormat.AlphaMask := ((1 shl AlphaPrec) - 1) shl AlphaShift;
+      bfFormat.PixelSize := BitsPerPixel / 8;
+    end;
+    pSourceMD := bfFormat.CreateMappingData;
+    pDestMD   := FormatDesc.CreateMappingData;
+    try
+      for y := 0 to aImage.Height-1 do begin
+        pSourceLine := aImage.PixelData + y {%H-}* aImage.DataDescription.BytesPerLine;
+        pDestLine   := ImageData        + y * Round(FormatDesc.PixelSize * aImage.Width);
+        for x := 0 to aImage.Width-1 do begin
+          bfFormat.Unmap(pSourceLine, pixel, pSourceMD);
+          FormatDesc.Map(pixel, pDestLine, pDestMD);
+        end;
+      end;
+    finally
+      FormatDesc.FreeMappingData(pDestMD);
+      bfFormat.FreeMappingData(pSourceMD);
+      bfFormat.Free;
+    end;
+  end;
+
+begin
+  result := false;
+  if not Assigned(aImage) then
+    exit;
+  for f := High(f) downto Low(f) do begin
+    FormatDesc := TFormatDescriptor.Get(f);
+    with aImage.DataDescription do
+      if FormatDesc.MaskMatch(
+        (QWord(1 shl RedPrec  )-1) shl RedShift,
+        (QWord(1 shl GreenPrec)-1) shl GreenShift,
+        (QWord(1 shl BluePrec )-1) shl BlueShift,
+        (QWord(1 shl AlphaPrec)-1) shl AlphaShift) then
+        break;
+  end;
+
+  if (f = tfEmpty) then
+    exit;
+
+  CanCopy :=
+    (Round(FormatDesc.PixelSize * 8)     = aImage.DataDescription.Depth) and
+    (aImage.DataDescription.BitsPerPixel = aImage.DataDescription.Depth);
+
+  ImageSize := FormatDesc.GetSize(aImage.Width, aImage.Height);
+  ImageData := GetMem(ImageSize);
+  try
+    if CanCopy then
+      Move(aImage.PixelData^, ImageData^, ImageSize)
+    else
+      CopyConvert;
+    SetDataPointer(ImageData, f, aImage.Width, aImage.Height); //be careful, Data could be freed by this method
+  except
+    if Assigned(ImageData) then
+      FreeMem(ImageData);
+    raise;
+  end;
+
+  result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AssignAlphaToLazIntfImage(const aImage: TLazIntfImage): Boolean;
+var
+  rid: TRawImageDescription;
+  FormatDesc: TFormatDescriptor;
+  Pixel: TglBitmapPixelData;
+  x, y: Integer;
+  srcMD: Pointer;
+  src, dst: PByte;
+begin
+  result := false;
+  if not Assigned(aImage) or (Format = tfEmpty) then
+    exit;
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
+    exit;
+
+  FillChar(rid{%H-}, SizeOf(rid), 0);
+  rid.Format       := ricfGray;
+  rid.Width        := Width;
+  rid.Height       := Height;
+  rid.Depth        := CountSetBits(FormatDesc.Range.a);
+  rid.BitOrder     := riboBitsInOrder;
+  rid.ByteOrder    := riboLSBFirst;
+  rid.LineOrder    := riloTopToBottom;
+  rid.LineEnd      := rileTight;
+  rid.BitsPerPixel := 8 * Ceil(rid.Depth / 8);
+  rid.RedPrec      := CountSetBits(FormatDesc.Range.a);
+  rid.GreenPrec    := 0;
+  rid.BluePrec     := 0;
+  rid.AlphaPrec    := 0;
+  rid.RedShift     := 0;
+  rid.GreenShift   := 0;
+  rid.BlueShift    := 0;
+  rid.AlphaShift   := 0;
+
+  rid.MaskBitsPerPixel  := 0;
+  rid.PaletteColorCount := 0;
+
+  aImage.DataDescription := rid;
+  aImage.CreateData;
+
+  srcMD := FormatDesc.CreateMappingData;
+  try
+    FormatDesc.PreparePixel(Pixel);
+    src := Data;
+    dst := aImage.PixelData;
+    for y := 0 to Height-1 do
+      for x := 0 to Width-1 do begin
+        FormatDesc.Unmap(src, Pixel, srcMD);
+        case rid.BitsPerPixel of
+           8: begin
+            dst^ := Pixel.Data.a;
+            inc(dst);
+          end;
+          16: begin
+            PWord(dst)^ := Pixel.Data.a;
+            inc(dst, 2);
+          end;
+          24: begin
+            PByteArray(dst)^[0] := PByteArray(@Pixel.Data.a)^[0];
+            PByteArray(dst)^[1] := PByteArray(@Pixel.Data.a)^[1];
+            PByteArray(dst)^[2] := PByteArray(@Pixel.Data.a)^[2];
+            inc(dst, 3);
+          end;
+          32: begin
+            PCardinal(dst)^ := Pixel.Data.a;
+            inc(dst, 4);
+          end;
+        else
+          raise EglBitmapUnsupportedFormat.Create(Format);
+        end;
+      end;
+  finally
+    FormatDesc.FreeMappingData(srcMD);
+  end;
+  result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromLazIntfImage(const aImage: TLazIntfImage; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+  tex: TglBitmap2D;
+begin
+  tex := TglBitmap2D.Create;
+  try
+    tex.AssignFromLazIntfImage(aImage);
+    result := AddAlphaFromglBitmap(tex, aFunc, aArgs);
+  finally
+    tex.Free;
+  end;
+end;
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromResource(const aInstance: Cardinal; aResource: String; aResType: PChar;
+  const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+  rs: TResourceStream;
+begin
+  PrepareResType(aResource, aResType);
+  rs := TResourceStream.Create(aInstance, aResource, aResType);
+  try
+    result := AddAlphaFromStream(rs, aFunc, aArgs);
+  finally
+    rs.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromResourceID(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar;
+  const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+  rs: TResourceStream;
+begin
+  rs := TResourceStream.CreateFromID(aInstance, aResourceID, aResType);
+  try
+    result := AddAlphaFromStream(rs, aFunc, aArgs);
+  finally
+    rs.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromFunc(const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+begin
+  if TFormatDescriptor.Get(Format).IsCompressed then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+  result := AddFunc(Self, aFunc, false, TFormatDescriptor.Get(Format).WithAlpha, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromFile(const aFileName: String; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+  FS: TFileStream;
+begin
+  FS := TFileStream.Create(aFileName, fmOpenRead);
+  try
+    result := AddAlphaFromStream(FS, aFunc, aArgs);
+  finally
+    FS.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromStream(const aStream: TStream; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+  tex: TglBitmap2D;
+begin
+  tex := TglBitmap2D.Create(aStream);
+  try
+    result := AddAlphaFromglBitmap(tex, aFunc, aArgs);
+  finally
+    tex.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromGlBitmap(const aBitmap: TglBitmap; aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
+var
+  DestData, DestData2, SourceData: pByte;
+  TempHeight, TempWidth: Integer;
+  SourceFD, DestFD: TFormatDescriptor;
+  SourceMD, DestMD, DestMD2: Pointer;
+
+  FuncRec: TglBitmapFunctionRec;
+begin
+  result := false;
+
+  Assert(Assigned(Data));
+  Assert(Assigned(aBitmap));
+  Assert(Assigned(aBitmap.Data));
+
+  if ((aBitmap.Width = Width) and (aBitmap.Height = Height)) then begin
+    result := ConvertTo(TFormatDescriptor.Get(Format).WithAlpha);
+
+    SourceFD := TFormatDescriptor.Get(aBitmap.Format);
+    DestFD   := TFormatDescriptor.Get(Format);
+
+    if not Assigned(aFunc) then begin
+      aFunc        := glBitmapAlphaFunc;
+      FuncRec.Args := {%H-}Pointer(SourceFD.HasAlpha);
+    end else
+      FuncRec.Args := aArgs;
+
+    // Values
+    TempHeight := aBitmap.FileHeight;
+    TempWidth  := aBitmap.FileWidth;
+
+    FuncRec.Sender          := Self;
+    FuncRec.Size            := Dimension;
+    FuncRec.Position.Fields := FuncRec.Size.Fields;
+
+    DestData   := Data;
+    DestData2  := Data;
+    SourceData := aBitmap.Data;
+
+    // Mapping
+    SourceFD.PreparePixel(FuncRec.Source);
+    DestFD.PreparePixel  (FuncRec.Dest);
+
+    SourceMD := SourceFD.CreateMappingData;
+    DestMD   := DestFD.CreateMappingData;
+    DestMD2  := DestFD.CreateMappingData;
+    try
+      FuncRec.Position.Y := 0;
+      while FuncRec.Position.Y < TempHeight do begin
+        FuncRec.Position.X := 0;
+        while FuncRec.Position.X < TempWidth do begin
+          SourceFD.Unmap(SourceData, FuncRec.Source, SourceMD);
+          DestFD.Unmap  (DestData,   FuncRec.Dest,   DestMD);
+          aFunc(FuncRec);
+          DestFD.Map(FuncRec.Dest, DestData2, DestMD2);
+          inc(FuncRec.Position.X);
+        end;
+        inc(FuncRec.Position.Y);
+      end;
+    finally
+      SourceFD.FreeMappingData(SourceMD);
+      DestFD.FreeMappingData(DestMD);
+      DestFD.FreeMappingData(DestMD2);
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromColorKey(const aRed, aGreen, aBlue: Byte; const aDeviation: Byte): Boolean;
+begin
+  result := AddAlphaFromColorKeyFloat(aRed / $FF, aGreen / $FF, aBlue / $FF, aDeviation / $FF);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromColorKeyRange(const aRed, aGreen, aBlue: Cardinal; const aDeviation: Cardinal): Boolean;
+var
+  PixelData: TglBitmapPixelData;
+begin
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+  result := AddAlphaFromColorKeyFloat(
+    aRed   / PixelData.Range.r,
+    aGreen / PixelData.Range.g,
+    aBlue  / PixelData.Range.b,
+    aDeviation / Max(PixelData.Range.r, Max(PixelData.Range.g, PixelData.Range.b)));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromColorKeyFloat(const aRed, aGreen, aBlue: Single; const aDeviation: Single): Boolean;
+var
+  values: array[0..2] of Single;
+  tmp: Cardinal;
+  i: Integer;
+  PixelData: TglBitmapPixelData;
+begin
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+  with PixelData do begin
+    values[0] := aRed;
+    values[1] := aGreen;
+    values[2] := aBlue;
+
+    for i := 0 to 2 do begin
+      tmp          := Trunc(Range.arr[i] * aDeviation);
+      Data.arr[i]  := Min(Range.arr[i], Trunc(Range.arr[i] * values[i] + tmp));
+      Range.arr[i] := Max(0,            Trunc(Range.arr[i] * values[i] - tmp));
+    end;
+    Data.a  := 0;
+    Range.a := 0;
+  end;
+  result := AddAlphaFromFunc(glBitmapColorKeyAlphaFunc, @PixelData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromValue(const aAlpha: Byte): Boolean;
+begin
+  result := AddAlphaFromValueFloat(aAlpha / $FF);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromValueRange(const aAlpha: Cardinal): Boolean;
+var
+  PixelData: TglBitmapPixelData;
+begin
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+  result := AddAlphaFromValueFloat(aAlpha / PixelData.Range.a);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.AddAlphaFromValueFloat(const aAlpha: Single): Boolean;
+var
+  PixelData: TglBitmapPixelData;
+begin
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+  with PixelData do
+    Data.a := Min(Range.a, Max(0, Round(Range.a * aAlpha)));
+  result := AddAlphaFromFunc(glBitmapValueAlphaFunc, @PixelData.Data.a);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.RemoveAlpha: Boolean;
+var
+  FormatDesc: TFormatDescriptor;
+begin
+  result := false;
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if Assigned(Data) then begin
+    if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
+      raise EglBitmapUnsupportedFormat.Create(Format);
+    result := ConvertTo(FormatDesc.WithoutAlpha);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.Clone: TglBitmap;
+var
+  Temp: TglBitmap;
+  TempPtr: PByte;
+  Size: Integer;
+begin
+  result := nil;
+  Temp := (ClassType.Create as TglBitmap);
+  try
+    // copy texture data if assigned
+    if Assigned(Data) then begin
+      Size := TFormatDescriptor.Get(Format).GetSize(fDimension);
+      GetMem(TempPtr, Size);
+      try
+        Move(Data^, TempPtr^, Size);
+        Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method
+      except
+        if Assigned(TempPtr) then
+          FreeMem(TempPtr);
+        raise;
+      end;
+    end else begin
+      TempPtr := nil;
+      Temp.SetDataPointer(TempPtr, Format, Width, Height); //be careful, Data could be freed by this method
+    end;
+
+       // copy properties
+    Temp.fID                      := ID;
+    Temp.fTarget                  := Target;
+    Temp.fFormat                  := Format;
+    Temp.fMipMap                  := MipMap;
+    Temp.fAnisotropic             := Anisotropic;
+    Temp.fBorderColor             := fBorderColor;
+    Temp.fDeleteTextureOnFree     := DeleteTextureOnFree;
+    Temp.fFreeDataAfterGenTexture := FreeDataAfterGenTexture;
+    Temp.fFilterMin               := fFilterMin;
+    Temp.fFilterMag               := fFilterMag;
+    Temp.fWrapS                   := fWrapS;
+    Temp.fWrapT                   := fWrapT;
+    Temp.fWrapR                   := fWrapR;
+    Temp.fFilename                := fFilename;
+    Temp.fCustomName              := fCustomName;
+    Temp.fCustomNameW             := fCustomNameW;
+    Temp.fCustomData              := fCustomData;
+
+    result := Temp;
+  except
+    FreeAndNil(Temp);
+    raise;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.ConvertTo(const aFormat: TglBitmapFormat): Boolean;
+var
+  SourceFD, DestFD: TFormatDescriptor;
+  SourcePD, DestPD: TglBitmapPixelData;
+  ShiftData: TShiftData;
+
+  function DataIsIdentical: Boolean;
+  begin
+    result :=
+      (SourceFD.RedMask   = DestFD.RedMask)   and
+      (SourceFD.GreenMask = DestFD.GreenMask) and
+      (SourceFD.BlueMask  = DestFD.BlueMask)  and
+      (SourceFD.AlphaMask = DestFD.AlphaMask);
+  end;
+
+  function CanCopyDirect: Boolean;
+  begin
+    result :=
+      ((SourcePD.Range.r = DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
+      ((SourcePD.Range.g = DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
+      ((SourcePD.Range.b = DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
+      ((SourcePD.Range.a = DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
+  end;
+
+  function CanShift: Boolean;
+  begin
+    result :=
+      ((SourcePD.Range.r >= DestPD.Range.r) or (SourcePD.Range.r = 0) or (DestPD.Range.r = 0)) and
+      ((SourcePD.Range.g >= DestPD.Range.g) or (SourcePD.Range.g = 0) or (DestPD.Range.g = 0)) and
+      ((SourcePD.Range.b >= DestPD.Range.b) or (SourcePD.Range.b = 0) or (DestPD.Range.b = 0)) and
+      ((SourcePD.Range.a >= DestPD.Range.a) or (SourcePD.Range.a = 0) or (DestPD.Range.a = 0));
+  end;
+
+  function GetShift(aSource, aDest: Cardinal) : ShortInt;
+  begin
+    result := 0;
+    while (aSource > aDest) and (aSource > 0) do begin
+      inc(result);
+      aSource := aSource shr 1;
+    end;
+  end;
+
+begin
+  if (aFormat <> fFormat) and (aFormat <> tfEmpty) then begin
+    SourceFD := TFormatDescriptor.Get(Format);
+    DestFD   := TFormatDescriptor.Get(aFormat);
+
+    if DataIsIdentical then begin
+      result := true;
+      Format := aFormat;
+      exit;
+    end;
+
+    SourceFD.PreparePixel(SourcePD);
+    DestFD.PreparePixel  (DestPD);
+
+    if CanCopyDirect then
+      result := AddFunc(Self, glBitmapConvertCopyFunc, false, aFormat)
+    else if CanShift then begin
+      ShiftData.r := GetShift(SourcePD.Range.r, DestPD.Range.r);
+      ShiftData.g := GetShift(SourcePD.Range.g, DestPD.Range.g);
+      ShiftData.b := GetShift(SourcePD.Range.b, DestPD.Range.b);
+      ShiftData.a := GetShift(SourcePD.Range.a, DestPD.Range.a);
+      result := AddFunc(Self, glBitmapConvertShiftRGBAFunc, false, aFormat, @ShiftData);
+    end else
+      result := AddFunc(Self, glBitmapConvertCalculateRGBAFunc, false, aFormat);
+  end else
+    result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.Invert(const aUseRGB: Boolean; const aUseAlpha: Boolean);
+begin
+  if aUseRGB or aUseAlpha then
+    AddFunc(glBitmapInvertFunc, false, {%H-}Pointer(
+      ((Byte(aUseAlpha) and 1) shl 1) or
+       (Byte(aUseRGB)   and 1)      ));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetBorderColor(const aRed, aGreen, aBlue, aAlpha: Single);
+begin
+  fBorderColor[0] := aRed;
+  fBorderColor[1] := aGreen;
+  fBorderColor[2] := aBlue;
+  fBorderColor[3] := aAlpha;
+  if (ID > 0) then begin
+    Bind(false);
+    glTexParameterfv(Target, GL_TEXTURE_BORDER_COLOR, @fBorderColor[0]);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.FreeData;
+var
+  TempPtr: PByte;
+begin
+  TempPtr := nil;
+  SetDataPointer(TempPtr, tfEmpty); //be careful, Data could be freed by this method
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.FillWithColor(const aRed, aGreen, aBlue: Byte;
+  const aAlpha: Byte);
+begin
+  FillWithColorFloat(aRed/$FF, aGreen/$FF, aBlue/$FF, aAlpha/$FF);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.FillWithColorRange(const aRed, aGreen, aBlue: Cardinal; const aAlpha: Cardinal);
+var
+  PixelData: TglBitmapPixelData;
+begin
+  TFormatDescriptor.GetAlpha(Format).PreparePixel(PixelData);
+  FillWithColorFloat(
+    aRed   / PixelData.Range.r,
+    aGreen / PixelData.Range.g,
+    aBlue  / PixelData.Range.b,
+    aAlpha / PixelData.Range.a);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.FillWithColorFloat(const aRed, aGreen, aBlue: Single; const aAlpha: Single);
+var
+  PixelData: TglBitmapPixelData;
+begin
+  TFormatDescriptor.Get(Format).PreparePixel(PixelData);
+  with PixelData do begin
+    Data.r := Max(0, Min(Range.r, Trunc(Range.r * aRed)));
+    Data.g := Max(0, Min(Range.g, Trunc(Range.g * aGreen)));
+    Data.b := Max(0, Min(Range.b, Trunc(Range.b * aBlue)));
+    Data.a := Max(0, Min(Range.a, Trunc(Range.a * aAlpha)));
+  end;
+  AddFunc(glBitmapFillWithColorFunc, false, @PixelData);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetFilter(const aMin, aMag: GLenum);
+begin
+  //check MIN filter
+  case aMin of
+    GL_NEAREST:
+      fFilterMin := GL_NEAREST;
+    GL_LINEAR:
+      fFilterMin := GL_LINEAR;
+    GL_NEAREST_MIPMAP_NEAREST:
+      fFilterMin := GL_NEAREST_MIPMAP_NEAREST;
+    GL_LINEAR_MIPMAP_NEAREST:
+      fFilterMin := GL_LINEAR_MIPMAP_NEAREST;
+    GL_NEAREST_MIPMAP_LINEAR:
+      fFilterMin := GL_NEAREST_MIPMAP_LINEAR;
+    GL_LINEAR_MIPMAP_LINEAR:
+      fFilterMin := GL_LINEAR_MIPMAP_LINEAR;
+    else
+      raise EglBitmap.Create('SetFilter - Unknow MIN filter.');
+  end;
+
+  //check MAG filter
+  case aMag of
+    GL_NEAREST:
+      fFilterMag := GL_NEAREST;
+    GL_LINEAR:
+      fFilterMag := GL_LINEAR;
+    else
+      raise EglBitmap.Create('SetFilter - Unknow MAG filter.');
+  end;
+
+  //apply filter
+  if (ID > 0) then begin
+    Bind(false);
+    glTexParameteri(Target, GL_TEXTURE_MAG_FILTER, fFilterMag);
+
+    if (MipMap = mmNone) or (Target = GL_TEXTURE_RECTANGLE) then begin
+      case fFilterMin of
+        GL_NEAREST, GL_LINEAR:
+          glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
+        GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR:
+          glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR:
+          glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+      end;
+    end else
+      glTexParameteri(Target, GL_TEXTURE_MIN_FILTER, fFilterMin);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetWrap(const S: GLenum; const T: GLenum; const R: GLenum);
+
+  procedure CheckAndSetWrap(const aValue: Cardinal; var aTarget: Cardinal);
+  begin
+    case aValue of
+      GL_CLAMP:
+        aTarget := GL_CLAMP;
+
+      GL_REPEAT:
+        aTarget := GL_REPEAT;
+
+      GL_CLAMP_TO_EDGE: begin
+        if GL_VERSION_1_2 or GL_EXT_texture_edge_clamp then
+          aTarget := GL_CLAMP_TO_EDGE
+        else
+          aTarget := GL_CLAMP;
+      end;
+
+      GL_CLAMP_TO_BORDER: begin
+        if GL_VERSION_1_3 or GL_ARB_texture_border_clamp then
+          aTarget := GL_CLAMP_TO_BORDER
+        else
+          aTarget := GL_CLAMP;
+      end;
+
+      GL_MIRRORED_REPEAT: begin
+        if GL_VERSION_1_4 or GL_ARB_texture_mirrored_repeat or GL_IBM_texture_mirrored_repeat then
+          aTarget := GL_MIRRORED_REPEAT
+        else
+          raise EglBitmap.Create('SetWrap - Unsupported Texturewrap GL_MIRRORED_REPEAT (S).');
+      end;
+    else
+      raise EglBitmap.Create('SetWrap - Unknow Texturewrap');
+    end;
+  end;
+
+begin
+  CheckAndSetWrap(S, fWrapS);
+  CheckAndSetWrap(T, fWrapT);
+  CheckAndSetWrap(R, fWrapR);
+
+  if (ID > 0) then begin
+    Bind(false);
+    glTexParameteri(Target, GL_TEXTURE_WRAP_S, fWrapS);
+    glTexParameteri(Target, GL_TEXTURE_WRAP_T, fWrapT);
+    glTexParameteri(Target, GL_TEXTURE_WRAP_R, fWrapR);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SetSwizzle(const r, g, b, a: GLenum);
+
+  procedure CheckAndSetValue(const aValue: GLenum; const aIndex: Integer);
+  begin
+    if (aValue = GL_ZERO) or (aValue =   GL_ONE) or (aValue = GL_ALPHA) or
+       (aValue =  GL_RED) or (aValue = GL_GREEN) or (aValue =  GL_BLUE) then
+      fSwizzle[aIndex] := aValue
+    else
+      raise EglBitmap.Create('SetSwizzle - Unknow Swizle Value');
+  end;
+
+begin
+  if not (GL_ARB_texture_swizzle or GL_EXT_texture_swizzle or GL_VERSION_3_3) then
+    raise EglBitmapNotSupported.Create('texture swizzle is not supported');
+  CheckAndSetValue(r, 0);
+  CheckAndSetValue(g, 1);
+  CheckAndSetValue(b, 2);
+  CheckAndSetValue(a, 3);
+
+  if (ID > 0) then begin
+    Bind(false);
+    glTexParameteriv(Target, GL_TEXTURE_SWIZZLE_RGBA, PGLint(@fSwizzle[0]));
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.Bind(const aEnableTextureUnit: Boolean);
+begin
+  if aEnableTextureUnit then
+    glEnable(Target);
+  if (ID > 0) then
+    glBindTexture(Target, ID);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.Unbind(const aDisableTextureUnit: Boolean);
+begin
+  if aDisableTextureUnit then
+    glDisable(Target);
+  glBindTexture(Target, 0);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create;
+begin
+  if (ClassType = TglBitmap) then
+    raise EglBitmap.Create('Don''t create TglBitmap directly. Use one of the deviated classes (TglBitmap2D) instead.');
+{$IFDEF GLB_NATIVE_OGL}
+  glbReadOpenGLExtensions;
+{$ENDIF}
+  inherited Create;
+  fFormat            := glBitmapGetDefaultFormat;
+  fFreeDataOnDestroy := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create(const aFileName: String);
+begin
+  Create;
+  LoadFromFile(aFileName);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create(const aStream: TStream);
+begin
+  Create;
+  LoadFromStream(aStream);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; aData: PByte);
+var
+  ImageSize: Integer;
+begin
+  Create;
+  if not Assigned(aData) then begin
+    ImageSize := TFormatDescriptor.Get(aFormat).GetSize(aSize);
+    GetMem(aData, ImageSize);
+    try
+      FillChar(aData^, ImageSize, #$FF);
+      SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method
+    except
+      if Assigned(aData) then
+        FreeMem(aData);
+      raise;
+    end;
+  end else begin
+    SetDataPointer(aData, aFormat, aSize.X, aSize.Y); //be careful, Data could be freed by this method
+    fFreeDataOnDestroy := false;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create(const aSize: TglBitmapPixelPosition; const aFormat: TglBitmapFormat; const aFunc: TglBitmapFunction; const aArgs: Pointer);
+begin
+  Create;
+  LoadFromFunc(aSize, aFunc, aFormat, aArgs);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create(const aInstance: Cardinal; const aResource: String; const aResType: PChar);
+begin
+  Create;
+  LoadFromResource(aInstance, aResource, aResType);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglBitmap.Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar);
+begin
+  Create;
+  LoadFromResourceID(aInstance, aResourceID, aResType);
+end;
+
+{$IFDEF GLB_SUPPORT_PNG_READ}
+{$IF DEFINED(GLB_LAZ_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//PNG/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
+const
+  MAGIC_LEN = 8;
+  PNG_MAGIC: String[MAGIC_LEN] = #$89#$50#$4E#$47#$0D#$0A#$1A#$0A;
+var
+  reader: TLazReaderPNG;
+  intf: TLazIntfImage;
+  StreamPos: Int64;
+  magic: String[MAGIC_LEN];
+begin
+  result := true;
+  StreamPos := aStream.Position;
+
+  SetLength(magic, MAGIC_LEN);
+  aStream.Read(magic[1], MAGIC_LEN);
+  aStream.Position := StreamPos;
+  if (magic <> PNG_MAGIC) then begin
+    result := false;
+    exit;
+  end;
+
+  intf   := TLazIntfImage.Create(0, 0);
+  reader := TLazReaderPNG.Create;
+  try try
+    reader.UpdateDescription := true;
+    reader.ImageRead(aStream, intf);
+    AssignFromLazIntfImage(intf);
+  except
+    result := false;
+    aStream.Position := StreamPos;
+    exit;
+  end;
+  finally
+    reader.Free;
+    intf.Free;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
+var
+  Surface: PSDL_Surface;
+  RWops: PSDL_RWops;
+begin
+  result := false;
+  RWops := glBitmapCreateRWops(aStream);
+  try
+    if IMG_isPNG(RWops) > 0 then begin
+      Surface := IMG_LoadPNG_RW(RWops);
+      try
+        AssignFromSurface(Surface);
+        result := true;
+      finally
+        SDL_FreeSurface(Surface);
+      end;
+    end;
+  finally
+    SDL_FreeRW(RWops);
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libPNG_read_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
+begin
+  TStream(png_get_io_ptr(png)).Read(buffer^, size);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
+var
+  StreamPos: Int64;
+  signature: array [0..7] of byte;
+  png: png_structp;
+  png_info: png_infop;
+
+  TempHeight, TempWidth: Integer;
+  Format: TglBitmapFormat;
+
+  png_data: pByte;
+  png_rows: array of pByte;
+  Row, LineSize: Integer;
+begin
+  result := false;
+
+  if not init_libPNG then
+    raise Exception.Create('LoadPNG - unable to initialize libPNG.');
+
+  try
+    // signature
+    StreamPos := aStream.Position;
+    aStream.Read(signature{%H-}, 8);
+    aStream.Position := StreamPos;
+
+    if png_check_sig(@signature, 8) <> 0 then begin
+      // png read struct
+      png := png_create_read_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
+      if png = nil then
+        raise EglBitmapException.Create('LoadPng - couldn''t create read struct.');
+
+      // png info
+      png_info := png_create_info_struct(png);
+      if png_info = nil then begin
+        png_destroy_read_struct(@png, nil, nil);
+        raise EglBitmapException.Create('LoadPng - couldn''t create info struct.');
+      end;
+
+      // set read callback
+      png_set_read_fn(png, aStream, glBitmap_libPNG_read_func);
+
+      // read informations
+      png_read_info(png, png_info);
+
+      // size
+      TempHeight := png_get_image_height(png, png_info);
+      TempWidth := png_get_image_width(png, png_info);
+
+      // format
+      case png_get_color_type(png, png_info) of
+        PNG_COLOR_TYPE_GRAY:
+          Format := tfLuminance8;
+        PNG_COLOR_TYPE_GRAY_ALPHA:
+          Format := tfLuminance8Alpha8;
+        PNG_COLOR_TYPE_RGB:
+          Format := tfRGB8;
+        PNG_COLOR_TYPE_RGB_ALPHA:
+          Format := tfRGBA8;
+        else
+          raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
+      end;
+
+      // cut upper 8 bit from 16 bit formats
+      if png_get_bit_depth(png, png_info) > 8 then
+        png_set_strip_16(png);
+
+      // expand bitdepth smaller than 8
+      if png_get_bit_depth(png, png_info) < 8 then
+        png_set_expand(png);
+
+      // allocating mem for scanlines
+      LineSize := png_get_rowbytes(png, png_info);
+      GetMem(png_data, TempHeight * LineSize);
+      try
+        SetLength(png_rows, TempHeight);
+        for Row := Low(png_rows) to High(png_rows) do begin
+          png_rows[Row] := png_data;
+          Inc(png_rows[Row], Row * LineSize);
+        end;
+
+        // read complete image into scanlines
+        png_read_image(png, @png_rows[0]);
+
+        // read end
+        png_read_end(png, png_info);
+
+        // destroy read struct
+        png_destroy_read_struct(@png, @png_info, nil);
+
+        SetLength(png_rows, 0);
+
+        // set new data
+        SetDataPointer(png_data, Format, TempWidth, TempHeight); //be careful, Data could be freed by this method
+
+        result := true;
+      except
+        if Assigned(png_data) then
+          FreeMem(png_data);
+        raise;
+      end;
+    end;
+  finally
+    quit_libPNG;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_PNGIMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadPNG(const aStream: TStream): Boolean;
+var
+  StreamPos: Int64;
+  Png: TPNGObject;
+  Header: String[8];
+  Row, Col, PixSize, LineSize: Integer;
+  NewImage, pSource, pDest, pAlpha: pByte;
+  PngFormat: TglBitmapFormat;
+  FormatDesc: TFormatDescriptor;
+
+const
+  PngHeader: String[8] = #137#80#78#71#13#10#26#10;
+
+begin
+  result := false;
+
+  StreamPos := aStream.Position;
+  aStream.Read(Header[0], SizeOf(Header));
+  aStream.Position := StreamPos;
+
+  {Test if the header matches}
+  if Header = PngHeader then begin
+    Png := TPNGObject.Create;
+    try
+      Png.LoadFromStream(aStream);
+
+      case Png.Header.ColorType of
+        COLOR_GRAYSCALE:
+          PngFormat := tfLuminance8;
+        COLOR_GRAYSCALEALPHA:
+          PngFormat := tfLuminance8Alpha8;
+        COLOR_RGB:
+          PngFormat := tfBGR8;
+        COLOR_RGBALPHA:
+          PngFormat := tfBGRA8;
+        else
+          raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
+      end;
+
+      FormatDesc := TFormatDescriptor.Get(PngFormat);
+      PixSize    := Round(FormatDesc.PixelSize);
+      LineSize   := FormatDesc.GetSize(Png.Header.Width, 1);
+
+      GetMem(NewImage, LineSize * Integer(Png.Header.Height));
+      try
+        pDest := NewImage;
+
+        case Png.Header.ColorType of
+          COLOR_RGB, COLOR_GRAYSCALE:
+            begin
+              for Row := 0 to Png.Height -1 do begin
+                Move (Png.Scanline[Row]^, pDest^, LineSize);
+                Inc(pDest, LineSize);
+              end;
+            end;
+          COLOR_RGBALPHA, COLOR_GRAYSCALEALPHA:
+            begin
+              PixSize := PixSize -1;
+
+              for Row := 0 to Png.Height -1 do begin
+                pSource := Png.Scanline[Row];
+                pAlpha := pByte(Png.AlphaScanline[Row]);
+
+                for Col := 0 to Png.Width -1 do begin
+                  Move (pSource^, pDest^, PixSize);
+                  Inc(pSource, PixSize);
+                  Inc(pDest, PixSize);
+
+                  pDest^ := pAlpha^;
+                  inc(pAlpha);
+                  Inc(pDest);
+                end;
+              end;
+            end;
+          else
+            raise EglBitmapException.Create ('LoadPng - Unsupported Colortype found.');
+        end;
+
+        SetDataPointer(NewImage, PngFormat, Png.Header.Width, Png.Header.Height); //be careful, Data could be freed by this method
+
+        result := true;
+      except
+        if Assigned(NewImage) then
+          FreeMem(NewImage);
+        raise;
+      end;
+    finally
+      Png.Free;
+    end;
+  end;
+end;
+{$IFEND}
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_PNG_WRITE}
+{$IFDEF GLB_LIB_PNG}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libPNG_write_func(png: png_structp; buffer: png_bytep; size: cardinal); cdecl;
+begin
+  TStream(png_get_io_ptr(png)).Write(buffer^, size);
+end;
+{$ENDIF}
+
+{$IF DEFINED(GLB_LAZ_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SavePNG(const aStream: TStream);
+var
+  png: TPortableNetworkGraphic;
+  intf: TLazIntfImage;
+  raw: TRawImage;
+begin
+  png  := TPortableNetworkGraphic.Create;
+  intf := TLazIntfImage.Create(0, 0);
+  try
+    if not AssignToLazIntfImage(intf) then
+      raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
+    intf.GetRawImage(raw);
+    png.LoadFromRawImage(raw, false);
+    png.SaveToStream(aStream);
+  finally
+    png.Free;
+    intf.Free;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_PNG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SavePNG(const aStream: TStream);
+var
+  png: png_structp;
+  png_info: png_infop;
+  png_rows: array of pByte;
+  LineSize: Integer;
+  ColorType: Integer;
+  Row: Integer;
+  FormatDesc: TFormatDescriptor;
+begin
+  if not (ftPNG in FormatGetSupportedFiles(Format)) then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  if not init_libPNG then
+    raise Exception.Create('unable to initialize libPNG.');
+
+  try
+    case Format of
+      tfAlpha8, tfLuminance8:
+        ColorType := PNG_COLOR_TYPE_GRAY;
+      tfLuminance8Alpha8:
+        ColorType := PNG_COLOR_TYPE_GRAY_ALPHA;
+      tfBGR8, tfRGB8:
+        ColorType := PNG_COLOR_TYPE_RGB;
+      tfBGRA8, tfRGBA8:
+        ColorType := PNG_COLOR_TYPE_RGBA;
+      else
+        raise EglBitmapUnsupportedFormat.Create(Format);
+    end;
+
+    FormatDesc := TFormatDescriptor.Get(Format);
+    LineSize := FormatDesc.GetSize(Width, 1);
+
+    // creating array for scanline
+    SetLength(png_rows, Height);
+    try
+      for Row := 0 to Height - 1 do begin
+        png_rows[Row] := Data;
+        Inc(png_rows[Row], Row * LineSize)
+      end;
+
+      // write struct
+      png := png_create_write_struct(PNG_LIBPNG_VER_STRING, nil, nil, nil);
+      if png = nil then
+        raise EglBitmapException.Create('SavePng - couldn''t create write struct.');
+
+      // create png info
+      png_info := png_create_info_struct(png);
+      if png_info = nil then begin
+        png_destroy_write_struct(@png, nil);
+        raise EglBitmapException.Create('SavePng - couldn''t create info struct.');
+      end;
+
+      // set read callback
+      png_set_write_fn(png, aStream, glBitmap_libPNG_write_func, nil);
+
+      // set compression
+      png_set_compression_level(png, 6);
+
+      if Format in [tfBGR8, tfBGRA8] then
+        png_set_bgr(png);
+
+      png_set_IHDR(png, png_info, Width, Height, 8, ColorType, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+      png_write_info(png, png_info);
+      png_write_image(png, @png_rows[0]);
+      png_write_end(png, png_info);
+      png_destroy_write_struct(@png, @png_info);
+    finally
+      SetLength(png_rows, 0);
+    end;
+  finally
+    quit_libPNG;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_PNGIMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SavePNG(const aStream: TStream);
+var
+  Png: TPNGObject;
+
+  pSource, pDest: pByte;
+  X, Y, PixSize: Integer;
+  ColorType: Cardinal;
+  Alpha: Boolean;
+
+  pTemp: pByte;
+  Temp: Byte;
+begin
+  if not (ftPNG in FormatGetSupportedFiles (Format)) then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  case Format of
+    tfAlpha8, tfLuminance8: begin
+      ColorType := COLOR_GRAYSCALE;
+      PixSize   := 1;
+      Alpha     := false;
+    end;
+    tfLuminance8Alpha8: begin
+      ColorType := COLOR_GRAYSCALEALPHA;
+      PixSize   := 1;
+      Alpha     := true;
+    end;
+    tfBGR8, tfRGB8: begin
+      ColorType := COLOR_RGB;
+      PixSize   := 3;
+      Alpha     := false;
+    end;
+    tfBGRA8, tfRGBA8: begin
+      ColorType := COLOR_RGBALPHA;
+      PixSize   := 3;
+      Alpha     := true
+    end;
+  else
+    raise EglBitmapUnsupportedFormat.Create(Format);
+  end;
+
+  Png := TPNGObject.CreateBlank(ColorType, 8, Width, Height);
+  try
+    // Copy ImageData
+    pSource := Data;
+    for Y := 0 to Height -1 do begin
+      pDest := png.ScanLine[Y];
+      for X := 0 to Width -1 do begin
+        Move(pSource^, pDest^, PixSize);
+        Inc(pDest, PixSize);
+        Inc(pSource, PixSize);
+        if Alpha then begin
+          png.AlphaScanline[Y]^[X] := pSource^;
+          Inc(pSource);
+        end;
+      end;
+
+      // convert RGB line to BGR
+      if Format in [tfRGB8, tfRGBA8] then begin
+        pTemp := png.ScanLine[Y];
+        for X := 0 to Width -1 do begin
+          Temp := pByteArray(pTemp)^[0];
+          pByteArray(pTemp)^[0] := pByteArray(pTemp)^[2];
+          pByteArray(pTemp)^[2] := Temp;
+          Inc(pTemp, 3);
+        end;
+      end;
+    end;
+
+    // Save to Stream
+    Png.CompressionLevel := 6;
+    Png.SaveToStream(aStream);
+  finally
+    FreeAndNil(Png);
+  end;
+end;
+{$IFEND}
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//JPEG////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+{$IFDEF GLB_LIB_JPEG}
+type
+  glBitmap_libJPEG_source_mgr_ptr = ^glBitmap_libJPEG_source_mgr;
+  glBitmap_libJPEG_source_mgr = record
+    pub: jpeg_source_mgr;
+
+    SrcStream: TStream;
+    SrcBuffer: array [1..4096] of byte;
+  end;
+
+  glBitmap_libJPEG_dest_mgr_ptr = ^glBitmap_libJPEG_dest_mgr;
+  glBitmap_libJPEG_dest_mgr = record
+    pub: jpeg_destination_mgr;
+
+    DestStream: TStream;
+    DestBuffer: array [1..4096] of byte;
+  end;
+
+procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl;
+begin
+  //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl;
+begin
+  //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl;
+begin
+  //DUMMY
+end;
+
+procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl;
+begin
+  //DUMMY
+end;
+
+
+procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl;
+begin
+  //DUMMY
+end;
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl;
+var
+  src: glBitmap_libJPEG_source_mgr_ptr;
+  bytes: integer;
+begin
+  src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
+
+  bytes := src^.SrcStream.Read(src^.SrcBuffer[1], 4096);
+       if (bytes <= 0) then begin
+               src^.SrcBuffer[1] := $FF;
+               src^.SrcBuffer[2] := JPEG_EOI;
+               bytes := 2;
+       end;
+
+       src^.pub.next_input_byte := @(src^.SrcBuffer[1]);
+       src^.pub.bytes_in_buffer := bytes;
+
+  result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libJPEG_skip_input_data(cinfo: j_decompress_ptr; num_bytes: Longint); cdecl;
+var
+  src: glBitmap_libJPEG_source_mgr_ptr;
+begin
+  src := glBitmap_libJPEG_source_mgr_ptr(cinfo^.src);
+
+  if num_bytes > 0 then begin
+    // wanted byte isn't in buffer so set stream position and read buffer
+    if num_bytes > src^.pub.bytes_in_buffer then begin
+      src^.SrcStream.Position := src^.SrcStream.Position + num_bytes - src^.pub.bytes_in_buffer;
+      src^.pub.fill_input_buffer(cinfo);
+    end else begin
+      // wanted byte is in buffer so only skip
+               inc(src^.pub.next_input_byte, num_bytes);
+               dec(src^.pub.bytes_in_buffer, num_bytes);
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl;
+var
+  dest: glBitmap_libJPEG_dest_mgr_ptr;
+begin
+  dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
+
+  if dest^.pub.free_in_buffer < Cardinal(Length(dest^.DestBuffer)) then begin
+    // write complete buffer
+    dest^.DestStream.Write(dest^.DestBuffer[1], SizeOf(dest^.DestBuffer));
+
+    // reset buffer
+    dest^.pub.next_output_byte := @dest^.DestBuffer[1];
+    dest^.pub.free_in_buffer := Length(dest^.DestBuffer);
+  end;
+
+  result := true;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmap_libJPEG_term_destination(cinfo: j_compress_ptr); cdecl;
+var
+  Idx: Integer;
+  dest: glBitmap_libJPEG_dest_mgr_ptr;
+begin
+  dest := glBitmap_libJPEG_dest_mgr_ptr(cinfo^.dest);
+
+  for Idx := Low(dest^.DestBuffer) to High(dest^.DestBuffer) do begin
+    // check for endblock
+    if (Idx < High(dest^.DestBuffer)) and (dest^.DestBuffer[Idx] = $FF) and (dest^.DestBuffer[Idx +1] = JPEG_EOI) then begin
+      // write endblock
+      dest^.DestStream.Write(dest^.DestBuffer[Idx], 2);
+
+      // leave
+      break;
+    end else
+      dest^.DestStream.Write(dest^.DestBuffer[Idx], 1);
+  end;
+end;
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_JPEG_READ}
+{$IF DEFINED(GLB_LAZ_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
+const
+  MAGIC_LEN = 2;
+  JPEG_MAGIC: String[MAGIC_LEN] = #$FF#$D8;
+var
+  intf: TLazIntfImage;
+  reader: TFPReaderJPEG;
+  StreamPos: Int64;
+  magic: String[MAGIC_LEN];
+begin
+  result := true;
+  StreamPos := aStream.Position;
+
+  SetLength(magic, MAGIC_LEN);
+  aStream.Read(magic[1], MAGIC_LEN);
+  aStream.Position := StreamPos;
+  if (magic <> JPEG_MAGIC) then begin
+    result := false;
+    exit;
+  end;
+
+  reader := TFPReaderJPEG.Create;
+  intf := TLazIntfImage.Create(0, 0);
+  try try
+    intf.DataDescription := GetDescriptionFromDevice(0, 0, 0);
+    reader.ImageRead(aStream, intf);
+    AssignFromLazIntfImage(intf);
+  except
+    result := false;
+    aStream.Position := StreamPos;
+    exit;
+  end;
+  finally
+    reader.Free;
+    intf.Free;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_SDL_IMAGE)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
+var
+  Surface: PSDL_Surface;
+  RWops: PSDL_RWops;
+begin
+  result := false;
+
+  RWops := glBitmapCreateRWops(aStream);
+  try
+    if IMG_isJPG(RWops) > 0 then begin
+      Surface := IMG_LoadJPG_RW(RWops);
+      try
+        AssignFromSurface(Surface);
+        result := true;
+      finally
+        SDL_FreeSurface(Surface);
+      end;
+    end;
+  finally
+    SDL_FreeRW(RWops);
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
+var
+  StreamPos: Int64;
+  Temp: array[0..1]of Byte;
+
+  jpeg: jpeg_decompress_struct;
+  jpeg_err: jpeg_error_mgr;
+
+  IntFormat: TglBitmapFormat;
+  pImage: pByte;
+  TempHeight, TempWidth: Integer;
+
+  pTemp: pByte;
+  Row: Integer;
+
+  FormatDesc: TFormatDescriptor;
+begin
+  result := false;
+
+  if not init_libJPEG then
+    raise Exception.Create('LoadJPG - unable to initialize libJPEG.');
+
+  try
+    // reading first two bytes to test file and set cursor back to begin
+    StreamPos := aStream.Position;
+    aStream.Read({%H-}Temp[0], 2);
+    aStream.Position := StreamPos;
+
+    // if Bitmap then read file.
+    if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
+      FillChar(jpeg{%H-}, SizeOf(jpeg_decompress_struct), $00);
+      FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
+
+      // error managment
+      jpeg.err := jpeg_std_error(@jpeg_err);
+      jpeg_err.error_exit     := glBitmap_libJPEG_error_exit;
+      jpeg_err.output_message := glBitmap_libJPEG_output_message;
+
+      // decompression struct
+      jpeg_create_decompress(@jpeg);
+
+      // allocation space for streaming methods
+      jpeg.src := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_source_mgr));
+
+      // seeting up custom functions
+      with glBitmap_libJPEG_source_mgr_ptr(jpeg.src)^ do begin
+        pub.init_source       := glBitmap_libJPEG_init_source;
+        pub.fill_input_buffer := glBitmap_libJPEG_fill_input_buffer;
+        pub.skip_input_data   := glBitmap_libJPEG_skip_input_data;
+        pub.resync_to_restart := jpeg_resync_to_restart; // use default method
+        pub.term_source       := glBitmap_libJPEG_term_source;
+
+        pub.bytes_in_buffer := 0;     // forces fill_input_buffer on first read
+        pub.next_input_byte := nil;   // until buffer loaded
+
+        SrcStream := aStream;
+      end;
+
+      // set global decoding state
+      jpeg.global_state := DSTATE_START;
+
+      // read header of jpeg
+      jpeg_read_header(@jpeg, false);
+
+      // setting output parameter
+      case jpeg.jpeg_color_space of
+        JCS_GRAYSCALE:
+          begin
+            jpeg.out_color_space := JCS_GRAYSCALE;
+            IntFormat := tfLuminance8;
+          end;
+        else
+          jpeg.out_color_space := JCS_RGB;
+          IntFormat := tfRGB8;
+      end;
+
+      // reading image
+      jpeg_start_decompress(@jpeg);
+
+      TempHeight := jpeg.output_height;
+      TempWidth := jpeg.output_width;
+
+      FormatDesc := TFormatDescriptor.Get(IntFormat);
+
+      // creating new image
+      GetMem(pImage, FormatDesc.GetSize(TempWidth, TempHeight));
+      try
+        pTemp := pImage;
+
+        for Row := 0 to TempHeight -1 do begin
+          jpeg_read_scanlines(@jpeg, @pTemp, 1);
+          Inc(pTemp, FormatDesc.GetSize(TempWidth, 1));
+        end;
+
+        // finish decompression
+        jpeg_finish_decompress(@jpeg);
+
+        // destroy decompression
+        jpeg_destroy_decompress(@jpeg);
+
+        SetDataPointer(pImage, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
+
+        result := true;
+      except
+        if Assigned(pImage) then
+          FreeMem(pImage);
+        raise;
+      end;
+    end;
+  finally
+    quit_libJPEG;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadJPEG(const aStream: TStream): Boolean;
+var
+  bmp: TBitmap;
+  jpg: TJPEGImage;
+  StreamPos: Int64;
+  Temp: array[0..1]of Byte;
+begin
+  result := false;
+
+  // reading first two bytes to test file and set cursor back to begin
+  StreamPos := aStream.Position;
+  aStream.Read(Temp[0], 2);
+  aStream.Position := StreamPos;
+
+  // if Bitmap then read file.
+  if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
+    bmp := TBitmap.Create;
+    try
+      jpg := TJPEGImage.Create;
+      try
+        jpg.LoadFromStream(aStream);
+        bmp.Assign(jpg);
+        result := AssignFromBitmap(bmp);
+      finally
+        jpg.Free;
+      end;
+    finally
+      bmp.Free;
+    end;
+  end;
+end;
+{$IFEND}
+{$ENDIF}
+
+{$IFDEF GLB_SUPPORT_JPEG_WRITE}
+{$IF DEFINED(GLB_LAZ_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveJPEG(const aStream: TStream);
+var
+  jpeg: TJPEGImage;
+  intf: TLazIntfImage;
+  raw: TRawImage;
+begin
+  jpeg := TJPEGImage.Create;
+  intf := TLazIntfImage.Create(0, 0);
+  try
+    if not AssignToLazIntfImage(intf) then
+      raise EglBitmap.Create('unable to create LazIntfImage from glBitmap');
+    intf.GetRawImage(raw);
+    jpeg.LoadFromRawImage(raw, false);
+    jpeg.SaveToStream(aStream);
+  finally
+    intf.Free;
+    jpeg.Free;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_LIB_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveJPEG(const aStream: TStream);
+var
+  jpeg: jpeg_compress_struct;
+  jpeg_err: jpeg_error_mgr;
+  Row: Integer;
+  pTemp, pTemp2: pByte;
+
+  procedure CopyRow(pDest, pSource: pByte);
+  var
+    X: Integer;
+  begin
+    for X := 0 to Width - 1 do begin
+      pByteArray(pDest)^[0] := pByteArray(pSource)^[2];
+      pByteArray(pDest)^[1] := pByteArray(pSource)^[1];
+      pByteArray(pDest)^[2] := pByteArray(pSource)^[0];
+      Inc(pDest, 3);
+      Inc(pSource, 3);
+    end;
+  end;
+
+begin
+  if not (ftJPEG in FormatGetSupportedFiles(Format)) then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  if not init_libJPEG then
+    raise Exception.Create('SaveJPG - unable to initialize libJPEG.');
+
+  try
+    FillChar(jpeg{%H-}, SizeOf(jpeg_compress_struct), $00);
+    FillChar(jpeg_err{%H-}, SizeOf(jpeg_error_mgr), $00);
+
+    // error managment
+    jpeg.err := jpeg_std_error(@jpeg_err);
+    jpeg_err.error_exit     := glBitmap_libJPEG_error_exit;
+    jpeg_err.output_message := glBitmap_libJPEG_output_message;
+
+    // compression struct
+    jpeg_create_compress(@jpeg);
+
+    // allocation space for streaming methods
+    jpeg.dest := jpeg.mem^.alloc_small(@jpeg, JPOOL_PERMANENT, SizeOf(glBitmap_libJPEG_dest_mgr));
+
+    // seeting up custom functions
+    with glBitmap_libJPEG_dest_mgr_ptr(jpeg.dest)^ do begin
+      pub.init_destination    := glBitmap_libJPEG_init_destination;
+      pub.empty_output_buffer := glBitmap_libJPEG_empty_output_buffer;
+      pub.term_destination    := glBitmap_libJPEG_term_destination;
+
+      pub.next_output_byte  := @DestBuffer[1];
+      pub.free_in_buffer    := Length(DestBuffer);
+
+      DestStream := aStream;
+    end;
+
+    // very important state
+    jpeg.global_state := CSTATE_START;
+    jpeg.image_width  := Width;
+    jpeg.image_height := Height;
+    case Format of
+      tfAlpha8, tfLuminance8: begin
+        jpeg.input_components := 1;
+        jpeg.in_color_space   := JCS_GRAYSCALE;
+      end;
+      tfRGB8, tfBGR8: begin
+        jpeg.input_components := 3;
+        jpeg.in_color_space   := JCS_RGB;
+      end;
+    end;
+
+    jpeg_set_defaults(@jpeg);
+    jpeg_set_quality(@jpeg, 95, true);
+    jpeg_start_compress(@jpeg, true);
+    pTemp := Data;
+
+    if Format = tfBGR8 then
+      GetMem(pTemp2, fRowSize)
+    else
+      pTemp2 := pTemp;
+
+    try
+      for Row := 0 to jpeg.image_height -1 do begin
+        // prepare row
+        if Format = tfBGR8 then
+          CopyRow(pTemp2, pTemp)
+        else
+          pTemp2 := pTemp;
+
+        // write row
+        jpeg_write_scanlines(@jpeg, @pTemp2, 1);
+        inc(pTemp, fRowSize);
+      end;
+    finally
+      // free memory
+      if Format = tfBGR8 then
+        FreeMem(pTemp2);
+    end;
+    jpeg_finish_compress(@jpeg);
+    jpeg_destroy_compress(@jpeg);
+  finally
+    quit_libJPEG;
+  end;
+end;
+
+{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveJPEG(const aStream: TStream);
+var
+  Bmp: TBitmap;
+  Jpg: TJPEGImage;
+begin
+  if not (ftJPEG in FormatGetSupportedFiles(Format)) then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  Bmp := TBitmap.Create;
+  try
+    Jpg := TJPEGImage.Create;
+    try
+      AssignToBitmap(Bmp);
+      if (Format in [tfAlpha8, tfLuminance8]) then begin
+        Jpg.Grayscale   := true;
+        Jpg.PixelFormat := jf8Bit;
+      end;
+      Jpg.Assign(Bmp);
+      Jpg.SaveToStream(aStream);
+    finally
+      FreeAndNil(Jpg);
+    end;
+  finally
+    FreeAndNil(Bmp);
+  end;
+end;
+{$IFEND}
+{$ENDIF}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//BMP/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+const
+  BMP_MAGIC          = $4D42;
+
+  BMP_COMP_RGB       = 0;
+  BMP_COMP_RLE8      = 1;
+  BMP_COMP_RLE4      = 2;
+  BMP_COMP_BITFIELDS = 3;
+
+type
+  TBMPHeader = packed record
+    bfType: Word;
+    bfSize: Cardinal;
+    bfReserved1: Word;
+    bfReserved2: Word;
+    bfOffBits: Cardinal;
+  end;
+
+  TBMPInfo = packed record
+    biSize: Cardinal;
+    biWidth: Longint;
+    biHeight: Longint;
+    biPlanes: Word;
+    biBitCount: Word;
+    biCompression: Cardinal;
+    biSizeImage: Cardinal;
+    biXPelsPerMeter: Longint;
+    biYPelsPerMeter: Longint;
+    biClrUsed: Cardinal;
+    biClrImportant: Cardinal;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadBMP(const aStream: TStream): Boolean;
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  function ReadInfo(out aInfo: TBMPInfo; out aMask: TglBitmapColorRec): TglBitmapFormat;
+  begin
+    result := tfEmpty;
+    aStream.Read(aInfo{%H-}, SizeOf(aInfo));
+    FillChar(aMask{%H-}, SizeOf(aMask), 0);
+
+    //Read Compression
+    case aInfo.biCompression of
+      BMP_COMP_RLE4,
+      BMP_COMP_RLE8: begin
+        raise EglBitmap.Create('RLE compression is not supported');
+      end;
+      BMP_COMP_BITFIELDS: begin
+        if (aInfo.biBitCount = 16) or (aInfo.biBitCount = 32) then begin
+          aStream.Read(aMask.r, SizeOf(aMask.r));
+          aStream.Read(aMask.g, SizeOf(aMask.g));
+          aStream.Read(aMask.b, SizeOf(aMask.b));
+          aStream.Read(aMask.a, SizeOf(aMask.a));
+        end else
+          raise EglBitmap.Create('Bitfields are only supported for 16bit and 32bit formats');
+      end;
+    end;
+
+    //get suitable format
+    case aInfo.biBitCount of
+       8: result := tfLuminance8;
+      16: result := tfX1RGB5;
+      24: result := tfRGB8;
+      32: result := tfXRGB8;
+    end;
+  end;
+
+  function ReadColorTable(var aFormat: TglBitmapFormat; const aInfo: TBMPInfo): TbmpColorTableFormat;
+  var
+    i, c: Integer;
+    ColorTable: TbmpColorTable;
+  begin
+    result := nil;
+    if (aInfo.biBitCount >= 16) then
+      exit;
+    aFormat := tfLuminance8;
+    c := aInfo.biClrUsed;
+    if (c = 0) then
+      c := 1 shl aInfo.biBitCount;
+    SetLength(ColorTable, c);
+    for i := 0 to c-1 do begin
+      aStream.Read(ColorTable[i], SizeOf(TbmpColorTableEnty));
+      if (ColorTable[i].r <> ColorTable[i].g) or (ColorTable[i].g <> ColorTable[i].b) then
+        aFormat := tfRGB8;
+    end;
+
+    result := TbmpColorTableFormat.Create;
+    result.PixelSize  := aInfo.biBitCount / 8;
+    result.ColorTable := ColorTable;
+    result.Range      := glBitmapColorRec($FF, $FF, $FF, $00);
+  end;
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  function CheckBitfields(var aFormat: TglBitmapFormat; const aMask: TglBitmapColorRec;
+    const aInfo: TBMPInfo): TbmpBitfieldFormat;
+  var
+    TmpFormat: TglBitmapFormat;
+    FormatDesc: TFormatDescriptor;
+  begin
+    result := nil;
+    if (aMask.r <> 0) or (aMask.g <> 0) or (aMask.b <> 0) or (aMask.a <> 0) then begin
+      for TmpFormat := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+        FormatDesc := TFormatDescriptor.Get(TmpFormat);
+        if FormatDesc.MaskMatch(aMask.r, aMask.g, aMask.b, aMask.a) then begin
+          aFormat := FormatDesc.Format;
+          exit;
+        end;
+      end;
+
+      if (aMask.a = 0) and TFormatDescriptor.Get(aFormat).HasAlpha then
+        aFormat := TFormatDescriptor.Get(aFormat).WithoutAlpha;
+      if (aMask.a <> 0) and not TFormatDescriptor.Get(aFormat).HasAlpha then
+        aFormat := TFormatDescriptor.Get(aFormat).WithAlpha;
+
+      result := TbmpBitfieldFormat.Create;
+      result.PixelSize := aInfo.biBitCount / 8;
+      result.RedMask   := aMask.r;
+      result.GreenMask := aMask.g;
+      result.BlueMask  := aMask.b;
+      result.AlphaMask := aMask.a;
+    end;
+  end;
+
+var
+  //simple types
+  StartPos: Int64;
+  ImageSize, rbLineSize, wbLineSize, Padding, i: Integer;
+  PaddingBuff: Cardinal;
+  LineBuf, ImageData, TmpData: PByte;
+  SourceMD, DestMD: Pointer;
+  BmpFormat: TglBitmapFormat;
+
+  //records
+  Mask: TglBitmapColorRec;
+  Header: TBMPHeader;
+  Info: TBMPInfo;
+
+  //classes
+  SpecialFormat: TFormatDescriptor;
+  FormatDesc: TFormatDescriptor;
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  procedure SpecialFormatReadLine(aData: PByte; aLineBuf: PByte);
+  var
+    i: Integer;
+    Pixel: TglBitmapPixelData;
+  begin
+    aStream.Read(aLineBuf^, rbLineSize);
+    SpecialFormat.PreparePixel(Pixel);
+    for i := 0 to Info.biWidth-1 do begin
+      SpecialFormat.Unmap(aLineBuf, Pixel, SourceMD);
+      glBitmapConvertPixel(Pixel, SpecialFormat, FormatDesc);
+      FormatDesc.Map(Pixel, aData, DestMD);
+    end;
+  end;
+
+begin
+  result        := false;
+  BmpFormat     := tfEmpty;
+  SpecialFormat := nil;
+  LineBuf       := nil;
+  SourceMD      := nil;
+  DestMD        := nil;
+
+  // Header
+  StartPos := aStream.Position;
+  aStream.Read(Header{%H-}, SizeOf(Header));
+
+  if Header.bfType = BMP_MAGIC then begin
+    try try
+      BmpFormat        := ReadInfo(Info, Mask);
+      SpecialFormat    := ReadColorTable(BmpFormat, Info);
+      if not Assigned(SpecialFormat) then
+        SpecialFormat  := CheckBitfields(BmpFormat, Mask, Info);
+      aStream.Position := StartPos + Header.bfOffBits;
+
+      if (BmpFormat <> tfEmpty) then begin
+        FormatDesc := TFormatDescriptor.Get(BmpFormat);
+        rbLineSize := Round(Info.biWidth * Info.biBitCount / 8); //ReadBuffer LineSize
+        wbLineSize := Trunc(Info.biWidth * FormatDesc.PixelSize);
+        Padding    := (((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3) - rbLineSize;
+
+        //get Memory
+        DestMD    := FormatDesc.CreateMappingData;
+        ImageSize := FormatDesc.GetSize(Info.biWidth, abs(Info.biHeight));
+        GetMem(ImageData, ImageSize);
+        if Assigned(SpecialFormat) then begin
+          GetMem(LineBuf, rbLineSize); //tmp Memory for converting Bitfields
+          SourceMD := SpecialFormat.CreateMappingData;
+        end;
+
+        //read Data
+        try try
+          FillChar(ImageData^, ImageSize, $FF);
+          TmpData := ImageData;
+          if (Info.biHeight > 0) then
+            Inc(TmpData, wbLineSize * (Info.biHeight-1));
+          for i := 0 to Abs(Info.biHeight)-1 do begin
+            if Assigned(SpecialFormat) then
+              SpecialFormatReadLine(TmpData, LineBuf)  //if is special format read and convert data
+            else
+              aStream.Read(TmpData^, wbLineSize);   //else only read data
+            if (Info.biHeight > 0) then
+              dec(TmpData, wbLineSize)
+            else
+              inc(TmpData, wbLineSize);
+            aStream.Read(PaddingBuff{%H-}, Padding);
+          end;
+          SetDataPointer(ImageData, BmpFormat, Info.biWidth, abs(Info.biHeight)); //be careful, Data could be freed by this method
+          result := true;
+        finally
+          if Assigned(LineBuf) then
+            FreeMem(LineBuf);
+          if Assigned(SourceMD) then
+            SpecialFormat.FreeMappingData(SourceMD);
+          FormatDesc.FreeMappingData(DestMD);
+        end;
+        except
+          if Assigned(ImageData) then
+            FreeMem(ImageData);
+          raise;
+        end;
+      end else
+        raise EglBitmap.Create('LoadBMP - No suitable format found');
+    except
+      aStream.Position := StartPos;
+      raise;
+    end;
+    finally
+      FreeAndNil(SpecialFormat);
+    end;
+  end
+    else aStream.Position := StartPos;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveBMP(const aStream: TStream);
+var
+  Header: TBMPHeader;
+  Info: TBMPInfo;
+  Converter: TFormatDescriptor;
+  FormatDesc: TFormatDescriptor;
+  SourceFD, DestFD: Pointer;
+  pData, srcData, dstData, ConvertBuffer: pByte;
+
+  Pixel: TglBitmapPixelData;
+  ImageSize, wbLineSize, rbLineSize, Padding, LineIdx, PixelIdx: Integer;
+  RedMask, GreenMask, BlueMask, AlphaMask: Cardinal;
+
+  PaddingBuff: Cardinal;
+
+  function GetLineWidth : Integer;
+  begin
+    result := ((Info.biWidth * Info.biBitCount + 31) and - 32) shr 3;
+  end;
+
+begin
+  if not (ftBMP in FormatGetSupportedFiles(Format)) then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  Converter  := nil;
+  FormatDesc := TFormatDescriptor.Get(Format);
+  ImageSize  := FormatDesc.GetSize(Dimension);
+
+  FillChar(Header{%H-}, SizeOf(Header), 0);
+  Header.bfType      := BMP_MAGIC;
+  Header.bfSize      := SizeOf(Header) + SizeOf(Info) + ImageSize;
+  Header.bfReserved1 := 0;
+  Header.bfReserved2 := 0;
+  Header.bfOffBits   := SizeOf(Header) + SizeOf(Info);
+
+  FillChar(Info{%H-}, SizeOf(Info), 0);
+  Info.biSize        := SizeOf(Info);
+  Info.biWidth       := Width;
+  Info.biHeight      := Height;
+  Info.biPlanes      := 1;
+  Info.biCompression := BMP_COMP_RGB;
+  Info.biSizeImage   := ImageSize;
+
+  try
+    case Format of
+      tfLuminance4: begin
+        Info.biBitCount  := 4;
+        Header.bfSize    := Header.bfSize    + 16 * SizeOf(Cardinal);
+        Header.bfOffBits := Header.bfOffBits + 16 * SizeOf(Cardinal); //16 ColorTable entries
+        Converter := TbmpColorTableFormat.Create;
+        with (Converter as TbmpColorTableFormat) do begin
+          PixelSize := 0.5;
+          Format    := Format;
+          Range     := glBitmapColorRec($F, $F, $F, $0);
+          CreateColorTable;
+        end;
+      end;
+
+      tfR3G3B2, tfLuminance8: begin
+        Info.biBitCount  :=  8;
+        Header.bfSize    := Header.bfSize    + 256 * SizeOf(Cardinal);
+        Header.bfOffBits := Header.bfOffBits + 256 * SizeOf(Cardinal); //256 ColorTable entries
+        Converter := TbmpColorTableFormat.Create;
+        with (Converter as TbmpColorTableFormat) do begin
+          PixelSize := 1;
+          Format    := Format;
+          if (Format = tfR3G3B2) then begin
+            Range := glBitmapColorRec($7, $7, $3, $0);
+            Shift := glBitmapShiftRec(0, 3, 6, 0);
+          end else
+            Range := glBitmapColorRec($FF, $FF, $FF, $0);
+          CreateColorTable;
+        end;
+      end;
+
+      tfRGBX4, tfXRGB4, tfRGB5X1, tfX1RGB5, tfR5G6B5, tfRGB5A1, tfA1RGB5, tfRGBA4, tfARGB4,
+      tfBGRX4, tfXBGR4, tfBGR5X1, tfX1BGR5, tfB5G6R5, tfBGR5A1, tfA1BGR5, tfBGRA4, tfABGR4: begin
+        Info.biBitCount    := 16;
+        Info.biCompression := BMP_COMP_BITFIELDS;
+      end;
+
+      tfBGR8, tfRGB8: begin
+        Info.biBitCount := 24;
+        if (Format = tfRGB8) then
+          Converter := TfdBGR8.Create; //use BGR8 Format Descriptor to Swap RGB Values
+      end;
+
+      tfRGB10X2, tfX2RGB10, tfRGB10A2, tfA2RGB10, tfRGBA8, tfARGB8,
+      tfBGR10X2, tfX2BGR10, tfBGR10A2, tfA2BGR10, tfBGRA8, tfABGR8: begin
+        Info.biBitCount    := 32;
+        Info.biCompression := BMP_COMP_BITFIELDS;
+      end;
+    else
+      raise EglBitmapUnsupportedFormat.Create(Format);
+    end;
+    Info.biXPelsPerMeter := 2835;
+    Info.biYPelsPerMeter := 2835;
+
+    // prepare bitmasks
+    if Info.biCompression = BMP_COMP_BITFIELDS then begin
+      Header.bfSize    := Header.bfSize    + 4 * SizeOf(Cardinal);
+      Header.bfOffBits := Header.bfOffBits + 4 * SizeOf(Cardinal);
+
+      RedMask    := FormatDesc.RedMask;
+      GreenMask  := FormatDesc.GreenMask;
+      BlueMask   := FormatDesc.BlueMask;
+      AlphaMask  := FormatDesc.AlphaMask;
+    end;
+
+    // headers
+    aStream.Write(Header, SizeOf(Header));
+    aStream.Write(Info, SizeOf(Info));
+
+    // colortable
+    if Assigned(Converter) and (Converter is TbmpColorTableFormat) then
+      with (Converter as TbmpColorTableFormat) do
+        aStream.Write(ColorTable[0].b,
+          SizeOf(TbmpColorTableEnty) * Length(ColorTable));
+
+    // bitmasks
+    if Info.biCompression = BMP_COMP_BITFIELDS then begin
+      aStream.Write(RedMask,   SizeOf(Cardinal));
+      aStream.Write(GreenMask, SizeOf(Cardinal));
+      aStream.Write(BlueMask,  SizeOf(Cardinal));
+      aStream.Write(AlphaMask, SizeOf(Cardinal));
+    end;
+
+    // image data
+    rbLineSize  := Round(Info.biWidth * FormatDesc.PixelSize);
+    wbLineSize  := Round(Info.biWidth * Info.biBitCount / 8);
+    Padding     := GetLineWidth - wbLineSize;
+    PaddingBuff := 0;
+
+    pData := Data;
+    inc(pData, (Height-1) * rbLineSize);
+
+    // prepare row buffer. But only for RGB because RGBA supports color masks
+    // so it's possible to change color within the image.
+    if Assigned(Converter) then begin
+      FormatDesc.PreparePixel(Pixel);
+      GetMem(ConvertBuffer, wbLineSize);
+      SourceFD := FormatDesc.CreateMappingData;
+      DestFD   := Converter.CreateMappingData;
+    end else
+      ConvertBuffer := nil;
+
+    try
+      for LineIdx := 0 to Height - 1 do begin
+        // preparing row
+        if Assigned(Converter) then begin
+          srcData := pData;
+          dstData := ConvertBuffer;
+          for PixelIdx := 0 to Info.biWidth-1 do begin
+            FormatDesc.Unmap(srcData, Pixel, SourceFD);
+            glBitmapConvertPixel(Pixel, FormatDesc, Converter);
+            Converter.Map(Pixel, dstData, DestFD);
+          end;
+          aStream.Write(ConvertBuffer^, wbLineSize);
+        end else begin
+          aStream.Write(pData^, rbLineSize);
+        end;
+        dec(pData, rbLineSize);
+        if (Padding > 0) then
+          aStream.Write(PaddingBuff, Padding);
+      end;
+    finally
+      // destroy row buffer
+      if Assigned(ConvertBuffer) then begin
+        FormatDesc.FreeMappingData(SourceFD);
+        Converter.FreeMappingData(DestFD);
+        FreeMem(ConvertBuffer);
+      end;
+    end;
+  finally
+    if Assigned(Converter) then
+      Converter.Free;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TGA/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+  TTGAHeader = packed record
+    ImageID: Byte;
+    ColorMapType: Byte;
+    ImageType: Byte;
+    //ColorMapSpec: Array[0..4] of Byte;
+    ColorMapStart: Word;
+    ColorMapLength: Word;
+    ColorMapEntrySize: Byte;
+    OrigX: Word;
+    OrigY: Word;
+    Width: Word;
+    Height: Word;
+    Bpp: Byte;
+    ImageDesc: Byte;
+  end;
+
+const
+  TGA_UNCOMPRESSED_RGB  =  2;
+  TGA_UNCOMPRESSED_GRAY =  3;
+  TGA_COMPRESSED_RGB    = 10;
+  TGA_COMPRESSED_GRAY   = 11;
+
+  TGA_NONE_COLOR_TABLE  = 0;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadTGA(const aStream: TStream): Boolean;
+var
+  Header: TTGAHeader;
+  ImageData: System.PByte;
+  StartPosition: Int64;
+  PixelSize, LineSize: Integer;
+  tgaFormat: TglBitmapFormat;
+  FormatDesc: TFormatDescriptor;
+  Counter: packed record
+    X, Y: packed record
+      low, high, dir: Integer;
+    end;
+  end;
+
+const
+  CACHE_SIZE = $4000;
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+  procedure ReadUncompressed;
+  var
+    i, j: Integer;
+    buf, tmp1, tmp2: System.PByte;
+  begin
+    buf := nil;
+    if (Counter.X.dir < 0) then
+      GetMem(buf, LineSize);
+    try
+      while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin
+        tmp1 := ImageData;
+        inc(tmp1, (Counter.Y.low * LineSize));          //pointer to LineStart
+        if (Counter.X.dir < 0) then begin               //flip X
+          aStream.Read(buf^, LineSize);
+          tmp2 := buf;
+          inc(tmp2, LineSize - PixelSize);              //pointer to last pixel in line
+          for i := 0 to Header.Width-1 do begin         //for all pixels in line
+            for j := 0 to PixelSize-1 do begin          //for all bytes in pixel
+              tmp1^ := tmp2^;
+              inc(tmp1);
+              inc(tmp2);
+            end;
+            dec(tmp2, 2*PixelSize);                     //move 2 backwards, because j-loop moved 1 forward
+          end;
+        end else
+          aStream.Read(tmp1^, LineSize);
+        inc(Counter.Y.low, Counter.Y.dir);              //move to next line index
+      end;
+    finally
+      if Assigned(buf) then
+        FreeMem(buf);
+    end;
+  end;
+
+  ////////////////////////////////////////////////////////////////////////////////////////
+  procedure ReadCompressed;
+
+    /////////////////////////////////////////////////////////////////
+    var
+      TmpData: System.PByte;
+      LinePixelsRead: Integer;
+    procedure CheckLine;
+    begin
+      if (LinePixelsRead >= Header.Width) then begin
+        LinePixelsRead := 0;
+        inc(Counter.Y.low, Counter.Y.dir);                //next line index
+        TmpData := ImageData;
+        inc(TmpData, Counter.Y.low * LineSize);           //set line
+        if (Counter.X.dir < 0) then                       //if x flipped then
+          inc(TmpData, LineSize - PixelSize);             //set last pixel
+      end;
+    end;
+
+    /////////////////////////////////////////////////////////////////
+    var
+      Cache: PByte;
+      CacheSize, CachePos: Integer;
+    procedure CachedRead(out Buffer; Count: Integer);
+    var
+      BytesRead: Integer;
+    begin
+      if (CachePos + Count > CacheSize) then begin
+        //if buffer overflow save non read bytes
+        BytesRead := 0;
+        if (CacheSize - CachePos > 0) then begin
+          BytesRead := CacheSize - CachePos;
+          Move(PByteArray(Cache)^[CachePos], Buffer{%H-}, BytesRead);
+          inc(CachePos, BytesRead);
+        end;
+
+        //load cache from file
+        CacheSize := Min(CACHE_SIZE, aStream.Size - aStream.Position);
+        aStream.Read(Cache^, CacheSize);
+        CachePos := 0;
+
+        //read rest of requested bytes
+        if (Count - BytesRead > 0) then begin
+          Move(PByteArray(Cache)^[CachePos], TByteArray(Buffer)[BytesRead], Count - BytesRead);
+          inc(CachePos, Count - BytesRead);
+        end;
+      end else begin
+        //if no buffer overflow just read the data
+        Move(PByteArray(Cache)^[CachePos], Buffer, Count);
+        inc(CachePos, Count);
+      end;
+    end;
+
+    procedure PixelToBuffer(const aData: PByte; var aBuffer: PByte);
+    begin
+      case PixelSize of
+        1: begin
+          aBuffer^ := aData^;
+          inc(aBuffer, Counter.X.dir);
+        end;
+        2: begin
+          PWord(aBuffer)^ := PWord(aData)^;
+          inc(aBuffer, 2 * Counter.X.dir);
+        end;
+        3: begin
+          PByteArray(aBuffer)^[0] := PByteArray(aData)^[0];
+          PByteArray(aBuffer)^[1] := PByteArray(aData)^[1];
+          PByteArray(aBuffer)^[2] := PByteArray(aData)^[2];
+          inc(aBuffer, 3 * Counter.X.dir);
+        end;
+        4: begin
+          PCardinal(aBuffer)^ := PCardinal(aData)^;
+          inc(aBuffer, 4 * Counter.X.dir);
+        end;
+      end;
+    end;
+
+  var
+    TotalPixelsToRead, TotalPixelsRead: Integer;
+    Temp: Byte;
+    buf: array [0..3] of Byte; //1 pixel is max 32bit long
+    PixelRepeat: Boolean;
+    PixelsToRead, PixelCount: Integer;
+  begin
+    CacheSize := 0;
+    CachePos  := 0;
+
+    TotalPixelsToRead := Header.Width * Header.Height;
+    TotalPixelsRead   := 0;
+    LinePixelsRead    := 0;
+
+    GetMem(Cache, CACHE_SIZE);
+    try
+      TmpData := ImageData;
+      inc(TmpData, Counter.Y.low * LineSize);           //set line
+      if (Counter.X.dir < 0) then                       //if x flipped then
+        inc(TmpData, LineSize - PixelSize);             //set last pixel
+
+      repeat
+        //read CommandByte
+        CachedRead(Temp, 1);
+        PixelRepeat  := (Temp and $80) > 0;
+        PixelsToRead := (Temp and $7F) + 1;
+        inc(TotalPixelsRead, PixelsToRead);
+
+        if PixelRepeat then
+          CachedRead(buf[0], PixelSize);
+        while (PixelsToRead > 0) do begin
+          CheckLine;
+          PixelCount := Min(Header.Width - LinePixelsRead, PixelsToRead); //max read to EOL or EOF
+          while (PixelCount > 0) do begin
+            if not PixelRepeat then
+              CachedRead(buf[0], PixelSize);
+            PixelToBuffer(@buf[0], TmpData);
+            inc(LinePixelsRead);
+            dec(PixelsToRead);
+            dec(PixelCount);
+          end;
+        end;
+      until (TotalPixelsRead >= TotalPixelsToRead);
+    finally
+      FreeMem(Cache);
+    end;
+  end;
+
+  function IsGrayFormat: Boolean;
+  begin
+    result := Header.ImageType in [TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_GRAY];
+  end;
+
+begin
+  result := false;
+
+  // reading header to test file and set cursor back to begin
+  StartPosition := aStream.Position;
+  aStream.Read(Header{%H-}, SizeOf(Header));
+
+  // no colormapped files
+  if (Header.ColorMapType = TGA_NONE_COLOR_TABLE) and (Header.ImageType in [
+    TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY, TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY]) then
+  begin
+    try
+      if Header.ImageID <> 0 then       // skip image ID
+        aStream.Position := aStream.Position + Header.ImageID;
+
+      tgaFormat := tfEmpty;
+      case Header.Bpp of
+         8: if IsGrayFormat then case (Header.ImageDesc and $F) of
+               0: tgaFormat := tfLuminance8;
+               8: tgaFormat := tfAlpha8;
+            end;
+
+        16: if IsGrayFormat then case (Header.ImageDesc and $F) of
+               0: tgaFormat := tfLuminance16;
+               8: tgaFormat := tfLuminance8Alpha8;
+            end else case (Header.ImageDesc and $F) of
+               0: tgaFormat := tfX1RGB5;
+               1: tgaFormat := tfA1RGB5;
+               4: tgaFormat := tfARGB4;
+            end;
+
+        24: if not IsGrayFormat then case (Header.ImageDesc and $F) of
+               0: tgaFormat := tfRGB8;
+            end;
+
+        32: if not IsGrayFormat then case (Header.ImageDesc and $F) of
+               2: tgaFormat := tfA2RGB10;
+               8: tgaFormat := tfARGB8;
+            end;
+      end;
+
+      if (tgaFormat = tfEmpty) then
+        raise EglBitmap.Create('LoadTga - unsupported format');
+
+      FormatDesc := TFormatDescriptor.Get(tgaFormat);
+      PixelSize  := FormatDesc.GetSize(1, 1);
+      LineSize   := FormatDesc.GetSize(Header.Width, 1);
+
+      GetMem(ImageData, LineSize * Header.Height);
+      try
+        //column direction
+        if ((Header.ImageDesc and (1 shl 4)) > 0) then begin
+          Counter.X.low  := Header.Height-1;;
+          Counter.X.high := 0;
+          Counter.X.dir  := -1;
+        end else begin
+          Counter.X.low  := 0;
+          Counter.X.high := Header.Height-1;
+          Counter.X.dir  := 1;
+        end;
+
+        // Row direction
+        if ((Header.ImageDesc and (1 shl 5)) > 0) then begin
+          Counter.Y.low  := 0;
+          Counter.Y.high := Header.Height-1;
+          Counter.Y.dir  := 1;
+        end else begin
+          Counter.Y.low  := Header.Height-1;;
+          Counter.Y.high := 0;
+          Counter.Y.dir  := -1;
+        end;
+
+        // Read Image
+        case Header.ImageType of
+          TGA_UNCOMPRESSED_RGB, TGA_UNCOMPRESSED_GRAY:
+            ReadUncompressed;
+          TGA_COMPRESSED_RGB, TGA_COMPRESSED_GRAY:
+            ReadCompressed;
+        end;
+
+        SetDataPointer(ImageData, tgaFormat, Header.Width, Header.Height); //be careful, Data could be freed by this method
+        result := true;
+      except
+        if Assigned(ImageData) then
+          FreeMem(ImageData);
+        raise;
+      end;
+    finally
+      aStream.Position := StartPosition;
+    end;
+  end
+    else aStream.Position := StartPosition;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveTGA(const aStream: TStream);
+var
+  Header: TTGAHeader;
+  LineSize, Size, x, y: Integer;
+  Pixel: TglBitmapPixelData;
+  LineBuf, SourceData, DestData: PByte;
+  SourceMD, DestMD: Pointer;
+  FormatDesc: TFormatDescriptor;
+  Converter: TFormatDescriptor;
+begin
+  if not (ftTGA in FormatGetSupportedFiles(Format)) then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  //prepare header
+  FillChar(Header{%H-}, SizeOf(Header), 0);
+
+  //set ImageType
+  if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8,
+                 tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8]) then
+    Header.ImageType := TGA_UNCOMPRESSED_GRAY
+  else
+    Header.ImageType := TGA_UNCOMPRESSED_RGB;
+
+  //set BitsPerPixel
+  if (Format in [tfLuminance8, tfLuminance6Alpha2, tfLuminance4Alpha4, tfAlpha8]) then
+    Header.Bpp := 8
+  else if (Format in [tfLuminance16, tfLuminance12Alpha4, tfLuminance8Alpha8,
+                      tfRGB5X1, tfBGR5X1, tfRGB5A1, tfBGR5A1, tfRGBA4, tfBGRA4]) then
+    Header.Bpp := 16
+  else if (Format in [tfBGR8, tfRGB8]) then
+    Header.Bpp := 24
+  else
+    Header.Bpp := 32;
+
+  //set AlphaBitCount
+  case Format of
+    tfRGB5A1, tfBGR5A1:
+      Header.ImageDesc := 1 and $F;
+    tfRGB10A2, tfBGR10A2:
+      Header.ImageDesc := 2 and $F;
+    tfRGBA4, tfBGRA4:
+      Header.ImageDesc := 4 and $F;
+    tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8:
+      Header.ImageDesc := 8 and $F;
+  end;
+
+  Header.Width     := Width;
+  Header.Height    := Height;
+  Header.ImageDesc := Header.ImageDesc or $20; //flip y
+  aStream.Write(Header, SizeOf(Header));
+
+  // convert RGB(A) to BGR(A)
+  Converter  := nil;
+  FormatDesc := TFormatDescriptor.Get(Format);
+  Size       := FormatDesc.GetSize(Dimension);
+  if Format in [tfRGB5X1, tfRGB5A1, tfRGBA4, tfRGB8, tfRGB10A2, tfRGBA8] then begin
+    if (FormatDesc.RGBInverted = tfEmpty) then
+      raise EglBitmap.Create('inverted RGB format is empty');
+    Converter := TFormatDescriptor.Get(FormatDesc.RGBInverted);
+    if not glBitmapColorRecCmp(Converter.Range, FormatDesc.Range) or
+       (Converter.PixelSize <> FormatDesc.PixelSize) then
+      raise EglBitmap.Create('invalid inverted RGB format');
+  end;
+
+  if Assigned(Converter) then begin
+    LineSize := FormatDesc.GetSize(Width, 1);
+    GetMem(LineBuf, LineSize);
+    SourceMD := FormatDesc.CreateMappingData;
+    DestMD   := Converter.CreateMappingData;
+    try
+      SourceData := Data;
+      for y := 0 to Height-1 do begin
+        DestData := LineBuf;
+        for x := 0 to Width-1 do begin
+          FormatDesc.Unmap(SourceData, Pixel, SourceMD);
+          Converter.Map(Pixel, DestData, DestMD);
+        end;
+        aStream.Write(LineBuf^, LineSize);
+      end;
+    finally
+      FreeMem(LineBuf);
+      FormatDesc.FreeMappingData(SourceMD);
+      FormatDesc.FreeMappingData(DestMD);
+    end;
+  end else
+    aStream.Write(Data^, Size);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//DDS/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+const
+  DDS_MAGIC: Cardinal         = $20534444;
+
+  // DDS_header.dwFlags
+  DDSD_CAPS                   = $00000001;
+  DDSD_HEIGHT                 = $00000002;
+  DDSD_WIDTH                  = $00000004;
+  DDSD_PIXELFORMAT            = $00001000;
+
+  // DDS_header.sPixelFormat.dwFlags
+  DDPF_ALPHAPIXELS            = $00000001;
+  DDPF_ALPHA                  = $00000002;
+  DDPF_FOURCC                 = $00000004;
+  DDPF_RGB                    = $00000040;
+  DDPF_LUMINANCE              = $00020000;
+
+  // DDS_header.sCaps.dwCaps1
+  DDSCAPS_TEXTURE             = $00001000;
+
+  // DDS_header.sCaps.dwCaps2
+  DDSCAPS2_CUBEMAP            = $00000200;
+
+  D3DFMT_DXT1                 = $31545844;
+  D3DFMT_DXT3                 = $33545844;
+  D3DFMT_DXT5                 = $35545844;
+
+type
+  TDDSPixelFormat = packed record
+    dwSize: Cardinal;
+    dwFlags: Cardinal;
+    dwFourCC: Cardinal;
+    dwRGBBitCount: Cardinal;
+    dwRBitMask: Cardinal;
+    dwGBitMask: Cardinal;
+    dwBBitMask: Cardinal;
+    dwABitMask: Cardinal;
+  end;
+
+  TDDSCaps = packed record
+    dwCaps1: Cardinal;
+    dwCaps2: Cardinal;
+    dwDDSX: Cardinal;
+    dwReserved: Cardinal;
+  end;
+
+  TDDSHeader = packed record
+    dwSize: Cardinal;
+    dwFlags: Cardinal;
+    dwHeight: Cardinal;
+    dwWidth: Cardinal;
+    dwPitchOrLinearSize: Cardinal;
+    dwDepth: Cardinal;
+    dwMipMapCount: Cardinal;
+    dwReserved: array[0..10] of Cardinal;
+    PixelFormat: TDDSPixelFormat;
+    Caps: TDDSCaps;
+    dwReserved2: Cardinal;
+  end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap.LoadDDS(const aStream: TStream): Boolean;
+var
+  Header: TDDSHeader;
+  Converter: TbmpBitfieldFormat;
+
+  function GetDDSFormat: TglBitmapFormat;
+  var
+    fd: TFormatDescriptor;
+    i: Integer;
+    Range: TglBitmapColorRec;
+    match: Boolean;
+  begin
+    result := tfEmpty;
+    with Header.PixelFormat do begin
+      // Compresses
+      if ((dwFlags and DDPF_FOURCC) > 0) then begin
+        case Header.PixelFormat.dwFourCC of
+          D3DFMT_DXT1: result := tfS3tcDtx1RGBA;
+          D3DFMT_DXT3: result := tfS3tcDtx3RGBA;
+          D3DFMT_DXT5: result := tfS3tcDtx5RGBA;
+        end;
+      end else if ((dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0) then begin
+        // prepare masks
+        if ((dwFlags and DDPF_LUMINANCE) = 0) then begin
+          Range.r := dwRBitMask;
+          Range.g := dwGBitMask;
+          Range.b := dwBBitMask;
+        end else begin
+          Range.r := dwRBitMask;
+          Range.g := dwRBitMask;
+          Range.b := dwRBitMask;
+        end;
+        Range.a := dwABitMask;
+
+        //find matching format
+        for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+          fd := TFormatDescriptor.Get(result);
+          if fd.MaskMatch(Range.r, Range.g, Range.b, Range.a) and
+             (8 * fd.PixelSize = dwRGBBitCount) then
+            exit;
+        end;
+
+        //find format with same Range
+        for i := 0 to 3 do begin
+          while ((Range.arr[i] and 1) = 0) and (Range.arr[i] > 0) do
+            Range.arr[i] := Range.arr[i] shr 1;
+        end;
+        for result := High(TglBitmapFormat) downto Low(TglBitmapFormat) do begin
+          fd := TFormatDescriptor.Get(result);
+          match := true;
+          for i := 0 to 3 do
+            if (fd.Range.arr[i] <> Range.arr[i]) then begin
+              match := false;
+              break;
+            end;
+          if match then
+            break;
+        end;
+
+        //no format with same range found -> use default
+        if (result = tfEmpty) then begin
+          if (dwABitMask > 0) then
+            result := tfRGBA8
+          else
+            result := tfRGB8;
+        end;
+
+        Converter := TbmpBitfieldFormat.Create;
+        Converter.RedMask   := dwRBitMask;
+        Converter.GreenMask := dwGBitMask;
+        Converter.BlueMask  := dwBBitMask;
+        Converter.AlphaMask := dwABitMask;
+        Converter.PixelSize := dwRGBBitCount / 8;
+      end;
+    end;
+  end;
+
+var
+  StreamPos: Int64;
+  x, y, LineSize, RowSize, Magic: Cardinal;
+  NewImage, TmpData, RowData, SrcData: System.PByte;
+  SourceMD, DestMD: Pointer;
+  Pixel: TglBitmapPixelData;
+  ddsFormat: TglBitmapFormat;
+  FormatDesc: TFormatDescriptor;
+
+begin
+  result    := false;
+  Converter := nil;
+  StreamPos := aStream.Position;
+
+  // Magic
+  aStream.Read(Magic{%H-}, sizeof(Magic));
+  if (Magic <> DDS_MAGIC) then begin
+    aStream.Position := StreamPos;
+    exit;
+  end;
+
+  //Header
+  aStream.Read(Header{%H-}, sizeof(Header));
+  if (Header.dwSize <> SizeOf(Header)) or
+     ((Header.dwFlags and (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) <>
+        (DDSD_PIXELFORMAT or DDSD_CAPS or DDSD_WIDTH or DDSD_HEIGHT)) then
+  begin
+    aStream.Position := StreamPos;
+    exit;
+  end;
+
+  if ((Header.Caps.dwCaps1 and DDSCAPS2_CUBEMAP) > 0) then
+    raise EglBitmap.Create('LoadDDS - CubeMaps are not supported');
+
+  ddsFormat := GetDDSFormat;
+  try
+    if (ddsFormat = tfEmpty) then
+      raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
+
+    FormatDesc := TFormatDescriptor.Get(ddsFormat);
+    LineSize   := Trunc(Header.dwWidth * FormatDesc.PixelSize);
+    GetMem(NewImage, Header.dwHeight * LineSize);
+    try
+      TmpData := NewImage;
+
+      //Converter needed
+      if Assigned(Converter) then begin
+        RowSize := Round(Header.dwWidth * Header.PixelFormat.dwRGBBitCount / 8);
+        GetMem(RowData, RowSize);
+        SourceMD := Converter.CreateMappingData;
+        DestMD   := FormatDesc.CreateMappingData;
+        try
+          for y := 0 to Header.dwHeight-1 do begin
+            TmpData := NewImage;
+            inc(TmpData, y * LineSize);
+            SrcData := RowData;
+            aStream.Read(SrcData^, RowSize);
+            for x := 0 to Header.dwWidth-1 do begin
+              Converter.Unmap(SrcData, Pixel, SourceMD);
+              glBitmapConvertPixel(Pixel, Converter, FormatDesc);
+              FormatDesc.Map(Pixel, TmpData, DestMD);
+            end;
+          end;
+        finally
+          Converter.FreeMappingData(SourceMD);
+          FormatDesc.FreeMappingData(DestMD);
+          FreeMem(RowData);
+        end;
+      end else
+
+      // Compressed
+      if ((Header.PixelFormat.dwFlags and DDPF_FOURCC) > 0) then begin
+        RowSize := Header.dwPitchOrLinearSize div Header.dwWidth;
+        for Y := 0 to Header.dwHeight-1 do begin
+          aStream.Read(TmpData^, RowSize);
+          Inc(TmpData, LineSize);
+        end;
+      end else
+
+      // Uncompressed
+      if (Header.PixelFormat.dwFlags and (DDPF_RGB or DDPF_ALPHAPIXELS or DDPF_LUMINANCE)) > 0 then begin
+        RowSize := (Header.PixelFormat.dwRGBBitCount * Header.dwWidth) shr 3;
+        for Y := 0 to Header.dwHeight-1 do begin
+          aStream.Read(TmpData^, RowSize);
+          Inc(TmpData, LineSize);
+        end;
+      end else
+        raise EglBitmap.Create('LoadDDS - unsupported Pixelformat found.');
+
+      SetDataPointer(NewImage, ddsFormat, Header.dwWidth, Header.dwHeight); //be careful, Data could be freed by this method
+      result := true;
+    except
+      if Assigned(NewImage) then
+        FreeMem(NewImage);
+      raise;
+    end;
+  finally
+    FreeAndNil(Converter);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap.SaveDDS(const aStream: TStream);
+var
+  Header: TDDSHeader;
+  FormatDesc: TFormatDescriptor;
+begin
+  if not (ftDDS in FormatGetSupportedFiles(Format)) then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  FormatDesc := TFormatDescriptor.Get(Format);
+
+  // Generell
+  FillChar(Header{%H-}, SizeOf(Header), 0);
+  Header.dwSize  := SizeOf(Header);
+  Header.dwFlags := DDSD_WIDTH or DDSD_HEIGHT or DDSD_CAPS or DDSD_PIXELFORMAT;
+
+  Header.dwWidth  := Max(1, Width);
+  Header.dwHeight := Max(1, Height);
+
+  // Caps
+  Header.Caps.dwCaps1 := DDSCAPS_TEXTURE;
+
+  // Pixelformat
+  Header.PixelFormat.dwSize := sizeof(Header);
+  if (FormatDesc.IsCompressed) then begin
+    Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_FOURCC;
+    case Format of
+      tfS3tcDtx1RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT1;
+      tfS3tcDtx3RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT3;
+      tfS3tcDtx5RGBA: Header.PixelFormat.dwFourCC := D3DFMT_DXT5;
+    end;
+  end else if (Format in [tfAlpha8, tfAlpha16]) then begin
+    Header.PixelFormat.dwFlags       := Header.PixelFormat.dwFlags or DDPF_ALPHA;
+    Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8);
+    Header.PixelFormat.dwABitMask    := FormatDesc.AlphaMask;
+  end else if (FormatDesc.RedMask = FormatDesc.GreenMask) and (FormatDesc.GreenMask = FormatDesc.BlueMask) then begin
+    Header.PixelFormat.dwFlags       := Header.PixelFormat.dwFlags or DDPF_LUMINANCE;
+    Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8);
+    Header.PixelFormat.dwRBitMask    := FormatDesc.RedMask;
+    Header.PixelFormat.dwABitMask    := FormatDesc.AlphaMask;
+  end else begin
+    Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_RGB;
+    Header.PixelFormat.dwRGBBitCount := Round(FormatDesc.PixelSize * 8);
+    Header.PixelFormat.dwRBitMask    := FormatDesc.RedMask;
+    Header.PixelFormat.dwGBitMask    := FormatDesc.GreenMask;
+    Header.PixelFormat.dwBBitMask    := FormatDesc.BlueMask;
+    Header.PixelFormat.dwABitMask    := FormatDesc.AlphaMask;
+  end;
+
+  if (FormatDesc.HasAlpha) then
+    Header.PixelFormat.dwFlags := Header.PixelFormat.dwFlags or DDPF_ALPHAPIXELS;
+
+  aStream.Write(DDS_MAGIC, sizeof(DDS_MAGIC));
+  aStream.Write(Header, SizeOf(Header));
+  aStream.Write(Data^, FormatDesc.GetSize(Dimension));
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap1D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+  const aWidth: Integer; const aHeight: Integer);
+var
+  pTemp: pByte;
+  Size: Integer;
+begin
+  if (aHeight > 1) then begin
+    Size := TFormatDescriptor.Get(aFormat).GetSize(aWidth, 1);
+    GetMem(pTemp, Size);
+    try
+      Move(aData^, pTemp^, Size);
+      FreeMem(aData);
+      aData := nil;
+    except
+      FreeMem(pTemp);
+      raise;
+    end;
+  end else
+    pTemp := aData;
+  inherited SetDataPointer(pTemp, aFormat, aWidth);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap1D.FlipHorz: Boolean;
+var
+  Col: Integer;
+  pTempDest, pDest, pSource: PByte;
+begin
+  result := inherited FlipHorz;
+  if Assigned(Data) and not TFormatDescriptor.Get(Format).IsCompressed then begin
+    pSource := Data;
+    GetMem(pDest, fRowSize);
+    try
+      pTempDest := pDest;
+      Inc(pTempDest, fRowSize);
+      for Col := 0 to Width-1 do begin
+        dec(pTempDest, fPixelSize); //dec before, because ptr is behind last byte of data
+        Move(pSource^, pTempDest^, fPixelSize);
+        Inc(pSource, fPixelSize);
+      end;
+      SetDataPointer(pDest, Format, Width); //be careful, Data could be freed by this method
+      result := true;
+    except
+      if Assigned(pDest) then
+        FreeMem(pDest);
+      raise;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.UploadData(const aBuildWithGlu: Boolean);
+var
+  FormatDesc: TFormatDescriptor;
+begin
+  // Upload data
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if FormatDesc.IsCompressed then begin
+    if not Assigned(glCompressedTexImage1D) then
+      raise EglBitmap.Create('compressed formats not supported by video adapter');
+    glCompressedTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.GetSize(Width, 1), Data)
+  end else if aBuildWithGlu then
+    gluBuild1DMipmaps(Target, FormatDesc.glInternalFormat, Width, FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
+  else
+    glTexImage1D(Target, 0, FormatDesc.glInternalFormat, Width, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
+
+  // Free Data
+  if (FreeDataAfterGenTexture) then
+    FreeData;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.GenTexture(const aTestTextureSize: Boolean);
+var
+  BuildWithGlu, TexRec: Boolean;
+  TexSize: Integer;
+begin
+  if Assigned(Data) then begin
+    // Check Texture Size
+    if (aTestTextureSize) then begin
+      glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
+
+      if (Width > TexSize) then
+        raise EglBitmapSizeToLarge.Create('TglBitmap1D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
+
+      TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and
+                (Target = GL_TEXTURE_RECTANGLE);
+      if not (IsPowerOfTwo(Width) or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
+        raise EglBitmapNonPowerOfTwo.Create('TglBitmap1D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+    end;
+
+    CreateId;
+    SetupParameters(BuildWithGlu);
+    UploadData(BuildWithGlu);
+    glAreTexturesResident(1, @fID, @fIsResident);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap1D.AfterConstruction;
+begin
+  inherited;
+  Target := GL_TEXTURE_1D;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap2D/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap2D.GetScanline(const aIndex: Integer): Pointer;
+begin
+  if (aIndex >= Low(fLines)) and (aIndex <= High(fLines)) then
+    result := fLines[aIndex]
+  else
+    result := nil;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.SetDataPointer(var aData: PByte; const aFormat: TglBitmapFormat;
+  const aWidth: Integer; const aHeight: Integer);
+var
+  Idx, LineWidth: Integer;
+begin
+  inherited SetDataPointer(aData, aFormat, aWidth, aHeight);
+
+  if not TFormatDescriptor.Get(aFormat).IsCompressed then begin
+    // Assigning Data
+    if Assigned(Data) then begin
+      SetLength(fLines, GetHeight);
+      LineWidth := Trunc(GetWidth * TFormatDescriptor.Get(Format).PixelSize);
+
+      for Idx := 0 to GetHeight-1 do begin
+        fLines[Idx] := Data;
+        Inc(fLines[Idx], Idx * LineWidth);
+      end;
+    end
+      else SetLength(fLines, 0);
+  end else begin
+    SetLength(fLines, 0);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.UploadData(const aTarget: GLenum; const aBuildWithGlu: Boolean);
+var
+  FormatDesc: TFormatDescriptor;
+begin
+  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if FormatDesc.IsCompressed then begin
+    if not Assigned(glCompressedTexImage2D) then
+      raise EglBitmap.Create('compressed formats not supported by video adapter');
+    glCompressedTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0, FormatDesc.GetSize(fDimension), Data)
+  end else if aBuildWithGlu then begin
+    gluBuild2DMipmaps(aTarget, FormatDesc.Components, Width, Height,
+      FormatDesc.glFormat, FormatDesc.glDataFormat, Data)
+  end else begin
+    glTexImage2D(aTarget, 0, FormatDesc.glInternalFormat, Width, Height, 0,
+      FormatDesc.glFormat, FormatDesc.glDataFormat, Data);
+  end;
+
+  // Freigeben
+  if (FreeDataAfterGenTexture) then
+    FreeData;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.AfterConstruction;
+begin
+  inherited;
+  Target := GL_TEXTURE_2D;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.GrabScreen(const aTop, aLeft, aRight, aBottom: Integer; const aFormat: TglBitmapFormat);
+var
+  Temp: pByte;
+  Size, w, h: Integer;
+  FormatDesc: TFormatDescriptor;
+begin
+  FormatDesc := TFormatDescriptor.Get(aFormat);
+  if FormatDesc.IsCompressed then
+    raise EglBitmapUnsupportedFormat.Create(aFormat);
+
+  w    := aRight  - aLeft;
+  h    := aBottom - aTop;
+  Size := FormatDesc.GetSize(w, h);
+  GetMem(Temp, Size);
+  try
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    glReadPixels(aLeft, aTop, w, h, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
+    SetDataPointer(Temp, aFormat, w, h); //be careful, Data could be freed by this method
+    FlipVert;
+  except
+    if Assigned(Temp) then
+      FreeMem(Temp);
+    raise;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.GetDataFromTexture;
+var
+  Temp: PByte;
+  TempWidth, TempHeight: Integer;
+  TempIntFormat: GLint;
+  IntFormat: TglBitmapFormat;
+  FormatDesc: TFormatDescriptor;
+begin
+  Bind;
+
+  // Request Data
+  glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_WIDTH,           @TempWidth);
+  glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_HEIGHT,          @TempHeight);
+  glGetTexLevelParameteriv(Target, 0, GL_TEXTURE_INTERNAL_FORMAT, @TempIntFormat);
+
+  IntFormat  := tfEmpty;
+  FormatDesc := (TglBitmapFormatDescriptor.GetByFormat(TempIntFormat) as TFormatDescriptor);
+  IntFormat  := FormatDesc.Format;
+
+  // Getting data from OpenGL
+  FormatDesc := TFormatDescriptor.Get(IntFormat);
+  GetMem(Temp, FormatDesc.GetSize(TempWidth, TempHeight));
+  try
+    if FormatDesc.IsCompressed then begin
+      if not Assigned(glGetCompressedTexImage) then
+        raise EglBitmap.Create('compressed formats not supported by video adapter');
+      glGetCompressedTexImage(Target, 0, Temp)
+    end else
+      glGetTexImage(Target, 0, FormatDesc.glFormat, FormatDesc.glDataFormat, Temp);
+    SetDataPointer(Temp, IntFormat, TempWidth, TempHeight); //be careful, Data could be freed by this method
+  except
+    if Assigned(Temp) then
+      FreeMem(Temp);
+    raise;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.GenTexture(const aTestTextureSize: Boolean);
+var
+  BuildWithGlu, PotTex, TexRec: Boolean;
+  TexSize: Integer;
+begin
+  if Assigned(Data) then begin
+    // Check Texture Size
+    if (aTestTextureSize) then begin
+      glGetIntegerv(GL_MAX_TEXTURE_SIZE, @TexSize);
+
+      if ((Height > TexSize) or (Width > TexSize)) then
+        raise EglBitmapSizeToLarge.Create('TglBitmap2D.GenTexture - The size for the texture is to large. It''s may be not conform with the Hardware.');
+
+      PotTex := IsPowerOfTwo(Height) and IsPowerOfTwo(Width);
+      TexRec := (GL_ARB_texture_rectangle or GL_EXT_texture_rectangle or GL_NV_texture_rectangle) and (Target = GL_TEXTURE_RECTANGLE);
+      if not (PotTex or GL_ARB_texture_non_power_of_two or GL_VERSION_2_0 or TexRec) then
+        raise EglBitmapNonPowerOfTwo.Create('TglBitmap2D.GenTexture - Rendercontex dosn''t support non power of two texture.');
+    end;
+
+    CreateId;
+    SetupParameters(BuildWithGlu);
+    UploadData(Target, BuildWithGlu);
+    glAreTexturesResident(1, @fID, @fIsResident);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap2D.FlipHorz: Boolean;
+var
+  Col, Row: Integer;
+  TempDestData, DestData, SourceData: PByte;
+  ImgSize: Integer;
+begin
+  result := inherited FlipHorz;
+  if Assigned(Data) then begin
+    SourceData := Data;
+    ImgSize := Height * fRowSize;
+    GetMem(DestData, ImgSize);
+    try
+      TempDestData := DestData;
+      Dec(TempDestData, fRowSize + fPixelSize);
+      for Row := 0 to Height -1 do begin
+        Inc(TempDestData, fRowSize * 2);
+        for Col := 0 to Width -1 do begin
+          Move(SourceData^, TempDestData^, fPixelSize);
+          Inc(SourceData, fPixelSize);
+          Dec(TempDestData, fPixelSize);
+        end;
+      end;
+      SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method
+      result := true;
+    except
+      if Assigned(DestData) then
+        FreeMem(DestData);
+      raise;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglBitmap2D.FlipVert: Boolean;
+var
+  Row: Integer;
+  TempDestData, DestData, SourceData: PByte;
+begin
+  result := inherited FlipVert;
+  if Assigned(Data) then begin
+    SourceData := Data;
+    GetMem(DestData, Height * fRowSize);
+    try
+      TempDestData := DestData;
+      Inc(TempDestData, Width * (Height -1) * fPixelSize);
+      for Row := 0 to Height -1 do begin
+        Move(SourceData^, TempDestData^, fRowSize);
+        Dec(TempDestData, fRowSize);
+        Inc(SourceData, fRowSize);
+      end;
+      SetDataPointer(DestData, Format, Width, Height); //be careful, Data could be freed by this method
+      result := true;
+    except
+      if Assigned(DestData) then
+        FreeMem(DestData);
+      raise;
+    end;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmap2D - ToNormalMap///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+  TMatrixItem = record
+    X, Y: Integer;
+    W: Single;
+  end;
+
+  PglBitmapToNormalMapRec = ^TglBitmapToNormalMapRec;
+  TglBitmapToNormalMapRec = Record
+    Scale: Single;
+    Heights: array of Single;
+    MatrixU : array of TMatrixItem;
+    MatrixV : array of TMatrixItem;
+  end;
+
+const
+  ONE_OVER_255 = 1 / 255;
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapToNormalMapPrepareFunc(var FuncRec: TglBitmapFunctionRec);
+var
+  Val: Single;
+begin
+  with FuncRec do begin
+    Val :=
+      Source.Data.r * LUMINANCE_WEIGHT_R +
+      Source.Data.g * LUMINANCE_WEIGHT_G +
+      Source.Data.b * LUMINANCE_WEIGHT_B;
+    PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Val * ONE_OVER_255;
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapToNormalMapPrepareAlphaFunc(var FuncRec: TglBitmapFunctionRec);
+begin
+  with FuncRec do
+    PglBitmapToNormalMapRec(Args)^.Heights[Position.Y * Size.X + Position.X] := Source.Data.a * ONE_OVER_255;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapToNormalMapFunc (var FuncRec: TglBitmapFunctionRec);
+type
+  TVec = Array[0..2] of Single;
+var
+  Idx: Integer;
+  du, dv: Double;
+  Len: Single;
+  Vec: TVec;
+
+  function GetHeight(X, Y: Integer): Single;
+  begin
+    with FuncRec do begin
+      X := Max(0, Min(Size.X -1, X));
+      Y := Max(0, Min(Size.Y -1, Y));
+      result := PglBitmapToNormalMapRec(Args)^.Heights[Y * Size.X + X];
+    end;
+  end;
+
+begin
+  with FuncRec do begin
+    with PglBitmapToNormalMapRec(Args)^ do begin
+      du := 0;
+      for Idx := Low(MatrixU) to High(MatrixU) do
+        du := du + GetHeight(Position.X + MatrixU[Idx].X, Position.Y + MatrixU[Idx].Y) * MatrixU[Idx].W;
+
+      dv := 0;
+      for Idx := Low(MatrixU) to High(MatrixU) do
+        dv := dv + GetHeight(Position.X + MatrixV[Idx].X, Position.Y + MatrixV[Idx].Y) * MatrixV[Idx].W;
+
+      Vec[0] := -du * Scale;
+      Vec[1] := -dv * Scale;
+      Vec[2] := 1;
+    end;
+
+    // Normalize
+    Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
+    if Len <> 0 then begin
+      Vec[0] := Vec[0] * Len;
+      Vec[1] := Vec[1] * Len;
+      Vec[2] := Vec[2] * Len;
+    end;
+
+    // Farbe zuweisem
+    Dest.Data.r := Trunc((Vec[0] + 1) * 127.5);
+    Dest.Data.g := Trunc((Vec[1] + 1) * 127.5);
+    Dest.Data.b := Trunc((Vec[2] + 1) * 127.5);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmap2D.ToNormalMap(const aFunc: TglBitmapNormalMapFunc; const aScale: Single; const aUseAlpha: Boolean);
+var
+  Rec: TglBitmapToNormalMapRec;
+
+  procedure SetEntry (var Matrix: array of TMatrixItem; Index, X, Y: Integer; W: Single);
+  begin
+    if (Index >= Low(Matrix)) and (Index <= High(Matrix)) then begin
+      Matrix[Index].X := X;
+      Matrix[Index].Y := Y;
+      Matrix[Index].W := W;
+    end;
+  end;
+
+begin
+  if TFormatDescriptor.Get(Format).IsCompressed then
+    raise EglBitmapUnsupportedFormat.Create(Format);
+
+  if aScale > 100 then
+    Rec.Scale := 100
+  else if aScale < -100 then
+    Rec.Scale := -100
+  else
+    Rec.Scale := aScale;
+
+  SetLength(Rec.Heights, Width * Height);
+  try
+    case aFunc of
+      nm4Samples: begin
+        SetLength(Rec.MatrixU, 2);
+        SetEntry(Rec.MatrixU, 0, -1,  0, -0.5);
+        SetEntry(Rec.MatrixU, 1,  1,  0,  0.5);
+
+        SetLength(Rec.MatrixV, 2);
+        SetEntry(Rec.MatrixV, 0,  0,  1,  0.5);
+        SetEntry(Rec.MatrixV, 1,  0, -1, -0.5);
+      end;
+
+      nmSobel: begin
+        SetLength(Rec.MatrixU, 6);
+        SetEntry(Rec.MatrixU, 0, -1,  1, -1.0);
+        SetEntry(Rec.MatrixU, 1, -1,  0, -2.0);
+        SetEntry(Rec.MatrixU, 2, -1, -1, -1.0);
+        SetEntry(Rec.MatrixU, 3,  1,  1,  1.0);
+        SetEntry(Rec.MatrixU, 4,  1,  0,  2.0);
+        SetEntry(Rec.MatrixU, 5,  1, -1,  1.0);
+
+        SetLength(Rec.MatrixV, 6);
+        SetEntry(Rec.MatrixV, 0, -1,  1,  1.0);
+        SetEntry(Rec.MatrixV, 1,  0,  1,  2.0);
+        SetEntry(Rec.MatrixV, 2,  1,  1,  1.0);
+        SetEntry(Rec.MatrixV, 3, -1, -1, -1.0);
+        SetEntry(Rec.MatrixV, 4,  0, -1, -2.0);
+        SetEntry(Rec.MatrixV, 5,  1, -1, -1.0);
+      end;
+
+      nm3x3: begin
+        SetLength(Rec.MatrixU, 6);
+        SetEntry(Rec.MatrixU, 0, -1,  1, -1/6);
+        SetEntry(Rec.MatrixU, 1, -1,  0, -1/6);
+        SetEntry(Rec.MatrixU, 2, -1, -1, -1/6);
+        SetEntry(Rec.MatrixU, 3,  1,  1,  1/6);
+        SetEntry(Rec.MatrixU, 4,  1,  0,  1/6);
+        SetEntry(Rec.MatrixU, 5,  1, -1,  1/6);
+
+        SetLength(Rec.MatrixV, 6);
+        SetEntry(Rec.MatrixV, 0, -1,  1,  1/6);
+        SetEntry(Rec.MatrixV, 1,  0,  1,  1/6);
+        SetEntry(Rec.MatrixV, 2,  1,  1,  1/6);
+        SetEntry(Rec.MatrixV, 3, -1, -1, -1/6);
+        SetEntry(Rec.MatrixV, 4,  0, -1, -1/6);
+        SetEntry(Rec.MatrixV, 5,  1, -1, -1/6);
+      end;
+
+      nm5x5: begin
+        SetLength(Rec.MatrixU, 20);
+        SetEntry(Rec.MatrixU,  0, -2,  2, -1 / 16);
+        SetEntry(Rec.MatrixU,  1, -1,  2, -1 / 10);
+        SetEntry(Rec.MatrixU,  2,  1,  2,  1 / 10);
+        SetEntry(Rec.MatrixU,  3,  2,  2,  1 / 16);
+        SetEntry(Rec.MatrixU,  4, -2,  1, -1 / 10);
+        SetEntry(Rec.MatrixU,  5, -1,  1, -1 /  8);
+        SetEntry(Rec.MatrixU,  6,  1,  1,  1 /  8);
+        SetEntry(Rec.MatrixU,  7,  2,  1,  1 / 10);
+        SetEntry(Rec.MatrixU,  8, -2,  0, -1 / 2.8);
+        SetEntry(Rec.MatrixU,  9, -1,  0, -0.5);
+        SetEntry(Rec.MatrixU, 10,  1,  0,  0.5);
+        SetEntry(Rec.MatrixU, 11,  2,  0,  1 / 2.8);
+        SetEntry(Rec.MatrixU, 12, -2, -1, -1 / 10);
+        SetEntry(Rec.MatrixU, 13, -1, -1, -1 /  8);
+        SetEntry(Rec.MatrixU, 14,  1, -1,  1 /  8);
+        SetEntry(Rec.MatrixU, 15,  2, -1,  1 / 10);
+        SetEntry(Rec.MatrixU, 16, -2, -2, -1 / 16);
+        SetEntry(Rec.MatrixU, 17, -1, -2, -1 / 10);
+        SetEntry(Rec.MatrixU, 18,  1, -2,  1 / 10);
+        SetEntry(Rec.MatrixU, 19,  2, -2,  1 / 16);
+
+        SetLength(Rec.MatrixV, 20);
+        SetEntry(Rec.MatrixV,  0, -2,  2,  1 / 16);
+        SetEntry(Rec.MatrixV,  1, -1,  2,  1 / 10);
+        SetEntry(Rec.MatrixV,  2,  0,  2,  0.25);
+        SetEntry(Rec.MatrixV,  3,  1,  2,  1 / 10);
+        SetEntry(Rec.MatrixV,  4,  2,  2,  1 / 16);
+        SetEntry(Rec.MatrixV,  5, -2,  1,  1 / 10);
+        SetEntry(Rec.MatrixV,  6, -1,  1,  1 /  8);
+        SetEntry(Rec.MatrixV,  7,  0,  1,  0.5);
+        SetEntry(Rec.MatrixV,  8,  1,  1,  1 /  8);
+        SetEntry(Rec.MatrixV,  9,  2,  1,  1 / 16);
+        SetEntry(Rec.MatrixV, 10, -2, -1, -1 / 16);
+        SetEntry(Rec.MatrixV, 11, -1, -1, -1 /  8);
+        SetEntry(Rec.MatrixV, 12,  0, -1, -0.5);
+        SetEntry(Rec.MatrixV, 13,  1, -1, -1 /  8);
+        SetEntry(Rec.MatrixV, 14,  2, -1, -1 / 10);
+        SetEntry(Rec.MatrixV, 15, -2, -2, -1 / 16);
+        SetEntry(Rec.MatrixV, 16, -1, -2, -1 / 10);
+        SetEntry(Rec.MatrixV, 17,  0, -2, -0.25);
+        SetEntry(Rec.MatrixV, 18,  1, -2, -1 / 10);
+        SetEntry(Rec.MatrixV, 19,  2, -2, -1 / 16);
+      end;
+    end;
+
+    // Daten Sammeln
+    if aUseAlpha and TFormatDescriptor.Get(Format).HasAlpha then
+      AddFunc(glBitmapToNormalMapPrepareAlphaFunc, false, @Rec)
+    else
+      AddFunc(glBitmapToNormalMapPrepareFunc, false, @Rec);
+    AddFunc(glBitmapToNormalMapFunc, false, @Rec);
+  finally
+    SetLength(Rec.Heights, 0);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapCubeMap////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.GenTexture(const aTestTextureSize: Boolean);
+begin
+  Assert(false, 'TglBitmapCubeMap.GenTexture - Don''t call GenTextures directly.');
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.AfterConstruction;
+begin
+  inherited;
+
+  if not (GL_VERSION_1_3 or GL_ARB_texture_cube_map or GL_EXT_texture_cube_map) then
+    raise EglBitmap.Create('TglBitmapCubeMap.AfterConstruction - CubeMaps are unsupported.');
+
+  SetWrap;
+  Target   := GL_TEXTURE_CUBE_MAP;
+  fGenMode := GL_REFLECTION_MAP;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.GenerateCubeMap(const aCubeTarget: Cardinal; const aTestTextureSize: Boolean);
+var
+  BuildWithGlu: Boolean;
+  TexSize: Integer;
+begin
+  if (aTestTextureSize) then begin
+    glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, @TexSize);
+
+    if (Height > TexSize) or (Width > TexSize) then
+      raise EglBitmapSizeToLarge.Create('TglBitmapCubeMap.GenTexture - The size for the Cubemap is to large. It''s may be not conform with the Hardware.');
+
+    if not ((IsPowerOfTwo(Height) and IsPowerOfTwo(Width)) or GL_VERSION_2_0 or GL_ARB_texture_non_power_of_two) then
+      raise EglBitmapNonPowerOfTwo.Create('TglBitmapCubeMap.GenTexture - Cubemaps dosn''t support non power of two texture.');
+  end;
+
+  if (ID = 0) then
+    CreateID;
+  SetupParameters(BuildWithGlu);
+  UploadData(aCubeTarget, BuildWithGlu);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.Bind(const aEnableTexCoordsGen: Boolean; const aEnableTextureUnit: Boolean);
+begin
+  inherited Bind (aEnableTextureUnit);
+  if aEnableTexCoordsGen then begin
+    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, fGenMode);
+    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, fGenMode);
+    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, fGenMode);
+    glEnable(GL_TEXTURE_GEN_S);
+    glEnable(GL_TEXTURE_GEN_T);
+    glEnable(GL_TEXTURE_GEN_R);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapCubeMap.Unbind(const aDisableTexCoordsGen: Boolean; const aDisableTextureUnit: Boolean);
+begin
+  inherited Unbind(aDisableTextureUnit);
+  if aDisableTexCoordsGen then begin
+    glDisable(GL_TEXTURE_GEN_S);
+    glDisable(GL_TEXTURE_GEN_T);
+    glDisable(GL_TEXTURE_GEN_R);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglBitmapNormalMap//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+type
+  TVec = Array[0..2] of Single;
+  TglBitmapNormalMapGetVectorFunc = procedure (out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+
+  PglBitmapNormalMapRec = ^TglBitmapNormalMapRec;
+  TglBitmapNormalMapRec = record
+    HalfSize : Integer;
+    Func: TglBitmapNormalMapGetVectorFunc;
+  end;
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+  aVec[0] := aHalfSize;
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := - (aPosition.X + 0.5 - aHalfSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegX(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+  aVec[0] := - aHalfSize;
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := aPosition.X + 0.5 - aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+  aVec[0] := aPosition.X + 0.5 - aHalfSize;
+  aVec[1] := aHalfSize;
+  aVec[2] := aPosition.Y + 0.5 - aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegY(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+  aVec[0] := aPosition.X + 0.5 - aHalfSize;
+  aVec[1] := - aHalfSize;
+  aVec[2] := - (aPosition.Y + 0.5 - aHalfSize);
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapPosZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+  aVec[0] := aPosition.X + 0.5 - aHalfSize;
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapNegZ(out aVec: TVec; const aPosition: TglBitmapPixelPosition; const aHalfSize: Integer);
+begin
+  aVec[0] := - (aPosition.X + 0.5 - aHalfSize);
+  aVec[1] := - (aPosition.Y + 0.5 - aHalfSize);
+  aVec[2] := - aHalfSize;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glBitmapNormalMapFunc(var FuncRec: TglBitmapFunctionRec);
+var
+  i: Integer;
+  Vec: TVec;
+  Len: Single;
+begin
+  with FuncRec do begin
+    with PglBitmapNormalMapRec(Args)^ do begin
+      Func(Vec, Position, HalfSize);
+
+      // Normalize
+      Len := 1 / Sqrt(Sqr(Vec[0]) + Sqr(Vec[1]) + Sqr(Vec[2]));
+      if Len <> 0 then begin
+        Vec[0] := Vec[0] * Len;
+        Vec[1] := Vec[1] * Len;
+        Vec[2] := Vec[2] * Len;
+      end;
+
+      // Scale Vector and AddVectro
+      Vec[0] := Vec[0] * 0.5 + 0.5;
+      Vec[1] := Vec[1] * 0.5 + 0.5;
+      Vec[2] := Vec[2] * 0.5 + 0.5;
+    end;
+
+    // Set Color
+    for i := 0 to 2 do
+      Dest.Data.arr[i] := Round(Vec[i] * 255);
+  end;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapNormalMap.AfterConstruction;
+begin
+  inherited;
+  fGenMode := GL_NORMAL_MAP;
+end;
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglBitmapNormalMap.GenerateNormalMap(const aSize: Integer; const aTestTextureSize: Boolean);
+var
+  Rec: TglBitmapNormalMapRec;
+  SizeRec: TglBitmapPixelPosition;
+begin
+  Rec.HalfSize := aSize div 2;
+  FreeDataAfterGenTexture := false;
+
+  SizeRec.Fields := [ffX, ffY];
+  SizeRec.X := aSize;
+  SizeRec.Y := aSize;
+
+  // Positive X
+  Rec.Func := glBitmapNormalMapPosX;
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_X, aTestTextureSize);
+
+  // Negative X
+  Rec.Func := glBitmapNormalMapNegX;
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, aTestTextureSize);
+
+  // Positive Y
+  Rec.Func := glBitmapNormalMapPosY;
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, aTestTextureSize);
+
+  // Negative Y
+  Rec.Func := glBitmapNormalMapNegY;
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, aTestTextureSize);
+
+  // Positive Z
+  Rec.Func := glBitmapNormalMapPosZ;
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, aTestTextureSize);
+
+  // Negative Z
+  Rec.Func := glBitmapNormalMapNegZ;
+  LoadFromFunc(SizeRec, glBitmapNormalMapFunc, tfBGR8, @Rec);
+  GenerateCubeMap(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, aTestTextureSize);
+end;
+
+
+initialization
+  glBitmapSetDefaultFormat (tfEmpty);
+  glBitmapSetDefaultMipmap (mmMipmap);
+  glBitmapSetDefaultFilter (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
+  glBitmapSetDefaultWrap   (GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE);
+  glBitmapSetDefaultSwizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA);
+
+  glBitmapSetDefaultFreeDataAfterGenTexture(true);
+  glBitmapSetDefaultDeleteTextureOnFree    (true);
+
+  TFormatDescriptor.Init;
+
+{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
+  OpenGLInitialized := false;
+  InitOpenGLCS := TCriticalSection.Create;
+{$ENDIF}
+
+finalization
+  TFormatDescriptor.Finalize;
+
+{$IFDEF GLB_NATIVE_OGL}
+  if Assigned(GL_LibHandle) then
+    glbFreeLibrary(GL_LibHandle);
+
+{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
+  if Assigned(GLU_LibHandle) then
+    glbFreeLibrary(GLU_LibHandle);
+  FreeAndNil(InitOpenGLCS);
+{$ENDIF}
+{$ENDIF}  
+
+end.

diff --git a/uglcCamera.pas b/uglcCamera.pas
new file mode 100644 (file)
index 0000000..197f676
--- /dev/null
+++ b/uglcCamera.pas
@@ -0,0 +1,271 @@
+unit uglcCamera;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Frustum und Kamera
+  Beispiel:
+    var
+      camera: TglcCamera;
+
+    camera := TglcCamera.Create;
+    try
+      camera.Perspective(45, 0.01, 100, 800/600);   // define perspective view
+      camera.Move(gluVector(2, 3, -5));             // move 2 right, 3 up and 5 back
+      camera.Tilt(-25);                             // turn 25 degrees down
+      camera.Turn(-10);                             // turn 10 degrees left
+      camera.Activate;                              // activate camera
+
+      // do normal rendering
+
+    finally
+      FreeAndNil(camera);
+    end;  }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils,
+  ugluVector, ugluMatrix;
+
+type
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglcFrustum = class(TObject)
+  private
+    function GetWidth: Single;
+    function GetHeight: Single;
+    function GetFOVAngle: Single;
+    function GetAspectRatio: Single;
+  protected
+    fIsOrthogonal: Boolean;
+    fTop, fBottom, fLeft, fRight, fNear, fFar: Single;
+  public
+    property Top         : Single  read fTop;
+    property Bottom      : Single  read fBottom;
+    property Left        : Single  read fLeft;
+    property Right       : Single  read fRight;
+    property Near        : Single  read fNear;
+    property Far         : Single  read fFar;
+    property Width       : Single  read GetWidth;
+    property Height      : Single  read GetHeight;
+    property FOVAngle    : Single  read GetFOVAngle;
+    property AspectRatio : Single  read GetAspectRatio;
+    property IsOrthogonal: Boolean read fIsOrthogonal;
+
+    procedure Frustum(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+    procedure Perspective(const aFOVAngle, aAspectRatio, aNear, aFar: Single);
+    procedure Ortho(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+    procedure Activate;
+    procedure Render;
+
+    constructor Create;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglcCamera = class(TglcFrustum)
+  private
+    fPosition: TgluMatrix4f;
+  public
+    property Position: TgluMatrix4f read fPosition write fPosition;
+
+    procedure Move(const aVec: TgluVector3f);
+    procedure Tilt(const aAngle: Single);
+    procedure Turn(const aAngle: Single);
+    procedure Roll(const aAngle: Single);
+    procedure Activate;
+    function GetRay(const aPos: TgluVector2f): TgluRayf;
+
+    constructor Create;
+  end;
+
+implementation
+
+uses
+  Math, dglOpenGL;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcFrustum///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetWidth: Single;
+begin
+  result := (fRight - fLeft);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetHeight: Single;
+begin
+  result := (fTop - fBottom);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetFOVAngle: Single;
+begin
+  result := arctan2(Height/2, fNear)/Pi*360;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrustum.GetAspectRatio: Single;
+begin
+  result := Height / Width;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Frustum(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+begin
+  fIsOrthogonal := false;
+  fTop          := aRight;
+  fBottom       := aLeft;
+  fLeft         := aBottom;
+  fRight        := aTop;
+  fNear         := aNear;
+  fFar          := aFar;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Perspective(const aFOVAngle, aAspectRatio, aNear, aFar: Single);
+begin
+  fIsOrthogonal := false;
+  fNear         := aNear;
+  fFar          := aFar;
+  fTop          := fNear * tan(aFOVAngle / 360 * Pi);
+  fBottom       := -fTop;
+  fRight        := aAspectRatio * fTop;
+  fLeft         := -fRight;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Ortho(const aLeft, aRight, aBottom, aTop, aNear, aFar: Single);
+begin
+  fIsOrthogonal := true;
+  fLeft         := aLeft;
+  fRight        := aRight;
+  fTop          := aTop;
+  fBottom       := aBottom;
+  fNear         := aNear;
+  fFar          := aFar;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Activate;
+begin
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity;
+  if fIsOrthogonal then
+    glOrtho(fLeft, fRight, fBottom, fTop, fNear, fFar)
+  else
+    glFrustum(fLeft, fRight, fBottom, fTop, fNear, fFar);
+  glMatrixMode(GL_MODELVIEW);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrustum.Render;
+var
+  min, max: TgluVector2f;
+begin
+  min[0] := fLeft   / fNear * fFar;
+  min[1] := fBottom / fNear * fFar;
+  max[0] := fRight  / fNear * fFar;
+  max[1] := fTop    / fNear * fFar;
+
+  glBegin(GL_LINE_LOOP);
+    glVertex3f(fLeft, fTop, -fNear);
+    glVertex3f(fLeft, fBottom, -fNear);
+    glVertex3f(fRight, fBottom, -fNear);
+    glVertex3f(fRight, fTop, -fNear);
+  glEnd;
+
+  glBegin(GL_LINE_LOOP);
+    glVertex3f(min[0], min[0], -fFar);
+    glVertex3f(min[0], max[0], -fFar);
+    glVertex3f(max[0], max[0], -fFar);
+    glVertex3f(max[0], min[0], -fFar);
+  glEnd;
+
+  glBegin(GL_LINES);
+    glVertex3f(0, 0, 0); glVertex3f(min[0], min[0], -fFar);
+    glVertex3f(0, 0, 0); glVertex3f(min[0], max[0], -fFar);
+    glVertex3f(0, 0, 0); glVertex3f(max[0], max[0], -fFar);
+    glVertex3f(0, 0, 0); glVertex3f(max[0], min[0], -fFar);
+  glEnd;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcFrustum.Create;
+begin
+  inherited Create;
+  fTop    := 0;
+  fBottom := 0;
+  fLeft   := 0;
+  fRight  := 0;
+  fNear   := 0;
+  fFar    := 0;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcCamera////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Move(const aVec: TgluVector3f);
+begin
+  fPosition := gluMatrixMult(gluMatrixTranslate(aVec), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Tilt(const aAngle: Single);
+begin
+  fPosition := gluMatrixMult(gluMatrixRotate(gluVector3f(1,0,0), aAngle), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Turn(const aAngle: Single);
+begin
+  fPosition := gluMatrixMult(gluMatrixRotate(gluVector3f(0,1,0), aAngle), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Roll(const aAngle: Single);
+begin
+  fPosition := gluMatrixMult(gluMatrixRotate(gluVector3f(0,0,1), aAngle), fPosition);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcCamera.Activate;
+begin
+  inherited Activate;
+  glLoadMatrixf(@fPosition[0, 0]);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcCamera.GetRay(const aPos: TgluVector2f): TgluRayf;
+var
+  p: TgluVector3f;
+begin
+  if (aPos[0] < 0) then
+    p[0] := -aPos[0] * fLeft
+  else
+    p[0] := aPos[0] * fRight;
+  if (aPos[1] < 0) then
+    p[1] := -aPos[1] * fBottom
+  else
+    p[1] := aPos[1] * fTop;
+  if (fIsOrthogonal) then begin
+    p[2] := 0;
+    result.p := fPosition * p;
+    result.v := fPosition * gluVector3f(0, 0, -1);
+  end else begin
+    p[2] := -fNear;
+    result.p := gluVector3f(0, 0, 0);
+    result.v := fPosition * p;
+  end;
+  result := gluRayNormalize(result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcCamera.Create;
+begin
+  inherited Create;
+  fPosition := gluMatrixIdentity;
+end;
+
+end.
+

diff --git a/uglcContext.pas b/uglcContext.pas
new file mode 100644 (file)
index 0000000..6255396
--- /dev/null
+++ b/uglcContext.pas
@@ -0,0 +1,346 @@
+unit uglcContext;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit enthält eine abstrakte Klassen-Kapselung für OpenGL Kontexte
+
+
+Abstrakte Contextklasse zum Erstellen von Renderkontexten auf Windows & Linux(bzw X11/Gtk2)
+Für aktuelle Plattform passende Klasse kann per GetPlatformClass gefunden werden.
+
+Bsp.:
+  //muss im GUI/Main-Thread aufgerufen werden:
+  pf := TglcContext.GetPlatformClass().MakePF();
+  fContext := TglcContext.GetPlatformClass().Create(MyTWinControl, PF);
+
+  //_kann_ in Background Thread abgerufen werden:
+  fContext.BuildContext();
+  [Arbeit mit dem Context]
+  fContext.CloseContext();
+
+  //im MainThread
+  FreeAndNil(fContext)
+
+
+weitere Funktionen:
+  MakePF()             erzeugt PixelFormatDescriptor mit Defaults
+  BuildContext()       baut Kontext (kann in BackgrounThread aufgerufen werden)
+  CloseContext()       gibt den Kontext frei (muss im selben Thread aufgerufen werden wie BuildContext;
+                       wird der Kontext nur im MainThread genutzt, muss CloseContext nicht explizit aufgerufen
+                       werden und wird beim zerstören des Kontext-Objekts ausgeführt)
+  Activate/Deactiveate Kontext aktiv schalten oder nicht
+  SwapBuffers          DoubleBuffering
+  SetSwapInterval      VSync
+  Share                ShareLists
+  EnableDebugOutput    GL-Debug via ARB_debug_output oder AMD_debug_output de/aktivieren
+}
+
+interface
+
+uses
+  SysUtils, Controls, dglOpenGL;
+
+const
+  GLC_CONTEXT_VERSION_UNKNOWN = -1;
+
+type
+  TMultiSample = 1..high(byte);
+  TglcContextPixelFormatSettings = packed record
+    DoubleBuffered: boolean;
+    Stereo: boolean;
+    MultiSampling: TMultiSample;
+    ColorBits: Integer;
+    DepthBits: Integer;
+    StencilBits: Integer;
+    AccumBits: Integer;
+    AuxBuffers: Integer;
+    Layer: Integer;
+  end;
+  TglcContextVersionSettings = packed record
+    Major: Integer;
+    Minor: Integer;
+    ForwardCompatible: Boolean;
+  end;
+  TSeverity = (svLow, svMedium, svHigh);
+  TLogEvent = procedure(const aSender: TObject; const aSeverity: TSeverity; const aMsg: String) of Object;
+
+  TglcDisplayFlag = (
+    dfFullscreen);
+  TglcDisplayFlags = set of TglcDisplayFlag;
+
+  EGLError = class(Exception);
+
+  { TglcContext }
+  TglcContextClass = class of TglcContext;
+  TglcContext = class
+  private
+    fControl: TWinControl;
+    fThreadID: TThreadID;
+    fEnableVsync: Boolean;
+    fLogEvent: TLogEvent;
+
+    function GetEnableVSync: Boolean;
+    procedure SetEnableVSync(aValue: Boolean);
+    procedure LogMsg(const aSeverity: TSeverity; const aMsg: String);
+    procedure SetDebugMode(const aEnable: Boolean);
+  protected
+    fUseVersion: Boolean;
+    fPixelFormatSettings: TglcContextPixelFormatSettings;
+    fVersionSettings: TglcContextVersionSettings;
+    procedure OpenContext; virtual;
+
+  public
+    property PixelFormatSettings: TglcContextPixelFormatSettings read fPixelFormatSettings;
+    property VersionSettings:     TglcContextVersionSettings     read fVersionSettings;
+
+    constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings); virtual; overload;
+    constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); virtual; overload;
+    destructor Destroy; override;
+
+    property ThreadID:    TThreadID read fThreadID;
+    property EnableVSync: Boolean   read GetEnableVSync write SetEnableVSync;
+
+    procedure BuildContext;
+    procedure EnableDebugOutput(const aLogEvent: TLogEvent);
+    procedure DisableDebugOutput;
+    procedure CloseContext; virtual;
+    procedure Activate; virtual; abstract;
+    procedure Deactivate; virtual; abstract;
+    function IsActive: boolean; virtual; abstract;
+    procedure SwapBuffers; virtual; abstract;
+    procedure SetSwapInterval(const aInterval: GLint); virtual; abstract;
+    function GetSwapInterval: GLint; virtual; abstract;
+    procedure Share(const aContext: TglcContext); virtual; abstract;
+
+  private class var
+    fMainContextThreadID: TThreadID;
+  public
+    class property MainContextThreadID: TThreadID read fMainContextThreadID;
+    class function MakePF(DoubleBuffered: boolean = true;
+                          Stereo: boolean=false;
+                          MultiSampling: TMultiSample=1;
+                          ColorBits: Integer=32;
+                          DepthBits: Integer=24;
+                          StencilBits: Integer=0;
+                          AccumBits: Integer=0;
+                          AuxBuffers: Integer=0;
+                          Layer: Integer=0): TglcContextPixelFormatSettings;
+    class function MakeVersion(const aMajor, aMinor: Integer; const aForwardCompatible: Boolean): TglcContextVersionSettings;
+    class function GetPlatformClass: TglcContextClass;
+    class function ChangeDisplaySettings(const aWidth, aHeight,
+      aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean; virtual; abstract;
+    class function IsAnyContextActive: boolean; virtual;
+  end;
+
+implementation
+
+uses
+  {$IFDEF WINDOWS}
+    uglcContextWGL
+  {$ENDIF}
+  {$IFDEF LINUX}
+    uglcContextGtk2GLX
+  {$ENDIF}
+  ;
+
+procedure GlDebugCallbackARB(source: GLenum; type_: GLenum; id: GLuint; severity: GLenum; {%H-}length: GLsizei; const message_: PGLchar; {%H-}userParam: PGLvoid); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}
+var
+  src, typ: String;
+  sv: TSeverity;
+begin
+  case source of
+    GL_DEBUG_SOURCE_API_ARB            : src:= 'API';
+    GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB  : src:= 'WINDOW';
+    GL_DEBUG_SOURCE_SHADER_COMPILER_ARB: src:= 'SHADER';
+    GL_DEBUG_SOURCE_THIRD_PARTY_ARB    : src:= '3RDPARTY';
+    GL_DEBUG_SOURCE_APPLICATION_ARB    : src:= 'APPLICATION';
+    GL_DEBUG_SOURCE_OTHER_ARB          : src:= 'OTHER';
+  end;
+  src:= 'GL_' + src;
+
+  case type_ of
+    GL_DEBUG_TYPE_ERROR_ARB               : typ:= 'ERROR';
+    GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB : typ:= 'DEPRECATED';
+    GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB  : typ:= 'UNDEF BEHAV';
+    GL_DEBUG_TYPE_PORTABILITY_ARB         : typ:= 'PORTABILITY';
+    GL_DEBUG_TYPE_PERFORMANCE_ARB         : typ:= 'PERFORMANCE';
+    GL_DEBUG_TYPE_OTHER_ARB               : typ:= 'OTHER';
+  end;
+
+  case severity of
+    GL_DEBUG_SEVERITY_LOW_ARB:    sv := svLow;
+    GL_DEBUG_SEVERITY_MEDIUM_ARB: sv := svMedium;
+    GL_DEBUG_SEVERITY_HIGH_ARB:   sv := svHigh;
+  end;
+
+  TglcContext(userParam).LogMsg(sv, format('%s [%d] %s',[typ, id, message_]));
+end;
+
+procedure GlDebugCallbackAMD(id: GLuint; category: GLenum; severity: GLenum; {%H-}length: GLsizei; const message_: PGLchar; {%H-}userParam: PGLvoid); {$IFDEF WINDOWS}stdcall; {$ELSE}cdecl; {$ENDIF}
+var
+  src: String;
+  sv: TSeverity;
+begin
+  case category of
+    GL_DEBUG_CATEGORY_API_ERROR_AMD            : src:= 'API';
+    GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD        : src:= 'WINDOW';
+    GL_DEBUG_CATEGORY_DEPRECATION_AMD          : src:= 'SHADER';
+    GL_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD   : src:= 'UNDEF BEHAV';
+    GL_DEBUG_CATEGORY_PERFORMANCE_AMD          : src:= 'PERFORMANCE';
+    GL_DEBUG_CATEGORY_SHADER_COMPILER_AMD      : src:= 'SHADER';
+    GL_DEBUG_CATEGORY_APPLICATION_AMD          : src:= 'APPLICATION';
+    GL_DEBUG_CATEGORY_OTHER_AMD                : src:= 'OTHER';
+  end;
+  src:= 'GL_' + src;
+
+  case severity of
+    GL_DEBUG_SEVERITY_LOW_AMD:    sv := svLow;
+    GL_DEBUG_SEVERITY_MEDIUM_AMD: sv := svMedium;
+    GL_DEBUG_SEVERITY_HIGH_AMD:   sv := svHigh;
+  end;
+
+  TglcContext(userParam).LogMsg(sv, format('[%d] %s',[id, message_]));
+end;
+
+function TglcContext.GetEnableVSync: Boolean;
+begin
+  result := fEnableVsync;
+end;
+
+procedure TglcContext.SetEnableVSync(aValue: Boolean);
+begin
+  fEnableVsync := aValue;
+  if IsActive then begin
+    if fEnableVsync then
+      SetSwapInterval(1)
+    else
+      SetSwapInterval(0);
+  end;
+end;
+
+procedure TglcContext.LogMsg(const aSeverity: TSeverity; const aMsg: String);
+begin
+  if Assigned(fLogEvent) then
+    fLogEvent(self, aSeverity, aMsg);
+end;
+
+procedure TglcContext.SetDebugMode(const aEnable: Boolean);
+begin
+  // ARB Debug Output
+  if GL_ARB_debug_output then begin
+    glDebugMessageCallbackARB(@GlDebugCallbackARB, self);
+    glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nil, aEnable);
+    if aEnable then begin
+      glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+      glDebugMessageInsertARB(GL_DEBUG_SOURCE_APPLICATION_ARB, GL_DEBUG_TYPE_OTHER_ARB, 0, GL_DEBUG_SEVERITY_LOW_ARB, -1, PGLchar('Attached ARB_debug_output'));
+    end;
+
+  // AMD Debug Output
+  end else if GL_AMD_debug_output then begin
+    glDebugMessageCallbackAMD(@GlDebugCallbackAMD, self);
+    glDebugMessageEnableAMD(GL_DONT_CARE, GL_DONT_CARE, 0, nil, aEnable);
+    if aEnable then
+      glDebugMessageInsertAMD(GL_DEBUG_CATEGORY_OTHER_AMD, GL_DEBUG_SEVERITY_LOW_ARB, 0, -1, PGLchar('Attached ARB_debug_output'));
+  end;
+end;
+
+procedure TglcContext.OpenContext;
+begin
+  fThreadID := GetCurrentThreadId;
+  if fMainContextThreadID = 0 then
+    fMainContextThreadID := fThreadID;
+end;
+
+class function TglcContext.MakePF(DoubleBuffered: boolean; Stereo: boolean; MultiSampling: TMultiSample; ColorBits: Integer;
+  DepthBits: Integer; StencilBits: Integer; AccumBits: Integer; AuxBuffers: Integer; Layer: Integer): TglcContextPixelFormatSettings;
+begin
+  Result.DoubleBuffered:= DoubleBuffered;
+  Result.Stereo:= Stereo;
+  Result.MultiSampling:= MultiSampling;
+  Result.ColorBits:= ColorBits;
+  Result.DepthBits:= DepthBits;
+  Result.StencilBits:= StencilBits;
+  Result.AccumBits:= AccumBits;
+  Result.AuxBuffers:= AuxBuffers;
+  Result.Layer:= Layer;
+end;
+
+class function TglcContext.MakeVersion(const aMajor, aMinor: Integer; const aForwardCompatible: Boolean): TglcContextVersionSettings;
+begin
+  result.Major := aMajor;
+  result.Minor := aMinor;
+  result.ForwardCompatible := aForwardCompatible;
+end;
+
+class function TglcContext.GetPlatformClass: TglcContextClass;
+begin
+  {$IFDEF WINDOWS}
+  Result:= TglcContextWGL;
+  {$ENDIF}
+  {$IFDEF LINUX}
+  Result:= TglcContextGtk2GLX;
+  {$ENDIF}
+end;
+
+class function TglcContext.IsAnyContextActive: boolean;
+begin
+  Result:= GetPlatformClass.IsAnyContextActive;
+end;
+
+constructor TglcContext.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings);
+begin
+  inherited Create;
+  fPixelFormatSettings := aPixelFormatSettings;
+  FControl             := aControl;
+  fThreadID            := 0;
+  fEnableVsync         := false;
+  fUseVersion          := false;
+  InitOpenGL();
+end;
+
+constructor TglcContext.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings);
+begin
+  Create(aControl, aPixelFormatSettings);
+  fVersionSettings := aVersionSettings;
+  fUseVersion      := true;
+end;
+
+destructor TglcContext.Destroy;
+begin
+  if (GetCurrentThreadId = fMainContextThreadID) then
+    fMainContextThreadID := 0;
+  CloseContext;
+  inherited Destroy;
+end;
+
+procedure TglcContext.BuildContext;
+begin
+  OpenContext;
+  Activate;
+  ReadImplementationProperties;
+  ReadExtensions;
+  SetEnableVSync(fEnableVsync);
+end;
+
+procedure TglcContext.EnableDebugOutput(const aLogEvent: TLogEvent);
+begin
+  fLogEvent := aLogEvent;
+  SetDebugMode(true);
+end;
+
+procedure TglcContext.DisableDebugOutput;
+begin
+  SetDebugMode(false);
+end;
+
+procedure TglcContext.CloseContext;
+begin
+  if fMainContextThreadID = fThreadID then
+    fMainContextThreadID := 0;
+end;
+
+initialization
+  TglcContext.fMainContextThreadID := 0;
+
+end.
+

diff --git a/uglcContextGtk2GLX.pas b/uglcContextGtk2GLX.pas
new file mode 100644 (file)
index 0000000..f9d1475
--- /dev/null
+++ b/uglcContextGtk2GLX.pas
@@ -0,0 +1,572 @@
+unit uglcContextGtk2GLX;\r
+\r
+{ Package:      OpenGLCore\r
+  Prefix:       glc - OpenGL Core\r
+  Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Kontexte für Linux\r
+  Hint:         diese Unit sollte niemals direkt genutzt werden (siehe uglcContext) }\r
+\r
+interface\r
+\r
+uses\r
+  SysUtils, Controls, uglcContext, LCLType, XUtil, XLib, gdk2x, gtk2, gdk2, dglOpenGL,\r
+  LMessages, uglcContextGtkCustomVisual;\r
+\r
+type\r
+  EGLXError = class(EGLError);\r
+\r
+  TRenderControl = class(TCustomVisualControl)\r
+  private\r
+    fTarget: TWinControl;\r
+  protected\r
+    procedure WndProc(var Message: TLMessage); override;\r
+  public\r
+    property Target: TWinControl read fTarget write fTarget;\r
+  end;\r
+\r
+  { TglcContextGtk2GLX }\r
+\r
+  TglcContextGtk2GLX = class(TglcContext)\r
+  private\r
+    FVisual: PXVisualInfo;\r
+    FDisplay: PDisplay;\r
+    FWidget: PGtkWidget;\r
+    FContext: GLXContext;\r
+    FRenderControl: TRenderControl;\r
+    procedure UpdateVisual(const aControl: TWinControl);\r
+  protected\r
+    procedure OpenContext; override;\r
+  public\r
+    constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings); override; overload;\r
+    constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); override; overload;\r
+    destructor Destroy; override;\r
+\r
+    procedure CloseContext; override;\r
+    procedure Activate; override;\r
+    procedure Deactivate; override;\r
+    function IsActive: boolean; override;\r
+    procedure SwapBuffers; override;\r
+    procedure SetSwapInterval(const aInterval: GLint); override;\r
+    procedure Share(const aContext: TglcContext); override;\r
+\r
+    class function ChangeDisplaySettings(const aWidth, aHeight,\r
+      aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean; override;\r
+    class function IsAnyContextActive: boolean; override;\r
+  end;\r
+\r
+implementation\r
+\r
+type\r
+  TGLIntArray = packed array of GLInt;\r
+\r
+{$region messages -fold}\r
+procedure TRenderControl.WndProc(var Message: TLMessage);\r
+begin\r
+  case Message.msg of\r
+    //LM_ACTIVATEITEM,\r
+    //LM_CHANGED,\r
+    //LM_FOCUS,\r
+    LM_CLICKED,\r
+    //LM_RELEASED,\r
+    LM_ENTER,\r
+    LM_LEAVE,\r
+    //LM_CHECKRESIZE,\r
+    //LM_SETEDITABLE,\r
+    //LM_MOVEWORD,\r
+    //LM_MOVEPAGE,\r
+    //LM_MOVETOROW,\r
+    //LM_MOVETOCOLUMN,\r
+    //LM_KILLCHAR,\r
+    //LM_KILLWORD,\r
+    //LM_KILLLINE,\r
+    //LM_CLOSEQUERY,\r
+    //LM_DRAGSTART,\r
+    //LM_MONTHCHANGED,\r
+    //LM_YEARCHANGED,\r
+    //LM_DAYCHANGED,\r
+    LM_LBUTTONTRIPLECLK,\r
+    LM_LBUTTONQUADCLK,\r
+    LM_MBUTTONTRIPLECLK,\r
+    LM_MBUTTONQUADCLK,\r
+    LM_RBUTTONTRIPLECLK,\r
+    LM_RBUTTONQUADCLK,\r
+    LM_MOUSEENTER,\r
+    LM_MOUSELEAVE,\r
+    LM_XBUTTONTRIPLECLK,\r
+    LM_XBUTTONQUADCLK,\r
+\r
+    //SC_SIZE,\r
+    //SC_MOVE,\r
+    //SC_MINIMIZE,\r
+    //SC_MAXIMIZE,\r
+    //SC_NEXTWINDOW,\r
+    //SC_PREVWINDOW,\r
+    //SC_CLOSE,\r
+    SC_VSCROLL,\r
+    SC_HSCROLL,\r
+    SC_MOUSEMENU,\r
+    SC_KEYMENU,\r
+    //SC_ARRANGE,\r
+    //SC_RESTORE,\r
+    //SC_TASKLIST,\r
+    //SC_SCREENSAVE,\r
+    //SC_HOTKEY,\r
+    //SC_DEFAULT,\r
+    //SC_MONITORPOWER,\r
+    //SC_CONTEXTHELP,\r
+    //SC_SEPARATOR,\r
+\r
+    //LM_MOVE,\r
+    //LM_SIZE,\r
+    LM_ACTIVATE,\r
+    LM_SETFOCUS,\r
+    LM_KILLFOCUS,\r
+    //LM_ENABLE,\r
+    //LM_GETTEXTLENGTH,\r
+    //LM_SHOWWINDOW,\r
+    //LM_CANCELMODE,\r
+    //LM_DRAWITEM,\r
+    //LM_MEASUREITEM,\r
+    //LM_DELETEITEM,\r
+    //LM_VKEYTOITEM,\r
+    //LM_CHARTOITEM,\r
+    //LM_COMPAREITEM,\r
+    //LM_WINDOWPOSCHANGING,\r
+    //LM_WINDOWPOSCHANGED,\r
+    //LM_NOTIFY,\r
+    //LM_HELP,\r
+    //LM_NOTIFYFORMAT,\r
+    //LM_CONTEXTMENU,\r
+    //LM_NCCALCSIZE,\r
+    //LM_NCHITTEST,\r
+    //LM_NCPAINT,\r
+    //LM_NCACTIVATE,\r
+    //LM_GETDLGCODE,\r
+    LM_NCMOUSEMOVE,\r
+    LM_NCLBUTTONDOWN,\r
+    LM_NCLBUTTONUP,\r
+    LM_NCLBUTTONDBLCLK,\r
+    LM_KEYDOWN,\r
+    LM_KEYUP,\r
+    LM_CHAR,\r
+    LM_SYSKEYDOWN,\r
+    LM_SYSKEYUP,\r
+    LM_SYSCHAR,\r
+    LM_COMMAND,\r
+    LM_SYSCOMMAND,\r
+    LM_TIMER,\r
+    LM_HSCROLL,\r
+    LM_VSCROLL,\r
+    //LM_CTLCOLORMSGBOX,\r
+    //LM_CTLCOLOREDIT,\r
+    //LM_CTLCOLORLISTBOX,\r
+    //LM_CTLCOLORBTN,\r
+    //LM_CTLCOLORDLG,\r
+    //LM_CTLCOLORSCROLLBAR,\r
+    //LM_CTLCOLORSTATIC,\r
+    LM_MOUSEMOVE,\r
+    LM_LBUTTONDOWN,\r
+    LM_LBUTTONUP,\r
+    LM_LBUTTONDBLCLK,\r
+    LM_RBUTTONDOWN,\r
+    LM_RBUTTONUP,\r
+    LM_RBUTTONDBLCLK,\r
+    LM_MBUTTONDOWN,\r
+    LM_MBUTTONUP,\r
+    LM_MBUTTONDBLCLK,\r
+    LM_MOUSEWHEEL,\r
+    LM_XBUTTONDOWN,\r
+    LM_XBUTTONUP,\r
+    LM_XBUTTONDBLCLK,\r
+    //LM_PARENTNOTIFY,\r
+    //LM_CAPTURECHANGED,\r
+    //LM_DROPFILES,\r
+    //LM_SELCHANGE,\r
+    LM_CUT,\r
+    LM_COPY,\r
+    LM_PASTE,\r
+    //LM_CLEAR,\r
+    //LM_CONFIGUREEVENT,\r
+    //LM_EXIT,\r
+    //LM_QUIT,\r
+    //LM_NULL,\r
+    //LM_PAINT,\r
+    //LM_ERASEBKGND,\r
+    //LM_SETCURSOR,\r
+    //LM_SETFONT:\r
+\r
+    //CM_ACTIVATE,\r
+    //CM_DEACTIVATE,\r
+    //CM_FOCUSCHANGED,\r
+    //CM_PARENTFONTCHANGED,\r
+    //CM_PARENTCOLORCHANGED,\r
+    //CM_HITTEST,\r
+    //CM_VISIBLECHANGED,\r
+    //CM_ENABLEDCHANGED,\r
+    //CM_COLORCHANGED,\r
+    //CM_FONTCHANGED,\r
+    //CM_CURSORCHANGED,\r
+    //CM_TEXTCHANGED,\r
+    CM_MOUSEENTER,\r
+    CM_MOUSELEAVE,\r
+    //CM_MENUCHANGED,\r
+    //CM_APPSYSCOMMAND,\r
+    //CM_BUTTONPRESSED,\r
+    //CM_SHOWINGCHANGED,\r
+    //CM_ENTER,\r
+    //CM_EXIT,\r
+    //CM_DESIGNHITTEST,\r
+    //CM_ICONCHANGED,\r
+    //CM_WANTSPECIALKEY,\r
+    //CM_RELEASE,\r
+    //CM_FONTCHANGE,\r
+    //CM_TABSTOPCHANGED,\r
+    //CM_UIACTIVATE,\r
+    //CM_CONTROLLISTCHANGE,\r
+    //CM_GETDATALINK,\r
+    //CM_CHILDKEY,\r
+    //CM_HINTSHOW,\r
+    //CM_SYSFONTCHANGED,\r
+    //CM_CONTROLCHANGE,\r
+    //CM_CHANGED,\r
+    //CM_BORDERCHANGED,\r
+    //CM_BIDIMODECHANGED,\r
+    //CM_PARENTBIDIMODECHANGED,\r
+    //CM_ALLCHILDRENFLIPPED,\r
+    //CM_ACTIONUPDATE,\r
+    //CM_ACTIONEXECUTE,\r
+    //CM_HINTSHOWPAUSE,\r
+    //CM_DOCKNOTIFICATION,\r
+    CM_MOUSEWHEEL,\r
+    //CM_APPSHOWBTNGLYPHCHANGED,\r
+    //CM_APPSHOWMENUGLYPHCHANGED,\r
+\r
+    //CN_BASE,\r
+    //CN_CHARTOITEM,\r
+    //CN_COMMAND,\r
+    //CN_COMPAREITEM,\r
+    //CN_CTLCOLORBTN,\r
+    //CN_CTLCOLORDLG,\r
+    //CN_CTLCOLOREDIT,\r
+    //CN_CTLCOLORLISTBOX,\r
+    //CN_CTLCOLORMSGBOX,\r
+    //CN_CTLCOLORSCROLLBAR,\r
+    //CN_CTLCOLORSTATIC,\r
+    //CN_DELETEITEM,\r
+    //CN_DRAWITEM,\r
+    CN_HSCROLL,\r
+    //CN_MEASUREITEM,\r
+    //CN_PARENTNOTIFY,\r
+    //CN_VKEYTOITEM,\r
+    CN_VSCROLL,\r
+    CN_KEYDOWN,\r
+    CN_KEYUP,\r
+    CN_CHAR,\r
+    CN_SYSKEYUP,\r
+    CN_SYSKEYDOWN,\r
+    CN_SYSCHAR,\r
+    CN_NOTIFY:\r
+    begin\r
+      if Assigned(fTarget) then\r
+        Message.Result := fTarget.Perform(Message.msg, Message.wParam, Message.lParam);\r
+    end;\r
+  end;\r
+  inherited WndProc(Message);\r
+end;\r
+\r
+{$endregion}\r
+\r
+function CreateOpenGLContextAttrList(UseFB: boolean; pf: TglcContextPixelFormatSettings): TGLIntArray;\r
+var\r
+  p: integer;\r
+\r
+  procedure Add(i: integer);\r
+  begin\r
+    SetLength(Result, p+1);\r
+    Result[p]:=i;\r
+    inc(p);\r
+  end;\r
+\r
+  procedure CreateList;\r
+  begin\r
+    if UseFB then begin Add(GLX_X_RENDERABLE); Add(1); end;\r
+    if pf.DoubleBuffered then begin\r
+      if UseFB then begin\r
+        Add(GLX_DOUBLEBUFFER); Add(1);\r
+      end else\r
+        Add(GLX_DOUBLEBUFFER);\r
+    end;\r
+    if not UseFB and (pf.ColorBits>24) then Add(GLX_RGBA);\r
+    if UseFB then begin\r
+      Add(GLX_DRAWABLE_TYPE);\r
+      Add(GLX_WINDOW_BIT);\r
+    end;\r
+    Add(GLX_RED_SIZE);  Add(8);\r
+    Add(GLX_GREEN_SIZE);  Add(8);\r
+    Add(GLX_BLUE_SIZE);  Add(8);\r
+    if pf.ColorBits>24 then\r
+      Add(GLX_ALPHA_SIZE);  Add(8);\r
+    Add(GLX_DEPTH_SIZE);  Add(pf.DepthBits);\r
+    Add(GLX_STENCIL_SIZE);  Add(pf.StencilBits);\r
+    Add(GLX_AUX_BUFFERS);  Add(pf.AUXBuffers);\r
+\r
+    if pf.MultiSampling > 1 then begin\r
+      Add(GLX_SAMPLE_BUFFERS_ARB); Add(1);\r
+      Add(GLX_SAMPLES_ARB); Add(pf.MultiSampling);\r
+    end;\r
+\r
+    Add(0); { 0 = X.None (be careful: GLX_NONE is something different) }\r
+  end;\r
+\r
+begin\r
+  SetLength(Result, 0);\r
+  p:=0;\r
+  CreateList;\r
+end;\r
+\r
+function FBglXChooseVisual(dpy:PDisplay; screen:longint; attrib_list:Plongint):PXVisualInfo;\r
+type\r
+  PGLXFBConfig = ^GLXFBConfig;\r
+var\r
+  FBConfigsCount: integer;\r
+  FBConfigs: PGLXFBConfig;\r
+  FBConfig: GLXFBConfig;\r
+begin\r
+  Result:= nil;\r
+  FBConfigsCount:=0;\r
+  FBConfigs:= glXChooseFBConfig(dpy, screen, attrib_list, @FBConfigsCount);\r
+  if FBConfigsCount = 0 then\r
+    exit;\r
+\r
+  { just choose the first FB config from the FBConfigs list.\r
+    More involved selection possible. }\r
+  FBConfig := FBConfigs^;\r
+  Result:=glXGetVisualFromFBConfig(dpy, FBConfig);\r
+end;\r
+\r
+\r
+{ TglcContextGtk2GLX }\r
+\r
+procedure TglcContextGtk2GLX.UpdateVisual(const aControl: TWinControl);\r
+var\r
+  attrList: TGLIntArray;\r
+  drawable: PGdkDrawable;\r
+begin\r
+  if not Assigned(aControl) then\r
+    raise EArgumentException.Create('aControl is not assigned');\r
+\r
+  {\r
+    Temporary (realized) widget to get to display\r
+  }\r
+  FWidget:= {%H-}PGtkWidget(PtrUInt(aControl.Handle));\r
+  gtk_widget_realize(FWidget);\r
+  drawable:= GTK_WIDGET(FWidget)^.window;\r
+\r
+  FDisplay:= GDK_WINDOW_XDISPLAY(drawable);\r
+\r
+  {\r
+    Find a suitable visual from PixelFormat using GLX 1.3 FBConfigs or\r
+    old-style Visuals\r
+  }\r
+  if Assigned(glXChooseFBConfig) then begin\r
+    attrList := CreateOpenGLContextAttrList(true, fPixelFormatSettings);\r
+    FVisual  := FBglXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+    if not Assigned(FVisual) and (fPixelFormatSettings.MultiSampling > 1) then begin\r
+      fPixelFormatSettings.MultiSampling := 1;\r
+      attrList := CreateOpenGLContextAttrList(true, fPixelFormatSettings);\r
+      FVisual  := FBglXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+    end;\r
+  end;\r
+  if not Assigned(FVisual) then begin\r
+    attrList := CreateOpenGLContextAttrList(false, fPixelFormatSettings);\r
+    FVisual  := glXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+    if not Assigned(FVisual) and (fPixelFormatSettings.MultiSampling > 1) then begin\r
+      fPixelFormatSettings.MultiSampling := 1;\r
+      attrList := CreateOpenGLContextAttrList(false, fPixelFormatSettings);\r
+      FVisual  := glXChooseVisual(FDisplay, DefaultScreen(FDisplay), @attrList[0]);\r
+    end;\r
+  end;\r
+  if not Assigned(FVisual) then\r
+    raise EGLXError.Create('choose visual failed');\r
+\r
+  {\r
+    Most widgets inherit the drawable of their parent. In contrast to Windows, descending from\r
+    TWinControl does not mean it's actually always a window of its own.\r
+    Famous example: TPanel is just a frame painted on a canvas.\r
+    Also, the LCL does somethin weird to colormaps in window creation, so we have\r
+    to use a custom widget here to have full control about visual selection.\r
+  }\r
+  FRenderControl:= TRenderControl.Create(aControl, FVisual^.visual^.visualid);\r
+  try\r
+    FRenderControl.Parent := aControl;\r
+    FRenderControl.HandleNeeded;\r
+    FRenderControl.Target := aControl;\r
+  except\r
+    FreeAndNil(FRenderControl);\r
+    raise;\r
+  end;\r
+\r
+  {\r
+    Real Widget handle, unrealized!!!\r
+  }\r
+  FWidget:= FRenderControl.Widget;\r
+  gtk_widget_realize(FWidget);\r
+  drawable:= GTK_WIDGET(FWidget)^.window;\r
+  FDisplay:= GDK_WINDOW_XDISPLAY(drawable);\r
+\r
+  // FRenderControl.Align:= alClient breaks the context or something\r
+  FRenderControl.BoundsRect := aControl.ClientRect;\r
+  FRenderControl.Anchors    := [akLeft, akTop, akRight, akBottom];\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.OpenContext;\r
+var\r
+  Attribs: array of GLint;\r
+  tmpContext: GLXContext;\r
+  glxID: GLXDrawable;\r
+begin\r
+  inherited OpenContext;\r
+\r
+  if not Assigned(FVisual) then\r
+    raise EGLXError.Create('Failed to find Visual');\r
+\r
+  tmpContext := glXCreateContext(FDisplay, FVisual, nil, true);\r
+  if fUseVersion and\r
+     (fVersionSettings.Major <> GLC_CONTEXT_VERSION_UNKNOWN) and\r
+     (fVersionSettings.Minor <> GLC_CONTEXT_VERSION_UNKNOWN) then\r
+  begin\r
+    // Set attributes to describe our requested context\r
+    SetLength(Attribs, 5);\r
+    Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB;\r
+    Attribs[1] := fVersionSettings.Major;\r
+    Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB;\r
+    Attribs[3] := fVersionSettings.Minor;\r
+\r
+    // Add context flag for forward compatible context\r
+    // Forward compatible means no more support for legacy functions like\r
+    // immediate mode (glvertex, glrotate, gltranslate, etc.)\r
+    if fVersionSettings.ForwardCompatible then begin\r
+      SetLength(Attribs, Length(Attribs)+2);\r
+      Attribs[4] := WGL_CONTEXT_FLAGS_ARB;\r
+      Attribs[5] := WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;\r
+    end;\r
+\r
+    // Attribute flags must be finalized with a zero\r
+    SetLength(Attribs, 1);\r
+    Attribs[High(Attribs)] := 0;\r
+\r
+    glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+    glXMakeCurrent(FDisplay, glxID, tmpContext);\r
+    ReadImplementationProperties;\r
+    if not Assigned(glXCreateContextAttribsARB) or not GLX_ARB_create_context then begin\r
+      glXDestroyContext(FDisplay, tmpContext);\r
+      raise Exception.Create('GLX_ARB_create_context not supported');\r
+    end;\r
+    FContext := glXCreateContextAttribsARB(FDisplay, FVisual, nil, true, @Attribs[0]);\r
+\r
+    glXDestroyContext(FDisplay, tmpContext);\r
+  end else\r
+    FContext := tmpContext;\r
+\r
+  if (FContext = nil) then\r
+    raise EGLXError.Create('Failed to create Context');\r
+end;\r
+\r
+constructor TglcContextGtk2GLX.Create(const aControl: TWinControl;\r
+  const aPixelFormatSettings: TglcContextPixelFormatSettings);\r
+begin\r
+  inherited Create(aControl, aPixelFormatSettings);\r
+  UpdateVisual(aControl);\r
+end;\r
+\r
+constructor TglcContextGtk2GLX.Create(const aControl: TWinControl;\r
+  const aPixelFormatSettings: TglcContextPixelFormatSettings;\r
+  const aVersionSettings: TglcContextVersionSettings);\r
+begin\r
+  inherited Create(aControl, aPixelFormatSettings, aVersionSettings);\r
+  UpdateVisual(aControl);\r
+end;\r
+\r
+destructor TglcContextGtk2GLX.Destroy;\r
+begin\r
+  FreeAndNil(FRenderControl);\r
+  XFree(FVisual);\r
+  inherited Destroy;\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.CloseContext;\r
+begin\r
+  if not Assigned(FWidget) then exit;\r
+  if Assigned(FContext) then\r
+    glXDestroyContext(FDisplay, FContext);\r
+  FreeAndNil(FRenderControl);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.Activate;\r
+var\r
+   glxID: GLXDrawable;\r
+begin\r
+  if not Assigned(FWidget) then exit;\r
+  // make sure the widget is realized\r
+  gtk_widget_realize(FWidget);\r
+  if not GTK_WIDGET_REALIZED(FWidget) then exit;\r
+\r
+  // make current\r
+  glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+  glXMakeCurrent(FDisplay, glxID, FContext);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.Deactivate;\r
+var\r
+   glxID: GLXDrawable;\r
+begin\r
+  if not Assigned(FWidget) then exit;\r
+  glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+  glXMakeCurrent(FDisplay, glxID, nil);\r
+end;\r
+\r
+function TglcContextGtk2GLX.IsActive: boolean;\r
+var\r
+  glxID: GLXDrawable;\r
+begin\r
+  glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+  Result:= (FContext = glXGetCurrentContext()) and\r
+           Assigned(FWidget) and\r
+           (glxID = glXGetCurrentDrawable());\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.SwapBuffers;\r
+var\r
+  glxID: GLXDrawable;\r
+begin\r
+  if not Assigned(FWidget) then exit;\r
+  glxID := GDK_DRAWABLE_XID(GTK_WIDGET(FWidget)^.window);\r
+  glXSwapBuffers(FDisplay, glxID);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.SetSwapInterval(const aInterval: GLint);\r
+var\r
+  drawable: PGdkDrawable;\r
+begin\r
+  drawable:= GTK_WIDGET(FWidget)^.window;\r
+  if GLX_EXT_swap_control then\r
+    glXSwapIntervalEXT(FDisplay, GDK_WINDOW_XWINDOW(drawable), aInterval);\r
+end;\r
+\r
+procedure TglcContextGtk2GLX.Share(const aContext: TglcContext);\r
+begin\r
+  raise Exception.Create('not yet implemented');\r
+end;\r
+\r
+class function TglcContextGtk2GLX.{%H-}ChangeDisplaySettings(const aWidth, aHeight,\r
+  aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean;\r
+begin\r
+  raise Exception.Create('not yet implemented');\r
+end;\r
+\r
+class function TglcContextGtk2GLX.IsAnyContextActive: boolean;\r
+begin\r
+  Result:= (glXGetCurrentContext()<>nil) and (glXGetCurrentDrawable()<>0);\r
+end;\r
+\r
+end.\r
+\r

diff --git a/uglcContextGtkCustomVisual.pas b/uglcContextGtkCustomVisual.pas
new file mode 100644 (file)
index 0000000..ffc8677
--- /dev/null
+++ b/uglcContextGtkCustomVisual.pas
@@ -0,0 +1,225 @@
+unit uglcContextGtkCustomVisual;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit enthält Klassen zum Erzeugen von Visuals (unter Linux),
+                auf denen ein OpenGL Kontext erstellt werden kann }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, Controls, LCLType, InterfaceBase, LMessages, WSLCLClasses, WSControls,
+  X, XLib, glib2, gdk2, gdk2x, gtk2, Gtk2Def, Gtk2Int;
+
+type
+  TCustomVisualControl = class(TWinControl)
+  private
+    FIntWidget: PGtkWidget;
+    FVisualID: TVisualID;
+  protected
+    function WSCreateHandle({%H-}const WSPrivate: TWSPrivateClass; const AParams: TCreateParams): TLCLIntfHandle;
+    procedure WSBeforeDestroyHandle;
+  public
+    constructor Create(TheOwner: TComponent; const aVisualID: TVisualID); overload;
+    property Widget: PGtkWidget read FIntWidget;
+  end;
+
+
+  TWSCustomVisualControl = class(TWSWinControl)
+  published
+    class function CreateHandle(const AWinControl: TWinControl;
+                                const AParams: TCreateParams): TLCLIntfHandle; override;
+    class procedure DestroyHandle(const AWinControl: TWinControl); override;
+  end;
+
+
+implementation
+
+type
+  PGtkCustomWidget = ^TGtkCustomWidget;
+  TGtkCustomWidget = record
+    darea: TGtkDrawingArea;
+  end;
+
+  PGtkCustomWidgetClass = ^TGtkCustomWidgetClass;
+  TGtkCustomWidgetClass = record
+    parent_class: TGtkDrawingAreaClass;
+  end;
+
+var
+  custom_widget_type: TGtkType = 0;
+  custom_widget_parent_class: Pointer = nil;
+
+function GTK_TYPE_CUSTOM_WIDGET: TGtkType; forward;
+
+
+procedure g_return_if_fail(b: boolean; const Msg: string);
+begin
+  if not b then raise Exception.Create(Msg);
+end;
+
+procedure g_return_if_fail(b: boolean);
+begin
+  g_return_if_fail(b,'');
+end;
+
+function GTK_IS_CUSTOM_WIDGET(obj: Pointer): Boolean;
+begin
+  GTK_IS_CUSTOM_WIDGET:=GTK_CHECK_TYPE(obj,GTK_TYPE_CUSTOM_WIDGET);
+end;
+
+function GTK_CUSTOM_WIDGET(obj: Pointer): PGtkCustomWidget;
+begin
+  g_return_if_fail(GTK_IS_CUSTOM_WIDGET(obj),'');
+  Result:=PGtkCustomWidget(obj);
+end;
+
+procedure gtk_custom_widget_init(custom_widget: PGTypeInstance; theClass: gpointer); cdecl;
+begin
+  if theClass=nil then ;
+  //DebugLn(['gtk_custom_widget_init START']);
+  gtk_widget_set_double_buffered(PGtkWidget(custom_widget),gdkFALSE);
+  GTK_WIDGET_UNSET_FLAGS(PGtkWidget(custom_widget),GTK_NO_WINDOW);
+  //DebugLn(['gtk_custom_widget_init END']);
+end;
+
+procedure gtk_custom_widget_destroy(obj: PGtkObject); cdecl;
+begin
+  g_return_if_fail (obj <>nil,'');
+  g_return_if_fail (GTK_IS_CUSTOM_WIDGET(obj),'');
+
+  if Assigned(GTK_OBJECT_CLASS(custom_widget_parent_class)^.destroy) then
+    GTK_OBJECT_CLASS(custom_widget_parent_class)^.destroy(obj);
+end;
+
+procedure gtk_custom_widget_class_init(klass: Pointer); cdecl;
+var
+  object_class: PGtkObjectClass;
+begin
+  custom_widget_parent_class := gtk_type_class(gtk_drawing_area_get_type());
+  g_return_if_fail(custom_widget_parent_class<>nil,'gtk_custom_widget_class_init parent_class=nil');
+  object_class := PGtkObjectClass(klass);
+  g_return_if_fail(object_class<>nil,'gtk_custom_widget_class_init object_class=nil');
+
+  object_class^.destroy := @gtk_custom_widget_destroy;
+end;
+
+function custom_widget_size_allocateCB(Widget: PGtkWidget; Size: pGtkAllocation;
+  Data: gPointer): GBoolean; cdecl;
+const
+  CallBackDefaultReturn = {$IFDEF GTK2}false{$ELSE}true{$ENDIF};
+var
+  SizeMsg: TLMSize;
+  GtkWidth, GtkHeight: integer;
+  LCLControl: TWinControl;
+begin
+  Result := CallBackDefaultReturn;
+  if not GTK_WIDGET_REALIZED(Widget) then begin
+    // the widget is not yet realized, so this GTK resize was not a user change.
+    // => ignore
+    exit;
+  end;
+  if Size=nil then ;
+  LCLControl:=TWinControl(Data);
+  if LCLControl=nil then exit;
+  //DebugLn(['gtkglarea_size_allocateCB ',DbgSName(LCLControl)]);
+
+  gtk_widget_get_size_request(Widget, @GtkWidth, @GtkHeight);
+
+  SizeMsg.Msg:=0;
+  FillChar(SizeMsg,SizeOf(SizeMsg),0);
+  with SizeMsg do
+  begin
+    Result := 0;
+    Msg := LM_SIZE;
+    SizeType := Size_SourceIsInterface;
+    Width := SmallInt(GtkWidth);
+    Height := SmallInt(GtkHeight);
+  end;
+  //DebugLn(['gtkglarea_size_allocateCB ',GtkWidth,',',GtkHeight]);
+  LCLControl.WindowProc(TLMessage(SizeMsg));
+end;
+
+function GTK_TYPE_CUSTOM_WIDGET: TGtkType;
+const
+  custom_widget_type_name = 'GtkGLArea';
+  custom_widget_info: TGtkTypeInfo = (
+    type_name: custom_widget_type_name;
+    object_size: SizeOf(TGtkCustomWidget);
+    class_size:  SizeOf(TGtkCustomWidgetClass);
+    class_init_func:  @gtk_custom_widget_class_init;
+    object_init_func: @gtk_custom_widget_init;
+    reserved_1: nil;
+    reserved_2: nil;
+    base_class_init_func: nil;
+  );
+begin
+  if (custom_widget_type=0) then begin
+    custom_widget_type:=gtk_type_unique(gtk_drawing_area_get_type(),@custom_widget_info);
+  end;
+  Result:=custom_widget_type;
+end;
+
+{ TCustomVisualControl }
+
+constructor TCustomVisualControl.Create(TheOwner: TComponent; const aVisualID: TVisualID);
+begin
+  inherited Create(TheOwner);
+  FIntWidget:= nil;
+  fVisualID:= aVisualID;
+  SetBounds(0, 0, 200, 200);
+end;
+
+function TCustomVisualControl.WSCreateHandle(const WSPrivate: TWSPrivateClass; const AParams: TCreateParams): TLCLIntfHandle;
+var
+  cmap: PGdkColormap;
+  gdkvis: PGdkVisual;
+begin
+  // is the requested VisualID different from what the widget would get?
+  cmap  := gdk_colormap_get_system;
+  gdkvis:= gdk_colormap_get_visual(cmap);
+  if XVisualIDFromVisual(gdk_x11_visual_get_xvisual(gdkvis)) <> FVisualID then begin
+    gdkvis:= gdkx_visual_get(FVisualID);
+    cmap  := gdk_colormap_new(gdkvis, false);
+  end;
+
+  FIntWidget:= gtk_type_new(GTK_TYPE_CUSTOM_WIDGET);
+  gtk_widget_set_colormap(FIntWidget, cmap);
+
+  Result:= TLCLIntfHandle({%H-}PtrUInt(FIntWidget));
+  PGtkobject(FIntWidget)^.flags:= PGtkobject(FIntWidget)^.flags or GTK_CAN_FOCUS;
+  TGTK2WidgetSet(WidgetSet).FinishCreateHandle(Self,FIntWidget,AParams);
+  g_signal_connect_after(FIntWidget, 'size-allocate', TGTKSignalFunc(@custom_widget_size_allocateCB), Self);
+end;
+
+procedure TCustomVisualControl.WSBeforeDestroyHandle;
+begin
+  if not HandleAllocated then exit;
+end;
+
+
+{ TWSCustomVisualControl }
+
+class function TWSCustomVisualControl.CreateHandle(const AWinControl: TWinControl; const AParams: TCreateParams): TLCLIntfHandle;
+begin
+  if csDesigning in AWinControl.ComponentState then begin
+    // do not use "inherited CreateHandle", because the LCL changes the hierarchy at run time
+    Result:= TWSWinControlClass(ClassParent).CreateHandle(AWinControl,AParams);
+  end else
+    Result:= (AWinControl as TCustomVisualControl).WSCreateHandle(WSPrivate, AParams);
+end;
+
+class procedure TWSCustomVisualControl.DestroyHandle(const AWinControl: TWinControl);
+begin
+  (AWinControl as TCustomVisualControl).WSBeforeDestroyHandle;
+  // do not use "inherited DestroyHandle", because the LCL changes the hierarchy at run time
+  TWSWinControlClass(ClassParent).DestroyHandle(AWinControl);
+end;
+
+initialization
+  RegisterWSComponent(TCustomVisualControl,TWSCustomVisualControl);
+
+end.
+

diff --git a/uglcContextWGL.pas b/uglcContextWGL.pas
new file mode 100644 (file)
index 0000000..76e0614
--- /dev/null
+++ b/uglcContextWGL.pas
@@ -0,0 +1,432 @@
+unit uglcContextWGL;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit enthält eine Klassen-Kapselung für OpenGL Kontexte für Windows
+  Hint:         diese Unit sollte niemals direkt genutzt werden (siehe uglcContext) }
+
+interface
+
+uses
+  Classes, SysUtils, Forms, Windows, uglcContext, dglOpenGL, Controls;
+
+type
+  EWGLError = class(EGLError);
+
+  { TglcContextWGL }
+
+  TglcContextWGL = class(TglcContext)
+  private
+    FDC: HDC;
+    FRC: HGLRC;
+    fHandle: THandle;
+    fPixelFormat: Integer;
+    {%H-}constructor Create(const aControl: TWinControl);
+  protected
+    procedure UpdatePixelFormat;
+    procedure OpenContext; override;
+    function FindPixelFormat: Integer;
+    function FindPixelFormatNoAA: Integer;
+    procedure OpenFromPF(PixelFormat: Integer);
+  public
+    constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings); override; overload;
+    constructor Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings); override; overload;
+
+    procedure CloseContext; override;
+    procedure Activate; override;
+    procedure Deactivate; override;
+    function IsActive: boolean; override;
+    procedure SwapBuffers; override;
+    procedure SetSwapInterval(const aInterval: GLint); override;
+    function GetSwapInterval: GLint; override;
+    procedure Share(const aContext: TglcContext); override;
+
+    class function ChangeDisplaySettings(const aWidth, aHeight, aBitPerPixel, aFreq: Integer;
+      const aFlags: TglcDisplayFlags): Boolean; override;
+    class function IsAnyContextActive: boolean; override;
+  end;
+
+implementation
+
+{ TglcContextWGL }
+
+constructor TglcContextWGL.Create(const aControl: TWinControl);
+begin
+  inherited Create(aControl, MakePF());
+  fHandle := aControl.Handle;
+end;
+
+procedure TglcContextWGL.UpdatePixelFormat;
+begin
+  fPixelFormat := FindPixelFormat;
+  if (fPixelFormat = 0) then begin
+    // try without MS
+    fPixelFormatSettings.MultiSampling := 1;
+    fPixelFormat := FindPixelFormat;
+  end;
+end;
+
+procedure TglcContextWGL.OpenContext;
+begin
+  inherited OpenContext;
+  OpenFromPF(fPixelFormat);
+end;
+
+function TglcContextWGL.FindPixelFormat: Integer;
+var
+  OldRC: HGLRC; OldDC: HDC;
+  tmpWnd: TForm;
+  tmpContext: TglcContextWGL;
+  pf, i, max: integer;
+  Count: GLuint;
+  PFList, SampleList: array[0..31] of GLint;
+
+  procedure ChoosePF(pPFList, pSampleList: PGLint; MaxCount: integer);
+  var
+    //ARB_Erweiterung vorhanden
+    //|          EXT_Erweiterung vorhanden
+    MultiARBSup, MultiEXTSup: Boolean;
+    //Liste der Integer Attribute
+    IAttrib: array[0..22] of GLint;
+    //Liste der Float Attribute (nur 0, da kein Wert)
+    FAttrib: GLFloat;
+    QueryAtrib, i: Integer;
+    PPosiblePF, PSample: PglInt;
+  begin
+    //Pixelformate mit AA auslesen
+    MultiARBSup := false;
+    MultiEXTSup := false;
+    if WGL_ARB_extensions_string and
+       WGL_ARB_pixel_format and
+       (WGL_ARB_MULTISAMPLE or GL_ARB_MULTISAMPLE) then
+      multiARBSup := true;
+    if WGL_EXT_extensions_string and
+       WGL_EXT_pixel_format and
+       (WGL_EXT_MULTISAMPLE or GL_EXT_MULTISAMPLE) then
+      multiEXTSup := true;
+
+    if multiARBSup then
+      Read_WGL_ARB_pixel_format
+    else if multiEXTSup then
+      Read_WGL_EXT_pixel_format;
+
+    if not (MultiARBSup or MultiEXTSup) then
+      exit;
+
+    IAttrib[00] := WGL_DRAW_TO_WINDOW_ARB;
+    IAttrib[01] := 1;
+
+    IAttrib[02] := WGL_SUPPORT_OPENGL_ARB;
+    IAttrib[03] := 1;
+
+    IAttrib[04] := WGL_DOUBLE_BUFFER_ARB;
+    if (fPixelFormatSettings.DoubleBuffered) then
+      IAttrib[05] := 1
+    else
+      IAttrib[05] := 0;
+
+    IAttrib[06] := WGL_PIXEL_TYPE_ARB;
+    IAttrib[07] := WGL_TYPE_RGBA_ARB;
+
+    IAttrib[08] := WGL_COLOR_BITS_ARB;
+    IAttrib[09] := fPixelFormatSettings.ColorBits;
+
+    IAttrib[10] := WGL_ALPHA_BITS_ARB;
+    IAttrib[11] := 0; //TODO: fPixelFormatSettings.AlphaBits;
+
+    IAttrib[12] := WGL_DEPTH_BITS_ARB;
+    IAttrib[13] := fPixelFormatSettings.DepthBits;
+
+    IAttrib[14] := WGL_STENCIL_BITS_ARB;
+    IAttrib[15] := fPixelFormatSettings.StencilBits;
+
+    IAttrib[16] := WGL_ACCUM_BITS_ARB;
+    IAttrib[17] := fPixelFormatSettings.AccumBits;
+
+    IAttrib[18] := WGL_AUX_BUFFERS_ARB;
+    IAttrib[19] := fPixelFormatSettings.AuxBuffers;
+
+    IAttrib[20] := WGL_SAMPLE_BUFFERS_ARB;
+    IAttrib[21] := 1;
+
+    IAttrib[22] := 0;
+    FAttrib     := 0;
+
+    if multiARBSup then
+      wglChoosePixelFormatARB(tmpContext.FDC, @IAttrib[0], @FAttrib, MaxCount, pPFList, @Count)
+    else if multiEXTSup then
+      wglChoosePixelFormatEXT(tmpContext.FDC, @IAttrib[0], @FAttrib, MaxCount, pPFList, @Count);
+
+    if Count > length(PFList) then
+      Count := length(PFList);
+
+    QueryAtrib := WGL_SAMPLES_ARB;
+    PSample    := pSampleList;
+    PPosiblePF := @PFList[0];
+    for i := 0 to Count-1 do begin
+      if multiARBSup then
+        wglGetPixelFormatAttribivARB(tmpContext.FDC, PPosiblePF^, 0, 1, @QueryAtrib, PSample)
+      else if multiEXTSup then
+        wglGetPixelFormatAttribivEXT(tmpContext.FDC, PPosiblePF^, 0, 1, @QueryAtrib, PSample);
+      inc(PSample);
+      inc(PPosiblePF);
+    end;
+  end;
+begin
+  if (fPixelFormatSettings.MultiSampling = 1) then begin
+    Result := FindPixelFormatNoAA;
+    exit;
+  end;
+  Result := 0;
+  OldDC  := wglGetCurrentDC();
+  OldRC  := wglGetCurrentContext();
+  try
+    tmpWnd     := TForm.Create(nil);
+    tmpContext := TglcContextWGL.Create(tmpWnd);
+    try
+      pf := tmpContext.FindPixelFormatNoAA;
+      tmpContext.OpenFromPF(pf);
+      tmpContext.Activate;
+
+      FillChar({%H-}PFList[0], Length(PFList), 0);
+      FillChar({%H-}SampleList[0], Length(SampleList), 0);
+      ChoosePF(@PFList[0], @SampleList[0], length(SampleList));
+      max := 0;
+      for i := 0 to Count-1 do begin
+        if (max < SampleList[i]) and (SampleList[i] <= fPixelFormatSettings.MultiSampling) and (PFList[i] <> 0) then begin
+          max := SampleList[i];
+          result := PFList[i];
+          if (max = fPixelFormatSettings.MultiSampling) then
+            break;
+        end;
+      end;
+      tmpContext.Deactivate;
+    finally
+      FreeAndNil(tmpContext);
+      FreeAndNil(tmpWnd);
+    end;
+  finally
+    if (OldDC <> 0) and (OldRC <> 0) then
+     ActivateRenderingContext(OldDC, OldRC);
+  end;
+end;
+
+function TglcContextWGL.FindPixelFormatNoAA: Integer;
+const
+  MemoryDCs = [OBJ_MEMDC, OBJ_METADC, OBJ_ENHMETADC];
+var
+  //DeviceContext
+  DC: HDC;
+  //Objekttyp des DCs
+  AType: DWord;
+  //Beschreibung zum passenden Pixelformat
+  PFDescriptor: TPixelFormatDescriptor;
+begin
+  result := 0;
+  DC := GetDC(fHandle);
+  if DC = 0 then begin
+    exit;
+  end;
+  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 begin
+      exit;
+    end;
+    if fPixelFormatSettings.DoubleBuffered then
+      dwFlags := dwFlags or PFD_DOUBLEBUFFER;
+    if fPixelFormatSettings.Stereo then
+      dwFlags := dwFlags or PFD_STEREO;
+    if AType in MemoryDCs then
+      dwFlags := dwFlags or PFD_DRAW_TO_BITMAP
+    else
+      dwFlags := dwFlags or PFD_DRAW_TO_WINDOW;
+
+    iPixelType   := PFD_TYPE_RGBA;
+    cColorBits   := fPixelFormatSettings.ColorBits;
+//TODO:    cAlphaBits   := fPixelFormatSettings.AlphaBits;
+    cDepthBits   := fPixelFormatSettings.DepthBits;
+    cStencilBits := fPixelFormatSettings.StencilBits;
+    cAccumBits   := fPixelFormatSettings.AccumBits;
+    cAuxBuffers  := fPixelFormatSettings.AuxBuffers;
+
+    if fPixelFormatSettings.Layer = 0 then
+      iLayerType := PFD_MAIN_PLANE
+    else if fPixelFormatSettings.Layer > 0 then
+      iLayerType := PFD_OVERLAY_PLANE
+    else
+      iLayerType := Byte(PFD_UNDERLAY_PLANE);
+  end;
+  result := ChoosePixelFormat(DC, @PFDescriptor);
+end;
+
+procedure TglcContextWGL.OpenFromPF(PixelFormat: Integer);
+var
+  tmpRC: HGLRC;
+  Attribs: array of GLint;
+  CreateContextAttribs: TwglCreateContextAttribsARB;
+begin
+  if PixelFormat = 0 then begin
+    raise EWGLError.Create('Invalid PixelFormat');
+  end;
+
+  FDC := GetDC(fHandle);
+  if FDC = 0 then begin
+    raise EWGLError.CreateFmt('Cannot create DC on %x',[fHandle]);
+  end;
+
+  if not SetPixelFormat(FDC, PixelFormat, nil) then begin
+    ReleaseDC(fHandle, FDC);
+    raise EWGLError.CreateFmt('Cannot set PF %d on Control %x DC %d',[PixelFormat, fHandle, FDC]);
+  end;
+
+  tmpRC := wglCreateContext(FDC);
+  if tmpRC = 0 then begin
+    ReleaseDC(fHandle, FDC);
+    raise EWGLError.CreateFmt('Cannot create context on Control %x DC %d',[PixelFormat, fHandle, FDC]);
+  end;
+
+  if fUseVersion and
+     (fVersionSettings.Major <> GLC_CONTEXT_VERSION_UNKNOWN) and
+     (fVersionSettings.Minor <> GLC_CONTEXT_VERSION_UNKNOWN) then
+  begin
+    { Code from dglOpenGL.pas (modified) }
+    wglMakeCurrent(FDC, tmpRC);
+
+    // Set attributes to describe our requested context
+    SetLength(Attribs, 5);
+    Attribs[0] := WGL_CONTEXT_MAJOR_VERSION_ARB;
+    Attribs[1] := fVersionSettings.Major;
+    Attribs[2] := WGL_CONTEXT_MINOR_VERSION_ARB;
+    Attribs[3] := fVersionSettings.Minor;
+
+    // Add context flag for forward compatible context
+    // Forward compatible means no more support for legacy functions like
+    // immediate mode (glvertex, glrotate, gltranslate, etc.)
+    if fVersionSettings.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
+    CreateContextAttribs := TwglCreateContextAttribsARB(wglGetProcAddress('wglCreateContextAttribsARB'));
+    if not Assigned(CreateContextAttribs) then begin
+      wglMakeCurrent(0, 0);
+      wglDeleteContext(tmpRC);
+      ReleaseDC(fHandle, FDC);
+      raise Exception.Create('Could not get function pointer adress for wglCreateContextAttribsARB - OpenGL 3.x and above not supported!');
+    end;
+
+    // Create context
+    FRC := CreateContextAttribs(FDC, 0, @Attribs[0]);
+    if (FRC = 0) then begin
+      wglMakeCurrent(0, 0);
+      wglDeleteContext(tmpRC);
+      ReleaseDC(fHandle, FDC);
+      raise Exception.Create('Could not create the desired OpenGL rendering context!');
+    end;
+
+    wglMakeCurrent(0, 0);
+    wglDeleteContext(tmpRC);
+  end else
+    FRC := tmpRC;
+end;
+
+constructor TglcContextWGL.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings);
+begin
+  inherited Create(aControl, aPixelFormatSettings);
+  fHandle := aControl.Handle;
+  UpdatePixelFormat;
+end;
+
+constructor TglcContextWGL.Create(const aControl: TWinControl; const aPixelFormatSettings: TglcContextPixelFormatSettings; const aVersionSettings: TglcContextVersionSettings);
+begin
+  inherited Create(aControl, aPixelFormatSettings, aVersionSettings);
+  fHandle := aControl.Handle;
+  UpdatePixelFormat;
+end;
+
+procedure TglcContextWGL.CloseContext;
+begin
+  if (FRC <> 0) then begin
+    Deactivate;
+    DestroyRenderingContext(FRC);
+    ReleaseDC(fHandle, FDC);
+    FRC := 0;
+    FDC := 0;
+  end;
+end;
+
+procedure TglcContextWGL.Activate;
+begin
+  ActivateRenderingContext(FDC, FRC);
+end;
+
+procedure TglcContextWGL.Deactivate;
+begin
+  if wglGetCurrentContext()=FRC then
+    DeactivateRenderingContext;
+end;
+
+function TglcContextWGL.IsActive: boolean;
+begin
+  Result:= (FRC <> 0) and
+           (FRC = wglGetCurrentContext()) and
+           (FDC = wglGetCurrentDC());
+end;
+
+procedure TglcContextWGL.SwapBuffers;
+begin
+  Windows.SwapBuffers(FDC);
+end;
+
+procedure TglcContextWGL.SetSwapInterval(const aInterval: GLint);
+begin
+  wglSwapIntervalEXT(aInterval);
+end;
+
+function TglcContextWGL.GetSwapInterval: GLint;
+begin
+  result := wglGetSwapIntervalEXT();
+end;
+
+procedure TglcContextWGL.Share(const aContext: TglcContext);
+begin
+  wglShareLists(FRC, (aContext as TglcContextWGL).FRC);
+end;
+
+class function TglcContextWGL.ChangeDisplaySettings(const aWidth, aHeight,
+  aBitPerPixel, aFreq: Integer; const aFlags: TglcDisplayFlags): Boolean;
+var
+  dm: TDeviceMode;
+  flags: Cardinal;
+begin
+  FillChar(dm{%H-}, SizeOf(dm), 0);
+  with dm do begin
+    dmSize             := SizeOf(dm);
+    dmPelsWidth        := aWidth;
+    dmPelsHeight       := aHeight;
+    dmDisplayFrequency := aFreq;
+    dmBitsPerPel       := aBitPerPixel;
+    dmFields           := DM_PELSWIDTH or DM_PELSHEIGHT or DM_BITSPERPEL or DM_DISPLAYFREQUENCY;
+  end;
+  flags := 0; //CDS_TEST;
+  if (dfFullscreen in aFlags) then
+    flags := flags or CDS_FULLSCREEN;
+  result := (Windows.ChangeDisplaySettings(dm, flags) = DISP_CHANGE_SUCCESSFUL);
+end;
+
+class function TglcContextWGL.IsAnyContextActive: boolean;
+begin
+  Result:= (wglGetCurrentContext()<>0) and (wglGetCurrentDC()<>0);
+end;
+
+end.
+

diff --git a/uglcFrameBufferObject.pas b/uglcFrameBufferObject.pas
new file mode 100644 (file)
index 0000000..b08fba3
--- /dev/null
+++ b/uglcFrameBufferObject.pas
@@ -0,0 +1,652 @@
+unit uglcFrameBufferObject;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit enthält eine Klassen-Kapselung der OpenGL FrameBufferObjekte
+  Beispiel:
+    var
+      fbo: TglcFrameBufferObject;
+      tex: TglcTextureBuffer;
+      buf: TglcRenderBuffer;
+
+    fbo := TglcFrameBufferObject.Create;
+    try
+      ffbo.SetSize(800, 600);
+
+      // creating texture buffer as color buffer
+      tex := TglcTextureBuffer.Create(TglcFormat.fmRGBA, TglcInternalFormat.ifRGBA16F);
+      fbo.AddBuffer(tex, TglcAttachment.atColor0, true);
+
+      // creating render buffer as depth buffer
+      buf := TglcRenderBuffer.Create(TglcInternalFormat.ifDepthComponent);
+      fbo.AddBuffer(buf, TglcAttachment.atDepth, true);
+
+      // render to frame buffer object
+      fbo.Bind;
+      // do normal rendering
+      fbo.Unbind;
+
+      // use texture buffer
+      tex.Bind;
+      // do normal rendering
+      tex.Unbind;
+    finally
+      FreeAndNil(fbo);
+    end; }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, fgl, dglOpenGl, uglcTypes;
+
+type
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglcBufferType = (btRenderBuffer, btTextureBuffer);
+  TglcBuffer = class(TObject)
+  private
+    fBufferType: TglcBufferType;
+    fWidth: Integer;
+    fHeight: Integer;
+
+    procedure SetWidth(const aValue: Integer);
+    procedure SetHeight(const aValue: Integer);
+  public
+    property Width : Integer read fWidth  write SetWidth;
+    property Height: Integer read fHeight write SetHeight;
+    property BufferType: TglcBufferType read fBufferType;
+
+    procedure SetSize(const aWidth, aHeight: Integer); virtual;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  EglcRenderBuffer = class(Exception);
+  TglcRenderBuffer = class(TglcBuffer)
+  private
+    fID: gluInt;
+    fFormat: TglcInternalFormat;
+
+    procedure UpdateRenderBufferStorage;
+    procedure SetFormat(const aValue: TglcInternalFormat);
+  public
+    property ID:     gluInt             read fID;
+    property Format: TglcInternalFormat read fFormat write SetFormat;
+
+    procedure SetSize(const aWidth, aHeight: Integer); override;
+    procedure Bind;
+    procedure Unbind;
+
+    constructor Create(const aFormat: TglcInternalFormat);
+    destructor Destroy; override;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  EglcTextureBuffer = class(exception);
+  TglcTextureBuffer = class(TglcBuffer)
+  private
+    fID: GLuint;
+    fFormat: TglcFormat;
+    fInternalFormat: TglcInternalFormat;
+    fBorder: Boolean;
+
+    procedure UpdateTexImage;
+    procedure SetFormat(const aValue: TglcFormat);
+    procedure SetInternalFormat(const aValue: TglcInternalFormat);
+    procedure SetBorder(const aValue: Boolean);
+  public
+    property ID            : GLuint             read fID;
+    property Border        : Boolean            read fBorder         write SetBorder;
+    property Format        : TglcFormat         read fFormat         write SetFormat;
+    property InternalFormat: TglcInternalFormat read fInternalFormat write SetInternalFormat;
+
+    procedure SetSize(const aWidth, aHeight: Integer); override;
+    procedure Bind(const aEnableTextureUnit: Boolean = true);
+    procedure Unbind(const aDisableTextureUnit: Boolean = true);
+
+    constructor Create(const aFormat: TglcFormat; const aInternalFormat: TglcInternalFormat);
+    destructor Destroy; override;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  EglcFrameBufferObject = class(Exception);
+  TglcFrameBufferObject = class(TObject)
+  private type
+    TglcAttachmentContainer = class(TObject)
+      Buffer: TglcBuffer;
+      Attachment: TglcAttachment;
+      OwnsObject: Boolean;
+      constructor Create(const aBuffer: TglcBuffer; const aAttachment: TglcAttachment; const aOwnsObject: Boolean = true);
+      destructor Destroy; override;
+    end;
+    TglcAttachmentContainerList = specialize TFPGObjectList<TglcAttachmentContainer>;
+  private
+    fID: GLuint;
+    fOwnsObjects: Boolean;
+    fWidth: Integer;
+    fHeight: Integer;
+    fBuffers: TglcAttachmentContainerList;
+
+    function GetBuffer(const aIndex: Integer): TglcBuffer;
+    procedure SetBuffer(const aIndex: Integer; const aValue: TglcBuffer);
+
+    function GetAttachment(const aIndex: Integer): TglcAttachment;
+    procedure SetAttachment(const aIndex: Integer; const aValue: TglcAttachment);
+
+    function GetBufferCount: Integer;
+
+    procedure Attach(const aIndex: Integer);
+    procedure Detach(const aIndex: Integer);
+
+    procedure SetWidth(const aValue: Integer);
+    procedure SetHeight(const aValue: Integer);
+    procedure CheckFrameBufferStatus;
+    procedure UpdateAndCheckFBO;
+  public
+    property ID         : GLuint  read fID;
+    property Count      : Integer read GetBufferCount;
+    property OwnsObjects: Boolean read fOwnsObjects;
+    property Width      : Integer read fWidth         write SetWidth;
+    property Height     : Integer read fHeight        write SetHeight;
+    property Attachments[const aIndex: Integer]: TglcAttachment read GetAttachment write SetAttachment;
+    property Buffers    [const aIndex: Integer]: TglcBuffer     read GetBuffer     write SetBuffer;
+
+    procedure AddBuffer(const aBuffer: TglcBuffer; const aAttachment: TglcAttachment; const aOwnsBuffer: Boolean = true);
+    procedure DelBuffer(const aIndex: Integer);
+    function RemBuffer(const aBuffer: TglcBuffer): Integer;
+    function IndexOfBuffer(const aBuffer: TglcBuffer): Integer;
+
+    procedure SetSize(const aWidth, aHeight: Integer);
+    function CheckAttachment(const aAttachment: TglcAttachment): Boolean;
+
+    procedure Bind(const aSetViewport: Boolean = true);
+    procedure Unbind(const aResetViewport: Boolean = true);
+
+    constructor Create(const aOwnBuffers: Boolean = true);
+    destructor Destroy; override;
+  end;
+
+implementation
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcBuffer////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcBuffer.SetWidth(const aValue: Integer);
+begin
+  SetSize(aValue, fHeight);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcBuffer.SetHeight(const aValue: Integer);
+begin
+  SetSize(fWidth, aValue);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcBuffer.SetSize(const aWidth, aHeight: Integer);
+begin
+  fWidth  := aWidth;
+  fHeight := aHeight;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcRenderBuffer//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.UpdateRenderBufferStorage;
+begin
+  glGetError; //clear Erroros
+  Bind;
+  glRenderbufferStorage(GL_RENDERBUFFER, GLenum(fFormat), fWidth, fHeight);
+  Unbind;
+  glcCheckAndRaiseError;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.SetFormat(const aValue: TglcInternalFormat);
+begin
+  fFormat := aValue;
+  UpdateRenderBufferStorage;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.SetSize(const aWidth, aHeight: Integer);
+begin
+  if (aWidth <= 0) or (aHeight <= 0) then
+    raise EglcRenderBuffer.Create('invalid width or height');
+  if (aWidth <> fWidth) or (aHeight <> fHeight) then begin
+    inherited SetSize(aWidth, aHeight);
+    UpdateRenderBufferStorage;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.Bind;
+begin
+  glBindRenderbuffer(GL_RENDERBUFFER, fID);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcRenderBuffer.Unbind;
+begin
+  glBindRenderbuffer(GL_RENDERBUFFER, 0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcRenderBuffer.Create(const aFormat: TglcInternalFormat);
+begin
+  inherited Create;
+  fBufferType := btRenderBuffer;
+  glGenRenderbuffers(1, @fID);
+  fFormat := aFormat;
+  SetSize(64, 64);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglcRenderBuffer.Destroy;
+begin
+  glDeleteRenderbuffers(1, @fID);
+  inherited Destroy;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcTextureBuffer/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.UpdateTexImage;
+begin
+  glGetError;   //clear errors
+  Bind(false);
+  glTexImage2D(GL_TEXTURE_2D, 0, GLenum(fInternalFormat), fWidth, fHeight, GLint(Byte(fBorder) and Byte(1)), GLenum(fFormat), GL_UNSIGNED_BYTE, nil);
+  Unbind(false);
+  glcCheckAndRaiseError;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetFormat(const aValue: TglcFormat);
+begin
+  if (fFormat <> aValue) then begin
+    fFormat := aValue;
+    UpdateTexImage;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetInternalFormat(const aValue: TglcInternalFormat);
+begin
+  if (fInternalFormat <> aValue) then begin
+    fInternalFormat := aValue;
+    UpdateTexImage;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetBorder(const aValue: Boolean);
+begin
+  if (fBorder <> aValue) then begin
+    fBorder := aValue;
+    UpdateTexImage;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.SetSize(const aWidth, aHeight: Integer);
+begin
+  if (aWidth <= 0) or (aHeight <= 0) then
+    raise EglcTextureBuffer.Create('invalid width or height');
+  if (aWidth <> fWidth) or (aHeight <> fHeight) then begin
+    inherited SetSize(aWidth, aHeight);
+    UpdateTexImage;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.Bind(const aEnableTextureUnit: Boolean = true);
+begin
+  if aEnableTextureUnit then
+    glEnable(GL_TEXTURE_2D);
+  glBindTexture(GL_TEXTURE_2D, fID);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcTextureBuffer.Unbind(const aDisableTextureUnit: Boolean = true);
+begin
+  if aDisableTextureUnit then
+    glDisable(GL_TEXTURE_2D);
+  glBindTexture(GL_TEXTURE_2D, 0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcTextureBuffer.Create(const aFormat: TglcFormat; const aInternalFormat: TglcInternalFormat);
+begin
+  inherited Create;
+  fBufferType := btTextureBuffer;
+
+  glGenTextures(1, @fID);
+  Bind(false);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  Unbind(false);
+
+  fFormat := aFormat;
+  fInternalFormat := aInternalFormat;
+  SetSize(64, 64);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglcTextureBuffer.Destroy;
+begin
+  glDeleteTextures(1, @fID);
+  inherited Destroy;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcAttachment////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcFrameBufferObject.TglcAttachmentContainer.Create(const aBuffer: TglcBuffer;
+  const aAttachment: TglcAttachment; const aOwnsObject: Boolean);
+begin
+  inherited Create;
+  Buffer     := aBuffer;
+  Attachment := aAttachment;
+  OwnsObject := aOwnsObject;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+destructor TglcFrameBufferObject.TglcAttachmentContainer.Destroy;
+begin
+  if OwnsObject then
+    Buffer.Free;
+  inherited Destroy;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcFrameBufferObject/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.GetBuffer(const aIndex: Integer): TglcBuffer;
+begin
+  if (aIndex >= 0) and (aIndex < fBuffers.Count) then
+    result := fBuffers[aIndex].Buffer
+  else
+    raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.SetBuffer(const aIndex: Integer; const aValue: TglcBuffer);
+begin
+  if (aIndex < 0) or (aIndex >= fBuffers.Count) then
+    raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+
+  if not Assigned(aValue) then
+    raise EglcFrameBufferObject.Create('invalid buffer');
+
+  Detach(aIndex);
+  fBuffers[aIndex].Buffer := aValue;
+  Attach(aIndex);
+  UpdateAndCheckFBO;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.GetAttachment(const aIndex: Integer): TglcAttachment;
+begin
+  if (aIndex >= 0) and (aIndex < fBuffers.Count) then
+    result := fBuffers[aIndex].Attachment
+  else
+    raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.SetAttachment(const aIndex: Integer; const aValue: TglcAttachment);
+begin
+  if (aIndex < 0) or (aIndex >= fBuffers.Count) then
+    raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+
+  if not CheckAttachment(aValue) then
+    raise EglcFrameBufferObject.Create('Attachment already assigned');
+
+  Detach(aIndex);
+  fBuffers[aIndex].Attachment := aValue;
+  Attach(aIndex);
+  UpdateAndCheckFBO;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.Attach(const aIndex: Integer);
+var
+  a: TglcAttachment;
+  b: TglcBuffer;
+begin
+  a := Attachments[aIndex];
+  b := Buffers[aIndex];
+  Bind(false);
+  if (b.BufferType = btRenderBuffer) then
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GLenum(a), GL_RENDERBUFFER, (b as TglcRenderBuffer).ID)
+  else
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GLenum(a), GL_TEXTURE_2D, (b as TglcTextureBuffer).ID, 0);
+  Unbind(false);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.Detach(const aIndex: Integer);
+var
+  a: TglcAttachment;
+  b: TglcBuffer;
+begin
+  a := Attachments[aIndex];
+  b := Buffers[aIndex];
+  Bind(false);
+  if (b.BufferType = btRenderBuffer) then
+    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GLenum(a), GL_RENDERBUFFER, 0)
+  else
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GLenum(a), GL_TEXTURE_2D, 0, 0);
+  Unbind(false);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//legt die neue Breite fest
+//@Value: Breite;
+procedure TglcFrameBufferObject.SetWidth(const aValue: Integer);
+begin
+  SetSize(aValue, fHeight);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//legt die neue Höhe fest
+//@Value: neue Höhe;
+procedure TglcFrameBufferObject.SetHeight(const aValue: Integer);
+begin
+  SetSize(fWidth, aValue);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.CheckFrameBufferStatus;
+begin
+  case glCheckFramebufferStatus(GL_FRAMEBUFFER) of
+    GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+      raise EglcFrameBufferObject.Create('Incomplete attachment');
+    GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+      raise EglcFrameBufferObject.Create('Missing attachment');
+    GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
+      raise EglcFrameBufferObject.Create('Incomplete dimensions');
+    GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
+      raise EglcFrameBufferObject.Create('Incomplete formats');
+    GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
+      raise EglcFrameBufferObject.Create('Incomplete draw buffer');
+    GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
+      raise EglcFrameBufferObject.Create('Incomplete read buffer');
+    GL_FRAMEBUFFER_UNSUPPORTED:
+      raise EglcFrameBufferObject.Create('Framebufferobjects unsupported');
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//prüft das FrameBufferObjekt auf Fehler
+procedure TglcFrameBufferObject.UpdateAndCheckFBO;
+
+  function IsColorAttachment(const a: TglcAttachment): Boolean;
+  begin
+    result := (GLenum(a) >= GL_COLOR_ATTACHMENT0) and (GLenum(a) <= GL_COLOR_ATTACHMENT15);
+  end;
+
+var
+  buff: array of GLenum;
+  b: GLboolean;
+  i: Integer;
+begin
+  if (fBuffers.Count = 0) then
+    exit;
+  Bind(false);
+
+  //find ColorBuffers
+  SetLength(buff, 0);
+  for i := 0 to fBuffers.Count-1 do
+    if IsColorAttachment(fBuffers[i].Attachment) then begin
+      SetLength(buff, Length(buff) + 1);
+      buff[High(buff)] := GLenum(fBuffers[i].Attachment);
+    end;
+
+  //set Read and Draw Buffer
+  if (Length(buff) = 0) then begin
+    glReadBuffer(GL_NONE);
+    glDrawBuffer(GL_NONE);
+  end else begin
+    glDrawBuffers(Length(buff), @buff[0]);
+    glGetBooleanv(GL_DOUBLEBUFFER, @b);
+    if b then
+      glReadBuffer(GL_BACK)
+    else
+      glReadBuffer(GL_FRONT);
+  end;
+  Unbind(false);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.GetBufferCount: Integer;
+begin
+  result := fBuffers.Count;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.AddBuffer(const aBuffer: TglcBuffer;
+  const aAttachment: TglcAttachment; const aOwnsBuffer: Boolean);
+begin
+  if not Assigned(aBuffer) then
+    raise EglcFrameBufferObject.Create('invalid buffer');
+  if not CheckAttachment(aAttachment) then
+    raise EglcFrameBufferObject.Create('attachment already assigned');
+
+  fBuffers.Add(TglcAttachmentContainer.Create(aBuffer, aAttachment, fOwnsObjects and aOwnsBuffer));
+  if OwnsObjects then
+    aBuffer.SetSize(fWidth, fHeight);
+  Attach(fBuffers.Count-1);
+
+  UpdateAndCheckFBO;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcFrameBufferObject.DelBuffer(const aIndex: Integer);
+begin
+  if (aIndex >= 0) and (aIndex < fBuffers.Count) then begin
+    Detach(aIndex);
+    fBuffers.Delete(aIndex);
+    UpdateAndCheckFBO;
+  end else
+    raise EglcFrameBufferObject.Create('Index out of Bounds: ' + IntToStr(aIndex));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.RemBuffer(const aBuffer: TglcBuffer): Integer;
+begin
+  result := IndexOfBuffer(aBuffer);
+  if (result >= 0) then
+    DelBuffer(result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.IndexOfBuffer(const aBuffer: TglcBuffer): Integer;
+var
+  i: Integer;
+begin
+  for i := 0 to fBuffers.Count-1 do
+    if (fBuffers[i].Buffer = aBuffer) then begin
+      result := i;
+      exit;
+    end;
+  result := -1;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//legt die Größe neu fest
+//@Width: neue Breite;
+//@Height: neue Höhe;
+procedure TglcFrameBufferObject.SetSize(const aWidth, aHeight: Integer);
+var
+  c: TglcAttachmentContainer;
+begin
+  if (aWidth <= 0) or (aHeight <= 0) then
+    raise EglcFrameBufferObject.Create('invalid width or height');
+
+  fWidth  := aWidth;
+  fHeight := aHeight;
+  if OwnsObjects then
+    for c in fBuffers do
+      if c.OwnsObject then
+        c.Buffer.SetSize(fWidth, fHeight);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcFrameBufferObject.CheckAttachment(const aAttachment: TglcAttachment): Boolean;
+var
+  i: Integer;
+begin
+  result := false;
+  for i := 0 to fBuffers.Count-1 do
+    if (fBuffers[i].Attachment = aAttachment) then
+      exit;
+  result := true;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Bindet das FrameBufferObjekt
+procedure TglcFrameBufferObject.Bind(const aSetViewport: Boolean = true);
+begin
+  glBindFramebuffer(GL_FRAMEBUFFER, fID);
+  if aSetViewport then begin
+    glPushAttrib(GL_VIEWPORT_BIT);
+    glViewPort(0, 0, fWidth, fHeight);
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Entbindet das FrameBufferObjekt
+procedure TglcFrameBufferObject.Unbind(const aResetViewport: Boolean = true);
+begin
+  if aResetViewport then
+    glPopAttrib;
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erzeugt das Objekt
+constructor TglcFrameBufferObject.Create(const aOwnBuffers: Boolean = true);
+begin
+  inherited Create;
+
+  glGenFramebuffers(1, @fID);
+  fWidth       := 64;
+  fHeight      := 64;
+  fOwnsObjects := aOwnBuffers;
+  fBuffers     := TglcAttachmentContainerList.Create(true); //containers are always owned by this object!
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//gibt das Objekt frei
+destructor TglcFrameBufferObject.Destroy;
+begin
+  fBuffers.Free;
+  glDeleteFramebuffers(1, @fID);
+  inherited Destroy;
+end;
+
+end.
+

diff --git a/uglcLight.pas b/uglcLight.pas
new file mode 100644 (file)
index 0000000..fd79ca5
--- /dev/null
+++ b/uglcLight.pas
@@ -0,0 +1,427 @@
+unit uglcLight;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit enthält eine Klassen-Kapselung der OpenGL Licht- und Material-Objekte }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, dglOpenGL, ugluVector, uglcTypes;
+
+type
+  TglcMaterialRec = packed record
+    Ambient: TgluVector4f;
+    Diffuse: TgluVector4f;
+    Specular: TgluVector4f;
+    Emission: TgluVector4f;
+    Shininess: GLfloat;
+  end;
+  PglcMaterialRec = ^TglcMaterialRec;
+
+  TglcLightType = (
+    ltGlobal = 0,
+    ltPoint  = 1,
+    ltSpot   = 2);
+  TglcLightRec = packed record
+    Ambient: TgluVector4f;
+    Diffuse: TgluVector4f;
+    Specular: TgluVector4f;
+    Position: TgluVector4f;
+    SpotDirection: TgluVector3f;
+    SpotExponent: GLfloat;
+    SpotCutoff: GLfloat;
+    ConstantAtt: GLfloat;
+    LinearAtt: GLfloat;
+    QuadraticAtt: GLfloat;
+  end;
+  PglcLightRec = ^TglcLightRec;
+
+const
+  MAT_DEFAULT_AMBIENT:   TgluVector4f = (0.2, 0.2, 0.2, 1.0);
+  MAT_DEFAULT_DIFFUSE:   TgluVector4f = (0.8, 0.8, 0.8, 1.0);
+  MAT_DEFAULT_SPECULAR:  TgluVector4f = (0.5, 0.5, 0.5, 1.0);
+  MAT_DEFAULT_EMISSION:  TgluVector4f = (0.0, 0.0, 0.0, 1.0);
+  MAT_DEFAULT_SHININESS: GLfloat      =  50.0;
+
+  LIGHT_DEFAULT_AMBIENT:        TgluVector4f = (0.4, 0.4, 0.4, 1.0);
+  LIGHT_DEFAULT_DIFFUSE:        TgluVector4f = (0.7, 0.7, 0.7, 1.0);
+  LIGHT_DEFAULT_SPECULAR:       TgluVector4f = (0.9, 0.9, 0.9, 1.0);
+  LIGHT_DEFAULT_POSITION:       TgluVector4f = (0.0, 0.0, 1.0, 0.0);
+  LIGHT_DEFAULT_SPOT_DIRECTION: TgluVector3f = (0.0, 0.0, -1.0);
+  LIGHT_DEFAULT_SPOT_EXPONENT:  GLfloat      =   0.0;
+  LIGHT_DEFAULT_SPOT_CUTOFF:    GLfloat      = 180.0;
+  LIGHT_DEFAULT_CONSTANT_ATT:   GLfloat      =   1.0;
+  LIGHT_DEFAULT_LINEAR_ATT:     GLfloat      =   0.0;
+  LIGHT_DEFAULT_QUADRATIC_ATT:  GLfloat      =   0.0;
+
+type
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglcMaterial = class(TObject)
+  private
+    fData: TglcMaterialRec;
+  public
+    property Diffuse:   TgluVector4f      read fData.Diffuse   write fData.Diffuse;
+    property Ambient:   TgluVector4f      read fData.Ambient   write fData.Ambient;
+    property Specular:  TgluVector4f      read fData.Specular  write fData.Specular;
+    property Emission:  TgluVector4f      read fData.Emission  write fData.Emission;
+    property Shininess: GLfloat           read fData.Shininess write fData.Shininess;
+    property Data:      TglcMaterialRec   read fData           write fData;
+
+    procedure Bind(const aFace: TglcFace);
+
+    class procedure Bind(const aFace: TglcFace; const aMaterial: TglcMaterialRec);
+    class function DefaultValues: TglcMaterialRec;
+
+    constructor Create;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  EglcLight = class(Exception);
+  TglcLight = class(TObject)
+  private
+    function GetDataPtr: PglcLightRec;
+  protected
+    fData: TglcLightRec;
+
+    procedure SetAmbient      (const aValue: TgluVector4f);   virtual;
+    procedure SetDiffuse      (const aValue: TgluVector4f);   virtual;
+    procedure SetSpecular     (const aValue: TgluVector4f);   virtual;
+    procedure SetPosition4f   (const aValue: TgluVector4f);   virtual;
+    procedure SetSpotDirection(const aValue: TgluVector3f);   virtual;
+    procedure SetSpotExponent (const aValue: GLfloat);        virtual;
+    procedure SetSpotCutoff   (const aValue: GLfloat);        virtual;
+    procedure SetConstantAtt  (const aValue: GLfloat);        virtual;
+    procedure SetLinearAtt    (const aValue: GLfloat);        virtual;
+    procedure SetQuadraticAtt (const aValue: GLfloat);        virtual;
+    procedure SetData         (const aValue: TglcLightRec);   virtual;
+
+    property Ambient:       TgluVector4f   read fData.Ambient       write SetAmbient;
+    property Diffuse:       TgluVector4f   read fData.Diffuse       write SetDiffuse;
+    property Specular:      TgluVector4f   read fData.Specular      write SetSpecular;
+    property Position4f:    TgluVector4f   read fData.Position      write SetPosition4f;
+    property SpotDirection: TgluVector3f   read fData.SpotDirection write SetSpotDirection;
+    property SpotExponent:  GLfloat        read fData.SpotExponent  write SetSpotExponent;
+    property SpotCutoff:    GLfloat        read fData.SpotCutoff    write SetSpotCutoff;
+    property ConstantAtt:   GLfloat        read fData.ConstantAtt   write SetConstantAtt;
+    property LinearAtt:     GLfloat        read fData.LinearAtt     write SetLinearAtt;
+    property QuadraticAtt:  GLfloat        read fData.QuadraticAtt  write SetQuadraticAtt;
+  public
+    property Data:    TglcLightRec read fData write SetData;
+    property DataPtr: PglcLightRec read GetDataPtr;
+
+    procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); virtual; abstract;
+
+    class procedure Bind(const aLightID: GLenum; const aLight: TglcLightRec;
+      const aEnableLighting: Boolean; const aLightType: TglcLightType);
+    class procedure Unbind(const aLightID: GLenum; const aDisableLighting: Boolean = true);
+    class function DefaultValues: TglcLightRec; virtual;
+
+    constructor Create;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglcLightGlobal = class(TglcLight)
+  private
+    function GetDirection: TgluVector3f;
+    procedure SetDirection(aValue: TgluVector3f);
+  public
+    property Ambient;
+    property Diffuse;
+    property Specular;
+    property Direction: TgluVector3f read GetDirection write SetDirection;
+
+    procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); override;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglcLightPoint = class(TglcLight)
+  private
+    fMaxSize: Single;
+    fSizeFactor: Single;
+    function GetPosition: TgluVector3f;
+    procedure SetPosition(const aValue: TgluVector3f);
+  protected
+    procedure SetMaxSize   (const aValue: Single); virtual;
+    procedure SetSizeFactor(const aValue: Single); virtual;
+  public
+    property Ambient;
+    property Diffuse;
+    property Specular;
+    property ConstantAtt;
+    property LinearAtt;
+    property QuadraticAtt;
+    property MaxSize:    Single       read fMaxSize    write SetMaxSize;
+    property SizeFactor: Single       read fSizeFactor write SetSizeFactor;
+    property Position:   TgluVector3f read GetPosition write SetPosition;
+
+    procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); override;
+
+    constructor Create;
+  end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+  TglcLightSpot = class(TglcLightPoint)
+  public
+    property SpotCutoff;
+    property SpotDirection;
+    property SpotExponent;
+
+    procedure Bind(const aLightID: GLenum; const aEnableLighting: Boolean = false); override;
+  end;
+
+implementation
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcMaterial//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcMaterial.Bind(const aFace: TglcFace);
+begin
+  Bind(aFace, fData);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglcMaterial.Bind(const aFace: TglcFace; const aMaterial: TglcMaterialRec);
+begin
+  glMaterialfv(GLenum(aFace), GL_AMBIENT,   @aMaterial.Ambient[0]);
+  glMaterialfv(GLenum(aFace), GL_DIFFUSE,   @aMaterial.Diffuse[0]);
+  glMaterialfv(GLenum(aFace), GL_EMISSION,  @aMaterial.Emission[0]);
+  glMaterialfv(GLenum(aFace), GL_SPECULAR,  @aMaterial.Specular[0]);
+  glMaterialfv(GLenum(aFace), GL_SHININESS, @aMaterial.Shininess);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglcMaterial.DefaultValues: TglcMaterialRec;
+begin
+  result.Ambient   := MAT_DEFAULT_AMBIENT;
+  result.Diffuse   := MAT_DEFAULT_DIFFUSE;
+  result.Specular  := MAT_DEFAULT_SPECULAR;
+  result.Emission  := MAT_DEFAULT_EMISSION;
+  result.Shininess := MAT_DEFAULT_SHININESS;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcMaterial.Create;
+begin
+  inherited Create;
+  fData := DefaultValues;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLight/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcLight.GetDataPtr: PglcLightRec;
+begin
+  result := @fData;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetAmbient(const aValue: TgluVector4f);
+begin
+  fData.Ambient := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetDiffuse(const aValue: TgluVector4f);
+begin
+  fData.Diffuse := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpecular(const aValue: TgluVector4f);
+begin
+  fData.Specular := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetPosition4f(const aValue: TgluVector4f);
+begin
+  fData.Position := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetConstantAtt(const aValue: GLfloat);
+begin
+  fData.ConstantAtt := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetLinearAtt(const aValue: GLfloat);
+begin
+  fData.LinearAtt := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetQuadraticAtt(const aValue: GLfloat);
+begin
+  fData.QuadraticAtt := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpotDirection(const aValue: TgluVector3f);
+begin
+  fData.SpotDirection := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpotExponent(const aValue: GLfloat);
+begin
+  fData.SpotExponent := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetSpotCutoff(const aValue: GLfloat);
+begin
+  fData.SpotCutoff := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLight.SetData(const aValue: TglcLightRec);
+begin
+  fData := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglcLight.Bind(const aLightID: GLenum; const aLight: TglcLightRec;
+  const aEnableLighting: Boolean; const aLightType: TglcLightType);
+begin
+  glEnable(aLightID);
+  if (aEnableLighting) then
+    glEnable(GL_LIGHTING);
+
+  if (aLightType in [ltGlobal, ltPoint, ltSpot]) then begin
+    glLightfv(aLightID, GL_AMBIENT,  @aLight.Ambient[0]);
+    glLightfv(aLightID, GL_DIFFUSE,  @aLight.Diffuse[0]);
+    glLightfv(aLightID, GL_SPECULAR, @aLight.Specular[0]);
+    glLightfv(aLightID, GL_POSITION, @aLight.Position[0]);
+  end else begin
+    glLightfv(aLightID, GL_AMBIENT,  @LIGHT_DEFAULT_AMBIENT[0]);
+    glLightfv(aLightID, GL_DIFFUSE,  @LIGHT_DEFAULT_DIFFUSE[0]);
+    glLightfv(aLightID, GL_SPECULAR, @LIGHT_DEFAULT_SPECULAR[0]);
+    glLightfv(aLightID, GL_POSITION, @LIGHT_DEFAULT_POSITION[0]);
+  end;
+
+  if (aLightType in [ltPoint, ltSpot]) then begin
+    glLightfv(aLightID, GL_CONSTANT_ATTENUATION,  @aLight.ConstantAtt);
+    glLightfv(aLightID, GL_LINEAR_ATTENUATION,    @aLight.LinearAtt);
+    glLightfv(aLightID, GL_QUADRATIC_ATTENUATION, @aLight.QuadraticAtt);
+  end else begin
+    glLightfv(aLightID, GL_CONSTANT_ATTENUATION,  @LIGHT_DEFAULT_CONSTANT_ATT);
+    glLightfv(aLightID, GL_LINEAR_ATTENUATION,    @LIGHT_DEFAULT_LINEAR_ATT);
+    glLightfv(aLightID, GL_QUADRATIC_ATTENUATION, @LIGHT_DEFAULT_QUADRATIC_ATT);
+  end;
+
+  if (aLightType in [ltSpot]) then begin
+    glLightfv(aLightID, GL_SPOT_DIRECTION, @aLight.SpotDirection[0]);
+    glLightfv(aLightID, GL_SPOT_EXPONENT,  @aLight.SpotExponent);
+    glLightfv(aLightID, GL_SPOT_CUTOFF,    @aLight.SpotCutoff);
+  end else begin
+    glLightfv(aLightID, GL_SPOT_DIRECTION, @LIGHT_DEFAULT_SPOT_DIRECTION[0]);
+    glLightfv(aLightID, GL_SPOT_EXPONENT,  @LIGHT_DEFAULT_SPOT_EXPONENT);
+    glLightfv(aLightID, GL_SPOT_CUTOFF,    @LIGHT_DEFAULT_SPOT_CUTOFF);
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class procedure TglcLight.Unbind(const aLightID: GLenum; const aDisableLighting: Boolean);
+begin
+  glDisable(aLightID);
+  if aDisableLighting then
+    glDisable(GL_LIGHTING);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class function TglcLight.DefaultValues: TglcLightRec;
+begin
+  result.Ambient       := LIGHT_DEFAULT_AMBIENT;
+  result.Diffuse       := LIGHT_DEFAULT_DIFFUSE;
+  result.Specular      := LIGHT_DEFAULT_SPECULAR;
+  result.Position      := LIGHT_DEFAULT_POSITION;
+  result.SpotDirection := LIGHT_DEFAULT_SPOT_DIRECTION;
+  result.SpotExponent  := LIGHT_DEFAULT_SPOT_EXPONENT;
+  result.SpotCutoff    := LIGHT_DEFAULT_SPOT_CUTOFF;
+  result.ConstantAtt   := LIGHT_DEFAULT_CONSTANT_ATT;
+  result.LinearAtt     := LIGHT_DEFAULT_LINEAR_ATT;
+  result.QuadraticAtt  := LIGHT_DEFAULT_QUADRATIC_ATT;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcLight.Create;
+begin
+  inherited Create;
+  fData  := DefaultValues;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLightGlobal///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcLightGlobal.GetDirection: TgluVector3f;
+begin
+  result := gluVector3f(Position4f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightGlobal.SetDirection(aValue: TgluVector3f);
+begin
+  Position4f := gluVector4f(aValue, 0.0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightGlobal.Bind(const aLightID: GLenum; const aEnableLighting: Boolean);
+begin
+  TglcLight.Bind(aLightID, fData, aEnableLighting, ltGlobal);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLightPoint////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function TglcLightPoint.GetPosition: TgluVector3f;
+begin
+  result := gluVector3f(fData.Position);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.SetPosition(const aValue: TgluVector3f);
+begin
+  SetPosition4f(gluVector4f(aValue, 1.0));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.SetMaxSize(const aValue: Single);
+begin
+  fMaxSize := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.SetSizeFactor(const aValue: Single);
+begin
+  fSizeFactor := aValue;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightPoint.Bind(const aLightID: GLenum; const aEnableLighting: Boolean);
+begin
+  TglcLight.Bind(aLightID, fData, aEnableLighting, ltPoint);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor TglcLightPoint.Create;
+begin
+  inherited Create;
+  Position    := gluVector3f(0.0, 0.0, 0.0);
+  fMaxSize    := 0;
+  fSizeFactor := 1.0;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//TglcLightSpot/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure TglcLightSpot.Bind(const aLightID: GLenum; const aEnableLighting: Boolean);
+begin
+  TglcLight.Bind(aLightID, fData, aEnableLighting, ltSpot);
+end;
+
+end.
+

diff --git a/uglcShader.pas b/uglcShader.pas
new file mode 100644 (file)
index 0000000..750e8bc
--- /dev/null
+++ b/uglcShader.pas
@@ -0,0 +1,975 @@
+unit uglcShader;\r
+\r
+{ Package:      OpenGLCore\r
+  Prefix:       glc - OpenGL Core\r
+  Beschreibung: diese Unit enthält eine Klassen-Kapselung der OpenGL Shader Objekte\r
+  Beispiel:\r
+    var\r
+      shader: TglcShaderProgram;\r
+\r
+    //write log message to console\r
+    //    @param aSender: object that send the message\r
+    //    @param aMsg:    message to write to console\r
+    procedure LogMessage(aSender: TObject; const aMsg: String);\r
+    begin\r
+      writeln(Format('[%p]: %s', [aSender, aMsg]);\r
+    end;\r
+\r
+    //load shader object from file and add it to 'shader'\r
+    //    @param aFilename: name of file to load shader code from\r
+    //    @param aType:     type of shader object to create\r
+    procedure LoadShaderObject(const aFilename: String; const aType: TglcShaderType);\r
+    var\r
+      sl: TStringList;\r
+      so: TglcShaderObject;\r
+    begin\r
+      sl := TStringList.Create;\r
+      try\r
+        sl.LoadFromFile(aFileName);\r
+        so := TglcShaderObject.Create(aType);\r
+        shader.add(so);\r
+      finally\r
+        FreeAndNil(sl, @LogMessage);\r
+      end;\r
+    end;\r
+\r
+    shader := TglcShaderProgram.Create(@LogMessage);\r
+    try\r
+      // load shader objects\r
+      LoadShaderObject('./test_shader.vert', TglcShaderType.stVertex);\r
+      LoadShaderObject('./test_shader.frag', TglcShaderType.stFragment);\r
+\r
+      // compile shader\r
+      shader.Compile;\r
+\r
+      // use shader\r
+      shader.Enable;\r
+      shader.Uniform1f('uTest', 0.1234);\r
+      // do normal rendering\r
+      shader.Disable;\r
+\r
+    finally\r
+      FreeAndNil(shader);\r
+    end; }\r
+\r
+{$mode objfpc}{$H+}\r
+\r
+interface\r
+\r
+uses\r
+  Classes, SysUtils, fgl, dglOpenGL, uglcTypes, ugluMatrix, uglcContext;\r
+\r
+type\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+  EglcShader = class(Exception);\r
+  TglcShaderProgram = class;\r
+  TglcShaderLogEvent = procedure(aSender: TObject; const aMsg: String) of Object;\r
+  TglcShaderObject = class(TObject)\r
+  private\r
+    fAtachedTo: TglcShaderProgram;\r
+    fShaderObj: GLHandle;\r
+    fShaderType: TglcShaderType;\r
+    fCode: String;\r
+    fOnLog: TglcShaderLogEvent;\r
+    fAttachedTo: TglcShaderProgram;\r
+\r
+    function GetInfoLog(aObj: GLHandle): String;\r
+    function GetCompiled: Boolean;\r
+    procedure Log(const aMsg: String);\r
+    procedure CreateShaderObj;\r
+    procedure AttachTo(const aProgram: TglcShaderProgram);\r
+  public\r
+    property ShaderObj : GLHandle           read fShaderObj;\r
+    property ShaderType: TglcShaderType     read fShaderType;\r
+    property Compiled:   Boolean            read GetCompiled;\r
+    property AtachedTo:  TglcShaderProgram  read fAtachedTo;\r
+    property Code:       String             read fCode  write fCode;\r
+    property OnLog:      TglcShaderLogEvent read fOnLog write fOnLog;\r
+\r
+    procedure Compile;\r
+\r
+    constructor Create(const aShaderType: TglcShaderType; const aLogEvent: TglcShaderLogEvent = nil);\r
+    destructor Destroy; override;\r
+  end;\r
+  TglcShaderObjectList = specialize TFPGObjectList<TglcShaderObject>;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+  TglcShaderProgram = class(TglcShaderObjectList)\r
+  private\r
+    fProgramObj: GLHandle;\r
+    fOnLog: TglcShaderLogEvent;\r
+    fFilename: String;\r
+\r
+    function GetUniformLocation(const aName: String; out aPos: glInt): Boolean;\r
+    function GetInfoLog(Obj: GLHandle): String;\r
+    function GetCompiled: Boolean;\r
+    function GetLinked: Boolean;\r
+\r
+    procedure CreateProgramObj;\r
+    procedure Log(const msg: String);\r
+    procedure AttachShaderObj(const aShaderObj: TglcShaderObject);\r
+  public\r
+    property ProgramObj: glHandle           read fProgramObj;\r
+    property Filename:   String             read fFilename;\r
+    property Compiled:   Boolean            read GetCompiled;\r
+    property Linked:     Boolean            read GetLinked;\r
+    property OnLog:      TglcShaderLogEvent read fOnLog               write fOnLog;\r
+\r
+    procedure Compile;\r
+    procedure Enable;\r
+    procedure Disable;\r
+\r
+    procedure Add(aShaderObj: TglcShaderObject);\r
+    procedure Delete(aID: Integer; aFreeOwnedObj: Boolean = True);\r
+    procedure Clear;\r
+\r
+    function Uniform1f(const aName: String; aP1: GLFloat): Boolean;\r
+    function Uniform2f(const aName: String; aP1, aP2: GLFloat): Boolean;\r
+    function Uniform3f(const aName: String; aP1, aP2, aP3: GLFloat): Boolean;\r
+    function Uniform4f(const aName: String; aP1, aP2, aP3, aP4: GLFloat): Boolean;\r
+    function Uniform1i(const aName: String; aP1: GLint): Boolean;\r
+    function Uniform2i(const aName: String; aP1, aP2: GLint): Boolean;\r
+    function Uniform3i(const aName: String; aP1, aP2, aP3: GLint): Boolean;\r
+    function Uniform4i(const aName: String; aP1, aP2, aP3, aP4: GLint): Boolean;\r
+    function Uniform1fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+    function Uniform2fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+    function Uniform3fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+    function Uniform4fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+    function Uniform1iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+    function Uniform2iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+    function Uniform3iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+    function Uniform4iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+    function UniformMatrix2fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix2f): Boolean;\r
+    function UniformMatrix3fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix3f): Boolean;\r
+    function UniformMatrix4fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix4f): Boolean;\r
+\r
+    function GetUniformfv(const aName: String; aP: PGLfloat): Boolean;\r
+    function GetUniformfi(const aName: String; aP: PGLint): Boolean;\r
+    function HasUniform(const aName: String): Boolean;\r
+\r
+    procedure LoadFromFile(const aFilename: String);\r
+    procedure LoadFromStream(const aStream: TStream);\r
+    procedure SaveToFile(const aFilename: String);\r
+    procedure SaveToStream(const aStream: TStream);\r
+\r
+    constructor Create(const aLogEvent: TglcShaderLogEvent = nil);\r
+    destructor Destroy; override;\r
+  end;\r
+\r
+implementation\r
+\r
+uses\r
+  RegExpr;\r
+\r
+const\r
+  ERROR_STR_VAR_NAME: String = 'can''t find the variable ''%s'' in the program';\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//glShaderObject////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRI//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ließt das Log eines OpenGL-Objekts aus\r
+//@Obj: Handle des Objekts, dessen Log ausgelesen werden soll;\r
+//@result: Log des Objekts;\r
+function TglcShaderObject.GetInfoLog(aObj: GLHandle): String;\r
+var\r
+  Msg: PChar;\r
+  bLen: GLint;\r
+  sLen: GLsizei;\r
+begin\r
+  bLen := 0;\r
+  glGetShaderiv(aObj, GL_INFO_LOG_LENGTH, @bLen);\r
+  if bLen > 1 then begin\r
+    GetMem(Msg, bLen * SizeOf(Char));\r
+    glGetShaderInfoLog(aObj, bLen, @sLen, Msg);\r
+    result := PChar(Msg);\r
+    Dispose(Msg);\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ließt aus, ob der Shader ohne Fehler kompiliert wurde\r
+//@result: TRUE wenn ohne Fehler kompiliert, sonst FALSE;\r
+function TglcShaderObject.GetCompiled: Boolean;\r
+var\r
+  value: glInt;\r
+begin\r
+  glGetShaderiv(fShaderObj, GL_COMPILE_STATUS, @value);\r
+  result := (value = GL_TRUE);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ruft das Log-Event auf, wenn es gesetzt ist\r
+//@msg: Nachricht die geloggt werden soll;\r
+procedure TglcShaderObject.Log(const aMsg: String);\r
+begin\r
+  if Assigned(fOnLog) then begin\r
+    fOnLog(self, aMsg);\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderObject.CreateShaderObj;\r
+begin\r
+  if (fShaderObj <> 0) then\r
+    exit;\r
+  fShaderObj := glCreateShader(GLenum(fShaderType));\r
+  if fShaderObj = 0 then\r
+    raise EglcShader.Create('can''t create ShaderObject');\r
+  Log('shader object created: #'+IntToHex(fShaderObj, 4));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderObject.AttachTo(const aProgram: TglcShaderProgram);\r
+begin\r
+  if (aProgram <> fAtachedTo) then begin\r
+    CreateShaderObj;\r
+    glAttachShader(aProgram.ProgramObj, fShaderObj);\r
+    fAttachedTo := aProgram;\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBL//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//kompiliert das Shader-Objekt\r
+procedure TglcShaderObject.Compile;\r
+var\r
+  len, i: GLint;\r
+  List: TStringList;\r
+  c: PAnsiChar;\r
+begin\r
+  CreateShaderObj;\r
+  len := Length(fCode);\r
+  if len > 0 then begin\r
+    c := PAnsiChar(fCode);\r
+    glShaderSource(fShaderObj, 1, @c, @len);\r
+    glCompileShader(fShaderObj);\r
+    List := TStringList.Create;\r
+    List.Text := GetInfoLog(fShaderObj);\r
+    for i := 0 to List.Count-1 do\r
+      Log(List[i]);\r
+    List.Free;\r
+  end else Log('error while compiling: no bound shader code');\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//erzeugt das Objekt\r
+//@ShaderType: Typ des Shader-Objekts;\r
+//@LogEvent: Event zum loggen von Fehlern und Ereignissen;\r
+//@raise: EglcShader wenn der Shadertyp unbekannt oder ungültig ist;\r
+constructor TglcShaderObject.Create(const aShaderType: TglcShaderType; const aLogEvent: TglcShaderLogEvent);\r
+begin\r
+  inherited Create;\r
+  fCode       := '';\r
+  fOnLog      := aLogEvent;\r
+  fShaderType := aShaderType;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//gibt das Objekt frei\r
+destructor TglcShaderObject.Destroy;\r
+begin\r
+  if (fShaderObj <> 0) then\r
+    glDeleteShader(fShaderObj);\r
+  inherited Destroy;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//glShaderProgram///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRIVATE//PRI//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+function TglcShaderProgram.GetUniformLocation(const aName: String; out aPos: glInt): Boolean;\r
+begin\r
+  aPos := glGetUniformLocation(fProgramObj, PChar(aName));\r
+  result := (aPos <> -1);\r
+  if not result then\r
+    Log(StringReplace(ERROR_STR_VAR_NAME, '%s', aName, [rfIgnoreCase, rfReplaceAll]));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ließt das Log eines OpenGL-Objekts aus\r
+//@Obj: Handle des Objekts, dessen Log ausgelesen werden soll;\r
+//@result: Log des Objekts;\r
+function TglcShaderProgram.GetInfoLog(Obj: GLHandle): String;\r
+var\r
+  Msg: PChar;\r
+  bLen: GLint;\r
+  sLen: GLsizei;\r
+begin\r
+  bLen := 0;\r
+  glGetProgramiv(Obj, GL_INFO_LOG_LENGTH, @bLen);\r
+  if bLen > 1 then begin\r
+    GetMem(Msg, bLen * SizeOf(Char));\r
+    glGetProgramInfoLog(Obj, bLen, @sLen, Msg);\r
+    result := PChar(Msg);\r
+    Dispose(Msg);\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//prüft ob alle Shader ohne Fehler compiliert wurden\r
+//@result: TRUE wenn alle erfolgreich compiliert, sonst FALSE;\r
+function TglcShaderProgram.GetCompiled: Boolean;\r
+var\r
+  i: Integer;\r
+begin\r
+  result := (Count > 0);\r
+  for i := 0 to Count-1 do\r
+    result := result and Items[i].Compiled;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//prüft ob das Programm ohne Fehler gelinkt wurde\r
+//@result: TRUE wenn linken erfolgreich, sonst FASLE;\r
+function TglcShaderProgram.GetLinked: Boolean;\r
+var\r
+  value: glInt;\r
+begin\r
+  glGetProgramiv(fProgramObj, GL_LINK_STATUS, @value);\r
+  result := (value = GL_TRUE);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderProgram.CreateProgramObj;\r
+begin\r
+  if (fProgramObj = 0) then begin\r
+    if GL_LibHandle = nil then\r
+      raise EglcShader.Create('TglShaderProgram.Create - OpenGL not initialized');\r
+\r
+    if not TglcContext.IsAnyContextActive then\r
+      raise EglcShader.Create('TglShaderProgram.Create - no valid render context');\r
+\r
+    fProgramObj := glCreateProgram();\r
+    Log('shader program created: #'+IntToHex(fProgramObj, 4));\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//ruft das Log-Event auf, wenn es gesetzt ist\r
+//@msg: Nachricht die geloggt werden soll;\r
+procedure TglcShaderProgram.Log(const msg: String);\r
+begin\r
+  if Assigned(fOnLog) then begin\r
+    fOnLog(self, msg);\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderProgram.AttachShaderObj(const aShaderObj: TglcShaderObject);\r
+begin\r
+  CreateProgramObj;\r
+  aShaderObj.AttachTo(self);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBLIC//PUBL//\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//Kompiliert den Shader-Code\r
+procedure TglcShaderProgram.Compile;\r
+var\r
+  i: Integer;\r
+  l: TStringList;\r
+begin\r
+  CreateProgramObj;\r
+  for i := 0 to Count-1 do begin\r
+    AttachShaderObj(Items[i]);\r
+    Items[i].Compile;\r
+  end;\r
+  glLinkProgram(fProgramObj);\r
+  l := TStringList.Create;\r
+  l.Text := GetInfoLog(fProgramObj);\r
+  for i := 0 to l.Count-1 do\r
+    Log(l[i]);\r
+  l.Free;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//aktiviert den Shader\r
+procedure TglcShaderProgram.Enable;\r
+begin\r
+  glUseProgram(fProgramObj);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//deaktiviert den Shader\r
+procedure TglcShaderProgram.Disable;\r
+begin\r
+  glUseProgram(0);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//fügt der Liste einen Shader hinzu\r
+//@ShaderObj: Objekt, das hinzugefügt werden soll;\r
+procedure TglcShaderProgram.Add(aShaderObj: TglcShaderObject);\r
+begin\r
+  inherited Add(aShaderObj);\r
+  if (fProgramObj <> 0) then\r
+    AttachShaderObj(aShaderObj);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//löscht ein ShaderObjekt aus der Liste\r
+//@ID: Index des Objekts, das gelöscht werden soll;\r
+//@FreeOwnedObj: wenn TRUE wird das gelöschte Objekt freigegeben;\r
+procedure TglcShaderProgram.Delete(aID: Integer; aFreeOwnedObj: Boolean);\r
+var\r
+  b: Boolean;\r
+begin\r
+  if (aID >= 0) and (aID < Count) and (fProgramObj <> 0) then begin\r
+    glDetachShader(fProgramObj, Items[aID].fShaderObj);\r
+    Items[aID].fAttachedTo := nil;\r
+  end;\r
+  b := FreeObjects;\r
+  FreeObjects := aFreeOwnedObj;\r
+  inherited Delete(aID);\r
+  FreeObjects := b;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+procedure TglcShaderProgram.Clear;\r
+begin\r
+  while (Count > 0) do\r
+    Delete(0);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 1-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1f(const aName: String; aP1: GLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform1f(pos, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 2-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2f(const aName: String; aP1, aP2: GLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform2f(pos, aP1, aP2);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 3-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3f(const aName: String; aP1, aP2, aP3: GLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform3f(pos, aP1, aP2, aP3);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 4-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@p4: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4f(const aName: String; aP1, aP2, aP3, aP4: GLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform4f(pos, aP1, aP2, aP3, aP4);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 1-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1i(const aName: String; aP1: GLint): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform1i(pos, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 2-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2i(const aName: String; aP1, aP2: GLint): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform2i(pos, aP1, aP2);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 3-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3i(const aName: String; aP1, aP2, aP3: GLint): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform3i(pos, aP1, aP2, aP3);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen 4-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@p2: Wert der Variable, der gesetzt werden soll;\r
+//@p3: Wert der Variable, der gesetzt werden soll;\r
+//@p4: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4i(const aName: String; aP1, aP2, aP3, aP4: GLint): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform4i(pos, aP1, aP2, aP3, aP4);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 1-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform1fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 2-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform2fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 3-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform3fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 4-Komponenten Float-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4fv(const aName: String; aCount: GLint; aP1: PGLFloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform4fv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 1-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform1iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform1iv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 2-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform2iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform2iv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 3-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform3iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform3iv(pos, aCount, aP1);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt einen oder mehrere 4-Komponenten Integer-Vektoren an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@count: Anzahl an Parametern auf die p1 zeigt;\r
+//@p1: Zeiger auf den ersten Wert der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.Uniform4iv(const aName: String; aCount: GLint; aP1: PGLInt): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniform4iv(pos, aCount, aP1) ;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt eine oder mehrere 2x2-Matrizen an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert;\r
+//@Count: Anzahl der zu übergebenden Elemente;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.UniformMatrix2fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix2f): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniformMatrix2fv(pos, aCount, aTranspose, PGLfloat(aP1));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt eine oder mehrere 3x3-Matrizen an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert;\r
+//@Count: Anzahl der zu übergebenden Elemente;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.UniformMatrix3fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix3f): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniformMatrix3fv(pos, aCount, aTranspose, PGLfloat(aP1));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//übergibt eine oder mehrere 4x4-Matrizen an den Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gesetzt werden soll;\r
+//@Transpose: wenn TRUe wird die matrix vor der Übergabe transponiert;\r
+//@Count: Anzahl der zu übergebenden Elemente;\r
+//@p1: Wert der Variable, der gesetzt werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.UniformMatrix4fv(const aName: String; aTranspose: Boolean; aCount: GLint; aP1: PgluMatrix4f): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glUniformMatrix4fv(pos, aCount, aTranspose, PGLfloat(aP1));\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//holt den Wert einer Float-Uniform-Variable aus dem Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gelesen werden soll;\r
+//@p: Zeiger auf die Variable, in die der gelesene Wert geschrieben werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.GetUniformfv(const aName: String; aP: PGLfloat): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glGetUniformfv(fProgramObj, pos, aP);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//holt den Wert einer Integer-Uniform-Variable aus dem Shader\r
+//!!!Der Shader muss dazu aktiviert sein!!!\r
+//@Name: Name der Variablen die gelesen werden soll;\r
+//@p: Zeiger auf die Variable, in die der gelesene Wert geschrieben werden soll;\r
+//@result: TRUE wenn erfolgreich, sonst FALSE (Variablenname konnte nicht aufgelöst werden);\r
+function TglcShaderProgram.GetUniformfi(const aName: String; aP: PGLint): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+  if result then\r
+    glGetUniformiv(fProgramObj, pos, aP);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+function TglcShaderProgram.HasUniform(const aName: String): Boolean;\r
+var\r
+  pos: GLint;\r
+begin\r
+  result := GetUniformLocation(aName, pos);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//läd den Shader aus einer Datei\r
+//@Filename: Datei aus der gelesen werden soll;\r
+//@raise: EglcShader, wenn Datei nicht vorhanden ist;\r
+procedure TglcShaderProgram.LoadFromFile(const aFilename: String);\r
+var\r
+  Stream: TFileStream;\r
+begin\r
+  if FileExists(aFilename) then begin\r
+    Stream := TFileStream.Create(aFilename, fmOpenRead);\r
+    try\r
+      LoadFromStream(Stream);\r
+      fFilename := aFilename;\r
+    finally\r
+      Stream.Free;\r
+    end;\r
+  end else raise EglcShader.Create('TglShaderProgram.LoadFromFile - file not found: '+Filename);\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//läd den Shader aus einem Stream\r
+//@Stream: Stream aus dem gelesen werden soll;\r
+//@raise: EglcShader wenn kein Stream-Objekt übergeben wurde;\r
+procedure TglcShaderProgram.LoadFromStream(const aStream: TStream);\r
+\r
+  function GetShaderType(const aStr: String): TglcShaderType;\r
+  begin\r
+    if (aStr = 'GL_VERTEX_SHADER') then\r
+      result := TglcShaderType.stVertex\r
+    else if (aStr = 'GL_FRAGMENT_SHADER') then\r
+      result := TglcShaderType.stFragment\r
+    else if (aStr = 'GL_GEOMETRY_SHADER') then\r
+      result := TglcShaderType.stGeometry\r
+    else if (aStr = 'GL_TESS_CONTROL_SHADER') then\r
+      result := TglcShaderType.stTessControl\r
+    else if (aStr = 'GL_TESS_EVALUATION_SHADER') then\r
+      result := TglcShaderType.stTessEvaluation\r
+    else\r
+      raise Exception.Create('invalid shader type: ' + aStr);\r
+  end;\r
+\r
+var\r
+  sl: TStringList;\r
+  s: String;\r
+  rx: TRegExpr;\r
+  LastMatchPos: PtrInt;\r
+  st: TglcShaderType;\r
+  o: TglcShaderObject;\r
+\r
+  procedure AddObj(const aPos: Integer);\r
+  begin\r
+    if (LastMatchPos > 0) then begin\r
+      o := TglcShaderObject.Create(st, fOnLog);\r
+      o.Code := Trim(Copy(s, LastMatchPos, aPos - LastMatchPos));\r
+      Add(o);\r
+    end;\r
+  end;\r
+\r
+begin\r
+  if not Assigned(aStream) then\r
+    raise EglcShader.Create('TglShaderProgram.SaveToStream - stream is nil');\r
+\r
+  Clear;\r
+  sl := TStringList.Create;\r
+  rx := TRegExpr.Create;\r
+  try\r
+    sl.LoadFromStream(aStream);\r
+    s := sl.Text;\r
+    LastMatchPos := 0;\r
+    rx.Expression  := '/\*\s*ShaderObject\s*:\s*(GL_[A-Z_]+)\s*\*/\s*$?';\r
+    rx.InputString := s;\r
+\r
+    while rx.Exec(LastMatchPos+1) do begin\r
+      AddObj(rx.MatchPos[0]);\r
+      LastMatchPos := rx.MatchPos[0] + rx.MatchLen[0];\r
+      st := GetShaderType(rx.Match[1]);\r
+    end;\r
+    AddObj(Length(s));\r
+  finally\r
+    rx.Free;\r
+    sl.Free;\r
+  end;\r
+\r
+\r
+  {\r
+  if Assigned(aStream) then begin\r
+    Clear;\r
+    fFilename := '';\r
+    reader := TutlStreamReader.Create(aStream);\r
+    try\r
+      if reader.ReadAnsiString <> GLSL_FILE_HEADER then\r
+        raise EglcShader.Create('TglShaderProgram.SaveToStream - incompatible file');\r
+      v := reader.ReadInteger;\r
+\r
+      if v >= 100 then begin //version 1.00\r
+        c := reader.ReadInteger;\r
+        for i := 0 to c-1 do begin\r
+          Add(TglcShaderObject.Create(Cardinal(reader.ReadInteger), fOnLog));\r
+          Last.fCode := reader.ReadAnsiString;\r
+        end;\r
+      end;\r
+    finally\r
+      reader.Free;\r
+    end;\r
+  end else\r
+  }\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//speichert den Shader in einer Datei\r
+//@Filename: Datei in die geschrieben werden soll;\r
+procedure TglcShaderProgram.SaveToFile(const aFilename: String);\r
+var\r
+  Stream: TFileStream;\r
+begin\r
+  Stream := TFileStream.Create(aFilename, fmCreate);\r
+  try\r
+    SaveToStream(Stream);\r
+    fFilename := aFilename;\r
+  finally\r
+    Stream.Free;\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//speichert den Shader in einen Stream\r
+//@Stream: Stream in den geschrieben werden soll;\r
+//@raise: EglcShader wenn kein Stream-Objekt übergeben wurde;\r
+//@raise: EglcShader wenn ungültige Datei;\r
+procedure TglcShaderProgram.SaveToStream(const aStream: TStream);\r
+var\r
+  i: Integer;\r
+  sl: TStringList;\r
+  sObj: TglcShaderObject;\r
+\r
+  function GetShaderTypeStr(const aShaderType: TglcShaderType): String;\r
+  begin\r
+    case aShaderType of\r
+      TglcShaderType.stVertex:          result := 'GL_VERTEX_SHADER';\r
+      TglcShaderType.stFragment:        result := 'GL_FRAGMENT_SHADER';\r
+      TglcShaderType.stGeometry:        result := 'GL_GEOMETRY_SHADER';\r
+      TglcShaderType.stTessControl:     result := 'GL_TESS_CONTROL_SHADER';\r
+      TglcShaderType.stTessEvaluation:  result := 'GL_TESS_EVALUATION_SHADER';\r
+    else\r
+      result := 'UNKNOWN';\r
+    end;\r
+  end;\r
+\r
+begin\r
+  if not Assigned(aStream) then\r
+    raise EglcShader.Create('TglShaderProgram.LoadFromStream - stream is nil');\r
+  fFilename := '';\r
+  sl := TStringList.Create;\r
+  try\r
+    for i := 0 to Count-1 do begin\r
+      sObj := Items[i];\r
+      sl.Add('/* ShaderObject: ' + GetShaderTypeStr(sObj.ShaderType) + ' */');\r
+      sl.Add(sObj.Code);\r
+    end;\r
+    sl.SaveToStream(aStream);\r
+  finally\r
+    sl.Free;\r
+  end;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//erzeugt das Objekt\r
+//@LogEvent: Event zum loggen von Fehlern und Ereignissen;\r
+//@raise: EglcShader wenn OpenGL nicht initialisiert werden konnte;\r
+//@raise:\r
+constructor TglcShaderProgram.Create(const aLogEvent: TglcShaderLogEvent);\r
+begin\r
+  inherited Create;\r
+  fOnLog      := aLogEvent;\r
+  fFilename   := '';\r
+  fProgramObj := 0;\r
+end;\r
+\r
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\r
+//gibt das Objekt frei\r
+destructor TglcShaderProgram.Destroy;\r
+begin\r
+  if (fProgramObj <> 0) then\r
+    glDeleteProgram(fProgramObj);\r
+  inherited Destroy;\r
+end;\r
+\r
+end.\r
+\r
\ No newline at end of file

diff --git a/uglcTypes.pas b/uglcTypes.pas
new file mode 100644 (file)
index 0000000..95ffb79
--- /dev/null
+++ b/uglcTypes.pas
@@ -0,0 +1,318 @@
+unit uglcTypes;
+
+{ Package:      OpenGLCore
+  Prefix:       glc - OpenGL Core
+  Beschreibung: diese Unit definiert Enum-Typen die OpenGL Konstanten wrappen und stellt zusätzlich
+                Funktions-Wrapper zur verfügung die diese Enum-Typen als Parameter entgegen nehmen }
+
+{$mode objfpc}{$H+}
+{$MACRO ON}
+{$SCOPEDENUMS ON}
+
+interface
+
+uses
+  dglOpenGL, sysutils;
+
+type
+  TglcFace = (
+    faFront = GL_FRONT,
+    faBack  = GL_BACK,
+    faBoth  = GL_FRONT_AND_BACK);
+
+  TglcPolygonMode = (
+    pmPoint = GL_POINT,
+    pmLine  = GL_LINE,
+    pmFill  = GL_FILL);
+
+  TglcDepthFunc = (
+    dfNever         = GL_NEVER,
+    dfLess          = GL_LESS,
+    dfEqual         = GL_EQUAL,
+    dfLessEqual     = GL_LEQUAL,
+    dfGreater       = GL_GREATER,
+    dfNotEqual      = GL_NOTEQUAL,
+    dfGreaterEqual  = GL_GEQUAL,
+    dfAlways        = GL_ALWAYS);
+
+  TglcClearBuffer = (
+    cbDepthBuffer   = GL_DEPTH_BUFFER_BIT,
+    cbAccumBuffer   = GL_ACCUM_BUFFER_BIT,
+    cbStencilBuffer = GL_STENCIL_BUFFER_BIT,
+    cbColorBuffer   = GL_COLOR_BUFFER_BIT);
+
+  TglcTextureMinFilter = (
+    mfNearest              = GL_NEAREST,
+    mfLinear               = GL_LINEAR,
+    mfNearestMipmapNearest = GL_NEAREST_MIPMAP_NEAREST,
+    mfLinearMipmapNearest  = GL_LINEAR_MIPMAP_NEAREST,
+    mfNearestMipmapLinear  = GL_NEAREST_MIPMAP_LINEAR,
+    mfLinearMipmapLinear   = GL_LINEAR_MIPMAP_LINEAR);
+
+  TglcTextureMagFilter = (
+    mfNearest = GL_NEAREST,
+    mfLinear  = GL_LINEAR);
+
+  TglcTextureWrap = (
+    twClamp          = GL_CLAMP,
+    twRepeat         = GL_REPEAT,
+    twClampToBorder  = GL_CLAMP_TO_BORDER,
+    twClampToEdge    = GL_CLAMP_TO_EDGE,
+    twMirroredRepeat = GL_MIRRORED_REPEAT);
+
+  TglcBlendFactor = (
+    bfZero               = GL_ZERO,
+    bfOne                = GL_ONE,
+    bfSrcColor           = GL_SRC_COLOR,
+    bfOneMinusSrcColor   = GL_ONE_MINUS_SRC_COLOR,
+    bfSrcAlpha           = GL_SRC_ALPHA,
+    bfOneMinusSrcAlpha   = GL_ONE_MINUS_SRC_ALPHA,
+    bfDstAlpha           = GL_DST_ALPHA,
+    bfOneMinusDstAlpha   = GL_ONE_MINUS_DST_ALPHA,
+    bfDstColor           = GL_DST_COLOR,
+    bfOneMinusDstColor   = GL_ONE_MINUS_DST_COLOR,
+    bfSrcAlphaSaturate   = GL_SRC_ALPHA_SATURATE,
+    bgConstColor         = GL_CONSTANT_COLOR,
+    bfOneMinusConstColor = GL_ONE_MINUS_CONSTANT_COLOR,
+    bfConstAlpha         = GL_CONSTANT_ALPHA,
+    bfOneMinusConstAlpha = GL_ONE_MINUS_CONSTANT_ALPHA);
+
+  TglcBlendMode = (
+    bmNone,
+    bmAlphaBlend,
+    bmAdditiveAlphaBlend,
+    bmAdditiveBlend);
+
+  TglcFormat = (
+    fmUnknown           = 0,
+    fmColorIndex        = GL_COLOR_INDEX,
+    fmDepthComponent    = GL_DEPTH_COMPONENT,
+    fmRed               = GL_RED,
+    fmGreen             = GL_GREEN,
+    fmBlue              = GL_BLUE,
+    fmAlpha             = GL_ALPHA,
+    fmRGB               = GL_RGB,
+    fmRGBA              = GL_RGBA,
+    fmLuminance         = GL_LUMINANCE,
+    fmLuminanceAlpha    = GL_LUMINANCE_ALPHA,
+    fmBGR               = GL_BGR,
+    fmBGRA              = GL_BGRA,
+    fmDepthStencil      = GL_DEPTH_STENCIL);
+
+  TglcInternalFormat = (
+    ifUnknown                   = 0,
+    ifDepthComponent            = GL_DEPTH_COMPONENT,
+    ifAlpha                     = GL_ALPHA,
+    ifRGB                       = GL_RGB,
+    ifRGBA                      = GL_RGBA,
+    ifLuminance                 = GL_LUMINANCE,
+    ifLuminanceAlpha            = GL_LUMINANCE_ALPHA,
+    ifR3G3B2                    = GL_R3_G3_B2,
+    ifAlpha4                    = GL_ALPHA4,
+    ifAlpha8                    = GL_ALPHA8,
+    ifAlpha12                   = GL_ALPHA12,
+    ifAlpha16                   = GL_ALPHA16,
+    ifLuminance4                = GL_LUMINANCE4,
+    ifLuminance8                = GL_LUMINANCE8,
+    ifLuminance12               = GL_LUMINANCE12,
+    ifLuminance16               = GL_LUMINANCE16,
+    ifLuminance4Alpha4          = GL_LUMINANCE4_ALPHA4,
+    ifLuminance6Alpha2          = GL_LUMINANCE6_ALPHA2,
+    ifLuminance8Alpha8          = GL_LUMINANCE8_ALPHA8,
+    ifLuminance12Alpha4         = GL_LUMINANCE12_ALPHA4,
+    ifLuminance12Alpha12        = GL_LUMINANCE12_ALPHA12,
+    ifLuminance16Alpha16        = GL_LUMINANCE16_ALPHA16,
+    ifIntensity                 = GL_INTENSITY,
+    ifIntensity4                = GL_INTENSITY4,
+    ifIntensity8                = GL_INTENSITY8,
+    ifIntensity12               = GL_INTENSITY12,
+    ifIntensity16               = GL_INTENSITY16,
+    ifRGB4                      = GL_RGB4,
+    ifRGB5                      = GL_RGB5,
+    ifRGB8                      = GL_RGB8,
+    ifRGB10                     = GL_RGB10,
+    ifRGB12                     = GL_RGB12,
+    ifRGB16                     = GL_RGB16,
+    ifRGBA2                     = GL_RGBA2,
+    ifRGBA4                     = GL_RGBA4,
+    ifRGB5A1                    = GL_RGB5_A1,
+    ifRGBA8                     = GL_RGBA8,
+    ifRGB10A2                   = GL_RGB10_A2,
+    ifRGBA12                    = GL_RGBA12,
+    ifRGBA16                    = GL_RGBA16,
+    ifDepthComponent16          = GL_DEPTH_COMPONENT16,
+    ifDepthComponent24          = GL_DEPTH_COMPONENT24,
+    ifDepthComponent32          = GL_DEPTH_COMPONENT32,
+    ifCompressedAlpha           = GL_COMPRESSED_ALPHA,
+    ifCompressedLuminance       = GL_COMPRESSED_LUMINANCE,
+    ifCompressedLuminanceAlpha  = GL_COMPRESSED_LUMINANCE_ALPHA,
+    ifCompressedIntensity       = GL_COMPRESSED_INTENSITY,
+    ifCompressedRGB             = GL_COMPRESSED_RGB,
+    ifCompressedRGBA            = GL_COMPRESSED_RGBA,
+    ifRGBA32f                   = GL_RGBA32F,
+    ifRGB32f                    = GL_RGB32F,
+    ifRGBA16F                   = GL_RGBA16F,
+    ifRGB16F                    = GL_RGB16F,
+    ifDepth24Stencil8           = GL_DEPTH24_STENCIL8,
+    ifSRGB                      = GL_SRGB,
+    ifSRGB8                     = GL_SRGB8,
+    ifSRGBA                     = GL_SRGB_ALPHA,
+    ifSRGBA8                    = GL_SRGB8_ALPHA8,
+    ifSLuminanceAlpha           = GL_SLUMINANCE_ALPHA,
+    ifSLuminance8Alpha8         = GL_SLUMINANCE8_ALPHA8,
+    ifSLuminance                = GL_SLUMINANCE,
+    ifSLuminance8               = GL_SLUMINANCE8,
+    ifDepth32fStencil8          = GL_DEPTH32F_STENCIL8,
+    ifStencil1                  = GL_STENCIL_INDEX1,
+    ifStencil4                  = GL_STENCIL_INDEX4,
+    ifStencil8                  = GL_STENCIL_INDEX8,
+    ifStencil16                 = GL_STENCIL_INDEX16);
+
+  TglcAttachment = (
+    atDepthStencil = GL_DEPTH_STENCIL_ATTACHMENT,
+    atColor0       = GL_COLOR_ATTACHMENT0,
+    atColor1       = GL_COLOR_ATTACHMENT1,
+    atColor2       = GL_COLOR_ATTACHMENT2,
+    atColor3       = GL_COLOR_ATTACHMENT3,
+    atColor4       = GL_COLOR_ATTACHMENT4,
+    atColor5       = GL_COLOR_ATTACHMENT5,
+    atColor6       = GL_COLOR_ATTACHMENT6,
+    atColor7       = GL_COLOR_ATTACHMENT7,
+    atColor8       = GL_COLOR_ATTACHMENT8,
+    atColor9       = GL_COLOR_ATTACHMENT9,
+    atColor10      = GL_COLOR_ATTACHMENT10,
+    atColor11      = GL_COLOR_ATTACHMENT11,
+    atColor12      = GL_COLOR_ATTACHMENT12,
+    atColor13      = GL_COLOR_ATTACHMENT13,
+    atColor14      = GL_COLOR_ATTACHMENT14,
+    atColor15      = GL_COLOR_ATTACHMENT15,
+    atDepth        = GL_DEPTH_ATTACHMENT,
+    atStencil      = GL_STENCIL_ATTACHMENT);
+
+  TglcShaderType = (
+    stFragment        = GL_FRAGMENT_SHADER,
+    stVertex          = GL_VERTEX_SHADER,
+    stGeometry        = GL_GEOMETRY_SHADER,
+    stTessEvaluation  = GL_TESS_EVALUATION_SHADER,
+    stTessControl     = GL_TESS_CONTROL_SHADER);
+
+  TglcBufferTarget = (
+    btArrayBuffer        = GL_ARRAY_BUFFER,
+    btElementArrayBuffer = GL_ELEMENT_ARRAY_BUFFER);
+
+  TglcBufferUsage = (
+    buStreamDraw  = GL_STREAM_DRAW,
+    buStreamRead  = GL_STREAM_READ,
+    buStreamCopy  = GL_STREAM_COPY,
+    buStaticDraw  = GL_STATIC_DRAW,
+    buStaticRead  = GL_STATIC_READ,
+    buStaticCopy  = GL_STATIC_COPY,
+    buDynamicDraw = GL_DYNAMIC_DRAW,
+    buDynamicRead = GL_DYNAMIC_READ,
+    buDynamicCopy = GL_DYNAMIC_COPY);
+
+  TglcBufferAccess = (
+    baReadOnly  = GL_READ_ONLY,
+    baWriteOnly = GL_WRITE_ONLY,
+    baReadWrite = GL_READ_WRITE);
+
+  EOpenGL = class(Exception)
+  private
+    fErrorCode: GLenum;
+  public
+    property ErrorCode: GLenum read fErrorCode;
+    constructor Create(const aErrorCode: GLenum);
+    constructor Create(const aMsg: String; const aErrorCode: GLenum);
+  end;
+
+procedure glcRenderFace(const aValue: TglcFace); inline;
+procedure glcPolygonMode(const aFace: TglcFace; const aValue: TglcPolygonMode); inline;
+procedure glcDepthFunc(const aValue: TglcDepthFunc); inline;
+procedure glcBlendFunc(const aSource, aDest: TglcBlendFactor); inline; overload;
+procedure glcBlendFunc(const aMode: TglcBlendMode); inline; overload;
+procedure glcCheckAndRaiseError;
+
+implementation
+
+type
+  TglcBlendModeValue = packed record
+    src, dst: TglcBlendFactor;
+  end;
+
+const
+  BLEND_MODE_VALUES: array[TglcBlendMode] of TglcBlendModeValue = (
+    (src: TglcBlendFactor.bfOne;         dst: TglcBlendFactor.bfZero),                        //bmNone
+    (src: TglcBlendFactor.bfSrcAlpha;    dst: TglcBlendFactor.bfOneMinusSrcAlpha),            //bmAlphaBlend
+    (src: TglcBlendFactor.bfSrcAlpha;    dst: TglcBlendFactor.bfOne),                         //bmAdditiveAlphaBlend
+    (src: TglcBlendFactor.bfOne;         dst: TglcBlendFactor.bfOne));                        //bmAdditiveBlend
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcRenderFace(const aValue: TglcFace);
+begin
+  case aValue of
+    TglcFace.faBoth: begin
+      glDisable(GL_CULL_FACE);
+    end;
+    TglcFace.faFront: begin
+      glEnable(GL_CULL_FACE);
+      glCullFace(GL_BACK);
+    end;
+    TglcFace.faBack: begin
+      glEnable(GL_CULL_FACE);
+      glCullFace(GL_FRONT);
+    end;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcPolygonMode(const aFace: TglcFace; const aValue: TglcPolygonMode);
+begin
+  glPolygonMode(GLenum(aFace), GLenum(aValue));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcDepthFunc(const aValue: TglcDepthFunc);
+begin
+  glDepthFunc(GLenum(aValue));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcBlendFunc(const aSource, aDest: TglcBlendFactor);
+begin
+  glBlendFunc(GLenum(aSource), GLenum(aDest));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcBlendFunc(const aMode: TglcBlendMode); overload;
+begin
+  glBlendFunc(GLenum(BLEND_MODE_VALUES[aMode].src), GLenum(BLEND_MODE_VALUES[aMode].dst));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+procedure glcCheckAndRaiseError;
+var
+  e: GLenum;
+begin
+  e := glGetError();
+  if (e <> GL_NO_ERROR) then
+    raise EOpenGL.Create(e);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//EOpenGL///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EOpenGL.Create(const aErrorCode: GLenum);
+begin
+  fErrorCode := aErrorCode;
+  inherited Create(gluErrorString(fErrorCode));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+constructor EOpenGL.Create(const aMsg: String; const aErrorCode: GLenum);
+begin
+  fErrorCode := aErrorCode;
+  inherited Create(aMsg + ': ' + gluErrorString(fErrorCode))
+end;
+
+end.
+

diff --git a/ugluMatrix.pas b/ugluMatrix.pas
new file mode 100644 (file)
index 0000000..1394a2d
--- /dev/null
+++ b/ugluMatrix.pas
@@ -0,0 +1,318 @@
+unit ugluMatrix;
+
+{ Package:      OpenGLCore
+  Prefix:       glu - OpenGL Utils
+  Beschreibung: diese Unit enthält Matrix-Typen und Methoden um diese zu erstellen und zu manipulieren }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, ugluVector;
+
+type
+  //Matrixtypen
+  TgluMatrix2ub = array[0..1] of TgluVector2ub;
+  TgluMatrix2i  = array[0..1] of TgluVector2i;
+  TgluMatrix2f  = array[0..1] of TgluVector2f;
+  TgluMatrix2d  = array[0..1] of TgluVector2d;
+
+  TgluMatrix3ub = array[0..2] of TgluVector3ub;
+  TgluMatrix3i  = array[0..2] of TgluVector3i;
+  TgluMatrix3f  = array[0..2] of TgluVector3f;
+  TgluMatrix3d  = array[0..2] of TgluVector3d;
+
+  TgluMatrix4ub = array[0..3] of TgluVector4ub;
+  TgluMatrix4i  = array[0..3] of TgluVector4i;
+  TgluMatrix4f  = array[0..3] of TgluVector4f;
+  TgluMatrix4d  = array[0..3] of TgluVector4d;
+
+  //MatrixPointer
+  PgluMatrix2ub = ^TgluMatrix2ub;
+  PgluMatrix2i  = ^TgluMatrix2i;
+  PgluMatrix2f  = ^TgluMatrix2f;
+  PgluMatrix2d  = ^TgluMatrix2d;
+
+  PgluMatrix3ub = ^TgluMatrix3ub;
+  PgluMatrix3i  = ^TgluMatrix3i;
+  PgluMatrix3f  = ^TgluMatrix3f;
+  PgluMatrix3d  = ^TgluMatrix3d;
+
+  PgluMatrix4ub = ^TgluMatrix4ub;
+  PgluMatrix4i  = ^TgluMatrix4i;
+  PgluMatrix4f  = ^TgluMatrix4f;
+  PgluMatrix4d  = ^TgluMatrix4d;
+
+  //Konstructoren
+  function gluMatrix4d(const m: TgluMatrix4f): TgluMatrix4d;
+
+  //Matrixfunktionen
+  function gluMatrixTranslate(const v: TgluVector3f): TgluMatrix4f;
+  function gluMatrixScale(const v: TgluVector3f): TgluMatrix4f; overload;
+  function gluMatrixScale(const s: Single): TgluMatrix4f; overload;
+  function gluMatrixRotate(axis: TgluVector3f; const angle: Single): TgluMatrix4f;
+  function gluMatrixMult(const m1, m2: TgluMatrix4f): TgluMatrix4f;
+  function gluMatrixMultVec(const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+  function gluMatrixTranspose(const m: TgluMatrix3f): TgluMatrix3f; overload;
+  function gluMatrixTranspose(const m: TgluMatrix4f): TgluMatrix4f; overload;
+  function gluMatrixSubMatrix(const m:TgluMatrix4f; const s, z: Integer): TgluMatrix3f;
+  function gluMatrixDeterminant(const m: TgluMatrix3f): Single; overload;
+  function gluMatrixDeterminant(const m: TgluMatrix4f): Single; overload;
+  function gluMatrixAdjoint(const m: TgluMatrix4f): TgluMatrix4f;
+  function gluMatrixInvert(const m: TgluMatrix4f): TgluMatrix4f;
+
+  operator * (const m1, m2: TgluMatrix4f): TgluMatrix4f;
+  operator * (const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+  operator * (const m: TgluMatrix4f; const v: TgluVector3f): TgluVector3f;
+
+const
+  maAxisX = 0;
+  maAxisY = 1;
+  maAxisZ = 2;
+  maPos   = 3;
+  gluMatrixIdentity: TgluMatrix4f = ((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1));
+
+implementation
+
+uses
+  Math;
+
+operator * (const m1, m2: TgluMatrix4f): TgluMatrix4f;
+begin
+  result := gluMatrixMult(m1, m2);
+end;
+
+operator * (const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+begin
+  result := gluMatrixMultVec(m, v);
+end;
+
+operator * (const m: TgluMatrix4f; const v: TgluVector3f): TgluVector3f;
+begin
+  result := gluVector3f(gluMatrixMultVec(m, gluVEctor4f(v, 1.0)));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluMatrix4d(const m: TgluMatrix4f): TgluMatrix4d;
+var
+  i, j: Integer;
+begin
+  for i := 0 to 3 do
+    for j := 0 to 3 do
+      result[i, j] := m[i, j];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt eine Translationsmatrix
+//@v: Vektor der Translationsmatrix;
+function gluMatrixTranslate(const v: TgluVector3f): TgluMatrix4f;
+var
+  i: Integer;
+begin
+  result := gluMatrixIdentity;
+  for i := 0 to 2 do
+    result[3, i] := v[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt eine Skalierungsmatrix
+//@v: Vektor der Skalierungsmatrix;
+function gluMatrixScale(const v: TgluVector3f): TgluMatrix4f;
+var
+  i: Integer;
+begin
+  result := gluMatrixIdentity;
+  for i := 0 to 2 do
+    result[i, i] := v[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluMatrixScale(const s: Single): TgluMatrix4f;
+var
+  i: Integer;
+begin
+  result := gluMatrixIdentity;
+  for i := 0 to 2 do
+    result[i, i] := s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt eine Rotationsmatrix;
+//@axis: Achse um die gedreht werden soll;
+//@angle: Winkel mit dem gedreht werden soll;
+function gluMatrixRotate(axis: TgluVector3f; const angle: Single): TgluMatrix4f;
+var
+  X, Y, Z, a, s, c: Single;
+begin
+  axis := gluVectorNormalize(axis);
+  X := axis[0];
+  Y := axis[1];
+  Z := axis[2];
+  a := angle/180*Pi;
+  s := sin(a);
+  c := cos(a);
+  result := gluMatrixIdentity;
+  result[maAxisX] := gluVector4f(
+    SQR(X) + (1-SQR(X))*c,
+    X*Y*(1-c) + Z*s,
+    X*Z*(1-c) - Y*s,
+    0);
+  result[maAxisY] := gluVector4f(
+    X*Y*(1-c) - Z*s,
+    SQR(Y) + (1-SQR(Y))*c,
+    Y*Z*(1-c) + X*s,
+    0);
+  result[maAxisZ] := gluVector4f(
+    X*Z*(1-c) + Y*s,
+    Y*Z*(1-c) - X*s,
+    SQR(Z) + (1-SQR(Z))*c,
+    0);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Mutlipliziert Matrix1 mit Matrix2
+//@Matrix1: 1. Multiplikator;
+//@Matrix2: 2. Multiplikator;
+//@result: Matrix1 * Matrix2
+function gluMatrixMult(const m1, m2: TgluMatrix4f): TgluMatrix4f;
+var
+  x, y, i: Integer;
+  sum: Single;
+begin
+  for x := 0 to 3 do begin
+    for y := 0 to 3 do begin
+      sum := 0;
+      for i := 0 to 3 do
+        sum := sum + m1[i, y] * m2[x, i];
+      result[x, y] := sum;
+    end;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Multiplizerit eine Matrix mit einem Vektor
+//@m: Matrix mit der multipliziert werden soll;
+//@v: Vektor mit dem multipliziert werden soll;
+//@result: Ergebnis der Multiplikation
+function gluMatrixMultVec(const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
+var
+  i, j: Integer;
+  sum: Single;
+begin
+  for i := 0 to 3 do begin
+    sum := 0;
+    for j := 0 to 3 do
+      sum := sum + m[j,i] * v[j];
+    result[i] := sum;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Transponierte Matrix
+//@m: Matrix die Transponiert werden soll;
+//@result: Transponierte Matrix;
+function gluMatrixTranspose(const m: TgluMatrix3f): TgluMatrix3f;
+var
+  i, j: Integer;
+begin
+  for i := 0 to 2 do
+    for j := 0 to 2 do
+      result[i, j] := m[j, i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Transponierte Matrix
+//@m: Matrix die Transponiert werden soll;
+//@result: Transponierte Matrix;
+function gluMatrixTranspose(const m: TgluMatrix4f): TgluMatrix4f;
+var
+  i, j: Integer;
+begin
+  for i := 0 to 3 do
+    for j := 0 to 3 do
+      result[i, j] := m[j, i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ermittelt die Untermatrix einer Matrix
+//@m: Matrix derren Untermatrix berechnet werden soll;
+//@s: Spalte die gelöscht werden soll;
+//@z: Zeile die gelöscht werden soll;
+//@result: Untermatrix von m
+function gluMatrixSubMatrix(const m: TgluMatrix4f; const s, z: Integer): TgluMatrix3f;
+var
+  x, y, i, j: Integer;
+begin
+  for i := 0 to 2 do
+    for j := 0 to 2 do begin
+      x := i;
+      y := j;
+      if (i >= s) then
+        inc(x);
+      if (j >= z) then
+        inc(y);
+      result[i, j] := m[x, y];
+    end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Determinante einer Matrix
+//@m: Matrix derren Determinaten berechnet werden soll;
+//@result: Determinante von m
+function gluMatrixDeterminant(const m: TgluMatrix3f): Single;
+begin
+  result :=
+    m[0,0] * m[1,1] * m[2,2] +
+    m[1,0] * m[2,1] * m[0,2] +
+    m[2,0] * m[0,1] * m[1,2] -
+    m[2,0] * m[1,1] * m[0,2] -
+    m[1,0] * m[0,1] * m[2,2] -
+    m[0,0] * m[2,1] * m[1,2];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Determinante einer Matrix
+//@m: Matrix derren Determinaten berechnet werden soll;
+//@result: Determinante von m
+function gluMatrixDeterminant(const m: TgluMatrix4f): Single;
+var
+  i: Integer;
+begin
+  result := 0;
+  for i := 0 to 3 do
+    result := result + power(-1, i) * m[i, 0] * gluMatrixDeterminant(gluMatrixSubMatrix(m, i, 0));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Adjunkte einer Matrix
+//@m: Matrix derren Adjunkte berechnet werden soll;
+//@result: Adjunkte von m
+function gluMatrixAdjoint(const m: TgluMatrix4f): TgluMatrix4f;
+var
+  i, j: Integer;
+begin
+  for i := 0 to 3 do
+    for j := 0 to 3 do
+      result[i, j] := power(-1, i+j) * gluMatrixDeterminant(gluMatrixSubMatrix(m, i, j));
+  result := gluMatrixTranspose(result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die inverse Matrix einer Matrix
+//@m: Matrix derren Inverse berechnet werden soll;
+//@result: Inverse Matrix von m;
+function gluMatrixInvert(const m: TgluMatrix4f): TgluMatrix4f;
+var
+  d: Single;
+  i, j: Integer;
+begin
+  d := gluMatrixDeterminant(m);
+  result := gluMatrixAdjoint(m);
+  for i := 0 to 3 do
+    for j := 0 to 3 do
+      result[i,j] := result[i,j] / d;
+end;
+
+end.
+

diff --git a/ugluQuaternion.pas b/ugluQuaternion.pas
new file mode 100644 (file)
index 0000000..b806282
--- /dev/null
+++ b/ugluQuaternion.pas
@@ -0,0 +1,384 @@
+unit ugluQuaternion;
+
+{ Package:      OpenGLCore
+  Prefix:       glu - OpenGL Utils
+  Beschreibung: diese Unit enthält Quaternion-Typen und Methoden um diese zu erstellen und zu manipulieren }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, ugluVector, ugluMatrix;
+
+type
+  TgluQuaternion = type TgluVector4f; // w,x,y,z
+
+{
+   Winkel                           : rad, außer glRotate-Komponenten
+   Absolute Werte                   : Orientation
+   Relative Werte/"Drehanweisungen" : Rotation
+   To/FromVector                    : Position im R^4
+
+   Alle Funktionen nehmen an, dass die Quaternion nur zur Rotation verwendet wird (kein Scale),
+   mathematisch also normalisiert ist. Es findet keine Überprüfung statt.
+}
+
+  //Quaternion Konstruktoren
+  function gluQuaternion(const W, X, Y, Z: Single): TgluQuaternion;
+  function gluQuaternionNormalize(const q: TgluQuaternion): TgluQuaternion;
+  procedure gluQuaternionNormalizeInplace(var q: TgluQuaternion);
+  function gluQuaternionToVector(const q: TgluQuaternion): TgluVector3f;
+  function gluVectorToQuaternion(const v: TgluVector3f): TgluQuaternion;
+
+  //Arithmetic
+  function gluQuaternionConjugate(const q: TgluQuaternion): TgluQuaternion;
+  function gluQuaternionMultiply(const l,r: TgluQuaternion): TgluQuaternion;
+  function gluQuaternionAdd(const a,b: TgluQuaternion): TgluQuaternion;
+  function gluQuaternionSubtract(const l,r: TgluQuaternion): TgluQuaternion;
+  function gluQuaternionScale(const q: TgluQuaternion; const f: Single): TgluQuaternion;
+
+
+  //To/From RotationMatrix
+  function gluQuaternionToMatrix(const q: TgluQuaternion): TgluMatrix4f;
+  function gluMatrixToQuaternion(const m: TgluMatrix4f): TgluQuaternion;
+
+  //To/From Axis/Angle {WINKEL IN °DEG}
+  function gluQuaternionToRotation(const q: TgluQuaternion; out angle: Single): TgluVector3f;
+  function gluRotationToQuaternion(const angle: Single; const axis: TgluVector3f): TgluQuaternion;
+
+  //Transforms
+  function gluQuaternionTransformVec(const q: TgluQuaternion; const v: TgluVector3f): TgluVector3f;
+
+  function gluQuaternionLookAt(const Location, Target, UpVector: TgluVector3f): TgluQuaternion;
+  //Rotation zw. Richtungen: Wie muss a modifiziert werden um b zu bekommen?
+  function gluVectorRotationTo(const a, b: TgluVector3f): TgluQuaternion;
+
+  //Modifying Quaternions
+  function gluQuaternionHalfAngle(const q: TgluQuaternion): TgluQuaternion;
+  function gluQuaternionAngleBetween(const a, b: TgluQuaternion): double;
+  function gluQuaternionSlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+  function gluQuaternionNlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+
+  operator +(const a, b: TgluQuaternion): TgluQuaternion;
+  operator -(const l, r: TgluQuaternion): TgluQuaternion;
+  operator *(const l, r: TgluQuaternion): TgluQuaternion;
+  operator *(const q: TgluQuaternion; const s: Single): TgluQuaternion;
+
+const
+  quW = 0;
+  quX = 1;
+  quY = 2;
+  quZ = 3;
+  gluQuaternionIdentity: TgluQuaternion = (1,0,0,0);
+
+implementation
+
+uses
+  Math;
+
+operator +(const a, b: TgluQuaternion): TgluQuaternion;
+begin
+  result := gluQuaternionAdd(a, b);
+end;
+
+operator -(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+  result := gluQuaternionSubtract(l, r);
+end;
+
+operator *(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+  result := gluQuaternionMultiply(l, r);
+end;
+
+operator *(const q: TgluQuaternion; const s: Single): TgluQuaternion;
+begin
+  result := gluQuaternionScale(q, s);
+end;
+
+function gluQuaternion(const W, X, Y, Z: Single): TgluQuaternion;
+begin
+  Result:= gluVector4f(W,X,Y,Z);
+end;
+
+function gluQuaternionNormalize(const q: TgluQuaternion): TgluQuaternion;
+begin
+  Result:= q;
+  gluQuaternionNormalizeInplace(Result);
+end;
+
+procedure gluQuaternionNormalizeInplace(var q: TgluQuaternion);
+var
+  s: Double;
+begin
+  s:= sqr(q[quX])+sqr(q[quY])+sqr(q[quZ])+sqr(q[quW]);
+  // already normalized?
+  if IsZero(s - 1) then
+    exit;
+  s:= 1/sqrt(s);
+  q[quX]:= q[quX] * s;
+  q[quY]:= q[quY] * s;
+  q[quZ]:= q[quZ] * s;
+  q[quW]:= q[quW] * s;
+end;
+
+function gluQuaternionToVector(const q: TgluQuaternion): TgluVector3f;
+begin
+  Result:= gluVector3f(q[quX], q[quY], q[quZ]);
+end;
+
+function gluVectorToQuaternion(const v: TgluVector3f): TgluQuaternion;
+begin
+  Result:= gluQuaternion(0, v[0], v[1], v[2]);
+end;
+
+
+function gluQuaternionConjugate(const q: TgluQuaternion): TgluQuaternion;
+begin
+  Result[quW] := q[quW];
+  Result[quX] := -q[quX];
+  Result[quY] := -q[quY];
+  Result[quZ] := -q[quZ];
+end;
+
+function gluQuaternionMultiply(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+  Result[quW] := -l[qux] * r[qux] - l[quy] * r[quy] - l[quz] * r[quz] + l[quw] * r[quw];
+  Result[quX] :=  l[qux] * r[quw] + l[quy] * r[quz] - l[quz] * r[quy] + l[quw] * r[qux];
+  Result[quY] := -l[qux] * r[quz] + l[quy] * r[quw] + l[quz] * r[qux] + l[quw] * r[quy];
+  Result[quZ] :=  l[qux] * r[quy] - l[quy] * r[qux] + l[quz] * r[quw] + l[quw] * r[quz];
+end;
+
+function gluQuaternionAdd(const a, b: TgluQuaternion): TgluQuaternion;
+begin
+  Result[quW] := a[quW] + b[quW];
+  Result[quX] := a[quX] + b[quX];
+  Result[quY] := a[quY] + b[quY];
+  Result[quZ] := a[quZ] + b[quZ];
+end;
+
+function gluQuaternionSubtract(const l, r: TgluQuaternion): TgluQuaternion;
+begin
+  Result[quW] := l[quW] - r[quW];
+  Result[quX] := l[quX] - r[quX];
+  Result[quY] := l[quY] - r[quY];
+  Result[quZ] := l[quZ] - r[quZ];
+end;
+
+function gluQuaternionScale(const q: TgluQuaternion; const f: Single): TgluQuaternion;
+begin
+  Result[quW] := q[quW] * f;
+  Result[quX] := q[quX] * f;
+  Result[quY] := q[quY] * f;
+  Result[quZ] := q[quZ] * f;
+end;
+
+// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToMatrix/index.htm
+function gluQuaternionToMatrix(const q: TgluQuaternion): TgluMatrix4f;
+var
+  qx,qy,qz,qw: Single;
+begin
+  qw:= q[quW];
+  qx:= q[quX];
+  qy:= q[quY];
+  qz:= q[quZ];
+  Result:= gluMatrixIdentity;
+  Result[maAxisX] := gluVector4f(
+    1 - 2*SQR(qy) - 2*SQR(qz),
+    2*qx*qy + 2*qz*qw,
+    2*qx*qz - 2*qy*qw,
+    0);
+  Result[maAxisY] := gluVector4f(
+    2*qx*qy - 2*qz*qw,
+    1 - 2*SQR(qx) - 2*SQR(qz),
+    2*qy*qz + 2*qx*qw,
+    0);
+  Result[maAxisZ] := gluVector4f(
+    2*qx*qz + 2*qy*qw,
+    2*qy*qz - 2*qx*qw,
+       1 - 2*SQR(qx) - 2*SQR(qy),
+    0);
+end;
+
+// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+function gluMatrixToQuaternion(const m: TgluMatrix4f): TgluQuaternion;
+var
+  trace, s: double;
+  q: TgluQuaternion;
+
+begin
+  trace := m[0][0] + m[1][1] + m[2][2]; // I removed + 1.0f; see discussion with Ethan
+  if( trace > 0 ) then begin// I changed M_EPSILON to 0
+    s := 0.5 / SQRT(trace+ 1.0);
+    q[quW] := 0.25 / s;
+    q[quX] := ( m[2][1] - m[1][2] ) * s;
+    q[quY] := ( m[0][2] - m[2][0] ) * s;
+    q[quZ] := ( m[1][0] - m[0][1] ) * s;
+  end else begin
+    if ( m[0][0] > m[1][1]) and (m[0][0] > m[2][2] ) then begin
+      s := 2.0 * SQRT( 1.0 + m[0][0] - m[1][1] - m[2][2]);
+      q[quW] := (m[2][1] - m[1][2] ) / s;
+      q[quX] := 0.25 * s;
+      q[quY] := (m[0][1] + m[1][0] ) / s;
+      q[quZ] := (m[0][2] + m[2][0] ) / s;
+    end else if (m[1][1] > m[2][2]) then begin
+      s := 2.0 * SQRT( 1.0 + m[1][1] - m[0][0] - m[2][2]);
+      q[quW] := (m[0][2] - m[2][0] ) / s;
+      q[quX] := (m[0][1] + m[1][0] ) / s;
+      q[quY] := 0.25 * s;
+      q[quZ] := (m[1][2] + m[2][1] ) / s;
+    end else begin
+      s := 2.0 * SQRT( 1.0 + m[2][2] - m[0][0] - m[1][1] );
+      q[quW] := (m[1][0] - m[0][1] ) / s;
+      q[quX] := (m[0][2] + m[2][0] ) / s;
+      q[quY] := (m[1][2] + m[2][1] ) / s;
+      q[quZ] := 0.25 * s;
+    end;
+  end;
+  Result:= q;
+end;
+
+// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
+function gluQuaternionToRotation(const q: TgluQuaternion; out angle: Single): TgluVector3f;
+var
+  s: double;
+begin
+  angle := radtodeg(2 * arccos(q[quW]));
+  s := sqrt(1-q[quW]*q[quW]); // assuming quaternion normalised then w is less than 1, so term always positive.
+  if (s < 0.001) then begin // test to avoid divide by zero, s is always positive due to sqrt
+    // if s close to zero then direction of axis not important
+    Result[0] := q[quX]; // if it is important that axis is normalised then replace with x=1; y=z=0;
+    Result[1] := q[quY];
+    Result[2] := q[quZ];
+  end else begin
+    Result[0] := q[quX] / s; // normalise axis
+    Result[1] := q[quY] / s;
+    Result[2] := q[quZ] / s;
+  end;
+end;
+
+function gluRotationToQuaternion(const angle: Single; const axis: TgluVector3f): TgluQuaternion;
+var
+  a: single;
+begin
+  a:= degtorad(angle) / 2;
+  Result:= gluQuaternion(
+    cos(a),
+    sin(a) * axis[0],
+    sin(a) * axis[1],
+    sin(a) * axis[2]);
+end;
+
+// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/index.htm
+function gluQuaternionTransformVec(const q: TgluQuaternion; const v: TgluVector3f): TgluVector3f;
+var
+  p: TgluQuaternion;
+begin
+  //Pout = q * Pin * q'
+  p:= gluQuaternionMultiply(q, gluVectorToQuaternion(v));
+  p:= gluQuaternionMultiply(p, gluQuaternionConjugate(q));
+  Result:= gluQuaternionToVector(p);
+end;
+
+// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/transforms/halfAngle.htm
+function gluQuaternionHalfAngle(const q: TgluQuaternion): TgluQuaternion;
+begin
+  Result:= q;
+  Result[quW]:= Result[quW] + 1;
+  gluQuaternionNormalizeInplace(Result);
+end;
+
+function gluQuaternionAngleBetween(const a, b: TgluQuaternion): double;
+var
+  cosHalfTheta: double;
+begin
+  cosHalfTheta:= a[quW] * b[quW] + a[quX] * b[quX] + a[quY] * b[quY] + a[quZ] * b[quZ];
+  Result:= arccos(cosHalfTheta) * 2;
+end;
+
+// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/index.htm
+function gluQuaternionSlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+var
+  qa,qb: TgluQuaternion;
+  cosHalfTheta, sinHalfTheta,
+    halfTheta,
+    ratioA, ratioB: double;
+begin
+  qa:= a;
+  qb:= b;
+       // Calculate angle between them.
+  cosHalfTheta:= a[quW] * b[quW] + a[quX] * b[quX] + a[quY] * b[quY] + a[quZ] * b[quZ];
+  if (cosHalfTheta < 0) then begin
+    qb:= gluQuaternion(
+      -b[quW],
+      -b[quX],
+      -b[quY],
+       b[quZ]
+    );
+    cosHalfTheta:= -cosHalfTheta;
+  end;
+
+  // if qa=qb or qa=-qb then theta = 0 and we can return qa
+       if abs(cosHalfTheta) >= 1.0 then begin
+               Result:= qa;
+    Exit;
+       end;
+
+       // Calculate temporary values.
+       halfTheta := arccos(cosHalfTheta);
+       sinHalfTheta := sqrt(1.0 - sqr(cosHalfTheta));
+       // if theta = 180 degrees then result is not fully defined
+       // we could rotate around any axis normal to qa or qb
+       if (abs(sinHalfTheta) < 0.001) then begin
+    Result:= gluQuaternionAdd(gluQuaternionScale(qa, 0.5), gluQuaternionScale(qb, 0.5));
+    exit
+  end;
+       ratioA := sin((1 - t) * halfTheta) / sinHalfTheta;
+       ratioB := sin(t * halfTheta) / sinHalfTheta;
+       //calculate Quaternion.
+  Result:= gluQuaternionAdd(gluQuaternionScale(qa, ratioA), gluQuaternionScale(qb, ratioB));
+end;
+
+function gluQuaternionNlerpOrientation(const a, b: TgluQuaternion; const t: single): TgluQuaternion;
+begin
+  Result:= gluQuaternionAdd(a, gluQuaternionScale(gluQuaternionSubtract(b,a), t));
+  gluQuaternionNormalizeInplace(Result);
+end;
+
+function gluQuaternionLookAt(const Location, Target, UpVector: TgluVector3f): TgluQuaternion;
+var
+  front, up, right: TgluVector3f;
+  w4_recip: Single;
+begin
+  front:= gluVectorSubtract(Location, Target); // eigentlich falschrum. don't ask.
+  up:= UpVector;
+  gluVectorOrthoNormalize(front, up);
+  right:= gluVectorProduct(up, front);
+
+  Result[quW]:= SQRT(1 + right[0] + up[1] + front[2]) * 0.5;
+  w4_recip:= 1 / (4 * Result[quW]);
+
+  Result[quX]:= (front[1] - up[2]) * w4_recip;
+       Result[quY]:= (right[2] - front[0]) * w4_recip;
+       Result[quZ]:= (up[0] - right[1]) * w4_recip;
+end;
+
+function gluVectorRotationTo(const a, b: TgluVector3f): TgluQuaternion;
+var
+  d, qw: single;
+  ax: TgluVector3f;
+begin
+  d:=gluVectorScalar(a, b);
+  ax:= gluVectorProduct(a, b);
+  qw:= gluVectorLength(a) * gluVectorLength(b) + d;
+       if (qw < 0.0001) then begin // vectors are 180 degrees apart
+    Result:= gluQuaternion(0, -a[2],a[1],a[0]);
+  end else begin
+    Result:= gluQuaternion(qw, ax[0],ax[1],ax[2]);
+  end;
+  gluQuaternionNormalizeInplace(Result);
+end;
+
+end.
+

diff --git a/ugluVector.pas b/ugluVector.pas
new file mode 100644 (file)
index 0000000..23d4680
--- /dev/null
+++ b/ugluVector.pas
@@ -0,0 +1,1193 @@
+unit ugluVector;
+
+{ Package:      OpenGLCore
+  Prefix:       glu - OpenGL Utils
+  Beschreibung: diese Unit enthält Vektor-Typen und Methoden um diese zu erstellen und zu manipulieren }
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, dglOpenGL;
+
+type
+  //Vektortypen
+  TgluVector2ub = TGLVectorub2;
+  TgluVector3ub = TGLVectorub3;
+  TgluVector4ub = TGLVectorub4;
+
+  TgluVector2i = TGLVectori2;
+  TgluVector3i = TGLVectori3;
+  TgluVector4i = TGLVectori4;
+
+  TgluVector2e = array[0..1] of GLenum;
+  TgluVector3e = array[0..2] of GLenum;
+  TgluVector4e = array[0..3] of GLenum;
+
+  TgluVector2f = TGLVectorf2;
+  TgluVector3f = TGLVectorf3;
+  TgluVector4f = TGLVectorf4;
+
+  TgluVector2d = TGLVectord2;
+  TgluVector3d = TGLVectord3;
+  TgluVector4d = TGLVectord4;
+
+  TgluVector2p = TGLVectorp2;
+  TgluVector3p = TGLVectorp3;
+  TgluVector4p = TGLVectorp4;
+
+  TgluPlanef = TgluVector4f;
+
+  TgluVector3fArr8 = array[0..7] of TgluVector4f;
+  TgluRayf = packed record
+    p, v: TgluVector3f;
+  end;
+
+  TgluRecord2ub = packed record
+    case Integer of
+      0: (x, y: gluByte);
+      1: (s, t: gluByte);
+      2: (u, v: gluByte);
+      3: (vec: TgluVector2ub);
+  end;
+  TgluRecord3ub = packed record
+    case Integer of
+      0: (x, y, z: gluByte);
+      1: (r, g, b: gluByte);
+      2: (u, v, w: gluByte);
+      3: (vec: TgluVector3ub);
+  end;
+  TgluRecord4ub = packed record
+    case Integer of
+      0: (x, y, z, w: gluByte);
+      1: (r, g, b, a: gluByte);
+      2: (vec: TgluVector4ub);
+  end;
+
+  TgluRecord2i = packed record
+    case Integer of
+      0: (x, y: glInt);
+      1: (s, t: glInt);
+      2: (u, v: glInt);
+      3: (vec: TgluVector2i);
+  end;
+  TgluRecord3i = packed record
+    case Integer of
+      0: (x, y, z: glInt);
+      1: (r, g, b: glInt);
+      2: (u, v, w: glInt);
+      3: (vec: TgluVector3i);
+  end;
+  TgluRecord4i = packed record
+    case Integer of
+      0: (x, y, z, w: glInt);
+      1: (r, g, b, a: glInt);
+      2: (vec: TgluVector4i);
+  end;
+
+  TgluRecord2f = packed record
+    case Integer of
+      0: (x, y: glFloat);
+      1: (s, t: glFloat);
+      2: (u, v: glFloat);
+      3: (vec: TgluVector2f);
+  end;
+  TgluRecord3f = packed record
+    case Integer of
+      0: (x, y, z: glFloat);
+      1: (r, g, b: glFloat);
+      2: (u, v, w: glFloat);
+      3: (vec: TgluVector3f);
+  end;
+  TgluRecord4f = packed record
+    case Integer of
+      0: (x, y, z, w: glFloat);
+      1: (r, g, b, a: glFloat);
+      2: (vec4: TgluVector4f);
+      3: (vec3: TgluVector3f);
+  end;
+
+  TgluRecord2d = packed record
+    case Integer of
+      0: (x, y: glDouble);
+      1: (s, t: glDouble);
+      2: (u, v: glDouble);
+      3: (vec: TgluVector2d);
+  end;
+  TgluRecord3d = packed record
+    case Integer of
+      0: (x, y, z: glDouble);
+      1: (r, g, b: glDouble);
+      2: (u, v, w: glDouble);
+      3: (vec: TgluVector3d);
+  end;
+  TgluRecord4d = packed record
+    case Integer of
+      0: (x, y, z, w: glDouble);
+      1: (r, g, b, a: glDouble);
+      2: (vec: TgluVector4d);
+  end;
+
+  //VectorPointer
+  PgluVector2i = ^TgluVector2i;
+  PgluVector3i = ^TgluVector3i;
+  PgluVector4i = ^TgluVector4i;
+
+  PgluVector2e = ^TgluVector2e;
+  PgluVector3e = ^TgluVector3e;
+  PgluVector4e = ^TgluVector4e;
+
+  PgluVector2ub = ^TgluVector2ub;
+  PgluVector3ub = ^TgluVector3ub;
+  PgluVector4ub = ^TgluVector4ub;
+
+  PgluVector2f = ^TgluVector2f;
+  PgluVector3f = ^TgluVector3f;
+  PgluVector4f = ^TgluVector4f;
+
+  PgluVector2d = ^TgluVector2d;
+  PgluVector3d = ^TgluVector3d;
+  PgluVector4d = ^TgluVector4d;
+
+  PgluVector2p = ^TgluVector2p;
+  PgluVector3p = ^TgluVector3p;
+  PgluVector4p = ^TgluVector4p;
+
+  TVectorColor = -$7FFFFFFF-1..$7FFFFFFF;
+
+  //Stream: Lese- und Schreibfunktionen
+  procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
+  procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
+  procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
+  function  gluVector2fRead(const aStream: TStream): TgluVector2f;
+  function  gluVector3fRead(const aStream: TStream): TgluVector3f;
+  function  gluVector4fRead(const aStream: TStream): TgluVector4f;
+
+  //Vektor Konstruktoren
+  function gluVector4f(const X, Y, Z, W: Single): TgluVector4f;
+  function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
+  function gluVector4d(const X, Y, Z, W: Single): TgluVector4d;
+  function gluVector3f(const X, Y, Z: Single): TgluVector3f; overload;
+  function gluVector3f(const v: TgluVector4f): TgluVector3f; overload;
+  function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f; overload;
+  function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f; overload;
+  function gluVector2f(const X, Y: Single): TgluVector2f;
+  function gluVector2f(const v3: TgluVector3f): TgluVector2f;
+  function gluVector2f(const v4: TgluVector4f): TgluVector2f;
+  function gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
+  function gluVector2i(const X, Y: Integer): TgluVector2i;
+  function gluVector2e(const X, Y: GLenum): TgluVector2e;
+  function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
+  function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;
+
+  //Vektorfunktionen
+  function gluVectorNormalize(const v: TgluVector4f): TgluVector4f; overload;
+  function gluVectorNormalize(const v: TgluVector3f): TgluVector3f; overload;
+  function gluVectorNormalize(const v: TgluVector2f): TgluVector2f; overload;
+  function gluVectorLength(const v: TgluVector3f): Single; overload;
+  function gluVectorLength(const v: TgluVector2f): Single; overload;
+  function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
+  function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
+  function gluVectorScalar(const v1, v2: TgluVector3f): Single; overload;
+  function gluVectorScalar(const v1, v2: TgluVector2f): Single; overload;
+  function gluVectorAngle(const v1, v2: TgluVector3f): Single; overload;
+  function gluVectorAngle(const v1, v2: TgluVector2f): Single; overload;
+  function gluVectorEquals(const v1, v2: TgluVector2f): Boolean; overload;
+  function gluVectorEquals(const v1, v2: TgluVector3f): Boolean; overload;
+  function gluVectorEquals(const v1, v2: TgluVector4f): Boolean; overload;
+  function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
+  function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
+  function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
+  function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
+  function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f; overload;
+  function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f; overload;
+  function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
+  function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
+  procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
+  function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;
+
+  //Ebnenfunktionen
+  function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
+  function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
+  function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
+  function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;
+
+  //Rayfunktionen
+  function gluRayf(const p, v: TgluVector3f): TgluRayf;
+  function gluRayNormalize(const r: TgluRayf): TgluRayf;
+  function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;
+
+  //Vektor Aus- und Eingaben
+  function gluVector4fToStr(const v: TgluVector4f; const round: Integer = 3): String;
+  function gluVector3fToStr(const v: TgluVector3f; const round: Integer = 3): String;
+  function gluVector2fToStr(const v: TgluVector2f; const round: Integer = 3): String;
+  function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
+  function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
+  function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
+  function gluStrToVector4f(str: String): TgluVector4f;
+  function gluStrToVector3f(str: String): TgluVector3f;
+  function gluStrToVector2f(str: String): TgluVector2f;
+  function gluVector4iToStr(const v: TgluVector4i): String;
+  function gluVector3iToStr(const v: TgluVector3i): String;
+  function gluVector2iToStr(const v: TgluVector2i): String;
+  function gluStrToVector4i(const str: String): TgluVector4i;
+  function gluStrToVector3i(const str: String): TgluVector3i;
+  function gluStrToVector2i(const str: String): TgluVector2i;
+  function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
+  function gluVectorToColor(const v: TgluVector3f): TVectorColor; overload;
+  function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
+  function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
+  function gluVectorHSVColor(v: TgluVector3f): TgluVector3f; overload;
+  function gluVectorHSVColor(v: TgluVector4f): TgluVector4f; overload;
+
+  operator >< (const v1, v2: TgluVector3f): TgluVector3f; inline;
+
+  operator * (const v1, v2: TgluVector4f): Single; inline; overload;
+  operator * (const v1, v2: TgluVector3f): Single; inline; overload;
+  operator * (const v1, v2: TgluVector2f): Single; inline; overload;
+
+  operator * (const v: TgluVector2f; const s: Single): TgluVector2f; inline; overload;
+  operator * (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;
+  operator * (const v: TgluVector4f; const s: Single): TgluVector4f; inline; overload;
+
+  operator * (const s: Single; const v: TgluVector2f): TgluVector2f; inline; overload;
+  operator * (const s: Single; const v: TgluVector3f): TgluVector3f; inline; overload;
+  operator * (const s: Single; const v: TgluVector4f): TgluVector4f; inline; overload;
+
+  operator / (const v: TgluVector3f; const s: Single): TgluVector3f; inline; overload;
+
+  operator = (const v1, v2: TgluVector2f): Boolean; inline; overload;
+  operator = (const v1, v2: TgluVector3f): Boolean; inline; overload;
+  operator = (const v1, v2: TgluVector4f): Boolean; inline; overload;
+
+  operator + (const v1, v2: TgluVector3f): TgluVector3f; inline;
+  operator - (const v1, v2: TgluVector3f): TgluVector3f; inline;
+
+const
+  gluVectorNull : TgluVector3f = (0,0,0);
+  gluVectorUnitX: TgluVector3f = (1,0,0);
+  gluVectorUnitY: TgluVector3f = (0,1,0);
+  gluVectorUnitZ: TgluVector3f = (0,0,1);
+
+implementation
+
+uses
+  Math;
+
+operator >< (const v1, v2: TgluVector3f): TgluVector3f;
+begin
+  result := gluVectorProduct(v1, v2);
+end;
+
+operator * (const v1, v2: TgluVector4f): Single;
+begin
+  result := gluVectorScalar(v1, v2);
+end;
+
+operator * (const v1, v2: TgluVector3f): Single;
+begin
+  result := gluVectorScalar(v1, v2);
+end;
+
+operator * (const v1, v2: TgluVector2f): Single;
+begin
+  result := gluVectorScalar(v1, v2);
+end;
+
+operator * (const v: TgluVector2f; const s: Single): TgluVector2f;
+begin
+  result := gluVectorMult(v, s);
+end;
+
+operator * (const v: TgluVector3f; const s: Single): TgluVector3f;
+begin
+  result := gluVectorMult(v, s);
+end;
+
+operator * (const v: TgluVector4f; const s: Single): TgluVector4f;
+begin
+  result := gluVectorMult(v, s);
+end;
+
+operator * (const s: Single; const v: TgluVector2f): TgluVector2f;
+begin
+  result := gluVectorMult(v, s);
+end;
+
+operator * (const s: Single; const v: TgluVector3f): TgluVector3f;
+begin
+  result := gluVectorMult(v, s);
+end;
+
+operator * (const s: Single; const v: TgluVector4f): TgluVector4f;
+begin
+  result := gluVectorMult(v, s);
+end;
+
+operator / (const v: TgluVector3f; const s: Single): TgluVector3f;
+begin
+  result := gluVectorDivide(v, s);
+end;
+
+operator = (const v1, v2: TgluVector2f): Boolean;
+begin
+  result := gluVectorEquals(v1, v2);
+end;
+
+operator = (const v1, v2: TgluVector3f): Boolean;
+begin
+  result := gluVectorEquals(v1, v2);
+end;
+
+operator = (const v1, v2: TgluVector4f): Boolean;
+begin
+  result := gluVectorEquals(v1, v2);
+end;
+
+operator + (const v1, v2: TgluVector3f): TgluVector3f;
+begin
+  result := gluVectorAdd(v1, v2);
+end;
+
+operator - (const v1, v2: TgluVector3f): TgluVector3f;
+begin
+  result := gluVectorSubtract(v1, v2);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//speichert einen Vector in einem Stream
+//@vec: Vector die gespeichert werden soll;
+//@aStream: Stream in dem gespeichert werden soll;
+procedure gluVector2fWrite(const vec: TgluVector2f; const aStream: TStream);
+begin
+  aStream.Write(vec[0], SizeOf(vec));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//speichert einen Vector in einem Stream
+//@vec: Vector die gespeichert werden soll;
+//@aStream: Stream in dem gespeichert werden soll;
+procedure gluVector3fWrite(const vec: TgluVector3f; const aStream: TStream);
+begin
+  aStream.Write(vec[0], SizeOf(vec));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//speichert einen Vector in einem Stream
+//@vec: Vector die gespeichert werden soll;
+//@aStream: Stream in dem gespeichert werden soll;
+procedure gluVector4fWrite(const vec: TgluVector4f; const aStream: TStream);
+begin
+  aStream.Write(vec[0], SizeOf(vec));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ließt einen Vector aus einem Stream
+//@aStream: Stream aus dem gelesen werden soll;
+//@result: gelesene Werte des Vectors;
+//@throw: Exception;
+function  gluVector2fRead(const aStream: TStream): TgluVector2f;
+begin
+  if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
+    raise Exception.Create('gluVector2fRead - unexpected stream size');
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ließt einen Vector aus einem Stream
+//@aStream: Stream aus dem gelesen werden soll;
+//@result: gelesene Werte des Vectors;
+//@throw: Exception;
+function gluVector3fRead(const aStream: TStream): TgluVector3f;
+begin
+  if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
+    raise Exception.Create('gluVector3fRead - unexpected stream size');
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//ließt einen Vector aus einem Stream
+//@aStream: Stream aus dem gelesen werden soll;
+//@result: gelesene Werte des Vectors;
+//@throw: Exception;
+function gluVector4fRead(const aStream: TStream): TgluVector4f;
+begin
+  if aStream.Read(result{%H-}, SizeOf(result)) < SizeOf(result) then
+    raise Exception.Create('gluVector4fRead - unexpected stream size');
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function gluVector4f(const X,Y,Z,W: Single): TgluVector4f;
+begin
+  result[0] := X;
+  result[1] := Y;
+  result[2] := Z;
+  result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector4f(const aVec: TgluVector3f; const W: Single): TgluVector4f;
+begin
+  PgluVector3f(@result[0])^ := aVec;
+  result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function gluVector4d(const X,Y,Z,W: Single): TgluVector4d;
+begin
+  result[0] := X;
+  result[1] := Y;
+  result[2] := Z;
+  result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@X: 1. Wert im Vector;
+//@Y: 2. Wert im Vector;
+//@Z: 3. Wert im Vector;
+function gluVector3f(const X,Y,Z: Single): TgluVector3f;
+begin
+  result[0] := X;
+  result[1] := Y;
+  result[2] := Z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@v: 4-Komponenten Vektor aus dem der Vektor erstellt werden soll;
+function gluVector3f(const v: TgluVector4f): TgluVector3f;
+begin
+  result := PgluVector3f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector3f(const v: TgluVector2f; const z: Single): TgluVector3f;
+begin
+  result[0] := v[0];
+  result[1] := v[1];
+  result[2] := z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erzeugt einen Vektor aus 2 Punkten
+//@p1: Punkt 1;
+//@p2: Punkt 2;
+//@result: Vektor zwischen den Punkten
+function gluVector3f(const p1, p2: TgluVector3f): TgluVector3f;
+var
+  i: Integer;
+begin
+  for i := 0 to 2 do
+    result[i] := p2[i] - p1[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@X: 1. Wert im Vector;
+//@Y: 2. Wert im Vector;
+function gluVector2f(const X,Y: Single): TgluVector2f;
+begin
+  result[0] := X;
+  result[1] := Y;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector2f(const v3: TgluVector3f): TgluVector2f;
+begin
+  result[0] := v3[0];
+  result[1] := v3[1];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector2f(const v4: TgluVector4f): TgluVector2f;
+begin
+  result[0] := v4[0];
+  result[1] := v4[1];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function  gluVector4i(const W, X, Y, Z: Integer): TgluVector4i;
+begin
+  result[0] := W;
+  result[1] := X;
+  result[2] := Y;
+  result[3] := Z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//erstellt einen Vector
+//@W: 1. Wert im Vector;
+//@X: 2. Wert im Vector;
+//@Y: 3. Wert im Vector;
+//@Z: 4. Wert im Vector;
+function  gluVector2i(const X, Y: Integer): TgluVector2i;
+begin
+  result[0] := X;
+  result[1] := Y;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector2e(const X, Y: GLenum): TgluVector2e;
+begin
+  result[0] := X;
+  result[1] := Y;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector3e(const X, Y, Z: GLenum): TgluVector3e;
+begin
+  result[0] := X;
+  result[1] := Y;
+  result[2] := Z;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVector4e(const X, Y, Z, W: GLenum): TgluVector4e;
+begin
+  result[0] := X;
+  result[1] := Y;
+  result[2] := Z;
+  result[3] := W;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorNormalize(const v: TgluVector4f): TgluVector4f;
+begin
+  result := v;
+  if (result[3] <> 0) then
+    result := gluVectorMult(result, result[3]);
+  PgluVector3f(@result[0])^ := gluVectorNormalize(PgluVector3f(@result[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Normalisiert einen Vector
+//@v: Vector der normalisiert werden soll;
+//@result: normalisierter Vector;
+function gluVectorNormalize(const v: TgluVector3f): TgluVector3f;
+var len: Single;
+begin
+  len := gluVectorLength(v);
+  if (len > 0) then begin
+    result[0] := v[0]/len;
+    result[1] := v[1]/len;
+    result[2] := v[2]/len;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Normalisiert einen Vector
+//@v: Vector der normalisiert werden soll;
+//@result: normalisierter Vector;
+function gluVectorNormalize(const v: TgluVector2f): TgluVector2f;
+var len: Single;
+begin
+  len := gluVectorLength(v);
+  result[0] := v[0]/len;
+  result[1] := v[1]/len;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Länge eines Vectors
+//@v: Vector dessen Länge berechnet werden soll;
+//@result: Lange des Vectors;
+function gluVectorLength(const v: TgluVector3f): Single;
+begin
+  result := SQRT(SQR(v[0])+SQR(v[1])+SQR(v[2]));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet die Länge eines Vectors
+//@v: Vector dessen Länge berechnet werden soll;
+//@result: Lange des Vectors;
+function gluVectorLength(const v: TgluVector2f): Single;
+begin
+  result := SQRT(SQR(v[0])+SQR(v[1]));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das VektorProdukt aus den Übergebenen Vektoren
+//@v1: 1. Vektor;
+//@v2: 2. Vektor;
+//@result: Vektor des Vektorprodukts aus v1 und v2;
+function gluVectorProduct(const v1, v2: TgluVector3f): TgluVector3f;
+begin
+  result[0] := v1[1]*v2[2] - v1[2]*v2[1];
+  result[1] := v1[2]*v2[0] - v1[0]*v2[2];
+  result[2] := v1[0]*v2[1] - v1[1]*v2[0];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das Skalarprodukt der übergebenen Vektoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Skalprodukt aus v1 und v2;
+function gluVectorScalar(const v1, v2: TgluVector4f): Single; overload;
+begin
+  result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2] + v1[3]*v2[3];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das Skalarprodukt der übergebenen Vektoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Skalprodukt aus v1 und v2;
+function gluVectorScalar(const v1, v2: TgluVector3f): Single;
+begin
+  result := v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet das Skalarprodukt der übergebenen Vektoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Skalprodukt aus v1 und v2;
+function gluVectorScalar(const v1, v2: TgluVector2f): Single;
+begin
+  result := v1[0]*v2[0] + v1[1]*v2[1];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet den Winkel zwischen den übergebenen Vectoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Winkel zwischen v1 und v2;
+function gluVectorAngle(const v1, v2: TgluVector3f): Single;
+begin
+  result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Berechnet den Winkel zwischen den übergebenen Vectoren
+//@v1: 1. vektor;
+//@v2: 2. Vektor;
+//@result: Winkel zwischen v1 und v2;
+function gluVectorAngle(const v1, v2: TgluVector2f): Single;
+begin
+  result := ArcCos(gluVectorScalar(v1, v2)/(gluVectorLength(v1)*gluVectorLength(v2)));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorEquals(const v1, v2: TgluVector2f): Boolean;
+begin
+  result := (v1[0] = v2[0]) and (v1[1] = v2[1]);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorEquals(const v1, v2: TgluVector3f): Boolean;
+begin
+  result := (v1[2] = v2[2]) and gluVectorEquals(PgluVector2f(@v1[0])^, PgluVector2f(@v2[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorEquals(const v1, v2: TgluVector4f): Boolean;
+begin
+  result := (v1[3] = v2[3]) and gluVectorEquals(PgluVector3f(@v1[0])^, PgluVector3f(@v2[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorMult(const v: TgluVector2f; const s: Single): TgluVector2f;
+begin
+  result[0] := v[0] * s;
+  result[1] := v[1] * s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//multipliziert den Vektor mit einem Skalar
+//@v: Vektor der multipliziert werden soll;
+//@s: Skalar;
+//@result: Elementweise multiplizierter Vektor;
+function gluVectorMult(const v: TgluVector3f; const s: Single): TgluVector3f;
+var
+  i: Integer;
+begin
+  for i := 0 to 2 do
+    result[i] := v[i] * s;
+end;
+
+function gluVectorMult(const v: TgluVector4f; const s: Single): TgluVector4f;
+var
+  i: Integer;
+begin
+  for i := 0 to 3 do
+    result[i] := v[i] * s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorDivide(const v: TgluVector3f; const s: Single): TgluVector3f;
+var
+  i: Integer;
+begin
+  for i := 0 to 3 do
+    result[i] := v[i] / s;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorClamp(const v: TgluVector3f; const aMin, aMax: Single): TgluVector3f;
+var i: Integer;
+begin
+  for i := 0 to High(v) do
+    result[i] := Min(Max(v[i], aMin), aMax);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluVectorClamp(const v: TgluVector4f; const aMin, aMax: Single): TgluVector4f;
+var i: Integer;
+begin
+  for i := 0 to High(v) do
+    result[i] := Min(Max(v[i], aMin), aMax);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//addiert zwei Vektoren
+//@v1: Vektor 1;
+//@v2: Vektor 2;
+//@result: elementweise Summe der beiden Vektoren;
+function gluVectorAdd(const v1, v2: TgluVector3f): TgluVector3f;
+var
+  i: Integer;
+begin
+  for i := 0 to 2 do
+    result[i] := v1[i] + v2[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//subtrahiert zwei Vektoren
+//@v1: Vektor 1;
+//@v2: Vektor 2;
+//@result: elementweise Differenz der beiden Vektoren;
+function gluVectorSubtract(const v1, v2: TgluVector3f): TgluVector3f;
+var
+  i: Integer;
+begin
+  for i := 0 to 2 do
+    result[i] := v1[i] - v2[i];
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//Verändert die Vektoren so, dass sie orthogonal und normalisiert sind, bleibt dabei in der gleichen Ebene
+//@v1: Vektor 1;
+//@v2: Vektor 2;
+procedure gluVectorOrthoNormalize(var reference, tangent: TgluVector3f);
+var
+  proj: TgluVector3f;
+begin
+  reference:= gluVectorNormalize(reference);
+
+  proj:= gluVectorMult(reference, gluVectorScalar(tangent, reference));
+  tangent:= gluVectorSubtract(tangent, proj);
+  tangent:= gluVectorNormalize(tangent);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//rechnet den übergebenen Vector in absolute (matrixunabhängige) Raumkoordinaten um
+//@v: Vector dessen absolute Koordinaten bestimmt werden sollen;
+//@result: absolute Raumkoordianten des Vectors v;
+function gluGetAbsCoord(const v: TgluVector3f): TgluVector3f;
+var
+  v4: TVector4f;
+  sum: Single;
+  i, j: Integer;
+  m: array[0..3, 0..3] of TGLFloat;
+begin
+  for i := 0 to 2 do
+    v4[i] := v[i];
+  v4[3] := 1;
+  glGetFloatv(GL_MODELVIEW_MATRIX, @m[0, 0]);
+  for i := 0 to 2 do begin
+    sum := 0;
+    for j := 0 to 3 do begin
+      sum := sum + m[j, i]*v4[j];
+    end;
+    result[i] := sum;
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//berechnet eine Ebene die durch 3 Punkte bestimmt wird
+//@p1: Punkt 1;
+//@p2: Punkt 2, Punkt auf dem der Normalenvekrtor steht;
+//@p3: Punkt 3;
+//@result: Parameter der Ebene (0, 1, 2: Normalvektor; 3: Abstand);
+function gluPlanef(const p1, p2, p3: TgluVector3f): TgluPlanef;
+var
+  n, v1, v2: TgluVector3f;
+begin
+  v1 := gluVector3f(p2, p1);
+  v2 := gluVector3f(p2, p3);
+  n := gluVectorProduct(v1, v2);
+  result := gluPlanef(n, p2);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluPlanef(const n, p: TgluVector3f): TgluPlanef;
+var
+  d: Single;
+begin
+  d := gluVectorScalar(n, p);
+  PgluVector3f(@result)^ := n;
+  result[3] := -d;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//normalisiert die Parameter einer Ebene
+//@p: Parameter der Ebene;
+//@result: normalisierte Prameter der Ebene;
+function gluPlaneNormalize(const p: TgluPlanef): TgluPlanef;
+var
+  m: Single;
+  i: Integer;
+begin
+  m := Sqrt(Sqr(p[0]) + Sqr(p[1]) + Sqr(p[2]));
+  for i := 0 to 3 do
+    result[i] := p[i] / m;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluPlaneCrossRay(const aPlane: TgluPlanef; const aRay: TgluRayf; out aPoint: TgluVector3f): Boolean;
+var
+  lambda, real: Double;
+  i: Integer;
+begin
+  result := false;
+  lambda := 0;
+  real   := 0;
+  for i := 0 to 2 do begin
+    lambda := lambda + aRay.v[i] * aPlane[i];
+    real   := real   + aRay.p[i] * aPlane[i];
+  end;
+  if (lambda = 0) then begin
+    aPoint := gluVector3f(0, 0, 0);
+    exit;
+  end;
+  lambda := (aPlane[3] - real) / lambda;
+  aPoint := gluRayPoint(aRay, -lambda);
+  result := true;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluRayf(const p, v: TgluVector3f): TgluRayf;
+begin
+  result.p := p;
+  result.v := v;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluRayNormalize(const r: TgluRayf): TgluRayf;
+begin
+  result.p := r.p;
+  result.v := gluVectorNormalize(r.v);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluRayPoint(const r: TgluRayf; const lambda: Single): TgluVector3f;
+begin
+  result := gluVectorAdd(r.p, gluVectorMult(r.v, lambda));
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//schriebt die Werte des Vektors in einen String
+//@v: Vektor der in einen String umgewandelt werden soll;
+//@round: Anzahl der Stellen auf die gerundet werden soll;
+//@result: String mit den erten des Vektors;
+function gluVector4fToStr(const v: TgluVector4f; const round: Integer): String;
+var
+  f: TFormatSettings;
+begin
+  f.DecimalSeparator := '.';
+  if (round >= 0) then
+    result := Format('%.*f; %.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2], round, v[3]], f)
+  else
+    result := Format('%f; %f; %f; %f;', [v[0], v[1], v[2], v[3]], f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//schriebt die Werte des Vektors in einen String
+//@v: Vektor der in einen String umgewandelt werden soll;
+//@round: Anzahl der Stellen auf die gerundet werden soll;
+//@result: String mit den erten des Vektors;
+function gluVector3fToStr(const v: TgluVector3f; const round: Integer): String;
+var
+  f: TFormatSettings;
+begin
+  f.DecimalSeparator := '.';
+  if (round >= 0) then
+    result := Format('%.*f; %.*f; %.*f;', [round, v[0], round, v[1], round, v[2]], f)
+  else
+    result := Format('%f; %f; %f;', [v[0], v[1], v[2]], f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//schriebt die Werte des Vektors in einen String
+//@v: Vektor der in einen String umgewandelt werden soll;
+//@round: Anzahl der Stellen auf die gerundet werden soll;
+//@result: String mit den erten des Vektors;
+function gluVector2fToStr(const v: TgluVector2f; const round: Integer): String;
+var
+  f: TFormatSettings;
+begin
+  f.DecimalSeparator := '.';
+  if (round >= 0) then
+    result := Format('%.*f; %.*f;', [round, v[0], round, v[1]], f)
+  else
+    result := Format('%f; %f;', [v[0], v[1]], f);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluStrToVectorIntern(str: String; const aAbortOnFailure: Boolean; out aVec: TgluVector4f): Boolean;
+var
+  i, j, p, l: Integer;
+  s: String;
+  format: TFormatSettings;
+  v: Single;
+begin
+  result := false;
+  FillChar(aVec{%H-}, SizeOf(aVec), 0);
+  FillChar(format{%H-}, SizeOf(format), 0);
+  format.DecimalSeparator := '.';
+  if (Length(str) > 0) and (str[Length(str)] <> ';') then
+    str := str + ';';
+  j := 0;
+  i := 1;
+  p := 1;
+  l := Length(str);
+  while (i <= l) do begin
+    if str[i] = ';' then begin
+      s := Trim(copy(str, p, i-p));
+      if not TryStrToFloat(s, v, format) then begin
+        if aAbortOnFailure then
+          exit;
+        v := 0;
+      end;
+      aVec[j] := v;
+      inc(j);
+      p := i+1;
+    end;
+    inc(i);
+  end;
+  result := true;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluTryStrToVector4f(str: String; out aVec: TgluVector4f): Boolean;
+begin
+  result := gluStrToVectorIntern(str, true, aVec);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluTryStrToVector3f(str: String; out aVec: TgluVector3f): Boolean;
+var
+  v: TgluVector4f;
+begin
+  if (Length(str) > 0) and (str[Length(str)] <> ';') then
+    str := str + ';';
+  result := gluTryStrToVector4f(str+'0;', v);
+  aVec := PgluVector3f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluTryStrToVector2f(str: String; out aVec: TgluVector2f): Boolean;
+var
+  v: TgluVector4f;
+begin
+  if (Length(str) > 0) and (str[Length(str)] <> ';') then
+    str := str + ';';
+  result := gluTryStrToVector4f(str+'0;0;', v);
+  aVec := PgluVector2f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen String in einen Vektor um
+//@str: String der in den Vektor umgewandelt werden soll;
+//@result: Vektor mit den Datein aus dem String;
+function gluStrToVector4f(str: String): TgluVector4f;
+begin
+  gluStrToVectorIntern(str, false, result);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen String in einen Vektor um
+//@str: String der in den Vektor umgewandelt werden soll;
+//@result: Vektor mit den Datein aus dem String;
+function gluStrToVector3f(str: String): TgluVector3f;
+var
+  v: TgluVector4f;
+begin
+  if (Length(str) > 0) and (str[Length(str)] <> ';') then
+    str := str + ';';
+  v := gluStrToVector4f(str+'0;');
+  result := PgluVector3f(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen String in einen Vektor um
+//@str: String der in den Vektor umgewandelt werden soll;
+//@result: Vektor mit den Datein aus dem String;
+function gluStrToVector2f(str: String): TgluVector2f;
+var
+  v: TgluVector3f;
+begin
+  if (Length(str) > 0) and (str[Length(str)] <> ';') then
+    str := str + ';';
+  v := gluStrToVector3f(str+'0;');
+  result := PgluVector2f(@v[0])^;
+end;
+
+function gluVector4iToStr(const v: TgluVector4i): String;
+begin
+  Result:= Format('%d;%d;%d;%d;',[v[0],v[1],v[2],v[3]]);
+end;
+
+function gluVector3iToStr(const v: TgluVector3i): String;
+begin
+  Result:= Format('%d;%d;%d;',[v[0],v[1],v[2]]);
+end;
+
+function gluVector2iToStr(const v: TgluVector2i): String;
+begin
+  Result:= Format('%d;%d;',[v[0],v[1]]);
+end;
+
+function gluStrToVector4i(const str: String): TgluVector4i;
+var
+  i, j, p, l: Integer;
+  v: integer;
+begin
+  FillChar(result{%H-}, SizeOf(result), 0);
+  j := 0;
+  i := 1;
+  p := 1;
+  l := Length(str);
+  while (i <= l) do begin
+    if str[i] = ';' then begin
+      if not TryStrToInt(copy(str, p, i-p), v) then
+        v := 0;
+      result[j] := v;
+      inc(j);
+      p := i+1;
+    end;
+    inc(i);
+  end;
+end;
+
+function gluStrToVector3i(const str: String): TgluVector3i;
+var
+  v: TgluVector4i;
+begin
+  v := gluStrToVector4i(str+'0;');
+  result := PgluVector3i(@v[0])^;
+end;
+
+function gluStrToVector2i(const str: String): TgluVector2i;
+var
+  v: TgluVector3i;
+begin
+  v := gluStrToVector3i(str+'0;');
+  result := PgluVector2i(@v[0])^;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen Vektor in eine Farbe um
+//@v: Vektor der umgewandelt werden soll;
+//@result: Farbe;
+function gluVectorToColor(const v: TgluVector4f): TVectorColor; overload;
+begin
+  result := gluVectorToColor(PgluVector3f(@v[0])^);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//wandelt einen Vektor in eine Farbe um
+//@v: Vektor der umgewandelt werden soll;
+//@result: Farbe;
+function gluVectorToColor(const v: TgluVector3f): TVectorColor;
+var
+  r, g, b: Byte;
+begin
+  r := round(255*v[0]);
+  g := round(255*v[1]);
+  b := round(255*v[2]);
+  result := r + (g shl 8) + (b shl 16);
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluColorToVector3f(const c: TVectorColor): TgluVector3f;
+begin
+  result[0] := ( c         and $FF) / 255;
+  result[1] := ((c shr  8) and $FF) / 255;
+  result[2] := ((c shr 16) and $FF) / 255;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function gluColorToVector4f(const c: TVectorColor; const a: Single): TgluVector4f;
+begin
+  PgluVector3f(@result[0])^ := gluColorToVector3f(c);
+  result[3] := a;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
+//@v: Farbe im HSV-Farbraum;
+//@result: Farbe im RGB-Farbraum;
+function gluVectorHSVColor(v: TgluVector3f): TgluVector3f;
+const
+  _H = 0;
+  _S = 1;
+  _V = 2;
+var
+  h: Integer;
+  f, p, q, t: Single;
+begin
+  v[_H] := 360*v[_H];
+//H normieren
+  while (v[_H] < 0) do
+    v[_H] := v[_H] + 360;
+  while (v[_H] > 360) do
+    v[_H] := v[_H] - 360;
+//V normieren
+  if (v[_V] < 0) then
+    v[_V] := 0;
+  if (v[_V] > 1) then
+    v[_V] := 1;
+
+  h := Floor(v[_H] / 60);
+  f := v[_H]/60 - h;
+  p := v[_V] * (1 - v[_S]);
+  q := v[_V] * (1 - v[_S] * f);
+  t := v[_V] * (1 - v[_S] * (1 - f));
+  case h of
+    1: result := gluVector3f(q, v[_V], p);
+    2: result := gluVector3f(p, v[_V], t);
+    3: result := gluVector3f(p, q, v[_V]);
+    4: result := gluVector3f(t, p, v[_V]);
+    5: result := gluVector3f(v[_V], p, q);
+  else
+    result := gluVector3f(v[_V], t, p);
+  end;
+end;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//rechnet eine Farbe im HSV-Farbraum in den RGB-Farbraum um
+//@v: Farbe im HSV-Farbraum;
+//@result: Farbe im RGB-Farbraum;
+function gluVectorHSVColor(v: TgluVector4f): TgluVector4f;
+begin
+  PgluVector3f(@result)^ := gluVectorHSVColor(PgluVector3f(@v)^);
+  result[3] := v[3];
+end;
+
+end.
+