OpenGLCore/dglOpenGLES.pas

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

       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
  { Types }
  GLbyte      = Byte;
  GLclampf    = Single;
  GLfixed     = Integer;
  GLclampx    = Integer;
  GLshort     = ShortInt;
  GLubyte     = Byte;
  GLushort    = Word;
  GLvoid      = Pointer;
  GLint64     = Int64;
  GLuint64    = UInt64;
  GLenum      = Cardinal;
  GLuint      = Cardinal;
  GLchar      = AnsiChar;
  GLbitfield  = Cardinal;
  GLint       = Integer;
  GLboolean   = ByteBool;
  GLsizei     = Integer;
  GLfloat     = Single;
  GLdouble    = Double;

  { Pointers }
  PGLbyte     = ^GLbyte;
  PGLclampf   = ^GLclampf;
  PGLfixed    = ^GLfixed;
  PGLshort    = ^GLshort;
  PGLubyte    = ^GLubyte;
  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;
  PGLdouble   = ^GLdouble;

  { Special }
  GLsync = Pointer;

  { Cutsom }
  TGLvectorub2 = array[0..1] of GLubyte;
  TGLvectorub3 = array[0..2] of GLubyte;
  TGLvectorub4 = array[0..3] of GLubyte;

  TGLvectori2 = array[0..1] of GLint;
  TGLvectori3 = array[0..2] of GLint;
  TGLvectori4 = array[0..3] of GLint;

  TGLvectorf2 = array[0..1] of GLfloat;
  TGLvectorf3 = array[0..2] of GLfloat;
  TGLvectorf4 = array[0..3] of GLfloat;

  TGLvectord2 = array[0..1] of GLdouble;
  TGLvectord3 = array[0..2] of GLdouble;
  TGLvectord4 = array[0..3] of GLdouble;

  TGLvectorp2 = array[0..1] of PGLvoid;
  TGLvectorp3 = array[0..2] of PGLvoid;
  TGLvectorp4 = array[0..3] of PGLvoid;

const
{ ============================================== OpenGL ES 1.0 ======================================================= }
{ ClearBufferMask }
  GL_DEPTH_BUFFER_BIT                               = $00000100;
  GL_STENCIL_BUFFER_BIT                             = $00000400;
  GL_COLOR_BUFFER_BIT                               = $00004000;

{ Boolean }
  GL_FALSE                                          = 0;
  GL_TRUE                                           = 1;

{ BeginMode }
  GL_POINTS                                         = $0000;
  GL_LINES                                          = $0001;
  GL_LINE_LOOP                                      = $0002;
  GL_LINE_STRIP                                     = $0003;
  GL_TRIANGLES                                      = $0004;
  GL_TRIANGLE_STRIP                                 = $0005;
  GL_TRIANGLE_FAN                                   = $0006;

{ AlphaFunction }
  GL_NEVER                                          = $0200;
  GL_LESS                                           = $0201;
  GL_EQUAL                                          = $0202;
  GL_LEQUAL                                         = $0203;
  GL_GREATER                                        = $0204;
  GL_NOTEQUAL                                       = $0205;
  GL_GEQUAL                                         = $0206;
  GL_ALWAYS                                         = $0207;

{ BlendingFactorDest }
  GL_ZERO                                           = 0;
  GL_ONE                                            = 1;
  GL_SRC_COLOR                                      = $0300;
  GL_ONE_MINUS_SRC_COLOR                            = $0301;
  GL_SRC_ALPHA                                      = $0302;
  GL_ONE_MINUS_SRC_ALPHA                            = $0303;
  GL_DST_ALPHA                                      = $0304;
  GL_ONE_MINUS_DST_ALPHA                            = $0305;

{ BlendingFactorSrc }
{ GL_ZERO }
{ GL_ONE }
  GL_DST_COLOR                                      = $0306;
  GL_ONE_MINUS_DST_COLOR                            = $0307;
  GL_SRC_ALPHA_SATURATE                             = $0308;
{ GL_SRC_ALPHA }
{ GL_ONE_MINUS_SRC_ALPHA }
{ GL_DST_ALPHA }
{ GL_ONE_MINUS_DST_ALPHA }

{ ClipPlaneName }
  GL_CLIP_PLANE0                                    = $3000;
  GL_CLIP_PLANE1                                    = $3001;
  GL_CLIP_PLANE2                                    = $3002;
  GL_CLIP_PLANE3                                    = $3003;
  GL_CLIP_PLANE4                                    = $3004;
  GL_CLIP_PLANE5                                    = $3005;

{ ColorMaterialFace }
{ GL_FRONT_AND_BACK }

{ ColorMaterialParameter }
{ GL_AMBIENT_AND_DIFFUSE }

{ ColorPointerType }
{ GL_UNSIGNED_BYTE }
{ GL_FLOAT }
{ GL_FIXED }

{ CullFaceMode }
  GL_FRONT                                          = $0404;
  GL_BACK                                           = $0405;
  GL_FRONT_AND_BACK                                 = $0408;

{ DepthFunction }
{ GL_NEVER }
{ GL_LESS }
{ GL_EQUAL }
{ GL_LEQUAL }
{ GL_GREATER }
{ GL_NOTEQUAL }
{ GL_GEQUAL }
{ GL_ALWAYS }

{ EnableCap }
  GL_FOG                                            = $0B60;
  GL_LIGHTING                                       = $0B50;
  GL_TEXTURE_2D                                     = $0DE1;
  GL_CULL_FACE                                      = $0B44;
  GL_ALPHA_TEST                                     = $0BC0;
  GL_BLEND                                          = $0BE2;
  GL_COLOR_LOGIC_OP                                 = $0BF2;
  GL_DITHER                                         = $0BD0;
  GL_STENCIL_TEST                                   = $0B90;
  GL_DEPTH_TEST                                     = $0B71;
{ GL_LIGHT0 }
{ GL_LIGHT1 }
{ GL_LIGHT2 }
{ GL_LIGHT3 }
{ GL_LIGHT4 }
{ GL_LIGHT5 }
{ GL_LIGHT6 }
{ GL_LIGHT7 }
  GL_POINT_SMOOTH                                   = $0B10;
  GL_LINE_SMOOTH                                    = $0B20;
  GL_SCISSOR_TEST                                   = $0C11;
  GL_COLOR_MATERIAL                                 = $0B57;
  GL_NORMALIZE                                      = $0BA1;
  GL_RESCALE_NORMAL                                 = $803A;
  GL_POLYGON_OFFSET_FILL                            = $8037;
  GL_VERTEX_ARRAY                                   = $8074;
  GL_NORMAL_ARRAY                                   = $8075;
  GL_COLOR_ARRAY                                    = $8076;
  GL_TEXTURE_COORD_ARRAY                            = $8078;
  GL_MULTISAMPLE                                    = $809D;
  GL_SAMPLE_ALPHA_TO_COVERAGE                       = $809E;
  GL_SAMPLE_ALPHA_TO_ONE                            = $809F;
  GL_SAMPLE_COVERAGE                                = $80A0;

