{ ============================================================================

       OpenGL 4.5 - Headertranslation
       Version 4.5

       Supported environments and targets :
        - (Linux) FreePascal (1.9.3 and up)

==============================================================================

       Copyright (C) DGL-OpenGL-Portteam
       All Rights Reserved

       Obtained through:
         - Delphi OpenGL Community(DGL)   - www.delphigl.com

       Converted and maintained by DGL's OpenGL-Portteam :
         - Bergmann89                     - http://www.bergmann89.de

==============================================================================

  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.

============================================================================== }

unit dglOpenGLES;

interface

{$IFDEF FPC}
  {$MODE Delphi}
{$ENDIF}

// detecting Linux
{$IFDEF linux}          // Linux
  {$DEFINE DGL_LINUX}
{$ENDIF}

//check if system is supported and set system dependent constants
uses
  sysutils
  {$IFDEF DGL_LINUX}
  , dl
  {$ENDIF}
  ;

{$IFDEF DGL_LINUX}
const
  LIBNAME_OPENGLES = 'libGLESv2.so';
  LIBNAME_EGL      = 'libEGL.so';

{$ELSE}
  {$ERROR 'unknown/unsupported system'}

{$ENDIF}

{ ================================================== OpenGL Es ======================================================= }
type
  { OpenGL ES 2.0 }
  GLbyte      = Byte;
  GLclampf    = Single;
  GLfixed     = Integer;
  GLshort     = ShortInt;
  GLushort    = Word;
  GLvoid      = Pointer;
  GLint64     = Int64;
  GLuint64    = UInt64;
  GLenum      = Cardinal;
  GLuint      = Cardinal;
  GLchar      = AnsiChar;
  GLbitfield  = Cardinal;
  GLint       = Integer;
  GLboolean   = ByteBool;
  GLsizei     = Integer;
  GLfloat     = Single;

  PGLbyte     = ^GLbyte;
  PGLclampf   = ^GLclampf;
  PGLfixed    = ^GLfixed;
  PGLshort    = ^GLshort;
  PGLushort   = ^GLushort;
  PGLvoid     = Pointer;
  PPGLvoid    = ^PGLvoid;
  PGLint64    = ^GLint64;
  PGLuint64   = ^GLuint64;
  PGLenum     = ^GLenum;
  PGLuint     = ^GLuint;
  PGLchar     = ^GLchar;
  PPGLchar    = ^PGLChar;
  PGLbitfield = ^GLbitfield;
  PGLint      = ^GLint;
  PGLboolean  = ^GLboolean;
  PGLsizei    = ^GLsizei;
  PGLfloat    = ^GLfloat;

  { OpenGL ES 3.0 }
  GLsync = Pointer;