{ ErrorCode }
  GL_NO_ERROR                                       = 0;
  GL_INVALID_ENUM                                   = $0500;
  GL_INVALID_VALUE                                  = $0501;
  GL_INVALID_OPERATION                              = $0502;
  GL_STACK_OVERFLOW                                 = $0503;
  GL_STACK_UNDERFLOW                                = $0504;
  GL_OUT_OF_MEMORY                                  = $0505;

{ FogMode }
{ GL_LINEAR }
  GL_EXP                                            = $0800;
  GL_EXP2                                           = $0801;

{ FogParameter }
  GL_FOG_DENSITY                                    = $0B62;
  GL_FOG_START                                      = $0B63;
  GL_FOG_END                                        = $0B64;
  GL_FOG_MODE                                       = $0B65;
  GL_FOG_COLOR                                      = $0B66;

{ FrontFaceDirection }
  GL_CW                                             = $0900;
  GL_CCW                                            = $0901;

{ GetPName }
  GL_CURRENT_COLOR                                  = $0B00;
  GL_CURRENT_NORMAL                                 = $0B02;
  GL_CURRENT_TEXTURE_COORDS                         = $0B03;
  GL_POINT_SIZE                                     = $0B11;
  GL_POINT_SIZE_MIN                                 = $8126;
  GL_POINT_SIZE_MAX                                 = $8127;
  GL_POINT_FADE_THRESHOLD_SIZE                      = $8128;
  GL_POINT_DISTANCE_ATTENUATION                     = $8129;
  GL_SMOOTH_POINT_SIZE_RANGE                        = $0B12;
  GL_LINE_WIDTH                                     = $0B21;
  GL_SMOOTH_LINE_WIDTH_RANGE                        = $0B22;
  GL_ALIASED_POINT_SIZE_RANGE                       = $846D;
  GL_ALIASED_LINE_WIDTH_RANGE                       = $846E;
  GL_CULL_FACE_MODE                                 = $0B45;
  GL_FRONT_FACE                                     = $0B46;
  GL_SHADE_MODEL                                    = $0B54;
  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_VALUE_MASK                             = $0B93;
  GL_STENCIL_FAIL                                   = $0B94;
  GL_STENCIL_PASS_DEPTH_FAIL                        = $0B95;
  GL_STENCIL_PASS_DEPTH_PASS                        = $0B96;
  GL_STENCIL_REF                                    = $0B97;
  GL_STENCIL_WRITEMASK                              = $0B98;
  GL_MATRIX_MODE                                    = $0BA0;
  GL_VIEWPORT                                       = $0BA2;
  GL_MODELVIEW_STACK_DEPTH                          = $0BA3;
  GL_PROJECTION_STACK_DEPTH                         = $0BA4;
  GL_TEXTURE_STACK_DEPTH                            = $0BA5;
  GL_MODELVIEW_MATRIX                               = $0BA6;
  GL_PROJECTION_MATRIX                              = $0BA7;
  GL_TEXTURE_MATRIX                                 = $0BA8;
  GL_ALPHA_TEST_FUNC                                = $0BC1;
  GL_ALPHA_TEST_REF                                 = $0BC2;
  GL_BLEND_DST                                      = $0BE0;
  GL_BLEND_SRC                                      = $0BE1;
  GL_LOGIC_OP_MODE                                  = $0BF0;
  GL_SCISSOR_BOX                                    = $0C10;
  GL_COLOR_CLEAR_VALUE                              = $0C22;
  GL_COLOR_WRITEMASK                                = $0C23;
  GL_UNPACK_ALIGNMENT                               = $0CF5;
  GL_PACK_ALIGNMENT                                 = $0D05;
  GL_MAX_LIGHTS                                     = $0D31;
  GL_MAX_CLIP_PLANES                                = $0D32;
  GL_MAX_TEXTURE_SIZE                               = $0D33;
  GL_MAX_MODELVIEW_STACK_DEPTH                      = $0D36;
  GL_MAX_PROJECTION_STACK_DEPTH                     = $0D38;
  GL_MAX_TEXTURE_STACK_DEPTH                        = $0D39;
  GL_MAX_VIEWPORT_DIMS                              = $0D3A;
  GL_MAX_TEXTURE_UNITS                              = $84E2;
  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_VERTEX_ARRAY_SIZE                              = $807A;
  GL_VERTEX_ARRAY_TYPE                              = $807B;
  GL_VERTEX_ARRAY_STRIDE                            = $807C;
  GL_NORMAL_ARRAY_TYPE                              = $807E;
  GL_NORMAL_ARRAY_STRIDE                            = $807F;
  GL_COLOR_ARRAY_SIZE                               = $8081;
  GL_COLOR_ARRAY_TYPE                               = $8082;
  GL_COLOR_ARRAY_STRIDE                             = $8083;
  GL_TEXTURE_COORD_ARRAY_SIZE                       = $8088;
  GL_TEXTURE_COORD_ARRAY_TYPE                       = $8089;
  GL_TEXTURE_COORD_ARRAY_STRIDE                     = $808A;
  GL_VERTEX_ARRAY_POINTER                           = $808E;
  GL_NORMAL_ARRAY_POINTER                           = $808F;
  GL_COLOR_ARRAY_POINTER                            = $8090;
  GL_TEXTURE_COORD_ARRAY_POINTER                    = $8092;
  GL_SAMPLE_BUFFERS                                 = $80A8;
  GL_SAMPLES                                        = $80A9;
  GL_SAMPLE_COVERAGE_VALUE                          = $80AA;
  GL_SAMPLE_COVERAGE_INVERT                         = $80AB;