const
  { OpenGL ES 2.0 }
  GL_DEPTH_BUFFER_BIT                               = $00000100;
  GL_STENCIL_BUFFER_BIT                             = $00000400;
  GL_COLOR_BUFFER_BIT                               = $00004000;
  GL_FALSE                                          = $0000;
  GL_TRUE                                           = $0001;
  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;
  GL_ZERO                                           = $0000;
  GL_ONE                                            = $0001;
  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;
  GL_DST_COLOR                                      = $0306;
  GL_ONE_MINUS_DST_COLOR                            = $0307;
  GL_SRC_ALPHA_SATURATE                             = $0308;
  GL_FUNC_ADD                                       = $8006;
  GL_BLEND_EQUATION                                 = $8009;
  GL_BLEND_EQUATION_RGB                             = $8009;
  GL_BLEND_EQUATION_ALPHA                           = $883D;
  GL_FUNC_SUBTRACT                                  = $800A;
  GL_FUNC_REVERSE_SUBTRACT                          = $800B;
  GL_BLEND_DST_RGB                                  = $80C8;
  GL_BLEND_SRC_RGB                                  = $80C9;
  GL_BLEND_DST_ALPHA                                = $80CA;
  GL_BLEND_SRC_ALPHA                                = $80CB;
  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_ARRAY_BUFFER                                   = $8892;
  GL_ELEMENT_ARRAY_BUFFER                           = $8893;
  GL_ARRAY_BUFFER_BINDING                           = $8894;
  GL_ELEMENT_ARRAY_BUFFER_BINDING                   = $8895;
  GL_STREAM_DRAW                                    = $88E0;
  GL_STATIC_DRAW                                    = $88E4;
  GL_DYNAMIC_DRAW                                   = $88E8;
  GL_BUFFER_SIZE                                    = $8764;
  GL_BUFFER_USAGE                                   = $8765;
  GL_CURRENT_VERTEX_ATTRIB                          = $8626;
  GL_FRONT                                          = $0404;
  GL_BACK                                           = $0405;
  GL_FRONT_AND_BACK                                 = $0408;
  GL_TEXTURE_2D                                     = $0DE1;
  GL_CULL_FACE                                      = $0B44;
  GL_BLEND                                          = $0BE2;
  GL_DITHER                                         = $0BD0;
  GL_STENCIL_TEST                                   = $0B90;
  GL_DEPTH_TEST                                     = $0B71;
  GL_SCISSOR_TEST                                   = $0C11;
  GL_POLYGON_OFFSET_FILL                            = $8037;
  GL_SAMPLE_ALPHA_TO_COVERAGE                       = $809E;
  GL_SAMPLE_COVERAGE                                = $80A0;
  GL_NO_ERROR                                       = $0000;
  GL_INVALID_ENUM                                   = $0500;
  GL_INVALID_VALUE                                  = $0501;
  GL_INVALID_OPERATION                              = $0502;
  GL_OUT_OF_MEMORY                                  = $0505;
  GL_CW                                             = $0900;
  GL_CCW                                            = $0901;
  GL_LINE_WIDTH                                     = $0B21;
  GL_ALIASED_POINT_SIZE_RANGE                       = $846D;
  GL_ALIASED_LINE_WIDTH_RANGE                       = $846E;
  GL_CULL_FACE_MODE                                 = $0B45;
  GL_FRONT_FACE                                     = $0B46;
  GL_DEPTH_RANGE                                    = $0B70;
  GL_DEPTH_WRITEMASK                                = $0B72;
  GL_DEPTH_CLEAR_VALUE                              = $0B73;
  GL_DEPTH_FUNC                                     = $0B74;
  GL_STENCIL_CLEAR_VALUE                            = $0B91;
  GL_STENCIL_FUNC                                   = $0B92;
  GL_STENCIL_FAIL                                   = $0B94;
  GL_STENCIL_PASS_DEPTH_FAIL                        = $0B95;
  GL_STENCIL_PASS_DEPTH_PASS                        = $0B96;
  GL_STENCIL_REF                                    = $0B97;
  GL_STENCIL_VALUE_MASK                             = $0B93;
  GL_STENCIL_WRITEMASK                              = $0B98;
  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_STENCIL_BACK_REF                               = $8CA3;
  GL_STENCIL_BACK_VALUE_MASK                        = $8CA4;
  GL_STENCIL_BACK_WRITEMASK                         = $8CA5;
  GL_VIEWPORT                                       = $0BA2;
  GL_SCISSOR_BOX                                    = $0C10;
  GL_COLOR_CLEAR_VALUE                              = $0C22;
  GL_COLOR_WRITEMASK                                = $0C23;
  GL_UNPACK_ALIGNMENT                               = $0CF5;
  GL_PACK_ALIGNMENT                                 = $0D05;
  GL_MAX_TEXTURE_SIZE                               = $0D33;
  GL_MAX_VIEWPORT_DIMS                              = $0D3A;
  GL_SUBPIXEL_BITS                                  = $0D50;
  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_POLYGON_OFFSET_UNITS                           = $2A00;
  GL_POLYGON_OFFSET_FACTOR                          = $8038;
  GL_TEXTURE_BINDING_2D                             = $8069;
  GL_SAMPLE_BUFFERS                                 = $80A8;
  GL_SAMPLES                                        = $80A9;
  GL_SAMPLE_COVERAGE_VALUE                          = $80AA;
  GL_SAMPLE_COVERAGE_INVERT                         = $80AB;
  GL_NUM_COMPRESSED_TEXTURE_FORMATS                 = $86A2;
  GL_COMPRESSED_TEXTURE_FORMATS                     = $86A3;
  GL_DONT_CARE                                      = $1100;
  GL_FASTEST                                        = $1101;
  GL_NICEST                                         = $1102;
  GL_GENERATE_MIPMAP_HINT                           = $8192;
  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_FIXED                                          = $140C;
  GL_DEPTH_COMPONENT                                = $1902;
  GL_ALPHA                                          = $1906;
  GL_RGB                                            = $1907;
  GL_RGBA                                           = $1908;
  GL_LUMINANCE                                      = $1909;
  GL_LUMINANCE_ALPHA                                = $190A;
  GL_UNSIGNED_SHORT_4_4_4_4                         = $8033;
  GL_UNSIGNED_SHORT_5_5_5_1                         = $8034;
  GL_UNSIGNED_SHORT_5_6_5                           = $8363;
  GL_FRAGMENT_SHADER                                = $8B30;
  GL_VERTEX_SHADER                                  = $8B31;
  GL_MAX_VERTEX_ATTRIBS                             = $8869;
  GL_MAX_VERTEX_UNIFORM_VECTORS                     = $8DFB;
  GL_MAX_VARYING_VECTORS                            = $8DFC;
  GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS               = $8B4D;
  GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS                 = $8B4C;
  GL_MAX_TEXTURE_IMAGE_UNITS                        = $8872;
  GL_MAX_FRAGMENT_UNIFORM_VECTORS                   = $8DFD;
  GL_SHADER_TYPE                                    = $8B4F;
  GL_DELETE_STATUS                                  = $8B80;
  GL_LINK_STATUS                                    = $8B82;
  GL_VALIDATE_STATUS                                = $8B83;
  GL_ATTACHED_SHADERS                               = $8B85;
  GL_ACTIVE_UNIFORMS                                = $8B86;
  GL_ACTIVE_UNIFORM_MAX_LENGTH                      = $8B87;
  GL_ACTIVE_ATTRIBUTES                              = $8B89;
  GL_ACTIVE_ATTRIBUTE_MAX_LENGTH                    = $8B8A;
  GL_SHADING_LANGUAGE_VERSION                       = $8B8C;
  GL_CURRENT_PROGRAM                                = $8B8D;
  GL_NEVER                                          = $0200;
  GL_LESS                                           = $0201;
  GL_EQUAL                                          = $0202;
  GL_LEQUAL                                         = $0203;
  GL_GREATER                                        = $0204;
  GL_NOTEQUAL                                       = $0205;
  GL_GEQUAL                                         = $0206;
  GL_ALWAYS                                         = $0207;
  GL_KEEP                                           = $1E00;
  GL_REPLACE                                        = $1E01;
  GL_INCR                                           = $1E02;
  GL_DECR                                           = $1E03;
  GL_INVERT                                         = $150A;
  GL_INCR_WRAP                                      = $8507;
  GL_DECR_WRAP                                      = $8508;
  GL_VENDOR                                         = $1F00;
  GL_RENDERER                                       = $1F01;
  GL_VERSION                                        = $1F02;
  GL_EXTENSIONS                                     = $1F03;
  GL_NEAREST                                        = $2600;
  GL_LINEAR                                         = $2601;
  GL_NEAREST_MIPMAP_NEAREST                         = $2700;
  GL_LINEAR_MIPMAP_NEAREST                          = $2701;
  GL_NEAREST_MIPMAP_LINEAR                          = $2702;
  GL_LINEAR_MIPMAP_LINEAR                           = $2703;
  GL_TEXTURE_MAG_FILTER                             = $2800;
  GL_TEXTURE_MIN_FILTER                             = $2801;
  GL_TEXTURE_WRAP_S                                 = $2802;
  GL_TEXTURE_WRAP_T                                 = $2803;
  GL_TEXTURE                                        = $1702;
  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_MAX_CUBE_MAP_TEXTURE_SIZE                      = $851C;
  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_REPEAT                                         = $2901;
  GL_CLAMP_TO_EDGE                                  = $812F;
  GL_MIRRORED_REPEAT                                = $8370;
  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_2D                                     = $8B5E;
  GL_SAMPLER_CUBE                                   = $8B60;
  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_VERTEX_ATTRIB_ARRAY_NORMALIZED                 = $886A;
  GL_VERTEX_ATTRIB_ARRAY_POINTER                    = $8645;
  GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING             = $889F;
  GL_IMPLEMENTATION_COLOR_READ_TYPE                 = $8B9A;
  GL_IMPLEMENTATION_COLOR_READ_FORMAT               = $8B9B;
  GL_COMPILE_STATUS                                 = $8B81;
  GL_INFO_LOG_LENGTH                                = $8B84;
  GL_SHADER_SOURCE_LENGTH                           = $8B88;
  GL_SHADER_COMPILER                                = $8DFA;
  GL_SHADER_BINARY_FORMATS                          = $8DF8;
  GL_NUM_SHADER_BINARY_FORMATS                      = $8DF9;
  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_FRAMEBUFFER                                    = $8D40;
  GL_RENDERBUFFER                                   = $8D41;
  GL_RGBA4                                          = $8056;
  GL_RGB5_A1                                        = $8057;
  GL_RGB565                                         = $8D62;
  GL_DEPTH_COMPONENT16                              = $81A5;
  GL_STENCIL_INDEX8                                 = $8D48;
  GL_RENDERBUFFER_WIDTH                             = $8D42;
  GL_RENDERBUFFER_HEIGHT                            = $8D43;
  GL_RENDERBUFFER_INTERNAL_FORMAT                   = $8D44;
  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_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_COLOR_ATTACHMENT0                              = $8CE0;
  GL_DEPTH_ATTACHMENT                               = $8D00;
  GL_STENCIL_ATTACHMENT                             = $8D20;
  GL_NONE                                           = $0000;
  GL_FRAMEBUFFER_COMPLETE                           = $8CD5;
  GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT              = $8CD6;
  GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT      = $8CD7;
  GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS              = $8CD9;
  GL_FRAMEBUFFER_UNSUPPORTED                        = $8CDD;
  GL_FRAMEBUFFER_BINDING                            = $8CA6;
  GL_RENDERBUFFER_BINDING                           = $8CA7;
  GL_MAX_RENDERBUFFER_SIZE                          = $84E8;
  GL_INVALID_FRAMEBUFFER_OPERATION                  = $0506;

  { OpenGL ES 3.0 }
  GL_READ_BUFFER                                    = $0C02;
  GL_UNPACK_ROW_LENGTH                              = $0CF2;
  GL_UNPACK_SKIP_ROWS                               = $0CF3;
  GL_UNPACK_SKIP_PIXELS                             = $0CF4;
  GL_PACK_ROW_LENGTH                                = $0D02;
  GL_PACK_SKIP_ROWS                                 = $0D03;
  GL_PACK_SKIP_PIXELS                               = $0D04;
  GL_COLOR                                          = $1800;
  GL_DEPTH                                          = $1801;
  GL_STENCIL                                        = $1802;
  GL_RED                                            = $1903;
  GL_RGB8                                           = $8051;
  GL_RGBA8                                          = $8058;
  GL_RGB10_A2                                       = $8059;
  GL_TEXTURE_BINDING_3D                             = $806A;
  GL_UNPACK_SKIP_IMAGES                             = $806D;
  GL_UNPACK_IMAGE_HEIGHT                            = $806E;
  GL_TEXTURE_3D                                     = $806F;
  GL_TEXTURE_WRAP_R                                 = $8072;
  GL_MAX_3D_TEXTURE_SIZE                            = $8073;
  GL_UNSIGNED_INT_2_10_10_10_REV                    = $8368;
  GL_MAX_ELEMENTS_VERTICES                          = $80E8;
  GL_MAX_ELEMENTS_INDICES                           = $80E9;
  GL_TEXTURE_MIN_LOD                                = $813A;
  GL_TEXTURE_MAX_LOD                                = $813B;
  GL_TEXTURE_BASE_LEVEL                             = $813C;
  GL_TEXTURE_MAX_LEVEL                              = $813D;
  GL_MIN                                            = $8007;
  GL_MAX                                            = $8008;
  GL_DEPTH_COMPONENT24                              = $81A6;
  GL_MAX_TEXTURE_LOD_BIAS                           = $84FD;
  GL_TEXTURE_COMPARE_MODE                           = $884C;
  GL_TEXTURE_COMPARE_FUNC                           = $884D;
  GL_CURRENT_QUERY                                  = $8865;
  GL_QUERY_RESULT                                   = $8866;
  GL_QUERY_RESULT_AVAILABLE                         = $8867;
  GL_BUFFER_MAPPED                                  = $88BC;
  GL_BUFFER_MAP_POINTER                             = $88BD;
  GL_STREAM_READ                                    = $88E1;
  GL_STREAM_COPY                                    = $88E2;
  GL_STATIC_READ                                    = $88E5;
  GL_STATIC_COPY                                    = $88E6;
  GL_DYNAMIC_READ                                   = $88E9;
  GL_DYNAMIC_COPY                                   = $88EA;
  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_MAX_FRAGMENT_UNIFORM_COMPONENTS                = $8B49;
  GL_MAX_VERTEX_UNIFORM_COMPONENTS                  = $8B4A;
  GL_SAMPLER_3D                                     = $8B5F;
  GL_SAMPLER_2D_SHADOW                              = $8B62;
  GL_FRAGMENT_SHADER_DERIVATIVE_HINT                = $8B8B;
  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_SRGB8_ALPHA8                                   = $8C43;
  GL_COMPARE_REF_TO_TEXTURE                         = $884E;
  GL_MAJOR_VERSION                                  = $821B;
  GL_MINOR_VERSION                                  = $821C;
  GL_NUM_EXTENSIONS                                 = $821D;
  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_MAX_VARYING_COMPONENTS                         = $8B4B;
  GL_TEXTURE_2D_ARRAY                               = $8C1A;
  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_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_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_RGB_INTEGER                                    = $8D98;
  GL_RGBA_INTEGER                                   = $8D99;
  GL_SAMPLER_2D_ARRAY                               = $8DC1;
  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_2D                                 = $8DCA;
  GL_INT_SAMPLER_3D                                 = $8DCB;
  GL_INT_SAMPLER_CUBE                               = $8DCC;
  GL_INT_SAMPLER_2D_ARRAY                           = $8DCF;
  GL_UNSIGNED_INT_SAMPLER_2D                        = $8DD2;
  GL_UNSIGNED_INT_SAMPLER_3D                        = $8DD3;
  GL_UNSIGNED_INT_SAMPLER_CUBE                      = $8DD4;
  GL_UNSIGNED_INT_SAMPLER_2D_ARRAY                  = $8DD7;
  GL_BUFFER_ACCESS_FLAGS                            = $911F;
  GL_BUFFER_MAP_LENGTH                              = $9120;
  GL_BUFFER_MAP_OFFSET                              = $9121;
  GL_DEPTH_COMPONENT32F                             = $8CAC;
  GL_DEPTH32F_STENCIL8                              = $8CAD;
  GL_FLOAT_32_UNSIGNED_INT_24_8_REV                 = $8DAD;
  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_DEPTH_STENCIL                                  = $84F9;
  GL_UNSIGNED_INT_24_8                              = $84FA;
  GL_DEPTH24_STENCIL8                               = $88F0;
  GL_UNSIGNED_NORMALIZED                            = $8C17;
  GL_DRAW_FRAMEBUFFER_BINDING                       = $8CA6;
  GL_READ_FRAMEBUFFER                               = $8CA8;
  GL_DRAW_FRAMEBUFFER                               = $8CA9;
  GL_READ_FRAMEBUFFER_BINDING                       = $8CAA;
  GL_RENDERBUFFER_SAMPLES                           = $8CAB;
  GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER           = $8CD4;
  GL_MAX_COLOR_ATTACHMENTS                          = $8CDF;
  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_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE             = $8D56;
  GL_MAX_SAMPLES                                    = $8D57;
  GL_HALF_FLOAT                                     = $140B;
  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_RG                                             = $8227;
  GL_RG_INTEGER                                     = $8228;
  GL_R8                                             = $8229;
  GL_RG8                                            = $822B;
  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_VERTEX_ARRAY_BINDING                           = $85B5;
  GL_R8_SNORM                                       = $8F94;
  GL_RG8_SNORM                                      = $8F95;
  GL_RGB8_SNORM                                     = $8F96;
  GL_RGBA8_SNORM                                    = $8F97;
  GL_SIGNED_NORMALIZED                              = $8F9C;
  GL_PRIMITIVE_RESTART_FIXED_INDEX                  = $8D69;
  GL_COPY_READ_BUFFER                               = $8F36;
  GL_COPY_WRITE_BUFFER                              = $8F37;
  GL_COPY_READ_BUFFER_BINDING                       = $8F36;
  GL_COPY_WRITE_BUFFER_BINDING                      = $8F37;
  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_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_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_FRAGMENT_SHADER    = $8A46;
  GL_INVALID_INDEX                                  = $FFFFFFFF;
  GL_MAX_VERTEX_OUTPUT_COMPONENTS                   = $9122;
  GL_MAX_FRAGMENT_INPUT_COMPONENTS                  = $9125;
  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_VERTEX_ATTRIB_ARRAY_DIVISOR                    = $88FE;
  GL_ANY_SAMPLES_PASSED                             = $8C2F;
  GL_ANY_SAMPLES_PASSED_CONSERVATIVE                = $8D6A;
  GL_SAMPLER_BINDING                                = $8919;
  GL_RGB10_A2UI                                     = $906F;
  GL_TEXTURE_SWIZZLE_R                              = $8E42;
  GL_TEXTURE_SWIZZLE_G                              = $8E43;
  GL_TEXTURE_SWIZZLE_B                              = $8E44;
  GL_TEXTURE_SWIZZLE_A                              = $8E45;
  GL_GREEN                                          = $1904;
  GL_BLUE                                           = $1905;
  GL_INT_2_10_10_10_REV                             = $8D9F;
  GL_TRANSFORM_FEEDBACK                             = $8E22;
  GL_TRANSFORM_FEEDBACK_PAUSED                      = $8E23;
  GL_TRANSFORM_FEEDBACK_ACTIVE                      = $8E24;
  GL_TRANSFORM_FEEDBACK_BINDING                     = $8E25;
  GL_PROGRAM_BINARY_RETRIEVABLE_HINT                = $8257;
  GL_PROGRAM_BINARY_LENGTH                          = $8741;
  GL_NUM_PROGRAM_BINARY_FORMATS                     = $87FE;
  GL_PROGRAM_BINARY_FORMATS                         = $87FF;
  GL_COMPRESSED_R11_EAC                             = $9270;
  GL_COMPRESSED_SIGNED_R11_EAC                      = $9271;
  GL_COMPRESSED_RG11_EAC                            = $9272;
  GL_COMPRESSED_SIGNED_RG11_EAC                     = $9273;
  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_TEXTURE_IMMUTABLE_FORMAT                       = $912F;
  GL_MAX_ELEMENT_INDEX                              = $8D6B;
  GL_NUM_SAMPLE_COUNTS                              = $9380;
  GL_TEXTURE_IMMUTABLE_LEVELS                       = $82DF;

  { OpenGL ES 3.1 }
  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_WORK_GROUP_INVOCATIONS             = $90EB;
  GL_MAX_COMPUTE_WORK_GROUP_COUNT                   = $91BE;
  GL_MAX_COMPUTE_WORK_GROUP_SIZE                    = $91BF;
  GL_COMPUTE_WORK_GROUP_SIZE                        = $8267;
  GL_DISPATCH_INDIRECT_BUFFER                       = $90EE;
  GL_DISPATCH_INDIRECT_BUFFER_BINDING               = $90EF;
  GL_COMPUTE_SHADER_BIT                             = $00000020;
  GL_DRAW_INDIRECT_BUFFER                           = $8F3F;
  GL_DRAW_INDIRECT_BUFFER_BINDING                   = $8F43;
  GL_MAX_UNIFORM_LOCATIONS                          = $826E;
  GL_FRAMEBUFFER_DEFAULT_WIDTH                      = $9310;
  GL_FRAMEBUFFER_DEFAULT_HEIGHT                     = $9311;
  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_SAMPLES                        = $9318;
  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_ATOMIC_COUNTER_BUFFER                          = $92C0;
  GL_TRANSFORM_FEEDBACK_VARYING                     = $92F4;
  GL_ACTIVE_RESOURCES                               = $92F5;
  GL_MAX_NAME_LENGTH                                = $92F6;
  GL_MAX_NUM_ACTIVE_VARIABLES                       = $92F7;
  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_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_VERTEX_SHADER_BIT                              = $00000001;
  GL_FRAGMENT_SHADER_BIT                            = $00000002;
  GL_ALL_SHADER_BITS                                = $FFFFFFFF;
  GL_PROGRAM_SEPARABLE                              = $8258;
  GL_ACTIVE_PROGRAM                                 = $8259;
  GL_PROGRAM_PIPELINE_BINDING                       = $825A;
  GL_ATOMIC_COUNTER_BUFFER_BINDING                  = $92C1;
  GL_ATOMIC_COUNTER_BUFFER_START                    = $92C2;
  GL_ATOMIC_COUNTER_BUFFER_SIZE                     = $92C3;
  GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS              = $92CC;
  GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS            = $92D0;
  GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS            = $92D1;
  GL_MAX_VERTEX_ATOMIC_COUNTERS                     = $92D2;
  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_UNSIGNED_INT_ATOMIC_COUNTER                    = $92DB;
  GL_MAX_IMAGE_UNITS                                = $8F38;
  GL_MAX_VERTEX_IMAGE_UNIFORMS                      = $90CA;
  GL_MAX_FRAGMENT_IMAGE_UNIFORMS                    = $90CE;
  GL_MAX_COMBINED_IMAGE_UNIFORMS                    = $90CF;
  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_BINDING_FORMAT                           = $906E;
  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_IMAGE_2D                                       = $904D;
  GL_IMAGE_3D                                       = $904E;
  GL_IMAGE_CUBE                                     = $9050;
  GL_IMAGE_2D_ARRAY                                 = $9053;
  GL_INT_IMAGE_2D                                   = $9058;
  GL_INT_IMAGE_3D                                   = $9059;
  GL_INT_IMAGE_CUBE                                 = $905B;
  GL_INT_IMAGE_2D_ARRAY                             = $905E;
  GL_UNSIGNED_INT_IMAGE_2D                          = $9063;
  GL_UNSIGNED_INT_IMAGE_3D                          = $9064;
  GL_UNSIGNED_INT_IMAGE_CUBE                        = $9066;
  GL_UNSIGNED_INT_IMAGE_2D_ARRAY                    = $9069;
  GL_IMAGE_FORMAT_COMPATIBILITY_TYPE                = $90C7;
  GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE             = $90C8;
  GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS            = $90C9;
  GL_READ_ONLY                                      = $88B8;
  GL_WRITE_ONLY                                     = $88B9;
  GL_READ_WRITE                                     = $88BA;
  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_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                     = $00002000;
  GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES           = $8F39;
  GL_DEPTH_STENCIL_TEXTURE_MODE                     = $90EA;
  GL_STENCIL_INDEX                                  = $1901;
  GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET              = $8E5E;
  GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET              = $8E5F;
  GL_SAMPLE_POSITION                                = $8E50;
  GL_SAMPLE_MASK                                    = $8E51;
  GL_SAMPLE_MASK_VALUE                              = $8E52;
  GL_TEXTURE_2D_MULTISAMPLE                         = $9100;
  GL_MAX_SAMPLE_MASK_WORDS                          = $8E59;
  GL_MAX_COLOR_TEXTURE_SAMPLES                      = $910E;
  GL_MAX_DEPTH_TEXTURE_SAMPLES                      = $910F;
  GL_MAX_INTEGER_SAMPLES                            = $9110;
  GL_TEXTURE_BINDING_2D_MULTISAMPLE                 = $9104;
  GL_TEXTURE_SAMPLES                                = $9106;
  GL_TEXTURE_FIXED_SAMPLE_LOCATIONS                 = $9107;
  GL_TEXTURE_WIDTH                                  = $1000;
  GL_TEXTURE_HEIGHT                                 = $1001;
  GL_TEXTURE_DEPTH                                  = $8071;
  GL_TEXTURE_INTERNAL_FORMAT                        = $1003;
  GL_TEXTURE_RED_SIZE                               = $805C;
  GL_TEXTURE_GREEN_SIZE                             = $805D;
  GL_TEXTURE_BLUE_SIZE                              = $805E;
  GL_TEXTURE_ALPHA_SIZE                             = $805F;
  GL_TEXTURE_DEPTH_SIZE                             = $884A;
  GL_TEXTURE_STENCIL_SIZE                           = $88F1;
  GL_TEXTURE_SHARED_SIZE                            = $8C3F;
  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_TEXTURE_COMPRESSED                             = $86A1;
  GL_SAMPLER_2D_MULTISAMPLE                         = $9108;
  GL_INT_SAMPLER_2D_MULTISAMPLE                     = $9109;
  GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE            = $910A;
  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_VERTEX_BINDING_BUFFER                          = $8F4F;
  GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET              = $82D9;
  GL_MAX_VERTEX_ATTRIB_BINDINGS                     = $82DA;
  GL_MAX_VERTEX_ATTRIB_STRIDE                       = $82E5;