{ GetTextureParameter }
{ GL_TEXTURE_MAG_FILTER }
{ GL_TEXTURE_MIN_FILTER }
{ GL_TEXTURE_WRAP_S }
{ GL_TEXTURE_WRAP_T }

  GL_NUM_COMPRESSED_TEXTURE_FORMATS                 = $86A2;
  GL_COMPRESSED_TEXTURE_FORMATS                     = $86A3;

{ HintMode }
  GL_DONT_CARE                                      = $1100;
  GL_FASTEST                                        = $1101;
  GL_NICEST                                         = $1102;

{ HintTarget }
  GL_PERSPECTIVE_CORRECTION_HINT                    = $0C50;
  GL_POINT_SMOOTH_HINT                              = $0C51;
  GL_LINE_SMOOTH_HINT                               = $0C52;
  GL_FOG_HINT                                       = $0C54;
  GL_GENERATE_MIPMAP_HINT                           = $8192;

{ LightModelParameter }
  GL_LIGHT_MODEL_AMBIENT                            = $0B53;
  GL_LIGHT_MODEL_TWO_SIDE                           = $0B52;

{ LightParameter }
  GL_AMBIENT                                        = $1200;
  GL_DIFFUSE                                        = $1201;
  GL_SPECULAR                                       = $1202;
  GL_POSITION                                       = $1203;
  GL_SPOT_DIRECTION                                 = $1204;
  GL_SPOT_EXPONENT                                  = $1205;
  GL_SPOT_CUTOFF                                    = $1206;
  GL_CONSTANT_ATTENUATION                           = $1207;
  GL_LINEAR_ATTENUATION                             = $1208;
  GL_QUADRATIC_ATTENUATION                          = $1209;

{ DataType }
  GL_BYTE                                           = $1400;
  GL_UNSIGNED_BYTE                                  = $1401;
  GL_SHORT                                          = $1402;
  GL_UNSIGNED_SHORT                                 = $1403;
  GL_FLOAT                                          = $1406;
  GL_FIXED                                          = $140C;

{ LogicOp }
  GL_CLEAR                                          = $1500;
  GL_AND                                            = $1501;
  GL_AND_REVERSE                                    = $1502;
  GL_COPY                                           = $1503;
  GL_AND_INVERTED                                   = $1504;
  GL_NOOP                                           = $1505;
  GL_XOR                                            = $1506;
  GL_OR                                             = $1507;
  GL_NOR                                            = $1508;
  GL_EQUIV                                          = $1509;
  GL_INVERT                                         = $150A;
  GL_OR_REVERSE                                     = $150B;
  GL_COPY_INVERTED                                  = $150C;
  GL_OR_INVERTED                                    = $150D;
  GL_NAND                                           = $150E;
  GL_SET                                            = $150F;

{ MaterialFace }
{ GL_FRONT_AND_BACK }

{ MaterialParameter }
  GL_EMISSION                                       = $1600;
  GL_SHININESS                                      = $1601;
  GL_AMBIENT_AND_DIFFUSE                            = $1602;
{ GL_AMBIENT }
{ GL_DIFFUSE }
{ GL_SPECULAR }

{ MatrixMode }
  GL_MODELVIEW                                      = $1700;
  GL_PROJECTION                                     = $1701;
  GL_TEXTURE                                        = $1702;

{ NormalPointerType }
{ GL_BYTE }
{ GL_SHORT }
{ GL_FLOAT }
{ GL_FIXED }

{ PixelFormat }
  GL_ALPHA                                          = $1906;
  GL_RGB                                            = $1907;
  GL_RGBA                                           = $1908;
  GL_LUMINANCE                                      = $1909;
  GL_LUMINANCE_ALPHA                                = $190A;

{ PixelType }
{ GL_UNSIGNED_BYTE }
  GL_UNSIGNED_SHORT_4_4_4_4                         = $8033;
  GL_UNSIGNED_SHORT_5_5_5_1                         = $8034;
  GL_UNSIGNED_SHORT_5_6_5                           = $8363;

{ ShadingModel }
  GL_FLAT                                           = $1D00;
  GL_SMOOTH                                         = $1D01;

{ StencilFunction }
{ GL_NEVER }
{ GL_LESS }
{ GL_EQUAL }
{ GL_LEQUAL }
{ GL_GREATER }
{ GL_NOTEQUAL }
{ GL_GEQUAL }
{ GL_ALWAYS }

{ StencilOp }
{ GL_ZERO }
  GL_KEEP                                           = $1E00;
  GL_REPLACE                                        = $1E01;
  GL_INCR                                           = $1E02;
  GL_DECR                                           = $1E03;
{ GL_INVERT }

{ StringName }
  GL_VENDOR                                         = $1F00;
  GL_RENDERER                                       = $1F01;
  GL_VERSION                                        = $1F02;
  GL_EXTENSIONS                                     = $1F03;

{ TexCoordPointerType }
{ GL_SHORT }
{ GL_FLOAT }
{ GL_FIXED }
{ GL_BYTE }

{ TextureEnvMode }
  GL_MODULATE                                       = $2100;
  GL_DECAL                                          = $2101;
{ GL_BLEND }
  GL_ADD                                            = $0104;
{ GL_REPLACE }

{ TextureEnvParameter }
  GL_TEXTURE_ENV_MODE                               = $2200;
  GL_TEXTURE_ENV_COLOR                              = $2201;

{ TextureEnvTarget }
  GL_TEXTURE_ENV                                    = $2300;

{ TextureMagFilter }
  GL_NEAREST                                        = $2600;
  GL_LINEAR                                         = $2601;

{ TextureMinFilter }
{ GL_NEAREST }
{ GL_LINEAR }
  GL_NEAREST_MIPMAP_NEAREST                         = $2700;
  GL_LINEAR_MIPMAP_NEAREST                          = $2701;
  GL_NEAREST_MIPMAP_LINEAR                          = $2702;
  GL_LINEAR_MIPMAP_LINEAR                           = $2703;

{ TextureParameterName }
  GL_TEXTURE_MAG_FILTER                             = $2800;
  GL_TEXTURE_MIN_FILTER                             = $2801;
  GL_TEXTURE_WRAP_S                                 = $2802;
  GL_TEXTURE_WRAP_T                                 = $2803;
  GL_GENERATE_MIPMAP                                = $8191;

{ TextureTarget }
{ GL_TEXTURE_2D }

{ TextureUnit }
  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_CLIENT_ACTIVE_TEXTURE                          = $84E1;

{ TextureWrapMode }
  GL_REPEAT                                         = $2901;
  GL_CLAMP_TO_EDGE                                  = $812F;

{ VertexPointerType }
{ GL_SHORT }
{ GL_FLOAT }
{ GL_FIXED }
{ GL_BYTE }

{ LightName }
  GL_LIGHT0                                         = $4000;
  GL_LIGHT1                                         = $4001;
  GL_LIGHT2                                         = $4002;
  GL_LIGHT3                                         = $4003;
  GL_LIGHT4                                         = $4004;
  GL_LIGHT5                                         = $4005;
  GL_LIGHT6                                         = $4006;
  GL_LIGHT7                                         = $4007;

{ Buffer Objects }
  GL_ARRAY_BUFFER                                   = $8892;
  GL_ELEMENT_ARRAY_BUFFER                           = $8893;

  GL_ARRAY_BUFFER_BINDING                           = $8894;
  GL_ELEMENT_ARRAY_BUFFER_BINDING                   = $8895;
  GL_VERTEX_ARRAY_BUFFER_BINDING                    = $8896;
  GL_NORMAL_ARRAY_BUFFER_BINDING                    = $8897;
  GL_COLOR_ARRAY_BUFFER_BINDING                     = $8898;
  GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING             = $889A;

  GL_STATIC_DRAW                                    = $88E4;
  GL_DYNAMIC_DRAW                                   = $88E8;

  GL_BUFFER_SIZE                                    = $8764;
  GL_BUFFER_USAGE                                   = $8765;

{ Texture combine + dot3 }
  GL_SUBTRACT                                       = $84E7;
  GL_COMBINE                                        = $8570;
  GL_COMBINE_RGB                                    = $8571;
  GL_COMBINE_ALPHA                                  = $8572;
  GL_RGB_SCALE                                      = $8573;
  GL_ADD_SIGNED                                     = $8574;
  GL_INTERPOLATE                                    = $8575;
  GL_CONSTANT                                       = $8576;
  GL_PRIMARY_COLOR                                  = $8577;
  GL_PREVIOUS                                       = $8578;
  GL_OPERAND0_RGB                                   = $8590;
  GL_OPERAND1_RGB                                   = $8591;
  GL_OPERAND2_RGB                                   = $8592;
  GL_OPERAND0_ALPHA                                 = $8598;
  GL_OPERAND1_ALPHA                                 = $8599;
  GL_OPERAND2_ALPHA                                 = $859A;

  GL_ALPHA_SCALE                                    = $0D1C;

  GL_SRC0_RGB                                       = $8580;
  GL_SRC1_RGB                                       = $8581;
  GL_SRC2_RGB                                       = $8582;
  GL_SRC0_ALPHA                                     = $8588;
  GL_SRC1_ALPHA                                     = $8589;
  GL_SRC2_ALPHA                                     = $858A;

  GL_DOT3_RGB                                       = $86AE;
  GL_DOT3_RGBA                                      = $86AF;

{ ============================================== OpenGL ES 2.0 ======================================================= }
{ BlendEquationSeparate }
  GL_FUNC_ADD                                       = $8006;
  GL_BLEND_EQUATION                                 = $8009;
  GL_BLEND_EQUATION_RGB                             = $8009;    // same as BLEND_EQUATION
  GL_BLEND_EQUATION_ALPHA                           = $883D;

{ BlendSubtract }
  GL_FUNC_SUBTRACT                                  = $800A;
  GL_FUNC_REVERSE_SUBTRACT                          = $800B;

{ Separate Blend Functions }
  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;

{ Buffer Objects }
  GL_STREAM_DRAW                                    = $88E0;
  GL_CURRENT_VERTEX_ATTRIB                          = $8626;

{ GetPName }
  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;

{ DataType }
  GL_INT                                            = $1404;
  GL_UNSIGNED_INT                                   = $1405;

{ PixelFormat }
  GL_DEPTH_COMPONENT                                = $1902;

{ Shaders }
  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;

{ StencilOp }
  GL_INCR_WRAP                                      = $8507;
  GL_DECR_WRAP                                      = $8508;

{ TextureTarget }
  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;

{ TextureWrapMode }
  GL_MIRRORED_REPEAT                                = $8370;

{ Uniform Types }
  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;

{ Vertex Arrays }
  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;

{ Read Format }
  GL_IMPLEMENTATION_COLOR_READ_TYPE                 = $8B9A;
  GL_IMPLEMENTATION_COLOR_READ_FORMAT               = $8B9B;

{ Shader Source }
  GL_COMPILE_STATUS                                 = $8B81;
  GL_INFO_LOG_LENGTH                                = $8B84;
  GL_SHADER_SOURCE_LENGTH                           = $8B88;
  GL_SHADER_COMPILER                                = $8DFA;

{ Shader Binary }
  GL_SHADER_BINARY_FORMATS                          = $8DF8;
  GL_NUM_SHADER_BINARY_FORMATS                      = $8DF9;

{ Shader Precision-Specified Types }
  GL_LOW_FLOAT                                      = $8DF0;
  GL_MEDIUM_FLOAT                                   = $8DF1;
  GL_HIGH_FLOAT                                     = $8DF2;
  GL_LOW_INT                                        = $8DF3;
  GL_MEDIUM_INT                                     = $8DF4;
  GL_HIGH_INT                                       = $8DF5;