type
  { OpenGL Es 2.0 }
  TglActiveTexture                        = procedure(aTexture: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglAttachShader                         = procedure(aProgram: GLuint; aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindAttribLocation                   = procedure(aProgram: GLuint; aIndex: GLuint; const aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindBuffer                           = procedure(aTarget: GLenum; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindFramebuffer                      = procedure(aTarget: GLenum; aFramebuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindRenderbuffer                     = procedure(aTarget: GLenum; aRenderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindTexture                          = procedure(aTarget: GLenum; aTexture: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendColor                           = procedure(aRed: GLfloat; aGreen: GLfloat; aBlue: GLfloat; aAlpha: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendEquation                        = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendEquationSeparate                = procedure(aModeRGB: GLenum; aModeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendFunc                            = procedure(aSFactor: GLenum; aDFactor: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendFuncSeparate                    = procedure(aSFactorRGB: GLenum; aDFactorRGB: GLenum; aSFactorAlpha: GLenum; aDFactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBufferData                           = procedure(aTarget: GLenum; aSize: PGLsizei; const aData: PGLvoid; aUsage: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBufferSubData                        = procedure(aTarget: GLenum; aOffset: PGLint; aSize: PGLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCheckFramebufferStatus               = function(aTarget: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClear                                = procedure(aMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearColor                           = procedure(aRed: GLfloat; aGreen: GLfloat; aBlue: GLfloat; aAlpha: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearDepthf                          = procedure(d: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearStencil                         = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglColorMask                            = procedure(aRed: GLboolean; aGreen: GLboolean; aBlue: GLboolean; aAlpha: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCompileShader                        = procedure(aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCompressedTexImage2D                 = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aBorder: GLint; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCompressedTexSubImage2D              = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCopyTexImage2D                       = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei; aBorder: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCopyTexSubImage2D                    = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCreateProgram                        = function: GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCreateShader                         = function(aType: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCullFace                             = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteBuffers                        = procedure(n: GLsizei; const aBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteFramebuffers                   = procedure(n: GLsizei; const aFrameBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteProgram                        = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteRenderbuffers                  = procedure(n: GLsizei; const aRenderBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteShader                         = procedure(aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteTextures                       = procedure(n: GLsizei; const aTextures: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDepthFunc                            = procedure(aFunc: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDepthMask                            = procedure(aFlag: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDepthRangef                          = procedure(n: GLfloat; aF: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDetachShader                         = procedure(aProgram: GLuint; aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDisable                              = procedure(aCap: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDisableVertexAttribArray             = procedure(aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawArrays                           = procedure(aMode: GLenum; aFirst: GLint; aCount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawElements                         = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglEnable                               = procedure(aCap: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglEnableVertexAttribArray              = procedure(aIndex: GLuint); {$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}
  TglFramebufferRenderbuffer              = procedure(aTarget: GLenum; aAttachment: GLenum; aRenderbuffertarget: GLenum; aRenderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFramebufferTexture2D                 = procedure(aTarget: GLenum; aAttachment: GLenum; aTextarget: GLenum; aTexture: GLuint; aLevel: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFrontFace                            = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenBuffers                           = procedure(n: GLsizei; aBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenerateMipmap                       = procedure(aTarget: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenFramebuffers                      = procedure(n: GLsizei; aFramebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenRenderbuffers                     = procedure(n: GLsizei; aRenderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenTextures                          = procedure(n: GLsizei; aTextures: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetActiveAttrib                      = procedure(aProgram: GLuint; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSize: PGLint; aType: PGLenum; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetActiveUniform                     = procedure(aProgram: GLuint; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSize: PGLint; aType: PGLenum; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetAttachedShaders                   = procedure(aProgram: GLuint; aMaxCount: GLsizei; aCount: PGLsizei; aShaders: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetAttribLocation                    = function(aProgram: GLuint; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetBooleanv                          = procedure(aPname: GLenum; aData: PGLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetBufferParameteriv                 = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetError                             = function: GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetFloatv                            = procedure(aPname: GLenum; aData: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetFramebufferAttachmentParameteriv  = procedure(aTarget: GLenum; aAttachment: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetIntegerv                          = procedure(aPname: GLenum; aData: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramiv                         = procedure(aProgram: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramInfoLog                    = procedure(aProgram: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aInfoLog: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetRenderbufferParameteriv           = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetShaderiv                          = procedure(aShader: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetShaderInfoLog                     = procedure(aShader: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aInfoLog: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetShaderPrecisionFormat             = procedure(aShadertype: GLenum; aPrecisiontype: GLenum; aRange: PGLint; aPrecision: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetShaderSource                      = procedure(aShader: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSource: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetString                            = function(aName: GLenum): PAnsiChar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexParameterfv                    = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexParameteriv                    = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetUniformfv                         = procedure(aProgram: GLuint; aLocation: GLint; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetUniformiv                         = procedure(aProgram: GLuint; aLocation: GLint; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetUniformLocation                   = function(aProgram: GLuint; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetVertexAttribfv                    = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetVertexAttribiv                    = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetVertexAttribPointerv              = procedure(aIndex: GLuint; aPname: GLenum; aPointer: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglHint                                 = procedure(aTarget: GLenum; aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsBuffer                             = function(aBuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsEnabled                            = function(aCap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsFramebuffer                        = function(aFramebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsProgram                            = function(aProgram: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsRenderbuffer                       = function(aRenderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsShader                             = function(aShader: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsTexture                            = function(aTexture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLineWidth                            = procedure(aWidth: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLinkProgram                          = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPixelStorei                          = procedure(aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPolygonOffset                        = procedure(aFactor: GLfloat; aUnits: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglReadPixels                           = procedure(aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aType: GLenum; aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglReleaseShaderCompiler                = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglRenderbufferStorage                  = procedure(aTarget: GLenum; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSampleCoverage                       = procedure(aValue: GLfloat; aInvert: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglScissor                              = procedure(aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglShaderBinary                         = procedure(aCount: GLsizei; const aShaders: PGLuint; aBinaryformat: GLenum; const aBinary: PGLvoid; aLength: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglShaderSource                         = procedure(aShader: GLuint; aCount: GLsizei; const aString: PPGLchar; const aLength: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilFunc                          = procedure(aFunc: GLenum; aRef: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilFuncSeparate                  = procedure(aFace: GLenum; aFunc: GLenum; aRef: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilMask                          = procedure(aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilMaskSeparate                  = procedure(aFace: GLenum; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilOp                            = procedure(aFail: GLenum; aZfail: GLenum; aZpass: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilOpSeparate                    = procedure(aFace: GLenum; aSfail: GLenum; aDpfail: GLenum; aDppass: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexImage2D                           = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLint; aWidth: GLsizei; aHeight: GLsizei; aBorder: GLint; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexParameterf                        = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexParameterfv                       = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexParameteri                        = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexParameteriv                       = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexSubImage2D                        = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1f                            = procedure(aLocation: GLint; aV0: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1fv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1i                            = procedure(aLocation: GLint; aV0: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1iv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2f                            = procedure(aLocation: GLint; aV0: GLfloat; aV1: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2fv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2i                            = procedure(aLocation: GLint; aV0: GLint; aV1: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2iv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3f                            = procedure(aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3fv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3i                            = procedure(aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3iv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4f                            = procedure(aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat; aV3: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4fv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4i                            = procedure(aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint; aV3: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4iv                           = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix2fv                     = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix3fv                     = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix4fv                     = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUseProgram                           = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglValidateProgram                      = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib1f                       = procedure(aIndex: GLuint; aX: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib1fv                      = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib2f                       = procedure(aIndex: GLuint; aX: GLfloat; aY: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib2fv                      = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib3f                       = procedure(aIndex: GLuint; aX: GLfloat; aY: GLfloat; aZ: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib3fv                      = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib4f                       = procedure(aIndex: GLuint; aX: GLfloat; aY: GLfloat; aZ: GLfloat; aW: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib4fv                      = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribPointer                  = procedure(aIndex: GLuint; aSize: GLint; aType: GLenum; aNormalized: GLboolean; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglViewport                             = procedure(aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  { OpenGL ES 3.0 }
  TglReadBuffer                           = procedure(aSrc: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawRangeElements                    = procedure(aMode: GLenum; aStart: GLuint; aEnd: GLuint; aCount: GLsizei; aType: GLenum; const aIndices: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexImage3D                           = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aBorder: GLint; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexSubImage3D                        = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCopyTexSubImage3D                    = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCompressedTexImage3D                 = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aBorder: GLint; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCompressedTexSubImage3D              = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFormat: GLenum; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenQueries                           = procedure(n: GLsizei; aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteQueries                        = procedure(n: GLsizei; const aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsQuery                              = function(aId: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBeginQuery                           = procedure(aTarget: GLenum; aId: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglEndQuery                             = procedure(aTarget: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetQueryiv                           = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetQueryObjectuiv                    = procedure(aId: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUnmapBuffer                          = function(aTarget: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetBufferPointerv                    = procedure(aTarget: GLenum; aPname: GLenum; aParams: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawBuffers                          = procedure(n: GLsizei; const aBufs: PGLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix2x3fv                   = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix3x2fv                   = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix2x4fv                   = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix4x2fv                   = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix3x4fv                   = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformMatrix4x3fv                   = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlitFramebuffer                      = procedure(aSrcX0: GLint; aSrcY0: GLint; aSrcX1: GLint; aSrcY1: GLint; aDstX0: GLint; aDstY0: GLint; aDstX1: GLint; aDstY1: GLint; aMask: GLbitfield; aFilter: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglRenderbufferStorageMultisample       = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFramebufferTextureLayer              = procedure(aTarget: GLenum; aAttachment: GLenum; aTexture: GLuint; aLevel: GLint; aLayer: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMapBufferRange                       = function(aTarget: GLenum; aOffset: PGLint; aLength: PGLsizei; aAccess: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFlushMappedBufferRange               = procedure(aTarget: GLenum; aOffset: PGLint; aLength: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindVertexArray                      = procedure(aArray: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteVertexArrays                   = procedure(n: GLsizei; const aArrays: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenVertexArrays                      = procedure(n: GLsizei; aArrays: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsVertexArray                        = function(aArray: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetIntegeri_v                        = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBeginTransformFeedback               = procedure(aPrimitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglEndTransformFeedback                 = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindBufferRange                      = procedure(aTarget: GLenum; aIndex: GLuint; aBuffer: GLuint; aOffset: PGLint; aSize: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindBufferBase                       = procedure(aTarget: GLenum; aIndex: GLuint; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTransformFeedbackVaryings            = procedure(aProgram: GLuint; aCount: GLsizei; const aVaryings: PPGLchar; aBufferMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTransformFeedbackVarying          = procedure(aProgram: GLuint; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSize: PGLsizei; aType: PGLenum; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribIPointer                 = procedure(aIndex: GLuint; aSize: GLint; aType: GLenum; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetVertexAttribIiv                   = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetVertexAttribIuiv                  = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribI4i                      = procedure(aIndex: GLuint; aX: GLint; aY: GLint; aZ: GLint; aW: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribI4ui                     = procedure(aIndex: GLuint; aX: GLuint; aY: GLuint; aZ: GLuint; aW: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribI4iv                     = procedure(aIndex: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribI4uiv                    = procedure(aIndex: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetUniformuiv                        = procedure(aProgram: GLuint; aLocation: GLint; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetFragDataLocation                  = function(aProgram: GLuint; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1ui                           = procedure(aLocation: GLint; aV0: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2ui                           = procedure(aLocation: GLint; aV0: GLuint; aV1: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3ui                           = procedure(aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4ui                           = procedure(aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint; aV3: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1uiv                          = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2uiv                          = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3uiv                          = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4uiv                          = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearBufferiv                        = procedure(aBuffer: GLenum; aDrawbuffer: GLint; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearBufferuiv                       = procedure(aBuffer: GLenum; aDrawbuffer: GLint; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearBufferfv                        = procedure(aBuffer: GLenum; aDrawbuffer: GLint; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearBufferfi                        = procedure(aBuffer: GLenum; aDrawbuffer: GLint; aDepth: GLfloat; aStencil: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetStringi                           = function(aName: GLenum; aIndex: GLuint): PGLchar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCopyBufferSubData                    = procedure(aReadTarget: GLenum; aWriteTarget: GLenum; aReadOffset: PGLint; aWriteOffset: PGLint; aSize: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetUniformIndices                    = procedure(aProgram: GLuint; aUniformCount: GLsizei; const aUniformNames: PPGLchar; aUniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetActiveUniformsiv                  = procedure(aProgram: GLuint; aUniformCount: GLsizei; const aUniformIndices: PGLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetUniformBlockIndex                 = function(aProgram: GLuint; const aUniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetActiveUniformBlockiv              = procedure(aProgram: GLuint; aUniformBlockIndex: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetActiveUniformBlockName            = procedure(aProgram: GLuint; aUniformBlockIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aUniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniformBlockBinding                  = procedure(aProgram: GLuint; aUniformBlockIndex: GLuint; aUniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawArraysInstanced                  = procedure(aMode: GLenum; aFirst: GLint; aCount: GLsizei; aInstancecount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawElementsInstanced                = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: PGLvoid; aInstanceCount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFenceSync                            = function(aCondition: GLenum; aFlags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsSync                               = function(aSync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteSync                           = procedure(aSync: GLsync); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClientWaitSync                       = function(aSync: GLsync; aFlags: GLbitfield; aTimeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglWaitSync                             = procedure(aSync: GLsync; aFlags: GLbitfield; aTimeout: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetInteger64v                        = procedure(aPname: GLenum; aData: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetSynciv                            = procedure(aSync: GLsync; aPname: GLenum; aBufSize: GLsizei; aLength: PGLsizei; aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetInteger64i_v                      = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetBufferParameteri64v               = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenSamplers                          = procedure(aCount: GLsizei; aSamplers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteSamplers                       = procedure(aCount: GLsizei; const aSamplers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsSampler                            = function(aSampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindSampler                          = procedure(aUnit: GLuint; aSampler: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSamplerParameteri                    = procedure(aSampler: GLuint; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSamplerParameteriv                   = procedure(aSampler: GLuint; aPname: GLenum; const aParam: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSamplerParameterf                    = procedure(aSampler: GLuint; aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSamplerParameterfv                   = procedure(aSampler: GLuint; aPname: GLenum; const aParam: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetSamplerParameteriv                = procedure(aSampler: GLuint; aPname: GLenum; const aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetSamplerParameterfv                = procedure(aSampler: GLuint; aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribDivisor                  = procedure(aIndex: GLuint; aDivisor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindTransformFeedback                = procedure(aTarget: GLenum; aId: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteTransformFeedbacks             = procedure(n: GLsizei; const aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenTransformFeedbacks                = procedure(n: GLsizei; const aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsTransformFeedback                  = function(aId: 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}
  TglGetProgramBinary                     = procedure(aProgram: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aBinaryFormat: PGLenum; aBinary: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramBinary                        = procedure(aProgram: GLuint; aBinaryFormat: GLenum; const aBinary: PGLvoid; aLength: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramParameteri                    = procedure(aProgram: GLuint; aPname: GLenum; aValue: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglInvalidateFramebuffer                = procedure(aTarget: GLenum; aNumAttachments: GLsizei; const aAttachments: PGLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglInvalidateSubFramebuffer             = procedure(aTarget: GLenum; aNumAttachments: GLsizei; const aAttachments: PGLenum; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexStorage2D                         = procedure(aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexStorage3D                         = procedure(aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetInternalformativ                  = procedure(aTarget: GLenum; aInternalformat: GLenum; aPname: GLenum; aBufSize: GLsizei; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  { OpenGL ES 3.1 }
  TglDispatchCompute                      = procedure(aNumGroupsX: GLuint; aNumGroupsY: GLuint; aNumGroupsZ: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDispatchComputeIndirect              = procedure(aIndirect: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawArraysIndirect                   = procedure(aMode: GLenum; const aIndirect: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDrawElementsIndirect                 = procedure(aMode: GLenum; aType: GLenum; const aIndirect: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFramebufferParameteri                = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetFramebufferParameteriv            = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramInterfaceiv                = procedure(aProgram: GLuint; aProgramInterface: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramResourceIndex              = function (aProgram: GLuint; aProgramInterface: GLenum; const aName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramResourceName               = procedure(aProgram: GLuint; aProgramInterface: GLenum; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramResourceiv                 = procedure(aProgram: GLuint; aProgramInterface: GLenum; aIndex: GLuint; aPropCount: GLsizei; const aProps: PGLenum; aBufSize: GLsizei; aLength: PGLsizei; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramResourceLocation           = function (aProgram: GLuint; aProgramInterface: GLenum; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUseProgramStages                     = procedure(aPipeline: GLuint; aStages: GLbitfield; aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglActiveShaderProgram                  = procedure(aPipeline: GLuint; aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCreateShaderProgramv                 = function (aType: GLenum; aCount: GLsizei; const aStrings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindProgramPipeline                  = procedure(aPipeline: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDeleteProgramPipelines               = procedure(aN: GLsizei; const aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenProgramPipelines                  = procedure(aN: GLsizei; aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglIsProgramPipeline                    = function (aPipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramPipelineiv                 = procedure(aPipeline: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1i                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2i                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3i                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4i                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint; aV3: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1ui                    = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2ui                    = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3ui                    = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4ui                    = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint; aV3: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1f                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2f                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3f                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4f                     = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat; aV3: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1iv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2iv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3iv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4iv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1uiv                   = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2uiv                   = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3uiv                   = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4uiv                   = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1fv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2fv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3fv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4fv                    = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix2fv              = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix3fv              = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix4fv              = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix2x3fv            = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix3x2fv            = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix2x4fv            = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix4x2fv            = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix3x4fv            = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniformMatrix4x3fv            = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglValidateProgramPipeline              = procedure(aPipeline: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetProgramPipelineInfoLog            = procedure(aPipeline: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aInfoLog: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindImageTexture                     = procedure(aUnit: GLuint; aTexture: GLuint; aLevel: GLint; aLayered: GLboolean; aLayer: GLint; aAccess: GLenum; aFormat: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetBooleaniV                         = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMemoryBarrier                        = procedure(aBarriers: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMemoryBarrierByRegion                = procedure(aBarriers: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexStorage2DMultisample              = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aFixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetMultisamplefv                     = procedure(aPname: GLenum; aIndex: GLuint; aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSampleMaski                          = procedure(aMaskNumber: GLuint; aMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexLevelParameteriv               = procedure(aTarget: GLenum; aLevel: GLint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexLevelParameterfv               = procedure(aTarget: GLenum; aLevel: GLint; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindVertexBuffer                     = procedure(aBindingindex: GLuint; aBuffer: GLuint; aOffset: PGLint; aStride: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribFormat                   = procedure(aAttribindex: GLuint; aSize: GLint; aType: GLenum; aNormalized: GLboolean; aRelativeoffset: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribIFormat                  = procedure(aAttribindex: GLuint; aSize: GLint; aType: GLenum; aRelativeoffset: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribBinding                  = procedure(aAttribindex: GLuint; aBindingindex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexBindingDivisor                 = procedure(aBindingindex: GLuint; aDivisor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}


var
  { *** PROCEDURES *** }
  { OpenGL ES 2.0 }
  glActiveTexture:                          TglActiveTexture;
  glAttachShader:                           TglAttachShader;
  glBindAttribLocation:                     TglBindAttribLocation;
  glBindBuffer:                             TglBindBuffer;
  glBindFramebuffer:                        TglBindFramebuffer;
  glBindRenderbuffer:                       TglBindRenderbuffer;
  glBindTexture:                            TglBindTexture;
  glBlendColor:                             TglBlendColor;
  glBlendEquation:                          TglBlendEquation;
  glBlendEquationSeparate:                  TglBlendEquationSeparate;
  glBlendFunc:                              TglBlendFunc;
  glBlendFuncSeparate:                      TglBlendFuncSeparate;
  glBufferData:                             TglBufferData;
  glBufferSubData:                          TglBufferSubData;
  glCheckFramebufferStatus:                 TglCheckFramebufferStatus;
  glClear:                                  TglClear;
  glClearColor:                             TglClearColor;
  glClearDepthf:                            TglClearDepthf;
  glClearStencil:                           TglClearStencil;
  glColorMask:                              TglColorMask;
  glCompileShader:                          TglCompileShader;
  glCompressedTexImage2D:                   TglCompressedTexImage2D;
  glCompressedTexSubImage2D:                TglCompressedTexSubImage2D;
  glCopyTexImage2D:                         TglCopyTexImage2D;
  glCopyTexSubImage2D:                      TglCopyTexSubImage2D;
  glCreateProgram:                          TglCreateProgram;
  glCreateShader:                           TglCreateShader;
  glCullFace:                               TglCullFace;
  glDeleteBuffers:                          TglDeleteBuffers;
  glDeleteFramebuffers:                     TglDeleteFramebuffers;
  glDeleteProgram:                          TglDeleteProgram;
  glDeleteRenderbuffers:                    TglDeleteRenderbuffers;
  glDeleteShader:                           TglDeleteShader;
  glDeleteTextures:                         TglDeleteTextures;
  glDepthFunc:                              TglDepthFunc;
  glDepthMask:                              TglDepthMask;
  glDepthRangef:                            TglDepthRangef;
  glDetachShader:                           TglDetachShader;
  glDisable:                                TglDisable;
  glDisableVertexAttribArray:               TglDisableVertexAttribArray;
  glDrawArrays:                             TglDrawArrays;
  glDrawElements:                           TglDrawElements;
  glEnable:                                 TglEnable;
  glEnableVertexAttribArray:                TglEnableVertexAttribArray;
  glFinish:                                 TglFinish;
  glFlush:                                  TglFlush;
  glFramebufferRenderbuffer:                TglFramebufferRenderbuffer;
  glFramebufferTexture2D:                   TglFramebufferTexture2D;
  glFrontFace:                              TglFrontFace;
  glGenBuffers:                             TglGenBuffers;
  glGenerateMipmap:                         TglGenerateMipmap;
  glGenFramebuffers:                        TglGenFramebuffers;
  glGenRenderbuffers:                       TglGenRenderbuffers;
  glGenTextures:                            TglGenTextures;
  glGetActiveAttrib:                        TglGetActiveAttrib;
  glGetActiveUniform:                       TglGetActiveUniform;
  glGetAttachedShaders:                     TglGetAttachedShaders;
  glGetAttribLocation:                      TglGetAttribLocation;
  glGetBooleanv:                            TglGetBooleanv;
  glGetBufferParameteriv:                   TglGetBufferParameteriv;
  glGetError:                               TglGetError;
  glGetFloatv:                              TglGetFloatv;
  glGetFramebufferAttachmentParameteriv:    TglGetFramebufferAttachmentParameteriv;
  glGetIntegerv:                            TglGetIntegerv;
  glGetProgramiv:                           TglGetProgramiv;
  glGetProgramInfoLog:                      TglGetProgramInfoLog;
  glGetRenderbufferParameteriv:             TglGetRenderbufferParameteriv;
  glGetShaderiv:                            TglGetShaderiv;
  glGetShaderInfoLog:                       TglGetShaderInfoLog;
  glGetShaderPrecisionFormat:               TglGetShaderPrecisionFormat;
  glGetShaderSource:                        TglGetShaderSource;
  glGetString:                              TglGetString;
  glGetTexParameterfv:                      TglGetTexParameterfv;
  glGetTexParameteriv:                      TglGetTexParameteriv;
  glGetUniformfv:                           TglGetUniformfv;
  glGetUniformiv:                           TglGetUniformiv;
  glGetUniformLocation:                     TglGetUniformLocation;
  glGetVertexAttribfv:                      TglGetVertexAttribfv;
  glGetVertexAttribiv:                      TglGetVertexAttribiv;
  glGetVertexAttribPointerv:                TglGetVertexAttribPointerv;
  glHint:                                   TglHint;
  glIsBuffer:                               TglIsBuffer;
  glIsEnabled:                              TglIsEnabled;
  glIsFramebuffer:                          TglIsFramebuffer;
  glIsProgram:                              TglIsProgram;
  glIsRenderbuffer:                         TglIsRenderbuffer;
  glIsShader:                               TglIsShader;
  glIsTexture:                              TglIsTexture;
  glLineWidth:                              TglLineWidth;
  glLinkProgram:                            TglLinkProgram;
  glPixelStorei:                            TglPixelStorei;
  glPolygonOffset:                          TglPolygonOffset;
  glReadPixels:                             TglReadPixels;
  glReleaseShaderCompiler:                  TglReleaseShaderCompiler;
  glRenderbufferStorage:                    TglRenderbufferStorage;
  glSampleCoverage:                         TglSampleCoverage;
  glScissor:                                TglScissor;
  glShaderBinary:                           TglShaderBinary;
  glShaderSource:                           TglShaderSource;
  glStencilFunc:                            TglStencilFunc;
  glStencilFuncSeparate:                    TglStencilFuncSeparate;
  glStencilMask:                            TglStencilMask;
  glStencilMaskSeparate:                    TglStencilMaskSeparate;
  glStencilOp:                              TglStencilOp;
  glStencilOpSeparate:                      TglStencilOpSeparate;
  glTexImage2D:                             TglTexImage2D;
  glTexParameterf:                          TglTexParameterf;
  glTexParameterfv:                         TglTexParameterfv;
  glTexParameteri:                          TglTexParameteri;
  glTexParameteriv:                         TglTexParameteriv;
  glTexSubImage2D:                          TglTexSubImage2D;
  glUniform1f:                              TglUniform1f;
  glUniform1fv:                             TglUniform1fv;
  glUniform1i:                              TglUniform1i;
  glUniform1iv:                             TglUniform1iv;
  glUniform2f:                              TglUniform2f;
  glUniform2fv:                             TglUniform2fv;
  glUniform2i:                              TglUniform2i;
  glUniform2iv:                             TglUniform2iv;
  glUniform3f:                              TglUniform3f;
  glUniform3fv:                             TglUniform3fv;
  glUniform3i:                              TglUniform3i;
  glUniform3iv:                             TglUniform3iv;
  glUniform4f:                              TglUniform4f;
  glUniform4fv:                             TglUniform4fv;
  glUniform4i:                              TglUniform4i;
  glUniform4iv:                             TglUniform4iv;
  glUniformMatrix2fv:                       TglUniformMatrix2fv;
  glUniformMatrix3fv:                       TglUniformMatrix3fv;
  glUniformMatrix4fv:                       TglUniformMatrix4fv;
  glUseProgram:                             TglUseProgram;
  glValidateProgram:                        TglValidateProgram;
  glVertexAttrib1f:                         TglVertexAttrib1f;
  glVertexAttrib1fv:                        TglVertexAttrib1fv;
  glVertexAttrib2f:                         TglVertexAttrib2f;
  glVertexAttrib2fv:                        TglVertexAttrib2fv;
  glVertexAttrib3f:                         TglVertexAttrib3f;
  glVertexAttrib3fv:                        TglVertexAttrib3fv;
  glVertexAttrib4f:                         TglVertexAttrib4f;
  glVertexAttrib4fv:                        TglVertexAttrib4fv;
  glVertexAttribPointer:                    TglVertexAttribPointer;
  glViewport:                               TglViewport;

  { OpenGL ES 3.0 }
  glReadBuffer:                             TglReadBuffer;
  glDrawRangeElements:                      TglDrawRangeElements;
  glTexImage3D:                             TglTexImage3D;
  glTexSubImage3D:                          TglTexSubImage3D;
  glCopyTexSubImage3D:                      TglCopyTexSubImage3D;
  glCompressedTexImage3D:                   TglCompressedTexImage3D;
  glCompressedTexSubImage3D:                TglCompressedTexSubImage3D;
  glGenQueries:                             TglGenQueries;
  glDeleteQueries:                          TglDeleteQueries;
  glIsQuery:                                TglIsQuery;
  glBeginQuery:                             TglBeginQuery;
  glEndQuery:                               TglEndQuery;
  glGetQueryiv:                             TglGetQueryiv;
  glGetQueryObjectuiv:                      TglGetQueryObjectuiv;
  glUnmapBuffer:                            TglUnmapBuffer;
  glGetBufferPointerv:                      TglGetBufferPointerv;
  glDrawBuffers:                            TglDrawBuffers;
  glUniformMatrix2x3fv:                     TglUniformMatrix2x3fv;
  glUniformMatrix3x2fv:                     TglUniformMatrix3x2fv;
  glUniformMatrix2x4fv:                     TglUniformMatrix2x4fv;
  glUniformMatrix4x2fv:                     TglUniformMatrix4x2fv;
  glUniformMatrix3x4fv:                     TglUniformMatrix3x4fv;
  glUniformMatrix4x3fv:                     TglUniformMatrix4x3fv;
  glBlitFramebuffer:                        TglBlitFramebuffer;
  glRenderbufferStorageMultisample:         TglRenderbufferStorageMultisample;
  glFramebufferTextureLayer:                TglFramebufferTextureLayer;
  glMapBufferRange:                         TglMapBufferRange;
  glFlushMappedBufferRange:                 TglFlushMappedBufferRange;
  glBindVertexArray:                        TglBindVertexArray;
  glDeleteVertexArrays:                     TglDeleteVertexArrays;
  glGenVertexArrays:                        TglGenVertexArrays;
  glIsVertexArray:                          TglIsVertexArray;
  glGetIntegeri_v:                          TglGetIntegeri_v;
  glBeginTransformFeedback:                 TglBeginTransformFeedback;
  glEndTransformFeedback:                   TglEndTransformFeedback;
  glBindBufferRange:                        TglBindBufferRange;
  glBindBufferBase:                         TglBindBufferBase;
  glTransformFeedbackVaryings:              TglTransformFeedbackVaryings;
  glGetTransformFeedbackVarying:            TglGetTransformFeedbackVarying;
  glVertexAttribIPointer:                   TglVertexAttribIPointer;
  glGetVertexAttribIiv:                     TglGetVertexAttribIiv;
  glGetVertexAttribIuiv:                    TglGetVertexAttribIuiv;
  glVertexAttribI4i:                        TglVertexAttribI4i;
  glVertexAttribI4ui:                       TglVertexAttribI4ui;
  glVertexAttribI4iv:                       TglVertexAttribI4iv;
  glVertexAttribI4uiv:                      TglVertexAttribI4uiv;
  glGetUniformuiv:                          TglGetUniformuiv;
  glGetFragDataLocation:                    TglGetFragDataLocation;
  glUniform1ui:                             TglUniform1ui;
  glUniform2ui:                             TglUniform2ui;
  glUniform3ui:                             TglUniform3ui;
  glUniform4ui:                             TglUniform4ui;
  glUniform1uiv:                            TglUniform1uiv;
  glUniform2uiv:                            TglUniform2uiv;
  glUniform3uiv:                            TglUniform3uiv;
  glUniform4uiv:                            TglUniform4uiv;
  glClearBufferiv:                          TglClearBufferiv;
  glClearBufferuiv:                         TglClearBufferuiv;
  glClearBufferfv:                          TglClearBufferfv;
  glClearBufferfi:                          TglClearBufferfi;
  glGetStringi:                             TglGetStringi;
  glCopyBufferSubData:                      TglCopyBufferSubData;
  glGetUniformIndices:                      TglGetUniformIndices;
  glGetActiveUniformsiv:                    TglGetActiveUniformsiv;
  glGetUniformBlockIndex:                   TglGetUniformBlockIndex;
  glGetActiveUniformBlockiv:                TglGetActiveUniformBlockiv;
  glGetActiveUniformBlockName:              TglGetActiveUniformBlockName;
  glUniformBlockBinding:                    TglUniformBlockBinding;
  glDrawArraysInstanced:                    TglDrawArraysInstanced;
  glDrawElementsInstanced:                  TglDrawElementsInstanced;
  glFenceSync:                              TglFenceSync;
  glIsSync:                                 TglIsSync;
  glDeleteSync:                             TglDeleteSync;
  glClientWaitSync:                         TglClientWaitSync;
  glWaitSync:                               TglWaitSync;
  glGetInteger64v:                          TglGetInteger64v;
  glGetSynciv:                              TglGetSynciv;
  glGetInteger64i_v:                        TglGetInteger64i_v;
  glGetBufferParameteri64v:                 TglGetBufferParameteri64v;
  glGenSamplers:                            TglGenSamplers;
  glDeleteSamplers:                         TglDeleteSamplers;
  glIsSampler:                              TglIsSampler;
  glBindSampler:                            TglBindSampler;
  glSamplerParameteri:                      TglSamplerParameteri;
  glSamplerParameteriv:                     TglSamplerParameteriv;
  glSamplerParameterf:                      TglSamplerParameterf;
  glSamplerParameterfv:                     TglSamplerParameterfv;
  glGetSamplerParameteriv:                  TglGetSamplerParameteriv;
  glGetSamplerParameterfv:                  TglGetSamplerParameterfv;
  glVertexAttribDivisor:                    TglVertexAttribDivisor;
  glBindTransformFeedback:                  TglBindTransformFeedback;
  glDeleteTransformFeedbacks:               TglDeleteTransformFeedbacks;
  glGenTransformFeedbacks:                  TglGenTransformFeedbacks;
  glIsTransformFeedback:                    TglIsTransformFeedback;
  glPauseTransformFeedback:                 TglPauseTransformFeedback;
  glResumeTransformFeedback:                TglResumeTransformFeedback;
  glGetProgramBinary:                       TglGetProgramBinary;
  glProgramBinary:                          TglProgramBinary;
  glProgramParameteri:                      TglProgramParameteri;
  glInvalidateFramebuffer:                  TglInvalidateFramebuffer;
  glInvalidateSubFramebuffer:               TglInvalidateSubFramebuffer;
  glTexStorage2D:                           TglTexStorage2D;
  glTexStorage3D:                           TglTexStorage3D;
  glGetInternalformativ:                    TglGetInternalformativ;

  { OpenGL ES 3.1 }
  glDispatchCompute:                        TglDispatchCompute;
  glDispatchComputeIndirect:                TglDispatchComputeIndirect;
  glDrawArraysIndirect:                     TglDrawArraysIndirect;
  glDrawElementsIndirect:                   TglDrawElementsIndirect;
  glFramebufferParameteri:                  TglFramebufferParameteri;
  glGetFramebufferParameteriv:              TglGetFramebufferParameteriv;
  glGetProgramInterfaceiv:                  TglGetProgramInterfaceiv;
  glGetProgramResourceIndex:                TglGetProgramResourceIndex;
  glGetProgramResourceName:                 TglGetProgramResourceName;
  glGetProgramResourceiv:                   TglGetProgramResourceiv;
  glGetProgramResourceLocation:             TglGetProgramResourceLocation;
  glUseProgramStages:                       TglUseProgramStages;
  glActiveShaderProgram:                    TglActiveShaderProgram;
  glCreateShaderProgramv:                   TglCreateShaderProgramv;
  glBindProgramPipeline:                    TglBindProgramPipeline;
  glDeleteProgramPipelines:                 TglDeleteProgramPipelines;
  glGenProgramPipelines:                    TglGenProgramPipelines;
  glIsProgramPipeline:                      TglIsProgramPipeline;
  glGetProgramPipelineiv:                   TglGetProgramPipelineiv;
  glProgramUniform1i:                       TglProgramUniform1i;
  glProgramUniform2i:                       TglProgramUniform2i;
  glProgramUniform3i:                       TglProgramUniform3i;
  glProgramUniform4i:                       TglProgramUniform4i;
  glProgramUniform1ui:                      TglProgramUniform1ui;
  glProgramUniform2ui:                      TglProgramUniform2ui;
  glProgramUniform3ui:                      TglProgramUniform3ui;
  glProgramUniform4ui:                      TglProgramUniform4ui;
  glProgramUniform1f:                       TglProgramUniform1f;
  glProgramUniform2f:                       TglProgramUniform2f;
  glProgramUniform3f:                       TglProgramUniform3f;
  glProgramUniform4f:                       TglProgramUniform4f;
  glProgramUniform1iv:                      TglProgramUniform1iv;
  glProgramUniform2iv:                      TglProgramUniform2iv;
  glProgramUniform3iv:                      TglProgramUniform3iv;
  glProgramUniform4iv:                      TglProgramUniform4iv;
  glProgramUniform1uiv:                     TglProgramUniform1uiv;
  glProgramUniform2uiv:                     TglProgramUniform2uiv;
  glProgramUniform3uiv:                     TglProgramUniform3uiv;
  glProgramUniform4uiv:                     TglProgramUniform4uiv;
  glProgramUniform1fv:                      TglProgramUniform1fv;
  glProgramUniform2fv:                      TglProgramUniform2fv;
  glProgramUniform3fv:                      TglProgramUniform3fv;
  glProgramUniform4fv:                      TglProgramUniform4fv;
  glProgramUniformMatrix2fv:                TglProgramUniformMatrix2fv;
  glProgramUniformMatrix3fv:                TglProgramUniformMatrix3fv;
  glProgramUniformMatrix4fv:                TglProgramUniformMatrix4fv;
  glProgramUniformMatrix2x3fv:              TglProgramUniformMatrix2x3fv;
  glProgramUniformMatrix3x2fv:              TglProgramUniformMatrix3x2fv;
  glProgramUniformMatrix2x4fv:              TglProgramUniformMatrix2x4fv;
  glProgramUniformMatrix4x2fv:              TglProgramUniformMatrix4x2fv;
  glProgramUniformMatrix3x4fv:              TglProgramUniformMatrix3x4fv;
  glProgramUniformMatrix4x3fv:              TglProgramUniformMatrix4x3fv;
  glValidateProgramPipeline:                TglValidateProgramPipeline;
  glGetProgramPipelineInfoLog:              TglGetProgramPipelineInfoLog;
  glBindImageTexture:                       TglBindImageTexture;
  glGetBooleaniV:                           TglGetBooleaniV;
  glMemoryBarrier:                          TglMemoryBarrier;
  glMemoryBarrierByRegion:                  TglMemoryBarrierByRegion;
  glTexStorage2DMultisample:                TglTexStorage2DMultisample;
  glGetMultisamplefv:                       TglGetMultisamplefv;
  glSampleMaski:                            TglSampleMaski;
  glGetTexLevelParameteriv:                 TglGetTexLevelParameteriv;
  glGetTexLevelParameterfv:                 TglGetTexLevelParameterfv;
  glBindVertexBuffer:                       TglBindVertexBuffer;
  glVertexAttribFormat:                     TglVertexAttribFormat;
  glVertexAttribIFormat:                    TglVertexAttribIFormat;
  glVertexAttribBinding:                    TglVertexAttribBinding;
  glVertexBindingDivisor:                   TglVertexBindingDivisor;


{ ===================================================== EGL ========================================================== }
type
  EGLint                = Integer;
  EGLboolean            = Cardinal;
  EGLenum               = Cardinal;
  EGLConfig             = Pointer;
  EGLContext            = Pointer;
  EGLDisplay            = Pointer;
  EGLSurface            = Pointer;
  EGLClientBuffer       = Pointer;
  EGLNativeDisplayType  = Pointer;
  EGLNativePixmapType   = Pointer;
  EGLNativeWindowType   = packed record
     element: Cardinal;
     width: Integer;
     height: Integer;
  end;

  PEGLint               = ^EGLint;
  PEGLboolean           = ^EGLboolean;
  PEGLenum              = ^EGLenum;
  PEGLConfig            = ^EGLConfig;
  PEGLContext           = ^EGLContext;
  PEGLDisplay           = ^EGLDisplay;
  PEGLSurface           = ^EGLSurface;
  PEGLClientBuffer      = ^EGLClientBuffer;
  PEGLNativeDisplayType = ^EGLNativeDisplayType;
  PEGLNativePixmapType  = ^EGLNativePixmapType;
  PEGLNativeWindowType  = ^EGLNativeWindowType;

const
  EGL_FALSE: EGLboolean = 0;
  EGL_TRUE:  EGLboolean = 1;

  EGL_DEFAULT_DISPLAY:  EGLNativeDisplayType  = nil;
  EGL_NO_CONTEXT:     	EGLContext           	= nil;
  EGL_NO_DISPLAY:			  EGLDisplay            = nil;
  EGL_NO_SURFACE:			  EGLSurface            = nil;

  EGL_DONT_CARE: EGLint = -1;

  EGL_SUCCESS                         = $3000;
  EGL_NOT_INITIALIZED                 = $3001;
  EGL_BAD_ACCESS                      = $3002;
  EGL_BAD_ALLOC                       = $3003;
  EGL_BAD_ATTRIBUTE                   = $3004;
  EGL_BAD_CONFIG                      = $3005;
  EGL_BAD_CONTEXT                     = $3006;
  EGL_BAD_CURRENT_SURFACE             = $3007;
  EGL_BAD_DISPLAY                     = $3008;
  EGL_BAD_MATCH                       = $3009;
  EGL_BAD_NATIVE_PIXMAP               = $300A;
  EGL_BAD_NATIVE_WINDOW               = $300B;
  EGL_BAD_PARAMETER                   = $300C;
  EGL_BAD_SURFACE                     = $300D;
  EGL_CONTEXT_LOST                    = $300E;

  EGL_BUFFER_SIZE                     = $3020;
  EGL_ALPHA_SIZE                      = $3021;
  EGL_BLUE_SIZE                       = $3022;
  EGL_GREEN_SIZE                      = $3023;
  EGL_RED_SIZE                        = $3024;
  EGL_DEPTH_SIZE                      = $3025;
  EGL_STENCIL_SIZE                    = $3026;
  EGL_CONFIG_CAVEAT                   = $3027;
  EGL_CONFIG_ID                       = $3028;
  EGL_LEVEL                           = $3029;
  EGL_MAX_PBUFFER_HEIGHT              = $302A;
  EGL_MAX_PBUFFER_PIXELS              = $302B;
  EGL_MAX_PBUFFER_WIDTH               = $302C;
  EGL_NATIVE_RENDERABLE               = $302D;
  EGL_NATIVE_VISUAL_ID                = $302E;
  EGL_NATIVE_VISUAL_TYPE              = $302F;
  EGL_SAMPLES                         = $3031;
  EGL_SAMPLE_BUFFERS                  = $3032;
  EGL_SURFACE_TYPE                    = $3033;
  EGL_TRANSPARENT_TYPE                = $3034;
  EGL_TRANSPARENT_BLUE_VALUE          = $3035;
  EGL_TRANSPARENT_GREEN_VALUE         = $3036;
  EGL_TRANSPARENT_RED_VALUE           = $3037;
  EGL_NONE                            = $3038;
  EGL_BIND_TO_TEXTURE_RGB             = $3039;
  EGL_BIND_TO_TEXTURE_RGBA            = $303A;
  EGL_MIN_SWAP_INTERVAL               = $303B;
  EGL_MAX_SWAP_INTERVAL               = $303C;
  EGL_LUMINANCE_SIZE                  = $303D;
  EGL_ALPHA_MASK_SIZE                 = $303E;
  EGL_COLOR_BUFFER_TYPE               = $303F;
  EGL_RENDERABLE_TYPE                 = $3040;
  EGL_MATCH_NATIVE_PIXMAP             = $3041;
  EGL_CONFORMANT                      = $3042;

  EGL_SLOW_CONFIG                     = $3050;
  EGL_NON_CONFORMANT_CONFIG           = $3051;
  EGL_TRANSPARENT_RGB                 = $3052;
  EGL_RGB_BUFFER                      = $308E;
  EGL_LUMINANCE_BUFFER                = $308F;

  EGL_NO_TEXTURE                      = $305C;
  EGL_TEXTURE_RGB                     = $305D;
  EGL_TEXTURE_RGBA                    = $305E;
  EGL_TEXTURE_2D                      = $305F;

  EGL_PBUFFER_BIT                     = $0001;
  EGL_PIXMAP_BIT                      = $0002;
  EGL_WINDOW_BIT                      = $0004;
  EGL_VG_COLORSPACE_LINEAR_BIT        = $0020;
  EGL_VG_ALPHA_FORMAT_PRE_BIT         = $0040;
  EGL_MULTISAMPLE_RESOLVE_BOX_BIT     = $0200;
  EGL_SWAP_BEHAVIOR_PRESERVED_BIT     = $0400;

  EGL_OPENGL_ES_BIT                   = $0001;
  EGL_OPENVG_BIT                      = $0002;
  EGL_OPENGL_ES2_BIT                  = $0004;
  EGL_OPENGL_BIT                      = $0008;

  EGL_VENDOR                          = $3053;
  EGL_VERSION                         = $3054;
  EGL_EXTENSIONS                      = $3055;
  EGL_CLIENT_APIS                     = $308D;

  EGL_HEIGHT                          = $3056;
  EGL_WIDTH                           = $3057;
  EGL_LARGEST_PBUFFER                 = $3058;
  EGL_TEXTURE_FORMAT                  = $3080;
  EGL_TEXTURE_TARGET                  = $3081;
  EGL_MIPMAP_TEXTURE                  = $3082;
  EGL_MIPMAP_LEVEL                    = $3083;
  EGL_RENDER_BUFFER                   = $3086;
  EGL_VG_COLORSPACE                   = $3087;
  EGL_VG_ALPHA_FORMAT                 = $3088;
  EGL_HORIZONTAL_RESOLUTION           = $3090;
  EGL_VERTICAL_RESOLUTION             = $3091;
  EGL_PIXEL_ASPECT_RATIO              = $3092;
  EGL_SWAP_BEHAVIOR                   = $3093;
  EGL_MULTISAMPLE_RESOLVE             = $3099;

  EGL_BACK_BUFFER                     = $3084;
  EGL_SINGLE_BUFFER                   = $3085;

  EGL_VG_COLORSPACE_sRGB              = $3089;
  EGL_VG_COLORSPACE_LINEAR            = $308A;

  EGL_VG_ALPHA_FORMAT_NONPRE          = $308B;
  EGL_VG_ALPHA_FORMAT_PRE             = $308C;

  EGL_DISPLAY_SCALING                 = 10000;

  EGL_UNKNOWN: EGLint                 = -1;

  EGL_BUFFER_PRESERVED                = $3094;
  EGL_BUFFER_DESTROYED                = $3095;

  EGL_OPENVG_IMAGE                    = $3096;

  EGL_CONTEXT_CLIENT_TYPE             = $3097;

  EGL_CONTEXT_CLIENT_VERSION          = $3098;

  EGL_MULTISAMPLE_RESOLVE_DEFAULT     = $309A;
  EGL_MULTISAMPLE_RESOLVE_BOX         = $309B;

  EGL_OPENGL_ES_API                   = $30A0;
  EGL_OPENVG_API                      = $30A1;
  EGL_OPENGL_API                      = $30A2;

  EGL_DRAW                            = $3059;
  EGL_READ                            = $305A;

  EGL_CORE_NATIVE_ENGINE              = $305B;

  EGL_COLORSPACE                      = EGL_VG_COLORSPACE;
  EGL_ALPHA_FORMAT                    = EGL_VG_ALPHA_FORMAT;
  EGL_COLORSPACE_sRGB                 = EGL_VG_COLORSPACE_sRGB;
  EGL_COLORSPACE_LINEAR               = EGL_VG_COLORSPACE_LINEAR;
  EGL_ALPHA_FORMAT_NONPRE             = EGL_VG_ALPHA_FORMAT_NONPRE;
  EGL_ALPHA_FORMAT_PRE                = EGL_VG_ALPHA_FORMAT_PRE;

type
  TeglGetError  = function: EGLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglGetDisplay  = function(aDisplayID: EGLNativeDisplayType): EGLDisplay; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglInitialize  = function(aDisplay: EGLDisplay; aMajor, aMinor: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglTerminate   = function(aDisplay: EGLDisplay): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglQueryString = function(aDisplay: EGLDisplay; aName: EGLint): PAnsiChar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglGetConfigs      = function(aDisplay: EGLDisplay; aConfigs: PEGLConfig; aConfigSize: EGLint; aNumConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglChooseConfig    = function(aDisplay: EGLDisplay; const aAttribList: PEGLint; aConfigs: PEGLConfig; aConfigSize: EGLint; aNumConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglGetConfigAttrib = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aAttribute: EGLint; aValue : PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglCreateWindowSurface   = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aWinType: PEGLNativeWindowType; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglCreatePbufferSurface  = function(aDisplay: EGLDisplay; aConfig: EGLConfig; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglCreatePixmapSurface   = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aPixmap: EGLNativePixmapType; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglDestroySurface        = function(aDisplay: EGLDisplay; aSurface: EGLSurface): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglQuerySurface          = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aAttribute: EGLint; aValue: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglBindAPI   = function(aApi: EGLenum): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglQueryAPI  = function: EGLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglWaitClient = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglReleaseThread = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglCreatePbufferFromClientBuffer = function(aDisplay: EGLDisplay; aBufType: EGLenum; aBuffer: EGLClientBuffer; aConfig: EGLConfig; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglSurfaceAttrib   = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aAttribute: EGLint; aValue: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglBindTexImage    = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aBuffer: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglReleaseTexImage = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aBuffer: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglSwapInterval = function(aDisplay: EGLDisplay; aInterval: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglCreateContext   = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aShareContext: EGLContext; const aAttribList: PEGLint): EGLContext; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglDestroyContext  = function(aDisplay: EGLDisplay; aContext: EGLContext): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglMakeCurrent     = function(aDisplay: EGLDisplay; aDraw: EGLSurface; aRead: EGLSurface; aContext: EGLContext): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglGetCurrentContext = function: EGLContext; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglGetCurrentSurface = function(aReadDraw: EGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglGetCurrentDisplay = function: EGLDisplay; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglQueryContext      = function(aDisplay: EGLDisplay; aContext: EGLContext; aAttribute: EGLint; aValue: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglWaitGL      = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglWaitNative  = function(aEngine: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglSwapBuffers = function(aDisplay: EGLDisplay; aSurface: EGLSurface): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglCopyBuffers = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aTarget: EGLNativePixmapType): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglGetProcAddress = function(const aProcName: PAnsiChar): Pointer; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}


var
  eglGetError: TeglGetError;

  eglGetDisplay:  TeglGetDisplay;
  eglInitialize:  TeglInitialize;
  eglTerminate:   TeglTerminate;

  eglQueryString: TeglQueryString;

  eglGetConfigs:      TeglGetConfigs;
  eglChooseConfig:    TeglChooseConfig;
  eglGetConfigAttrib: TeglGetConfigAttrib;

  eglCreateWindowSurface:   TeglCreateWindowSurface;
  eglCreatePbufferSurface:  TeglCreatePbufferSurface;
  eglCreatePixmapSurface:   TeglCreatePixmapSurface;
  eglDestroySurface:        TeglDestroySurface;
  eglQuerySurface:          TeglQuerySurface;

  eglBindAPI:   TeglBindAPI;
  eglQueryAPI:  TeglQueryAPI;

  eglWaitClient: TeglWaitClient;

  eglReleaseThread: TeglReleaseThread;

  eglCreatePbufferFromClientBuffer: TeglCreatePbufferFromClientBuffer;

  eglSurfaceAttrib:   TeglSurfaceAttrib;
  eglBindTexImage:    TeglBindTexImage;
  eglReleaseTexImage: TeglReleaseTexImage;

  eglSwapInterval: TeglSwapInterval;

  eglCreateContext:   TeglCreateContext;
  eglDestroyContext:  TeglDestroyContext;
  eglMakeCurrent:     TeglMakeCurrent;

  eglGetCurrentContext: TeglGetCurrentContext;
  eglGetCurrentSurface: TeglGetCurrentSurface;
  eglGetCurrentDisplay: TeglGetCurrentDisplay;
  eglQueryContext:      TeglQueryContext;

  eglWaitGL:      TeglWaitGL;
  eglWaitNative:  TeglWaitNative;
  eglSwapBuffers: TeglSwapBuffers;
  eglCopyBuffers: TeglCopyBuffers;

  eglGetProcAddress: TeglGetProcAddress;


{ =================================================== DelphiGL ======================================================= }
type
  EdglOpenGLES = class(Exception);
  EeglError = class(EdglOpenGLES)
  public
    ErrorCode: EGLint;
    constructor Create(const msg: string; const aErrorCode: EGLint);
  end;

  TdglRenderContext = packed record
    Display: EGLDisplay;
    Surface: EGLSurface;
    Context: EGLContext;
  end;

function InitOpenGLES(const aOpenGLESLibName: String = LIBNAME_OPENGLES; aEGLLibName: String = LIBNAME_EGL): Boolean;

function CreateRenderingContext(const aDisplayType: EGLNativeDisplayType;
                                const aWindowType: PEGLNativeWindowType;
                                const aConfigAttribs: PEGLint;
                                const aContextAttribs: PEGLint): TdglRenderContext;
procedure DestroyRenderingContext(const aContext: TdglRenderContext);
function ActivateRenderingContext(const aContext: TdglRenderContext): Boolean;
function DeactivateRenderingContext(const aContext: TdglRenderContext): Boolean;
procedure SwapBuffers(const aContext: TdglRenderContext);

procedure ReadExtensions;

implementation

var
  LibHandleOpenGLES: Pointer = nil;
  LibHandleEGL:      Pointer = nil;

function dglLoadLibrary(const aName: PChar): Pointer;
begin
  {$IFDEF DGL_LINUX}
  result := dlopen(aName, RTLD_LAZY);
  {$ENDIF}
end;

function dglGetProcAddress(const aProcName: PAnsiChar): Pointer;
begin
  result := nil;

  if Assigned(LibHandleOpenGLES) then
    result := dlsym(LibHandleOpenGLES, aProcName);

  if not Assigned(result) and Assigned(eglGetProcAddress) then
    result := eglGetProcAddress(aProcName);

  if not Assigned(result) and Assigned(LibHandleEGL) then
    result := dlsym(LibHandleEGL, aProcName);
end;

function dglFreeAndNilLibrary(var aLibHandle: Pointer): Boolean;
begin
  if Assigned(aLibHandle) then begin
    {$IFDEF DGL_LINUX}
    result := (dlclose(aLibHandle) = 0);
    aLibHandle := nil;
    {$ENDIF}
  end else
    result := false;
end;

procedure ReadOpenGLCore;
begin

end;

function InitOpenGLES(const aOpenGLESLibName: String; aEGLLibName: String): Boolean;
begin
  result := true;

  if Assigned(LibHandleOpenGLES) then
    dglFreeAndNilLibrary(LibHandleOpenGLES);

  if Assigned(LibHandleEGL) then
    dglFreeAndNilLibrary(LibHandleEGL);

  LibHandleOpenGLES := dglLoadLibrary(PChar(aOpenGLESLibName));
  LibHandleEGL      := dglLoadLibrary(PChar(aEGLLibName));

  // load EGL procedures
  if Assigned(LibHandleEGL) then begin
    eglGetProcAddress                 := dglGetProcAddress('eglGetProcAddress');
    eglGetError                       := dglGetProcAddress('eglGetError');
    eglGetDisplay                     := dglGetProcAddress('eglGetDisplay');
    eglInitialize                     := dglGetProcAddress('eglInitialize');
    eglTerminate                      := dglGetProcAddress('eglTerminate');
    eglQueryString                    := dglGetProcAddress('eglQueryString');
    eglGetConfigs                     := dglGetProcAddress('eglGetConfigs');
    eglChooseConfig                   := dglGetProcAddress('eglChooseConfig');
    eglGetConfigAttrib                := dglGetProcAddress('eglGetConfigAttrib');
    eglCreateWindowSurface            := dglGetProcAddress('eglCreateWindowSurface');
    eglCreatePbufferSurface           := dglGetProcAddress('eglCreatePbufferSurface');
    eglCreatePixmapSurface            := dglGetProcAddress('eglCreatePixmapSurface');
    eglDestroySurface                 := dglGetProcAddress('eglDestroySurface');
    eglQuerySurface                   := dglGetProcAddress('eglQuerySurface');
    eglBindAPI                        := dglGetProcAddress('eglBindAPI');
    eglQueryAPI                       := dglGetProcAddress('eglQueryAPI');
    eglWaitClient                     := dglGetProcAddress('eglWaitClient');
    eglReleaseThread                  := dglGetProcAddress('eglReleaseThread');
    eglCreatePbufferFromClientBuffer  := dglGetProcAddress('eglCreatePbufferFromClientBuffer');
    eglSurfaceAttrib                  := dglGetProcAddress('eglSurfaceAttrib');
    eglBindTexImage                   := dglGetProcAddress('eglBindTexImage');
    eglReleaseTexImage                := dglGetProcAddress('eglReleaseTexImage');
    eglSwapInterval                   := dglGetProcAddress('eglSwapInterval');
    eglCreateContext                  := dglGetProcAddress('eglCreateContext');
    eglDestroyContext                 := dglGetProcAddress('eglDestroyContext');
    eglMakeCurrent                    := dglGetProcAddress('eglMakeCurrent');
    eglGetCurrentContext              := dglGetProcAddress('eglGetCurrentContext');
    eglGetCurrentSurface              := dglGetProcAddress('eglGetCurrentSurface');
    eglGetCurrentDisplay              := dglGetProcAddress('eglGetCurrentDisplay');
    eglQueryContext                   := dglGetProcAddress('eglQueryContext');
    eglWaitGL                         := dglGetProcAddress('eglWaitGL');
    eglWaitNative                     := dglGetProcAddress('eglWaitNative');
    eglSwapBuffers                    := dglGetProcAddress('eglSwapBuffers');
    eglCopyBuffers                    := dglGetProcAddress('eglCopyBuffers');
  end else
    result := false;
end;

procedure RaiseEglError(const aMsg: String);
var err: EGLint;
begin
  err := eglGetError();
  raise EeglError.Create(aMsg + ' ErrorCode: 0x' + IntToHex(err, 8), err);
end;

function CreateRenderingContext(const aDisplayType: EGLNativeDisplayType; const aWindowType: PEGLNativeWindowType;
  const aConfigAttribs: PEGLint; const aContextAttribs: PEGLint): TdglRenderContext;
var
  ConfigCount: EGLint;
  Config: EGLConfig;
begin
  if (not Assigned(LibHandleOpenGLES) or not Assigned(LibHandleEGL)) and
     not InitOpenGLES then
      raise EdglOpenGLES.Create('unable to initialize OpenGL library');

  result.Display := eglGetDisplay(aDisplayType);
  if (result.Display = EGL_NO_DISPLAY) then
    RaiseEglError('unable to get display.');

  if (eglInitialize(result.Display, nil, nil) <> EGL_TRUE) then
    RaiseEglError('unable to initialize egl.');

  if (eglChooseConfig(result.Display, aConfigAttribs, @Config, 1, @ConfigCount) <> EGL_TRUE) or
     (ConfigCount < 1) then
    RaiseEglError('unable to get suitable config.');

  if (eglBindAPI(EGL_OPENGL_ES_API) <> EGL_TRUE) then
    RaiseEglError('unable to get an appropriate EGL frame buffer configuration.');

  result.Surface := eglCreateWindowSurface(result.Display, Config, aWindowType, nil);
  if (result.Surface = EGL_NO_SURFACE) then
    RaiseEglError('unable to create window surface.');

  result.Context := eglCreateContext(result.Display, Config, EGL_NO_CONTEXT, aContextAttribs);
  if (result.Context = EGL_NO_CONTEXT) then begin
    eglDestroySurface(result.Display, result.Surface);
    RaiseEglError('unable to create context.');
  end;
end;

procedure DestroyRenderingContext(const aContext: TdglRenderContext);
begin
  if (eglGetCurrentContext = aContext.Context) and
     not DeactivateRenderingContext(aContext) then
    RaiseEglError('unable to unbind context.');

  if (eglDestroyContext(aContext.Display, aContext.Context) <> EGL_TRUE) then
    RaiseEglError('unable to destory context.');

  if (eglDestroySurface(aContext.Display, aContext.Surface) <> EGL_TRUE) then
    RaiseEglError('unable to destroy surface.');
end;

function ActivateRenderingContext(const aContext: TdglRenderContext): Boolean;
begin
  result := (eglMakeCurrent(aContext.Display, aContext.Surface, aContext.Surface, aContext.Context) = GL_TRUE);
end;

function DeactivateRenderingContext(const aContext: TdglRenderContext): Boolean;
begin
  result := (eglMakeCurrent(aContext.Display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT) = EGL_TRUE);
end;

procedure SwapBuffers(const aContext: TdglRenderContext);
begin
  eglSwapBuffers(aContext.Display, aContext.Surface);
end;

procedure ReadExtensions;
begin
  glActiveTexture                           := dglGetProcAddress('glActiveTexture');
  glAttachShader                            := dglGetProcAddress('glAttachShader');
  glBindAttribLocation                      := dglGetProcAddress('glBindAttribLocation');
  glBindBuffer                              := dglGetProcAddress('glBindBuffer');
  glBindFramebuffer                         := dglGetProcAddress('glBindFramebuffer');
  glBindRenderbuffer                        := dglGetProcAddress('glBindRenderbuffer');
  glBindTexture                             := dglGetProcAddress('glBindTexture');
  glBlendColor                              := dglGetProcAddress('glBlendColor');
  glBlendEquation                           := dglGetProcAddress('glBlendEquation');
  glBlendEquationSeparate                   := dglGetProcAddress('glBlendEquationSeparate');
  glBlendFunc                               := dglGetProcAddress('glBlendFunc');
  glBlendFuncSeparate                       := dglGetProcAddress('glBlendFuncSeparate');
  glBufferData                              := dglGetProcAddress('glBufferData');
  glBufferSubData                           := dglGetProcAddress('glBufferSubData');
  glCheckFramebufferStatus                  := dglGetProcAddress('glCheckFramebufferStatus');
  glClear                                   := dglGetProcAddress('glClear');
  glClearColor                              := dglGetProcAddress('glClearColor');
  glClearDepthf                             := dglGetProcAddress('glClearDepthf');
  glClearStencil                            := dglGetProcAddress('glClearStencil');
  glColorMask                               := dglGetProcAddress('glColorMask');
  glCompileShader                           := dglGetProcAddress('glCompileShader');
  glCompressedTexImage2D                    := dglGetProcAddress('glCompressedTexImage2D');
  glCompressedTexSubImage2D                 := dglGetProcAddress('glCompressedTexSubImage2D');
  glCopyTexImage2D                          := dglGetProcAddress('glCopyTexImage2D');
  glCopyTexSubImage2D                       := dglGetProcAddress('glCopyTexSubImage2D');
  glCreateProgram                           := dglGetProcAddress('glCreateProgram');
  glCreateShader                            := dglGetProcAddress('glCreateShader');
  glCullFace                                := dglGetProcAddress('glCullFace');
  glDeleteBuffers                           := dglGetProcAddress('glDeleteBuffers');
  glDeleteFramebuffers                      := dglGetProcAddress('glDeleteFramebuffers');
  glDeleteProgram                           := dglGetProcAddress('glDeleteProgram');
  glDeleteRenderbuffers                     := dglGetProcAddress('glDeleteRenderbuffers');
  glDeleteShader                            := dglGetProcAddress('glDeleteShader');
  glDeleteTextures                          := dglGetProcAddress('glDeleteTextures');
  glDepthFunc                               := dglGetProcAddress('glDepthFunc');
  glDepthMask                               := dglGetProcAddress('glDepthMask');
  glDepthRangef                             := dglGetProcAddress('glDepthRangef');
  glDetachShader                            := dglGetProcAddress('glDetachShader');
  glDisable                                 := dglGetProcAddress('glDisable');
  glDisableVertexAttribArray                := dglGetProcAddress('glDisableVertexAttribArray');
  glDrawArrays                              := dglGetProcAddress('glDrawArrays');
  glDrawElements                            := dglGetProcAddress('glDrawElements');
  glEnable                                  := dglGetProcAddress('glEnable');
  glEnableVertexAttribArray                 := dglGetProcAddress('glEnableVertexAttribArray');
  glFinish                                  := dglGetProcAddress('glFinish');
  glFlush                                   := dglGetProcAddress('glFlush');
  glFramebufferRenderbuffer                 := dglGetProcAddress('glFramebufferRenderbuffer');
  glFramebufferTexture2D                    := dglGetProcAddress('glFramebufferTexture2D');
  glFrontFace                               := dglGetProcAddress('glFrontFace');
  glGenBuffers                              := dglGetProcAddress('glGenBuffers');
  glGenerateMipmap                          := dglGetProcAddress('glGenerateMipmap');
  glGenFramebuffers                         := dglGetProcAddress('glGenFramebuffers');
  glGenRenderbuffers                        := dglGetProcAddress('glGenRenderbuffers');
  glGenTextures                             := dglGetProcAddress('glGenTextures');
  glGetActiveAttrib                         := dglGetProcAddress('glGetActiveAttrib');
  glGetActiveUniform                        := dglGetProcAddress('glGetActiveUniform');
  glGetAttachedShaders                      := dglGetProcAddress('glGetAttachedShaders');
  glGetAttribLocation                       := dglGetProcAddress('glGetAttribLocation');
  glGetBooleanv                             := dglGetProcAddress('glGetBooleanv');
  glGetBufferParameteriv                    := dglGetProcAddress('glGetBufferParameteriv');
  glGetError                                := dglGetProcAddress('glGetError');
  glGetFloatv                               := dglGetProcAddress('glGetFloatv');
  glGetFramebufferAttachmentParameteriv     := dglGetProcAddress('glGetFramebufferAttachmentParameteriv');
  glGetIntegerv                             := dglGetProcAddress('glGetIntegerv');
  glGetProgramiv                            := dglGetProcAddress('glGetProgramiv');
  glGetProgramInfoLog                       := dglGetProcAddress('glGetProgramInfoLog');
  glGetRenderbufferParameteriv              := dglGetProcAddress('glGetRenderbufferParameteriv');
  glGetShaderiv                             := dglGetProcAddress('glGetShaderiv');
  glGetShaderInfoLog                        := dglGetProcAddress('glGetShaderInfoLog');
  glGetShaderPrecisionFormat                := dglGetProcAddress('glGetShaderPrecisionFormat');
  glGetShaderSource                         := dglGetProcAddress('glGetShaderSource');
  glGetString                               := dglGetProcAddress('glGetString');
  glGetTexParameterfv                       := dglGetProcAddress('glGetTexParameterfv');
  glGetTexParameteriv                       := dglGetProcAddress('glGetTexParameteriv');
  glGetUniformfv                            := dglGetProcAddress('glGetUniformfv');
  glGetUniformiv                            := dglGetProcAddress('glGetUniformiv');
  glGetUniformLocation                      := dglGetProcAddress('glGetUniformLocation');
  glGetVertexAttribfv                       := dglGetProcAddress('glGetVertexAttribfv');
  glGetVertexAttribiv                       := dglGetProcAddress('glGetVertexAttribiv');
  glGetVertexAttribPointerv                 := dglGetProcAddress('glGetVertexAttribPointerv');
  glHint                                    := dglGetProcAddress('glHint');
  glIsBuffer                                := dglGetProcAddress('glIsBuffer');
  glIsEnabled                               := dglGetProcAddress('glIsEnabled');
  glIsFramebuffer                           := dglGetProcAddress('glIsFramebuffer');
  glIsProgram                               := dglGetProcAddress('glIsProgram');
  glIsRenderbuffer                          := dglGetProcAddress('glIsRenderbuffer');
  glIsShader                                := dglGetProcAddress('glIsShader');
  glIsTexture                               := dglGetProcAddress('glIsTexture');
  glLineWidth                               := dglGetProcAddress('glLineWidth');
  glLinkProgram                             := dglGetProcAddress('glLinkProgram');
  glPixelStorei                             := dglGetProcAddress('glPixelStorei');
  glPolygonOffset                           := dglGetProcAddress('glPolygonOffset');
  glReadPixels                              := dglGetProcAddress('glReadPixels');
  glReleaseShaderCompiler                   := dglGetProcAddress('glReleaseShaderCompiler');
  glRenderbufferStorage                     := dglGetProcAddress('glRenderbufferStorage');
  glSampleCoverage                          := dglGetProcAddress('glSampleCoverage');
  glScissor                                 := dglGetProcAddress('glScissor');
  glShaderBinary                            := dglGetProcAddress('glShaderBinary');
  glShaderSource                            := dglGetProcAddress('glShaderSource');
  glStencilFunc                             := dglGetProcAddress('glStencilFunc');
  glStencilFuncSeparate                     := dglGetProcAddress('glStencilFuncSeparate');
  glStencilMask                             := dglGetProcAddress('glStencilMask');
  glStencilMaskSeparate                     := dglGetProcAddress('glStencilMaskSeparate');
  glStencilOp                               := dglGetProcAddress('glStencilOp');
  glStencilOpSeparate                       := dglGetProcAddress('glStencilOpSeparate');
  glTexImage2D                              := dglGetProcAddress('glTexImage2D');
  glTexParameterf                           := dglGetProcAddress('glTexParameterf');
  glTexParameterfv                          := dglGetProcAddress('glTexParameterfv');
  glTexParameteri                           := dglGetProcAddress('glTexParameteri');
  glTexParameteriv                          := dglGetProcAddress('glTexParameteriv');
  glTexSubImage2D                           := dglGetProcAddress('glTexSubImage2D');
  glUniform1f                               := dglGetProcAddress('glUniform1f');
  glUniform1fv                              := dglGetProcAddress('glUniform1fv');
  glUniform1i                               := dglGetProcAddress('glUniform1i');
  glUniform1iv                              := dglGetProcAddress('glUniform1iv');
  glUniform2f                               := dglGetProcAddress('glUniform2f');
  glUniform2fv                              := dglGetProcAddress('glUniform2fv');
  glUniform2i                               := dglGetProcAddress('glUniform2i');
  glUniform2iv                              := dglGetProcAddress('glUniform2iv');
  glUniform3f                               := dglGetProcAddress('glUniform3f');
  glUniform3fv                              := dglGetProcAddress('glUniform3fv');
  glUniform3i                               := dglGetProcAddress('glUniform3i');
  glUniform3iv                              := dglGetProcAddress('glUniform3iv');
  glUniform4f                               := dglGetProcAddress('glUniform4f');
  glUniform4fv                              := dglGetProcAddress('glUniform4fv');
  glUniform4i                               := dglGetProcAddress('glUniform4i');
  glUniform4iv                              := dglGetProcAddress('glUniform4iv');
  glUniformMatrix2fv                        := dglGetProcAddress('glUniformMatrix2fv');
  glUniformMatrix3fv                        := dglGetProcAddress('glUniformMatrix3fv');
  glUniformMatrix4fv                        := dglGetProcAddress('glUniformMatrix4fv');
  glUseProgram                              := dglGetProcAddress('glUseProgram');
  glValidateProgram                         := dglGetProcAddress('glValidateProgram');
  glVertexAttrib1f                          := dglGetProcAddress('glVertexAttrib1f');
  glVertexAttrib1fv                         := dglGetProcAddress('glVertexAttrib1fv');
  glVertexAttrib2f                          := dglGetProcAddress('glVertexAttrib2f');
  glVertexAttrib2fv                         := dglGetProcAddress('glVertexAttrib2fv');
  glVertexAttrib3f                          := dglGetProcAddress('glVertexAttrib3f');
  glVertexAttrib3fv                         := dglGetProcAddress('glVertexAttrib3fv');
  glVertexAttrib4f                          := dglGetProcAddress('glVertexAttrib4f');
  glVertexAttrib4fv                         := dglGetProcAddress('glVertexAttrib4fv');
  glVertexAttribPointer                     := dglGetProcAddress('glVertexAttribPointer');
  glViewport                                := dglGetProcAddress('glViewport');

  { OpenGL ES 3.0 }
  glReadBuffer                              := dglGetProcAddress('glReadBuffer');
  glDrawRangeElements                       := dglGetProcAddress('glDrawRangeElements');
  glTexImage3D                              := dglGetProcAddress('glTexImage3D');
  glTexSubImage3D                           := dglGetProcAddress('glTexSubImage3D');
  glCopyTexSubImage3D                       := dglGetProcAddress('glCopyTexSubImage3D');
  glCompressedTexImage3D                    := dglGetProcAddress('glCompressedTexImage3D');
  glCompressedTexSubImage3D                 := dglGetProcAddress('glCompressedTexSubImage3D');
  glGenQueries                              := dglGetProcAddress('glGenQueries');
  glDeleteQueries                           := dglGetProcAddress('glDeleteQueries');
  glIsQuery                                 := dglGetProcAddress('glIsQuery');
  glBeginQuery                              := dglGetProcAddress('glBeginQuery');
  glEndQuery                                := dglGetProcAddress('glEndQuery');
  glGetQueryiv                              := dglGetProcAddress('glGetQueryiv');
  glGetQueryObjectuiv                       := dglGetProcAddress('glGetQueryObjectuiv');
  glUnmapBuffer                             := dglGetProcAddress('glUnmapBuffer');
  glGetBufferPointerv                       := dglGetProcAddress('glGetBufferPointerv');
  glDrawBuffers                             := dglGetProcAddress('glDrawBuffers');
  glUniformMatrix2x3fv                      := dglGetProcAddress('glUniformMatrix2x3fv');
  glUniformMatrix3x2fv                      := dglGetProcAddress('glUniformMatrix3x2fv');
  glUniformMatrix2x4fv                      := dglGetProcAddress('glUniformMatrix2x4fv');
  glUniformMatrix4x2fv                      := dglGetProcAddress('glUniformMatrix4x2fv');
  glUniformMatrix3x4fv                      := dglGetProcAddress('glUniformMatrix3x4fv');
  glUniformMatrix4x3fv                      := dglGetProcAddress('glUniformMatrix4x3fv');
  glBlitFramebuffer                         := dglGetProcAddress('glBlitFramebuffer');
  glRenderbufferStorageMultisample          := dglGetProcAddress('glRenderbufferStorageMultisample');
  glFramebufferTextureLayer                 := dglGetProcAddress('glFramebufferTextureLayer');
  glMapBufferRange                          := dglGetProcAddress('glMapBufferRange');
  glFlushMappedBufferRange                  := dglGetProcAddress('glFlushMappedBufferRange');
  glBindVertexArray                         := dglGetProcAddress('glBindVertexArray');
  glDeleteVertexArrays                      := dglGetProcAddress('glDeleteVertexArrays');
  glGenVertexArrays                         := dglGetProcAddress('glGenVertexArrays');
  glIsVertexArray                           := dglGetProcAddress('glIsVertexArray');
  glGetIntegeri_v                           := dglGetProcAddress('glGetIntegeri_v');
  glBeginTransformFeedback                  := dglGetProcAddress('glBeginTransformFeedback');
  glEndTransformFeedback                    := dglGetProcAddress('glEndTransformFeedback');
  glBindBufferRange                         := dglGetProcAddress('glBindBufferRange');
  glBindBufferBase                          := dglGetProcAddress('glBindBufferBase');
  glTransformFeedbackVaryings               := dglGetProcAddress('glTransformFeedbackVaryings');
  glGetTransformFeedbackVarying             := dglGetProcAddress('glGetTransformFeedbackVarying');
  glVertexAttribIPointer                    := dglGetProcAddress('glVertexAttribIPointer');
  glGetVertexAttribIiv                      := dglGetProcAddress('glGetVertexAttribIiv');
  glGetVertexAttribIuiv                     := dglGetProcAddress('glGetVertexAttribIuiv');
  glVertexAttribI4i                         := dglGetProcAddress('glVertexAttribI4i');
  glVertexAttribI4ui                        := dglGetProcAddress('glVertexAttribI4ui');
  glVertexAttribI4iv                        := dglGetProcAddress('glVertexAttribI4iv');
  glVertexAttribI4uiv                       := dglGetProcAddress('glVertexAttribI4uiv');
  glGetUniformuiv                           := dglGetProcAddress('glGetUniformuiv');
  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');
  glClearBufferiv                           := dglGetProcAddress('glClearBufferiv');
  glClearBufferuiv                          := dglGetProcAddress('glClearBufferuiv');
  glClearBufferfv                           := dglGetProcAddress('glClearBufferfv');
  glClearBufferfi                           := dglGetProcAddress('glClearBufferfi');
  glGetStringi                              := dglGetProcAddress('glGetStringi');
  glCopyBufferSubData                       := dglGetProcAddress('glCopyBufferSubData');
  glGetUniformIndices                       := dglGetProcAddress('glGetUniformIndices');
  glGetActiveUniformsiv                     := dglGetProcAddress('glGetActiveUniformsiv');
  glGetUniformBlockIndex                    := dglGetProcAddress('glGetUniformBlockIndex');
  glGetActiveUniformBlockiv                 := dglGetProcAddress('glGetActiveUniformBlockiv');
  glGetActiveUniformBlockName               := dglGetProcAddress('glGetActiveUniformBlockName');
  glUniformBlockBinding                     := dglGetProcAddress('glUniformBlockBinding');
  glDrawArraysInstanced                     := dglGetProcAddress('glDrawArraysInstanced');
  glDrawElementsInstanced                   := dglGetProcAddress('glDrawElementsInstanced');
  glFenceSync                               := dglGetProcAddress('glFenceSync');
  glIsSync                                  := dglGetProcAddress('glIsSync');
  glDeleteSync                              := dglGetProcAddress('glDeleteSync');
  glClientWaitSync                          := dglGetProcAddress('glClientWaitSync');
  glWaitSync                                := dglGetProcAddress('glWaitSync');
  glGetInteger64v                           := dglGetProcAddress('glGetInteger64v');
  glGetSynciv                               := dglGetProcAddress('glGetSynciv');
  glGetInteger64i_v                         := dglGetProcAddress('glGetInteger64i_v');
  glGetBufferParameteri64v                  := dglGetProcAddress('glGetBufferParameteri64v');
  glGenSamplers                             := dglGetProcAddress('glGenSamplers');
  glDeleteSamplers                          := dglGetProcAddress('glDeleteSamplers');
  glIsSampler                               := dglGetProcAddress('glIsSampler');
  glBindSampler                             := dglGetProcAddress('glBindSampler');
  glSamplerParameteri                       := dglGetProcAddress('glSamplerParameteri');
  glSamplerParameteriv                      := dglGetProcAddress('glSamplerParameteriv');
  glSamplerParameterf                       := dglGetProcAddress('glSamplerParameterf');
  glSamplerParameterfv                      := dglGetProcAddress('glSamplerParameterfv');
  glGetSamplerParameteriv                   := dglGetProcAddress('glGetSamplerParameteriv');
  glGetSamplerParameterfv                   := dglGetProcAddress('glGetSamplerParameterfv');
  glVertexAttribDivisor                     := dglGetProcAddress('glVertexAttribDivisor');
  glBindTransformFeedback                   := dglGetProcAddress('glBindTransformFeedback');
  glDeleteTransformFeedbacks                := dglGetProcAddress('glDeleteTransformFeedbacks');
  glGenTransformFeedbacks                   := dglGetProcAddress('glGenTransformFeedbacks');
  glIsTransformFeedback                     := dglGetProcAddress('glIsTransformFeedback');
  glPauseTransformFeedback                  := dglGetProcAddress('glPauseTransformFeedback');
  glResumeTransformFeedback                 := dglGetProcAddress('glResumeTransformFeedback');
  glGetProgramBinary                        := dglGetProcAddress('glGetProgramBinary');
  glProgramBinary                           := dglGetProcAddress('glProgramBinary');
  glProgramParameteri                       := dglGetProcAddress('glProgramParameteri');
  glInvalidateFramebuffer                   := dglGetProcAddress('glInvalidateFramebuffer');
  glInvalidateSubFramebuffer                := dglGetProcAddress('glInvalidateSubFramebuffer');
  glTexStorage2D                            := dglGetProcAddress('glTexStorage2D');
  glTexStorage3D                            := dglGetProcAddress('glTexStorage3D');
  glGetInternalformativ                     := dglGetProcAddress('glGetInternalformativ');

  { OpenGL ES 3.1 }
  glDispatchCompute                         := dglGetProcAddress('glDispatchCompute');
  glDispatchComputeIndirect                 := dglGetProcAddress('glDispatchComputeIndirect');
  glDrawArraysIndirect                      := dglGetProcAddress('glDrawArraysIndirect');
  glDrawElementsIndirect                    := dglGetProcAddress('glDrawElementsIndirect');
  glFramebufferParameteri                   := dglGetProcAddress('glFramebufferParameteri');
  glGetFramebufferParameteriv               := dglGetProcAddress('glGetFramebufferParameteriv');
  glGetProgramInterfaceiv                   := dglGetProcAddress('glGetProgramInterfaceiv');
  glGetProgramResourceIndex                 := dglGetProcAddress('glGetProgramResourceIndex');
  glGetProgramResourceName                  := dglGetProcAddress('glGetProgramResourceName');
  glGetProgramResourceiv                    := dglGetProcAddress('glGetProgramResourceiv');
  glGetProgramResourceLocation              := dglGetProcAddress('glGetProgramResourceLocation');
  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');
  glProgramUniform2i                        := dglGetProcAddress('glProgramUniform2i');
  glProgramUniform3i                        := dglGetProcAddress('glProgramUniform3i');
  glProgramUniform4i                        := dglGetProcAddress('glProgramUniform4i');
  glProgramUniform1ui                       := dglGetProcAddress('glProgramUniform1ui');
  glProgramUniform2ui                       := dglGetProcAddress('glProgramUniform2ui');
  glProgramUniform3ui                       := dglGetProcAddress('glProgramUniform3ui');
  glProgramUniform4ui                       := dglGetProcAddress('glProgramUniform4ui');
  glProgramUniform1f                        := dglGetProcAddress('glProgramUniform1f');
  glProgramUniform2f                        := dglGetProcAddress('glProgramUniform2f');
  glProgramUniform3f                        := dglGetProcAddress('glProgramUniform3f');
  glProgramUniform4f                        := dglGetProcAddress('glProgramUniform4f');
  glProgramUniform1iv                       := dglGetProcAddress('glProgramUniform1iv');
  glProgramUniform2iv                       := dglGetProcAddress('glProgramUniform2iv');
  glProgramUniform3iv                       := dglGetProcAddress('glProgramUniform3iv');
  glProgramUniform4iv                       := dglGetProcAddress('glProgramUniform4iv');
  glProgramUniform1uiv                      := dglGetProcAddress('glProgramUniform1uiv');
  glProgramUniform2uiv                      := dglGetProcAddress('glProgramUniform2uiv');
  glProgramUniform3uiv                      := dglGetProcAddress('glProgramUniform3uiv');
  glProgramUniform4uiv                      := dglGetProcAddress('glProgramUniform4uiv');
  glProgramUniform1fv                       := dglGetProcAddress('glProgramUniform1fv');
  glProgramUniform2fv                       := dglGetProcAddress('glProgramUniform2fv');
  glProgramUniform3fv                       := dglGetProcAddress('glProgramUniform3fv');
  glProgramUniform4fv                       := dglGetProcAddress('glProgramUniform4fv');
  glProgramUniformMatrix2fv                 := dglGetProcAddress('glProgramUniformMatrix2fv');
  glProgramUniformMatrix3fv                 := dglGetProcAddress('glProgramUniformMatrix3fv');
  glProgramUniformMatrix4fv                 := dglGetProcAddress('glProgramUniformMatrix4fv');
  glProgramUniformMatrix2x3fv               := dglGetProcAddress('glProgramUniformMatrix2x3fv');
  glProgramUniformMatrix3x2fv               := dglGetProcAddress('glProgramUniformMatrix3x2fv');
  glProgramUniformMatrix2x4fv               := dglGetProcAddress('glProgramUniformMatrix2x4fv');
  glProgramUniformMatrix4x2fv               := dglGetProcAddress('glProgramUniformMatrix4x2fv');
  glProgramUniformMatrix3x4fv               := dglGetProcAddress('glProgramUniformMatrix3x4fv');
  glProgramUniformMatrix4x3fv               := dglGetProcAddress('glProgramUniformMatrix4x3fv');
  glValidateProgramPipeline                 := dglGetProcAddress('glValidateProgramPipeline');
  glGetProgramPipelineInfoLog               := dglGetProcAddress('glGetProgramPipelineInfoLog');
  glBindImageTexture                        := dglGetProcAddress('glBindImageTexture');
  glGetBooleaniV                            := dglGetProcAddress('glGetBooleaniV');
  glMemoryBarrier                           := dglGetProcAddress('glMemoryBarrier');
  glMemoryBarrierByRegion                   := dglGetProcAddress('glMemoryBarrierByRegion');
  glTexStorage2DMultisample                 := dglGetProcAddress('glTexStorage2DMultisample');
  glGetMultisamplefv                        := dglGetProcAddress('glGetMultisamplefv');
  glSampleMaski                             := dglGetProcAddress('glSampleMaski');
  glGetTexLevelParameteriv                  := dglGetProcAddress('glGetTexLevelParameteriv');
  glGetTexLevelParameterfv                  := dglGetProcAddress('glGetTexLevelParameterfv');
  glBindVertexBuffer                        := dglGetProcAddress('glBindVertexBuffer');
  glVertexAttribFormat                      := dglGetProcAddress('glVertexAttribFormat');
  glVertexAttribIFormat                     := dglGetProcAddress('glVertexAttribIFormat');
  glVertexAttribBinding                     := dglGetProcAddress('glVertexAttribBinding');
  glVertexBindingDivisor                    := dglGetProcAddress('glVertexBindingDivisor');
end;

constructor EeglError.Create(const msg: string; const aErrorCode: EGLint);
begin
  inherited Create(msg);
  ErrorCode := aErrorCode;
end;

end.