{ Framebuffer Object. }
  GL_FRAMEBUFFER                                    = $8D40;
  GL_RENDERBUFFER                                   = $8D41;

  GL_RGBA4                                          = $8056;
  GL_RGB5_A1                                        = $8057;
  GL_RGB565                                         = $8D62;
  GL_DEPTH_COMPONENT16                              = $81A5;
  GL_STENCIL_INDEX                                  = $1901;
  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                                           = 0;

  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_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 1.0 ======================================================= }
{ Available only in Common profile }
  TglAlphaFunc                              = procedure(aFunc: GLenum; aRef: GLclampf); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearColor                             = procedure(aRed: GLclampf; aGreen: GLclampf; aBlue: GLclampf; aAlpha: GLclampf); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearDepthf                            = procedure(aDepth: GLclampf); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClipPlanef                             = procedure(aPlane: GLenum; const aEquation: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglColor4f                                = procedure(aRed: GLfloat; aGreen: GLfloat; aBlue: GLfloat; aAlpha: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDepthRangef                            = procedure(aZNear: GLclampf; aZFar: GLclampf); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFogf                                   = procedure(aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFogfv                                  = procedure(aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFrustumf                               = procedure(aLeft: GLfloat; aRight: GLfloat; aBottom: GLfloat; aTop: GLfloat; aZNear: GLfloat; aZFar: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetClipPlanef                          = procedure(aPname: GLenum; aEquation: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetFloatv                              = procedure(aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetLightfv                             = procedure(aLight: GLenum; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetMaterialfv                          = procedure(aFace: GLenum; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexEnvfv                            = procedure(aEnv: GLenum; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexParameterfv                      = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightModelf                            = procedure(aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightModelfv                           = procedure(aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightf                                 = procedure(aLight: GLenum; aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightfv                                = procedure(aLight: GLenum; aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLineWidth                              = procedure(aWidth: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLoadMatrixf                            = procedure(const aMatrix: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMaterialf                              = procedure(aFace: GLenum; aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMaterialfv                             = procedure(aFace: GLenum; aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMultMatrixf                            = procedure(const aMatrix: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMultiTexCoord4f                        = procedure(aTarget: GLenum; s: GLfloat; t: GLfloat; r: GLfloat; q: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglNormal3f                               = procedure(nx: GLfloat; ny: GLfloat; nz: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglOrthof                                 = procedure(aLeft: GLfloat; aRight: GLfloat; aBottom: GLfloat; aTop: GLfloat; aZNear: GLfloat; aZFar: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPointParameterf                        = procedure(aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPointParameterfv                       = procedure(aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPointSize                              = procedure(aSize: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPolygonOffset                          = procedure(aFactor: GLfloat; aUnits: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglRotatef                                = procedure(aAngle: GLfloat; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglScalef                                 = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexEnvf                                = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexEnvfv                               = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLfloat); {$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}
  TglTranslatef                             = procedure(x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

{ Available in both Common and Common-Lite profiles }
  TglActiveTexture                          = procedure(aTexture: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglAlphaFuncx                             = procedure(aFunc: GLenum; aRef: GLclampx); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindBuffer                             = procedure(aTarget: GLenum; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBindTexture                            = procedure(aTarget: GLenum; aTexture: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendFunc                              = procedure(aSfactor: GLenum; aDfactor: 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}
  TglClear                                  = procedure(aMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearColorx                            = procedure(aRed: GLclampx; aGreen: GLclampx; aBlue: GLclampx; aAlpha: GLclampx); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearDepthx                            = procedure(aDepth: GLclampx); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClearStencil                           = procedure(aStencil: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClientActiveTexture                    = procedure(aTexture: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglClipPlanex                             = procedure(aPlane: GLenum; const aEquation: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglColor4ub                               = procedure(aRed: GLubyte; aGreen: GLubyte; aBlue: GLubyte; aAlpha: GLubyte); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglColor4x                                = procedure(aRed: GLfixed; aGreen: GLfixed; aBlue: GLfixed; aAlpha: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglColorMask                              = procedure(aRed: GLboolean; aGreen: GLboolean; aBlue: GLboolean; aAlpha: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglColorPointer                           = procedure(aSize: GLint; aType: GLenum; aStride: GLsizei; const aPointer: PGLvoid); {$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; x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei; aBorder: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCopyTexSubImage2D                      = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei); {$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}
  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}
  TglDepthRangex                            = procedure(aZNear: GLclampx; aZFar: GLclampx); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDisable                                = procedure(aCap: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDisableClientState                     = procedure(aArray: GLenum); {$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}
  TglEnableClientState                      = procedure(aArray: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFinish                                 = procedure(); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFlush                                  = procedure(); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFogx                                   = procedure(aPname: GLenum; aParam: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFogxv                                  = procedure(aPname: GLenum; const aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFrontFace                              = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglFrustumx                               = procedure(aLeft: GLfixed; aRight: GLfixed; aBottom: GLfixed; aTop: GLfixed; aZNear: GLfixed; aZFar: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetBooleanv                            = procedure(aPname: GLenum; aParams: PGLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetBufferParameteriv                   = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetClipPlanex                          = procedure(aPname: GLenum; aEquation: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenBuffers                             = procedure(n: GLsizei; aBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGenTextures                            = procedure(n: GLsizei; aTextures: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetError                               = function (): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetFixedv                              = procedure(aPname: GLenum; aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetIntegerv                            = procedure(aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetLightxv                             = procedure(aLight: GLenum; aPname: GLenum; aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetMaterialxv                          = procedure(aFace: GLenum; aPname: GLenum; aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetPointerv                            = procedure(aPname: GLenum; aParams: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetString                              = function (name: GLenum): PGLubyte; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexEnviv                            = procedure(aEnv: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexEnvxv                            = procedure(aEnv: GLenum; aPname: GLenum; aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexParameteriv                      = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetTexParameterxv                      = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLfixed); {$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}
  TglIsTexture                              = function (aTexture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightModelx                            = procedure(aPname: GLenum; aParam: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightModelxv                           = procedure(aPname: GLenum; const aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightx                                 = procedure(aLight: GLenum; aPname: GLenum; aParam: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLightxv                                = procedure(aLight: GLenum; aPname: GLenum; const aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLineWidthx                             = procedure(aWidth: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLoadIdentity                           = procedure(); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLoadMatrix                             = procedure(const aMatrix: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglLogicOp                                = procedure(aOpcode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMaterialx                              = procedure(aFace: GLenum; aPname: GLenum; aParam: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMaterialxv                             = procedure(aFace: GLenum; aPname: GLenum; const aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMatrixMode                             = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMultMatrixx                            = procedure(const aMatrix: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglMultiTexCoord4x                        = procedure(aTarget: GLenum; s: GLfixed; t: GLfixed; r: GLfixed; q: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglNormal3x                               = procedure(nx: GLfixed; ny: GLfixed; nz: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglNormalPointer                          = procedure(aType: GLenum; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglOrthox                                 = procedure(aLeft: GLfixed; aRight: GLfixed; aBottom: GLfixed; aTop: GLfixed; aZNear: GLfixed; aZFar: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPixelStorei                            = procedure(aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPointParameterx                        = procedure(aPname: GLenum; aParam: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPointParameterxv                       = procedure(aPname: GLenum; const aParams: PGLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPointSizex                             = procedure(aSize: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPolygonOffsetx                         = procedure(aFactor: GLfixed; aUnits: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPopMatrix                              = procedure(); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglPushMatrix                             = procedure(); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglReadPixels                             = procedure(x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aType: GLenum; aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglRotatex                                = procedure(aAngle: GLfixed; x: GLfixed; y: GLfixed; z: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSampleCoverage                         = procedure(aValue: GLclampf; aInvert: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglSampleCoveragex                        = procedure(aValue: GLclampx; aInvert: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglScalex                                 = procedure(x: GLfixed; y: GLfixed; z: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglScissor                                = procedure(x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglShadeModel                             = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilFunc                            = procedure(aFunc: GLenum; aRef: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilMask                            = procedure(aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilOp                              = procedure(aFail: GLenum; aZfail: GLenum; aZpass: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexCoordPointer                        = procedure(aSize: GLint; aType: GLenum; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexEnvi                                = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexEnvx                                = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexEnviv                               = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexEnvxv                               = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLfixed); {$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}
  TglTexParameteri                          = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexParameterx                          = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexParameteriv                         = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglTexParameterxv                         = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLfixed); {$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}
  TglTranslatex                             = procedure(x: GLfixed; y: GLfixed; z: GLfixed); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexPointer                          = procedure(aSize: GLint; aType: GLenum; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglViewport                               = procedure(x: GLint; y: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

{ ============================================== OpenGL ES 2.0 ======================================================= }
  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}
  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}
  TglBlendColor                             = procedure(aRed: GLclampf; aGreen: GLclampf; aBlue: GLclampf; aAlpha: GLclampf); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendEquation                          = procedure( mode : GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendEquationSeparate                  = procedure(aModeRGB: GLenum; aModeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglBlendFuncSeparate                      = procedure(aSrcRGB: GLenum; aDstRGB: GLenum; aSrcAlpha: GLenum; aDstAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCheckFramebufferStatus                 = function (aTarget: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglCompileShader                          = procedure(aShader: GLuint); {$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}
  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}
  TglDetachShader                           = procedure(aProgram: GLuint; aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglDisableVertexAttribArray               = procedure(aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglEnableVertexAttribArray                = procedure(aIndex: GLuint); {$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}
  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}
  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): Integer; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetFramebufferAttachmentParameteriv    = procedure(aTarget: GLenum; aAttachment: GLenum; aPname: GLenum; aParams: 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}
  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): Integer; {$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}
  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}
  TglLinkProgram                            = procedure(aProgram: GLuint); {$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}
  TglShaderBinary                           = procedure(n: 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}
  TglStencilFuncSeparate                    = procedure(aFace: GLenum; aFunc: GLenum; aRef: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilMaskSeparate                    = procedure(aFace: GLenum; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglStencilOpSeparate                      = procedure(aFace: GLenum; aFail: GLenum; aZfail: GLenum; aZpass: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1f                              = procedure(aLocation: GLint; x: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1fv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1i                              = procedure(aLocation: GLint; x: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform1iv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2f                              = procedure(aLocation: GLint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2fv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2i                              = procedure(aLocation: GLint; x: GLint; y: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2iv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3f                              = procedure(aLocation: GLint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3fv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3i                              = procedure(aLocation: GLint; x: GLint; y: GLint; z: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3iv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4f                              = procedure(aLocation: GLint; x: GLfloat; y: GLfloat; z: GLfloat; aW: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4fv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4i                              = procedure(aLocation: GLint; x: GLint; y: GLint; z: GLint; aW: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4iv                             = procedure(aLocation: GLint; aCount: GLsizei; const aV: 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; x: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib1fv                        = procedure(aIndex: GLuint; const aValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib2f                         = procedure(aIndex: GLuint; x: GLfloat; y: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib2fv                        = procedure(aIndex: GLuint; const aValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib3f                         = procedure(aIndex: GLuint; x: GLfloat; y: GLfloat; z: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib3fv                        = procedure(aIndex: GLuint; const aValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib4f                         = procedure(aIndex: GLuint; x: GLfloat; y: GLfloat; z: GLfloat; aW: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttrib4fv                        = procedure(aIndex: GLuint; const aValues: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribPointer                    = procedure(aIndex: GLuint; aSize: GLint; aType: GLenum; aNormalized: GLboolean; aStride: GLsizei; const aPtr: PGLvoid); {$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; x: GLint; y: 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: PGLuint); {$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 aBuffers: 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(srcX0: GLint; srcY0: GLint; srcX1: GLint; srcY1: GLint; dstX0: GLint; dstY0: GLint; dstX1: GLint; dstY1: 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}
  TglGetIntegeriv                           = 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; x: GLint; y: GLint; z: GLint; aW: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglVertexAttribI4ui                       = procedure(aIndex: GLuint; x: GLuint; y: GLuint; z: 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: PGLuint); {$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; v0: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform2ui                             = procedure(aLocation: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform3ui                             = procedure(aLocation: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglUniform4ui                             = procedure(aLocation: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: 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): PGLubyte; {$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; aValues: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetInteger64iv                         = 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; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglGetSamplerParameterfv                  = procedure(aSampler: GLuint; aPname: GLenum; 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; 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; x: GLint; y: 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; v0: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2i                       = procedure(aProgram: GLuint; aLocation: GLint; v0: GLint; v1: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3i                       = procedure(aProgram: GLuint; aLocation: GLint; v0: GLint; v1: GLint; v2: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4i                       = procedure(aProgram: GLuint; aLocation: GLint; v0: GLint; v1: GLint; v2: GLint; v3: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1ui                      = procedure(aProgram: GLuint; aLocation: GLint; v0: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2ui                      = procedure(aProgram: GLuint; aLocation: GLint; v0: GLuint; v1: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3ui                      = procedure(aProgram: GLuint; aLocation: GLint; v0: GLuint; v1: GLuint; v2: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4ui                      = procedure(aProgram: GLuint; aLocation: GLint; v0: GLuint; v1: GLuint; v2: GLuint; v3: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform1f                       = procedure(aProgram: GLuint; aLocation: GLint; v0: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform2f                       = procedure(aProgram: GLuint; aLocation: GLint; v0: GLfloat; v1: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform3f                       = procedure(aProgram: GLuint; aLocation: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TglProgramUniform4f                       = procedure(aProgram: GLuint; aLocation: GLint; v0: GLfloat; v1: GLfloat; v2: GLfloat; v3: 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; aVal: 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
{ ============================================== OpenGL ES 1.0 ======================================================= }
{ Available only in Common profile }
  glAlphaFunc:                              TglAlphaFunc;
  glClearColor:                             TglClearColor;
  glClearDepthf:                            TglClearDepthf;
  glClipPlanef:                             TglClipPlanef;
  glColor4f:                                TglColor4f;
  glDepthRangef:                            TglDepthRangef;
  glFogf:                                   TglFogf;
  glFogfv:                                  TglFogfv;
  glFrustumf:                               TglFrustumf;
  glGetClipPlanef:                          TglGetClipPlanef;
  glGetFloatv:                              TglGetFloatv;
  glGetLightfv:                             TglGetLightfv;
  glGetMaterialfv:                          TglGetMaterialfv;
  glGetTexEnvfv:                            TglGetTexEnvfv;
  glGetTexParameterfv:                      TglGetTexParameterfv;
  glLightModelf:                            TglLightModelf;
  glLightModelfv:                           TglLightModelfv;
  glLightf:                                 TglLightf;
  glLightfv:                                TglLightfv;
  glLineWidth:                              TglLineWidth;
  glLoadMatrixf:                            TglLoadMatrixf;
  glMaterialf:                              TglMaterialf;
  glMaterialfv:                             TglMaterialfv;
  glMultMatrixf:                            TglMultMatrixf;
  glMultiTexCoord4f:                        TglMultiTexCoord4f;
  glNormal3f:                               TglNormal3f;
  glOrthof:                                 TglOrthof;
  glPointParameterf:                        TglPointParameterf;
  glPointParameterfv:                       TglPointParameterfv;
  glPointSize:                              TglPointSize;
  glPolygonOffset:                          TglPolygonOffset;
  glRotatef:                                TglRotatef;
  glScalef:                                 TglScalef;
  glTexEnvf:                                TglTexEnvf;
  glTexEnvfv:                               TglTexEnvfv;
  glTexParameterf:                          TglTexParameterf;
  glTexParameterfv:                         TglTexParameterfv;
  glTranslatef:                             TglTranslatef;

{ Available in both Common and Common-Lite profiles }
  glActiveTexture:                          TglActiveTexture;
  glAlphaFuncx:                             TglAlphaFuncx;
  glBindBuffer:                             TglBindBuffer;
  glBindTexture:                            TglBindTexture;
  glBlendFunc:                              TglBlendFunc;
  glBufferData:                             TglBufferData;
  glBufferSubData:                          TglBufferSubData;
  glClear:                                  TglClear;
  glClearColorx:                            TglClearColorx;
  glClearDepthx:                            TglClearDepthx;
  glClearStencil:                           TglClearStencil;
  glClientActiveTexture:                    TglClientActiveTexture;
  glClipPlanex:                             TglClipPlanex;
  glColor4ub:                               TglColor4ub;
  glColor4x:                                TglColor4x;
  glColorMask:                              TglColorMask;
  glColorPointer:                           TglColorPointer;
  glCompressedTexImage2D:                   TglCompressedTexImage2D;
  glCompressedTexSubImage2D:                TglCompressedTexSubImage2D;
  glCopyTexImage2D:                         TglCopyTexImage2D;
  glCopyTexSubImage2D:                      TglCopyTexSubImage2D;
  glCullFace:                               TglCullFace;
  glDeleteBuffers:                          TglDeleteBuffers;
  glDeleteTextures:                         TglDeleteTextures;
  glDepthFunc:                              TglDepthFunc;
  glDepthMask:                              TglDepthMask;
  glDepthRangex:                            TglDepthRangex;
  glDisable:                                TglDisable;
  glDisableClientState:                     TglDisableClientState;
  glDrawArrays:                             TglDrawArrays;
  glDrawElements:                           TglDrawElements;
  glEnable:                                 TglEnable;
  glEnableClientState:                      TglEnableClientState;
  glFinish:                                 TglFinish;
  glFlush:                                  TglFlush;
  glFogx:                                   TglFogx;
  glFogxv:                                  TglFogxv;
  glFrontFace:                              TglFrontFace;
  glFrustumx:                               TglFrustumx;
  glGetBooleanv:                            TglGetBooleanv;
  glGetBufferParameteriv:                   TglGetBufferParameteriv;
  glGetClipPlanex:                          TglGetClipPlanex;
  glGenBuffers:                             TglGenBuffers;
  glGenTextures:                            TglGenTextures;
  glGetError:                               TglGetError;
  glGetFixedv:                              TglGetFixedv;
  glGetIntegerv:                            TglGetIntegerv;
  glGetLightxv:                             TglGetLightxv;
  glGetMaterialxv:                          TglGetMaterialxv;
  glGetPointerv:                            TglGetPointerv;
  glGetString:                              TglGetString;
  glGetTexEnviv:                            TglGetTexEnviv;
  glGetTexEnvxv:                            TglGetTexEnvxv;
  glGetTexParameteriv:                      TglGetTexParameteriv;
  glGetTexParameterxv:                      TglGetTexParameterxv;
  glHint:                                   TglHint;
  glIsBuffer:                               TglIsBuffer;
  glIsEnabled:                              TglIsEnabled;
  glIsTexture:                              TglIsTexture;
  glLightModelx:                            TglLightModelx;
  glLightModelxv:                           TglLightModelxv;
  glLightx:                                 TglLightx;
  glLightxv:                                TglLightxv;
  glLineWidthx:                             TglLineWidthx;
  glLoadIdentity:                           TglLoadIdentity;
  glLoadMatrix:                             TglLoadMatrix;
  glLogicOp:                                TglLogicOp;
  glMaterialx:                              TglMaterialx;
  glMaterialxv:                             TglMaterialxv;
  glMatrixMode:                             TglMatrixMode;
  glMultMatrixx:                            TglMultMatrixx;
  glMultiTexCoord4x:                        TglMultiTexCoord4x;
  glNormal3x:                               TglNormal3x;
  glNormalPointer:                          TglNormalPointer;
  glOrthox:                                 TglOrthox;
  glPixelStorei:                            TglPixelStorei;
  glPointParameterx:                        TglPointParameterx;
  glPointParameterxv:                       TglPointParameterxv;
  glPointSizex:                             TglPointSizex;
  glPolygonOffsetx:                         TglPolygonOffsetx;
  glPopMatrix:                              TglPopMatrix;
  glPushMatrix:                             TglPushMatrix;
  glReadPixels:                             TglReadPixels;
  glRotatex:                                TglRotatex;
  glSampleCoverage:                         TglSampleCoverage;
  glSampleCoveragex:                        TglSampleCoveragex;
  glScalex:                                 TglScalex;
  glScissor:                                TglScissor;
  glShadeModel:                             TglShadeModel;
  glStencilFunc:                            TglStencilFunc;
  glStencilMask:                            TglStencilMask;
  glStencilOp:                              TglStencilOp;
  glTexCoordPointer:                        TglTexCoordPointer;
  glTexEnvi:                                TglTexEnvi;
  glTexEnvx:                                TglTexEnvx;
  glTexEnviv:                               TglTexEnviv;
  glTexEnvxv:                               TglTexEnvxv;
  glTexImage2D:                             TglTexImage2D;
  glTexParameteri:                          TglTexParameteri;
  glTexParameterx:                          TglTexParameterx;
  glTexParameteriv:                         TglTexParameteriv;
  glTexParameterxv:                         TglTexParameterxv;
  glTexSubImage2D:                          TglTexSubImage2D;
  glTranslatex:                             TglTranslatex;
  glVertexPointer:                          TglVertexPointer;
  glViewport:                               TglViewport;

{ ============================================== OpenGL ES 2.0 ======================================================= }
  glAttachShader:                           TglAttachShader;
  glBindAttribLocation:                     TglBindAttribLocation;
  glBindFramebuffer:                        TglBindFramebuffer;
  glBindRenderbuffer:                       TglBindRenderbuffer;
  glBlendColor:                             TglBlendColor;
  glBlendEquation:                          TglBlendEquation;
  glBlendEquationSeparate:                  TglBlendEquationSeparate;
  glBlendFuncSeparate:                      TglBlendFuncSeparate;
  glCheckFramebufferStatus:                 TglCheckFramebufferStatus;
  glCompileShader:                          TglCompileShader;
  glCreateProgram:                          TglCreateProgram;
  glCreateShader:                           TglCreateShader;
  glDeleteFramebuffers:                     TglDeleteFramebuffers;
  glDeleteProgram:                          TglDeleteProgram;
  glDeleteRenderbuffers:                    TglDeleteRenderbuffers;
  glDeleteShader:                           TglDeleteShader;
  glDetachShader:                           TglDetachShader;
  glDisableVertexAttribArray:               TglDisableVertexAttribArray;
  glEnableVertexAttribArray:                TglEnableVertexAttribArray;
  glFramebufferRenderbuffer:                TglFramebufferRenderbuffer;
  glFramebufferTexture2D:                   TglFramebufferTexture2D;
  glGenerateMipmap:                         TglGenerateMipmap;
  glGenFramebuffers:                        TglGenFramebuffers;
  glGenRenderbuffers:                       TglGenRenderbuffers;
  glGetActiveAttrib:                        TglGetActiveAttrib;
  glGetActiveUniform:                       TglGetActiveUniform;
  glGetAttachedShaders:                     TglGetAttachedShaders;
  glGetAttribLocation:                      TglGetAttribLocation;
  glGetFramebufferAttachmentParameteriv:    TglGetFramebufferAttachmentParameteriv;
  glGetProgramiv:                           TglGetProgramiv;
  glGetProgramInfoLog:                      TglGetProgramInfoLog;
  glGetRenderbufferParameteriv:             TglGetRenderbufferParameteriv;
  glGetShaderiv:                            TglGetShaderiv;
  glGetShaderInfoLog:                       TglGetShaderInfoLog;
  glGetShaderPrecisionFormat:               TglGetShaderPrecisionFormat;
  glGetShaderSource:                        TglGetShaderSource;
  glGetUniformfv:                           TglGetUniformfv;
  glGetUniformiv:                           TglGetUniformiv;
  glGetUniformLocation:                     TglGetUniformLocation;
  glGetVertexAttribfv:                      TglGetVertexAttribfv;
  glGetVertexAttribiv:                      TglGetVertexAttribiv;
  glGetVertexAttribPointerv:                TglGetVertexAttribPointerv;
  glIsFramebuffer:                          TglIsFramebuffer;
  glIsProgram:                              TglIsProgram;
  glIsRenderbuffer:                         TglIsRenderbuffer;
  glIsShader:                               TglIsShader;
  glLinkProgram:                            TglLinkProgram;
  glReleaseShaderCompiler:                  TglReleaseShaderCompiler;
  glRenderbufferStorage:                    TglRenderbufferStorage;
  glShaderBinary:                           TglShaderBinary;
  glShaderSource:                           TglShaderSource;
  glStencilFuncSeparate:                    TglStencilFuncSeparate;
  glStencilMaskSeparate:                    TglStencilMaskSeparate;
  glStencilOpSeparate:                      TglStencilOpSeparate;
  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;

{ ============================================== 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;
  glGetIntegeriv:                           TglGetIntegeriv;
  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;
  glGetInteger64iv:                         TglGetInteger64iv;
  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; name: EGLint): PAnsiChar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}

  TeglGetConfigs      = function(aDisplay: EGLDisplay; aConfigs: PEGLConfig; aConfigSize: EGLint; numConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
  TeglChooseConfig    = function(aDisplay: EGLDisplay; const aAttribList: PEGLint; aConfigs: PEGLConfig; aConfigSize: EGLint; numConfig: 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 name: PChar): Pointer;
begin
  {$IFDEF DGL_LINUX}
  result := dlopen(name, 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

end;

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

end.