--- /dev/null
+{ ============================================================================
+
+ 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
+{$IFDEF DGL_LINUX}
+uses
+ dl;
+
+const
+ LIBNAME_OPENGLES = 'libGLESv2.so';
+ LIBNAME_EGL = 'libEGL.so';
+
+{$ELSE}
+ {$ERROR 'unknown/unsupported system'}
+
+{$ENDIF}
+
+{ ================================================== OpenGL Es ======================================================= }
+type
+ { OpenGL ES 2.0 }
+ GLbyte = Byte;
+ GLclampf = Single;
+ GLfixed = Integer;
+ GLshort = ShortInt;
+ GLushort = Word;
+ GLvoid = Pointer;
+ GLint64 = Int64;
+ GLuint64 = UInt64;
+ GLenum = Cardinal;
+ GLuint = Cardinal;
+ GLchar = AnsiChar;
+ GLbitfield = Cardinal;
+ GLint = Integer;
+ GLboolean = ByteBool;
+ GLsizei = Integer;
+ GLfloat = Single;
+
+ PGLbyte = ^GLbyte;
+ PGLclampf = ^GLclampf;
+ PGLfixed = ^GLfixed;
+ PGLshort = ^GLshort;
+ PGLushort = ^GLushort;
+ PGLvoid = Pointer;
+ PPGLvoid = ^PGLvoid;
+ PGLint64 = ^GLint64;
+ PGLuint64 = ^GLuint64;
+ PGLenum = ^GLenum;
+ PGLuint = ^GLuint;
+ PGLchar = ^GLchar;
+ PPGLchar = ^PGLChar;
+ PGLbitfield = ^GLbitfield;
+ PGLint = ^GLint;
+ PGLboolean = ^GLboolean;
+ PGLsizei = ^GLsizei;
+ PGLfloat = ^GLfloat;
+
+ { OpenGL ES 3.0 }
+ GLsync = Pointer;
+
+
+const
+ { OpenGL ES 2.0 }
+ GL_DEPTH_BUFFER_BIT = $00000100;
+ GL_STENCIL_BUFFER_BIT = $00000400;
+ GL_COLOR_BUFFER_BIT = $00004000;
+ GL_FALSE = $0000;
+ GL_TRUE = $0001;
+ GL_POINTS = $0000;
+ GL_LINES = $0001;
+ GL_LINE_LOOP = $0002;
+ GL_LINE_STRIP = $0003;
+ GL_TRIANGLES = $0004;
+ GL_TRIANGLE_STRIP = $0005;
+ GL_TRIANGLE_FAN = $0006;
+ GL_ZERO = $0000;
+ GL_ONE = $0001;
+ GL_SRC_COLOR = $0300;
+ GL_ONE_MINUS_SRC_COLOR = $0301;
+ GL_SRC_ALPHA = $0302;
+ GL_ONE_MINUS_SRC_ALPHA = $0303;
+ GL_DST_ALPHA = $0304;
+ GL_ONE_MINUS_DST_ALPHA = $0305;
+ GL_DST_COLOR = $0306;
+ GL_ONE_MINUS_DST_COLOR = $0307;
+ GL_SRC_ALPHA_SATURATE = $0308;
+ GL_FUNC_ADD = $8006;
+ GL_BLEND_EQUATION = $8009;
+ GL_BLEND_EQUATION_RGB = $8009;
+ GL_BLEND_EQUATION_ALPHA = $883D;
+ GL_FUNC_SUBTRACT = $800A;
+ GL_FUNC_REVERSE_SUBTRACT = $800B;
+ GL_BLEND_DST_RGB = $80C8;
+ GL_BLEND_SRC_RGB = $80C9;
+ GL_BLEND_DST_ALPHA = $80CA;
+ GL_BLEND_SRC_ALPHA = $80CB;
+ GL_CONSTANT_COLOR = $8001;
+ GL_ONE_MINUS_CONSTANT_COLOR = $8002;
+ GL_CONSTANT_ALPHA = $8003;
+ GL_ONE_MINUS_CONSTANT_ALPHA = $8004;
+ GL_BLEND_COLOR = $8005;
+ GL_ARRAY_BUFFER = $8892;
+ GL_ELEMENT_ARRAY_BUFFER = $8893;
+ GL_ARRAY_BUFFER_BINDING = $8894;
+ GL_ELEMENT_ARRAY_BUFFER_BINDING = $8895;
+ GL_STREAM_DRAW = $88E0;
+ GL_STATIC_DRAW = $88E4;
+ GL_DYNAMIC_DRAW = $88E8;
+ GL_BUFFER_SIZE = $8764;
+ GL_BUFFER_USAGE = $8765;
+ GL_CURRENT_VERTEX_ATTRIB = $8626;
+ GL_FRONT = $0404;
+ GL_BACK = $0405;
+ GL_FRONT_AND_BACK = $0408;
+ GL_TEXTURE_2D = $0DE1;
+ GL_CULL_FACE = $0B44;
+ GL_BLEND = $0BE2;
+ GL_DITHER = $0BD0;
+ GL_STENCIL_TEST = $0B90;
+ GL_DEPTH_TEST = $0B71;
+ GL_SCISSOR_TEST = $0C11;
+ GL_POLYGON_OFFSET_FILL = $8037;
+ GL_SAMPLE_ALPHA_TO_COVERAGE = $809E;
+ GL_SAMPLE_COVERAGE = $80A0;
+ GL_NO_ERROR = $0000;
+ GL_INVALID_ENUM = $0500;
+ GL_INVALID_VALUE = $0501;
+ GL_INVALID_OPERATION = $0502;
+ GL_OUT_OF_MEMORY = $0505;
+ GL_CW = $0900;
+ GL_CCW = $0901;
+ GL_LINE_WIDTH = $0B21;
+ GL_ALIASED_POINT_SIZE_RANGE = $846D;
+ GL_ALIASED_LINE_WIDTH_RANGE = $846E;
+ GL_CULL_FACE_MODE = $0B45;
+ GL_FRONT_FACE = $0B46;
+ GL_DEPTH_RANGE = $0B70;
+ GL_DEPTH_WRITEMASK = $0B72;
+ GL_DEPTH_CLEAR_VALUE = $0B73;
+ GL_DEPTH_FUNC = $0B74;
+ GL_STENCIL_CLEAR_VALUE = $0B91;
+ GL_STENCIL_FUNC = $0B92;
+ GL_STENCIL_FAIL = $0B94;
+ GL_STENCIL_PASS_DEPTH_FAIL = $0B95;
+ GL_STENCIL_PASS_DEPTH_PASS = $0B96;
+ GL_STENCIL_REF = $0B97;
+ GL_STENCIL_VALUE_MASK = $0B93;
+ GL_STENCIL_WRITEMASK = $0B98;
+ GL_STENCIL_BACK_FUNC = $8800;
+ GL_STENCIL_BACK_FAIL = $8801;
+ GL_STENCIL_BACK_PASS_DEPTH_FAIL = $8802;
+ GL_STENCIL_BACK_PASS_DEPTH_PASS = $8803;
+ GL_STENCIL_BACK_REF = $8CA3;
+ GL_STENCIL_BACK_VALUE_MASK = $8CA4;
+ GL_STENCIL_BACK_WRITEMASK = $8CA5;
+ GL_VIEWPORT = $0BA2;
+ GL_SCISSOR_BOX = $0C10;
+ GL_COLOR_CLEAR_VALUE = $0C22;
+ GL_COLOR_WRITEMASK = $0C23;
+ GL_UNPACK_ALIGNMENT = $0CF5;
+ GL_PACK_ALIGNMENT = $0D05;
+ GL_MAX_TEXTURE_SIZE = $0D33;
+ GL_MAX_VIEWPORT_DIMS = $0D3A;
+ GL_SUBPIXEL_BITS = $0D50;
+ GL_RED_BITS = $0D52;
+ GL_GREEN_BITS = $0D53;
+ GL_BLUE_BITS = $0D54;
+ GL_ALPHA_BITS = $0D55;
+ GL_DEPTH_BITS = $0D56;
+ GL_STENCIL_BITS = $0D57;
+ GL_POLYGON_OFFSET_UNITS = $2A00;
+ GL_POLYGON_OFFSET_FACTOR = $8038;
+ GL_TEXTURE_BINDING_2D = $8069;
+ GL_SAMPLE_BUFFERS = $80A8;
+ GL_SAMPLES = $80A9;
+ GL_SAMPLE_COVERAGE_VALUE = $80AA;
+ GL_SAMPLE_COVERAGE_INVERT = $80AB;
+ GL_NUM_COMPRESSED_TEXTURE_FORMATS = $86A2;
+ GL_COMPRESSED_TEXTURE_FORMATS = $86A3;
+ GL_DONT_CARE = $1100;
+ GL_FASTEST = $1101;
+ GL_NICEST = $1102;
+ GL_GENERATE_MIPMAP_HINT = $8192;
+ GL_BYTE = $1400;
+ GL_UNSIGNED_BYTE = $1401;
+ GL_SHORT = $1402;
+ GL_UNSIGNED_SHORT = $1403;
+ GL_INT = $1404;
+ GL_UNSIGNED_INT = $1405;
+ GL_FLOAT = $1406;
+ GL_FIXED = $140C;
+ GL_DEPTH_COMPONENT = $1902;
+ GL_ALPHA = $1906;
+ GL_RGB = $1907;
+ GL_RGBA = $1908;
+ GL_LUMINANCE = $1909;
+ GL_LUMINANCE_ALPHA = $190A;
+ GL_UNSIGNED_SHORT_4_4_4_4 = $8033;
+ GL_UNSIGNED_SHORT_5_5_5_1 = $8034;
+ GL_UNSIGNED_SHORT_5_6_5 = $8363;
+ GL_FRAGMENT_SHADER = $8B30;
+ GL_VERTEX_SHADER = $8B31;
+ GL_MAX_VERTEX_ATTRIBS = $8869;
+ GL_MAX_VERTEX_UNIFORM_VECTORS = $8DFB;
+ GL_MAX_VARYING_VECTORS = $8DFC;
+ GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = $8B4D;
+ GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS = $8B4C;
+ GL_MAX_TEXTURE_IMAGE_UNITS = $8872;
+ GL_MAX_FRAGMENT_UNIFORM_VECTORS = $8DFD;
+ GL_SHADER_TYPE = $8B4F;
+ GL_DELETE_STATUS = $8B80;
+ GL_LINK_STATUS = $8B82;
+ GL_VALIDATE_STATUS = $8B83;
+ GL_ATTACHED_SHADERS = $8B85;
+ GL_ACTIVE_UNIFORMS = $8B86;
+ GL_ACTIVE_UNIFORM_MAX_LENGTH = $8B87;
+ GL_ACTIVE_ATTRIBUTES = $8B89;
+ GL_ACTIVE_ATTRIBUTE_MAX_LENGTH = $8B8A;
+ GL_SHADING_LANGUAGE_VERSION = $8B8C;
+ GL_CURRENT_PROGRAM = $8B8D;
+ GL_NEVER = $0200;
+ GL_LESS = $0201;
+ GL_EQUAL = $0202;
+ GL_LEQUAL = $0203;
+ GL_GREATER = $0204;
+ GL_NOTEQUAL = $0205;
+ GL_GEQUAL = $0206;
+ GL_ALWAYS = $0207;
+ GL_KEEP = $1E00;
+ GL_REPLACE = $1E01;
+ GL_INCR = $1E02;
+ GL_DECR = $1E03;
+ GL_INVERT = $150A;
+ GL_INCR_WRAP = $8507;
+ GL_DECR_WRAP = $8508;
+ GL_VENDOR = $1F00;
+ GL_RENDERER = $1F01;
+ GL_VERSION = $1F02;
+ GL_EXTENSIONS = $1F03;
+ GL_NEAREST = $2600;
+ GL_LINEAR = $2601;
+ GL_NEAREST_MIPMAP_NEAREST = $2700;
+ GL_LINEAR_MIPMAP_NEAREST = $2701;
+ GL_NEAREST_MIPMAP_LINEAR = $2702;
+ GL_LINEAR_MIPMAP_LINEAR = $2703;
+ GL_TEXTURE_MAG_FILTER = $2800;
+ GL_TEXTURE_MIN_FILTER = $2801;
+ GL_TEXTURE_WRAP_S = $2802;
+ GL_TEXTURE_WRAP_T = $2803;
+ GL_TEXTURE = $1702;
+ GL_TEXTURE_CUBE_MAP = $8513;
+ GL_TEXTURE_BINDING_CUBE_MAP = $8514;
+ GL_TEXTURE_CUBE_MAP_POSITIVE_X = $8515;
+ GL_TEXTURE_CUBE_MAP_NEGATIVE_X = $8516;
+ GL_TEXTURE_CUBE_MAP_POSITIVE_Y = $8517;
+ GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = $8518;
+ GL_TEXTURE_CUBE_MAP_POSITIVE_Z = $8519;
+ GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = $851A;
+ GL_MAX_CUBE_MAP_TEXTURE_SIZE = $851C;
+ GL_TEXTURE0 = $84C0;
+ GL_TEXTURE1 = $84C1;
+ GL_TEXTURE2 = $84C2;
+ GL_TEXTURE3 = $84C3;
+ GL_TEXTURE4 = $84C4;
+ GL_TEXTURE5 = $84C5;
+ GL_TEXTURE6 = $84C6;
+ GL_TEXTURE7 = $84C7;
+ GL_TEXTURE8 = $84C8;
+ GL_TEXTURE9 = $84C9;
+ GL_TEXTURE10 = $84CA;
+ GL_TEXTURE11 = $84CB;
+ GL_TEXTURE12 = $84CC;
+ GL_TEXTURE13 = $84CD;
+ GL_TEXTURE14 = $84CE;
+ GL_TEXTURE15 = $84CF;
+ GL_TEXTURE16 = $84D0;
+ GL_TEXTURE17 = $84D1;
+ GL_TEXTURE18 = $84D2;
+ GL_TEXTURE19 = $84D3;
+ GL_TEXTURE20 = $84D4;
+ GL_TEXTURE21 = $84D5;
+ GL_TEXTURE22 = $84D6;
+ GL_TEXTURE23 = $84D7;
+ GL_TEXTURE24 = $84D8;
+ GL_TEXTURE25 = $84D9;
+ GL_TEXTURE26 = $84DA;
+ GL_TEXTURE27 = $84DB;
+ GL_TEXTURE28 = $84DC;
+ GL_TEXTURE29 = $84DD;
+ GL_TEXTURE30 = $84DE;
+ GL_TEXTURE31 = $84DF;
+ GL_ACTIVE_TEXTURE = $84E0;
+ GL_REPEAT = $2901;
+ GL_CLAMP_TO_EDGE = $812F;
+ GL_MIRRORED_REPEAT = $8370;
+ GL_FLOAT_VEC2 = $8B50;
+ GL_FLOAT_VEC3 = $8B51;
+ GL_FLOAT_VEC4 = $8B52;
+ GL_INT_VEC2 = $8B53;
+ GL_INT_VEC3 = $8B54;
+ GL_INT_VEC4 = $8B55;
+ GL_BOOL = $8B56;
+ GL_BOOL_VEC2 = $8B57;
+ GL_BOOL_VEC3 = $8B58;
+ GL_BOOL_VEC4 = $8B59;
+ GL_FLOAT_MAT2 = $8B5A;
+ GL_FLOAT_MAT3 = $8B5B;
+ GL_FLOAT_MAT4 = $8B5C;
+ GL_SAMPLER_2D = $8B5E;
+ GL_SAMPLER_CUBE = $8B60;
+ GL_VERTEX_ATTRIB_ARRAY_ENABLED = $8622;
+ GL_VERTEX_ATTRIB_ARRAY_SIZE = $8623;
+ GL_VERTEX_ATTRIB_ARRAY_STRIDE = $8624;
+ GL_VERTEX_ATTRIB_ARRAY_TYPE = $8625;
+ GL_VERTEX_ATTRIB_ARRAY_NORMALIZED = $886A;
+ GL_VERTEX_ATTRIB_ARRAY_POINTER = $8645;
+ GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = $889F;
+ GL_IMPLEMENTATION_COLOR_READ_TYPE = $8B9A;
+ GL_IMPLEMENTATION_COLOR_READ_FORMAT = $8B9B;
+ GL_COMPILE_STATUS = $8B81;
+ GL_INFO_LOG_LENGTH = $8B84;
+ GL_SHADER_SOURCE_LENGTH = $8B88;
+ GL_SHADER_COMPILER = $8DFA;
+ GL_SHADER_BINARY_FORMATS = $8DF8;
+ GL_NUM_SHADER_BINARY_FORMATS = $8DF9;
+ GL_LOW_FLOAT = $8DF0;
+ GL_MEDIUM_FLOAT = $8DF1;
+ GL_HIGH_FLOAT = $8DF2;
+ GL_LOW_INT = $8DF3;
+ GL_MEDIUM_INT = $8DF4;
+ GL_HIGH_INT = $8DF5;
+ GL_FRAMEBUFFER = $8D40;
+ GL_RENDERBUFFER = $8D41;
+ GL_RGBA4 = $8056;
+ GL_RGB5_A1 = $8057;
+ GL_RGB565 = $8D62;
+ GL_DEPTH_COMPONENT16 = $81A5;
+ GL_STENCIL_INDEX8 = $8D48;
+ GL_RENDERBUFFER_WIDTH = $8D42;
+ GL_RENDERBUFFER_HEIGHT = $8D43;
+ GL_RENDERBUFFER_INTERNAL_FORMAT = $8D44;
+ GL_RENDERBUFFER_RED_SIZE = $8D50;
+ GL_RENDERBUFFER_GREEN_SIZE = $8D51;
+ GL_RENDERBUFFER_BLUE_SIZE = $8D52;
+ GL_RENDERBUFFER_ALPHA_SIZE = $8D53;
+ GL_RENDERBUFFER_DEPTH_SIZE = $8D54;
+ GL_RENDERBUFFER_STENCIL_SIZE = $8D55;
+ GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = $8CD0;
+ GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = $8CD1;
+ GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = $8CD2;
+ GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = $8CD3;
+ GL_COLOR_ATTACHMENT0 = $8CE0;
+ GL_DEPTH_ATTACHMENT = $8D00;
+ GL_STENCIL_ATTACHMENT = $8D20;
+ GL_NONE = $0000;
+ GL_FRAMEBUFFER_COMPLETE = $8CD5;
+ GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = $8CD6;
+ GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = $8CD7;
+ GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = $8CD9;
+ GL_FRAMEBUFFER_UNSUPPORTED = $8CDD;
+ GL_FRAMEBUFFER_BINDING = $8CA6;
+ GL_RENDERBUFFER_BINDING = $8CA7;
+ GL_MAX_RENDERBUFFER_SIZE = $84E8;
+ GL_INVALID_FRAMEBUFFER_OPERATION = $0506;
+
+ { OpenGL ES 3.0 }
+ GL_READ_BUFFER = $0C02;
+ GL_UNPACK_ROW_LENGTH = $0CF2;
+ GL_UNPACK_SKIP_ROWS = $0CF3;
+ GL_UNPACK_SKIP_PIXELS = $0CF4;
+ GL_PACK_ROW_LENGTH = $0D02;
+ GL_PACK_SKIP_ROWS = $0D03;
+ GL_PACK_SKIP_PIXELS = $0D04;
+ GL_COLOR = $1800;
+ GL_DEPTH = $1801;
+ GL_STENCIL = $1802;
+ GL_RED = $1903;
+ GL_RGB8 = $8051;
+ GL_RGBA8 = $8058;
+ GL_RGB10_A2 = $8059;
+ GL_TEXTURE_BINDING_3D = $806A;
+ GL_UNPACK_SKIP_IMAGES = $806D;
+ GL_UNPACK_IMAGE_HEIGHT = $806E;
+ GL_TEXTURE_3D = $806F;
+ GL_TEXTURE_WRAP_R = $8072;
+ GL_MAX_3D_TEXTURE_SIZE = $8073;
+ GL_UNSIGNED_INT_2_10_10_10_REV = $8368;
+ GL_MAX_ELEMENTS_VERTICES = $80E8;
+ GL_MAX_ELEMENTS_INDICES = $80E9;
+ GL_TEXTURE_MIN_LOD = $813A;
+ GL_TEXTURE_MAX_LOD = $813B;
+ GL_TEXTURE_BASE_LEVEL = $813C;
+ GL_TEXTURE_MAX_LEVEL = $813D;
+ GL_MIN = $8007;
+ GL_MAX = $8008;
+ GL_DEPTH_COMPONENT24 = $81A6;
+ GL_MAX_TEXTURE_LOD_BIAS = $84FD;
+ GL_TEXTURE_COMPARE_MODE = $884C;
+ GL_TEXTURE_COMPARE_FUNC = $884D;
+ GL_CURRENT_QUERY = $8865;
+ GL_QUERY_RESULT = $8866;
+ GL_QUERY_RESULT_AVAILABLE = $8867;
+ GL_BUFFER_MAPPED = $88BC;
+ GL_BUFFER_MAP_POINTER = $88BD;
+ GL_STREAM_READ = $88E1;
+ GL_STREAM_COPY = $88E2;
+ GL_STATIC_READ = $88E5;
+ GL_STATIC_COPY = $88E6;
+ GL_DYNAMIC_READ = $88E9;
+ GL_DYNAMIC_COPY = $88EA;
+ GL_MAX_DRAW_BUFFERS = $8824;
+ GL_DRAW_BUFFER0 = $8825;
+ GL_DRAW_BUFFER1 = $8826;
+ GL_DRAW_BUFFER2 = $8827;
+ GL_DRAW_BUFFER3 = $8828;
+ GL_DRAW_BUFFER4 = $8829;
+ GL_DRAW_BUFFER5 = $882A;
+ GL_DRAW_BUFFER6 = $882B;
+ GL_DRAW_BUFFER7 = $882C;
+ GL_DRAW_BUFFER8 = $882D;
+ GL_DRAW_BUFFER9 = $882E;
+ GL_DRAW_BUFFER10 = $882F;
+ GL_DRAW_BUFFER11 = $8830;
+ GL_DRAW_BUFFER12 = $8831;
+ GL_DRAW_BUFFER13 = $8832;
+ GL_DRAW_BUFFER14 = $8833;
+ GL_DRAW_BUFFER15 = $8834;
+ GL_MAX_FRAGMENT_UNIFORM_COMPONENTS = $8B49;
+ GL_MAX_VERTEX_UNIFORM_COMPONENTS = $8B4A;
+ GL_SAMPLER_3D = $8B5F;
+ GL_SAMPLER_2D_SHADOW = $8B62;
+ GL_FRAGMENT_SHADER_DERIVATIVE_HINT = $8B8B;
+ GL_PIXEL_PACK_BUFFER = $88EB;
+ GL_PIXEL_UNPACK_BUFFER = $88EC;
+ GL_PIXEL_PACK_BUFFER_BINDING = $88ED;
+ GL_PIXEL_UNPACK_BUFFER_BINDING = $88EF;
+ GL_FLOAT_MAT2x3 = $8B65;
+ GL_FLOAT_MAT2x4 = $8B66;
+ GL_FLOAT_MAT3x2 = $8B67;
+ GL_FLOAT_MAT3x4 = $8B68;
+ GL_FLOAT_MAT4x2 = $8B69;
+ GL_FLOAT_MAT4x3 = $8B6A;
+ GL_SRGB = $8C40;
+ GL_SRGB8 = $8C41;
+ GL_SRGB8_ALPHA8 = $8C43;
+ GL_COMPARE_REF_TO_TEXTURE = $884E;
+ GL_MAJOR_VERSION = $821B;
+ GL_MINOR_VERSION = $821C;
+ GL_NUM_EXTENSIONS = $821D;
+ GL_RGBA32F = $8814;
+ GL_RGB32F = $8815;
+ GL_RGBA16F = $881A;
+ GL_RGB16F = $881B;
+ GL_VERTEX_ATTRIB_ARRAY_INTEGER = $88FD;
+ GL_MAX_ARRAY_TEXTURE_LAYERS = $88FF;
+ GL_MIN_PROGRAM_TEXEL_OFFSET = $8904;
+ GL_MAX_PROGRAM_TEXEL_OFFSET = $8905;
+ GL_MAX_VARYING_COMPONENTS = $8B4B;
+ GL_TEXTURE_2D_ARRAY = $8C1A;
+ GL_TEXTURE_BINDING_2D_ARRAY = $8C1D;
+ GL_R11F_G11F_B10F = $8C3A;
+ GL_UNSIGNED_INT_10F_11F_11F_REV = $8C3B;
+ GL_RGB9_E5 = $8C3D;
+ GL_UNSIGNED_INT_5_9_9_9_REV = $8C3E;
+ GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = $8C76;
+ GL_TRANSFORM_FEEDBACK_BUFFER_MODE = $8C7F;
+ GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = $8C80;
+ GL_TRANSFORM_FEEDBACK_VARYINGS = $8C83;
+ GL_TRANSFORM_FEEDBACK_BUFFER_START = $8C84;
+ GL_TRANSFORM_FEEDBACK_BUFFER_SIZE = $8C85;
+ GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = $8C88;
+ GL_RASTERIZER_DISCARD = $8C89;
+ GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = $8C8A;
+ GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = $8C8B;
+ GL_INTERLEAVED_ATTRIBS = $8C8C;
+ GL_SEPARATE_ATTRIBS = $8C8D;
+ GL_TRANSFORM_FEEDBACK_BUFFER = $8C8E;
+ GL_TRANSFORM_FEEDBACK_BUFFER_BINDING = $8C8F;
+ GL_RGBA32UI = $8D70;
+ GL_RGB32UI = $8D71;
+ GL_RGBA16UI = $8D76;
+ GL_RGB16UI = $8D77;
+ GL_RGBA8UI = $8D7C;
+ GL_RGB8UI = $8D7D;
+ GL_RGBA32I = $8D82;
+ GL_RGB32I = $8D83;
+ GL_RGBA16I = $8D88;
+ GL_RGB16I = $8D89;
+ GL_RGBA8I = $8D8E;
+ GL_RGB8I = $8D8F;
+ GL_RED_INTEGER = $8D94;
+ GL_RGB_INTEGER = $8D98;
+ GL_RGBA_INTEGER = $8D99;
+ GL_SAMPLER_2D_ARRAY = $8DC1;
+ GL_SAMPLER_2D_ARRAY_SHADOW = $8DC4;
+ GL_SAMPLER_CUBE_SHADOW = $8DC5;
+ GL_UNSIGNED_INT_VEC2 = $8DC6;
+ GL_UNSIGNED_INT_VEC3 = $8DC7;
+ GL_UNSIGNED_INT_VEC4 = $8DC8;
+ GL_INT_SAMPLER_2D = $8DCA;
+ GL_INT_SAMPLER_3D = $8DCB;
+ GL_INT_SAMPLER_CUBE = $8DCC;
+ GL_INT_SAMPLER_2D_ARRAY = $8DCF;
+ GL_UNSIGNED_INT_SAMPLER_2D = $8DD2;
+ GL_UNSIGNED_INT_SAMPLER_3D = $8DD3;
+ GL_UNSIGNED_INT_SAMPLER_CUBE = $8DD4;
+ GL_UNSIGNED_INT_SAMPLER_2D_ARRAY = $8DD7;
+ GL_BUFFER_ACCESS_FLAGS = $911F;
+ GL_BUFFER_MAP_LENGTH = $9120;
+ GL_BUFFER_MAP_OFFSET = $9121;
+ GL_DEPTH_COMPONENT32F = $8CAC;
+ GL_DEPTH32F_STENCIL8 = $8CAD;
+ GL_FLOAT_32_UNSIGNED_INT_24_8_REV = $8DAD;
+ GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = $8210;
+ GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = $8211;
+ GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE = $8212;
+ GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = $8213;
+ GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = $8214;
+ GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = $8215;
+ GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = $8216;
+ GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = $8217;
+ GL_FRAMEBUFFER_DEFAULT = $8218;
+ GL_FRAMEBUFFER_UNDEFINED = $8219;
+ GL_DEPTH_STENCIL_ATTACHMENT = $821A;
+ GL_DEPTH_STENCIL = $84F9;
+ GL_UNSIGNED_INT_24_8 = $84FA;
+ GL_DEPTH24_STENCIL8 = $88F0;
+ GL_UNSIGNED_NORMALIZED = $8C17;
+ GL_DRAW_FRAMEBUFFER_BINDING = $8CA6;
+ GL_READ_FRAMEBUFFER = $8CA8;
+ GL_DRAW_FRAMEBUFFER = $8CA9;
+ GL_READ_FRAMEBUFFER_BINDING = $8CAA;
+ GL_RENDERBUFFER_SAMPLES = $8CAB;
+ GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = $8CD4;
+ GL_MAX_COLOR_ATTACHMENTS = $8CDF;
+ GL_COLOR_ATTACHMENT1 = $8CE1;
+ GL_COLOR_ATTACHMENT2 = $8CE2;
+ GL_COLOR_ATTACHMENT3 = $8CE3;
+ GL_COLOR_ATTACHMENT4 = $8CE4;
+ GL_COLOR_ATTACHMENT5 = $8CE5;
+ GL_COLOR_ATTACHMENT6 = $8CE6;
+ GL_COLOR_ATTACHMENT7 = $8CE7;
+ GL_COLOR_ATTACHMENT8 = $8CE8;
+ GL_COLOR_ATTACHMENT9 = $8CE9;
+ GL_COLOR_ATTACHMENT10 = $8CEA;
+ GL_COLOR_ATTACHMENT11 = $8CEB;
+ GL_COLOR_ATTACHMENT12 = $8CEC;
+ GL_COLOR_ATTACHMENT13 = $8CED;
+ GL_COLOR_ATTACHMENT14 = $8CEE;
+ GL_COLOR_ATTACHMENT15 = $8CEF;
+ GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = $8D56;
+ GL_MAX_SAMPLES = $8D57;
+ GL_HALF_FLOAT = $140B;
+ GL_MAP_READ_BIT = $0001;
+ GL_MAP_WRITE_BIT = $0002;
+ GL_MAP_INVALIDATE_RANGE_BIT = $0004;
+ GL_MAP_INVALIDATE_BUFFER_BIT = $0008;
+ GL_MAP_FLUSH_EXPLICIT_BIT = $0010;
+ GL_MAP_UNSYNCHRONIZED_BIT = $0020;
+ GL_RG = $8227;
+ GL_RG_INTEGER = $8228;
+ GL_R8 = $8229;
+ GL_RG8 = $822B;
+ GL_R16F = $822D;
+ GL_R32F = $822E;
+ GL_RG16F = $822F;
+ GL_RG32F = $8230;
+ GL_R8I = $8231;
+ GL_R8UI = $8232;
+ GL_R16I = $8233;
+ GL_R16UI = $8234;
+ GL_R32I = $8235;
+ GL_R32UI = $8236;
+ GL_RG8I = $8237;
+ GL_RG8UI = $8238;
+ GL_RG16I = $8239;
+ GL_RG16UI = $823A;
+ GL_RG32I = $823B;
+ GL_RG32UI = $823C;
+ GL_VERTEX_ARRAY_BINDING = $85B5;
+ GL_R8_SNORM = $8F94;
+ GL_RG8_SNORM = $8F95;
+ GL_RGB8_SNORM = $8F96;
+ GL_RGBA8_SNORM = $8F97;
+ GL_SIGNED_NORMALIZED = $8F9C;
+ GL_PRIMITIVE_RESTART_FIXED_INDEX = $8D69;
+ GL_COPY_READ_BUFFER = $8F36;
+ GL_COPY_WRITE_BUFFER = $8F37;
+ GL_COPY_READ_BUFFER_BINDING = $8F36;
+ GL_COPY_WRITE_BUFFER_BINDING = $8F37;
+ GL_UNIFORM_BUFFER = $8A11;
+ GL_UNIFORM_BUFFER_BINDING = $8A28;
+ GL_UNIFORM_BUFFER_START = $8A29;
+ GL_UNIFORM_BUFFER_SIZE = $8A2A;
+ GL_MAX_VERTEX_UNIFORM_BLOCKS = $8A2B;
+ GL_MAX_FRAGMENT_UNIFORM_BLOCKS = $8A2D;
+ GL_MAX_COMBINED_UNIFORM_BLOCKS = $8A2E;
+ GL_MAX_UNIFORM_BUFFER_BINDINGS = $8A2F;
+ GL_MAX_UNIFORM_BLOCK_SIZE = $8A30;
+ GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = $8A31;
+ GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = $8A33;
+ GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = $8A34;
+ GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = $8A35;
+ GL_ACTIVE_UNIFORM_BLOCKS = $8A36;
+ GL_UNIFORM_TYPE = $8A37;
+ GL_UNIFORM_SIZE = $8A38;
+ GL_UNIFORM_NAME_LENGTH = $8A39;
+ GL_UNIFORM_BLOCK_INDEX = $8A3A;
+ GL_UNIFORM_OFFSET = $8A3B;
+ GL_UNIFORM_ARRAY_STRIDE = $8A3C;
+ GL_UNIFORM_MATRIX_STRIDE = $8A3D;
+ GL_UNIFORM_IS_ROW_MAJOR = $8A3E;
+ GL_UNIFORM_BLOCK_BINDING = $8A3F;
+ GL_UNIFORM_BLOCK_DATA_SIZE = $8A40;
+ GL_UNIFORM_BLOCK_NAME_LENGTH = $8A41;
+ GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS = $8A42;
+ GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = $8A43;
+ GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = $8A44;
+ GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = $8A46;
+ GL_INVALID_INDEX = $FFFFFFFF;
+ GL_MAX_VERTEX_OUTPUT_COMPONENTS = $9122;
+ GL_MAX_FRAGMENT_INPUT_COMPONENTS = $9125;
+ GL_MAX_SERVER_WAIT_TIMEOUT = $9111;
+ GL_OBJECT_TYPE = $9112;
+ GL_SYNC_CONDITION = $9113;
+ GL_SYNC_STATUS = $9114;
+ GL_SYNC_FLAGS = $9115;
+ GL_SYNC_FENCE = $9116;
+ GL_SYNC_GPU_COMMANDS_COMPLETE = $9117;
+ GL_UNSIGNALED = $9118;
+ GL_SIGNALED = $9119;
+ GL_ALREADY_SIGNALED = $911A;
+ GL_TIMEOUT_EXPIRED = $911B;
+ GL_CONDITION_SATISFIED = $911C;
+ GL_WAIT_FAILED = $911D;
+ GL_SYNC_FLUSH_COMMANDS_BIT = $00000001;
+ GL_TIMEOUT_IGNORED = $FFFFFFFFFFFFFFFF;
+ GL_VERTEX_ATTRIB_ARRAY_DIVISOR = $88FE;
+ GL_ANY_SAMPLES_PASSED = $8C2F;
+ GL_ANY_SAMPLES_PASSED_CONSERVATIVE = $8D6A;
+ GL_SAMPLER_BINDING = $8919;
+ GL_RGB10_A2UI = $906F;
+ GL_TEXTURE_SWIZZLE_R = $8E42;
+ GL_TEXTURE_SWIZZLE_G = $8E43;
+ GL_TEXTURE_SWIZZLE_B = $8E44;
+ GL_TEXTURE_SWIZZLE_A = $8E45;
+ GL_GREEN = $1904;
+ GL_BLUE = $1905;
+ GL_INT_2_10_10_10_REV = $8D9F;
+ GL_TRANSFORM_FEEDBACK = $8E22;
+ GL_TRANSFORM_FEEDBACK_PAUSED = $8E23;
+ GL_TRANSFORM_FEEDBACK_ACTIVE = $8E24;
+ GL_TRANSFORM_FEEDBACK_BINDING = $8E25;
+ GL_PROGRAM_BINARY_RETRIEVABLE_HINT = $8257;
+ GL_PROGRAM_BINARY_LENGTH = $8741;
+ GL_NUM_PROGRAM_BINARY_FORMATS = $87FE;
+ GL_PROGRAM_BINARY_FORMATS = $87FF;
+ GL_COMPRESSED_R11_EAC = $9270;
+ GL_COMPRESSED_SIGNED_R11_EAC = $9271;
+ GL_COMPRESSED_RG11_EAC = $9272;
+ GL_COMPRESSED_SIGNED_RG11_EAC = $9273;
+ GL_COMPRESSED_RGB8_ETC2 = $9274;
+ GL_COMPRESSED_SRGB8_ETC2 = $9275;
+ GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9276;
+ GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = $9277;
+ GL_COMPRESSED_RGBA8_ETC2_EAC = $9278;
+ GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = $9279;
+ GL_TEXTURE_IMMUTABLE_FORMAT = $912F;
+ GL_MAX_ELEMENT_INDEX = $8D6B;
+ GL_NUM_SAMPLE_COUNTS = $9380;
+ GL_TEXTURE_IMMUTABLE_LEVELS = $82DF;
+
+ { OpenGL ES 3.1 }
+ GL_COMPUTE_SHADER = $91B9;
+ GL_MAX_COMPUTE_UNIFORM_BLOCKS = $91BB;
+ GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = $91BC;
+ GL_MAX_COMPUTE_IMAGE_UNIFORMS = $91BD;
+ GL_MAX_COMPUTE_SHARED_MEMORY_SIZE = $8262;
+ GL_MAX_COMPUTE_UNIFORM_COMPONENTS = $8263;
+ GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = $8264;
+ GL_MAX_COMPUTE_ATOMIC_COUNTERS = $8265;
+ GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = $8266;
+ GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = $90EB;
+ GL_MAX_COMPUTE_WORK_GROUP_COUNT = $91BE;
+ GL_MAX_COMPUTE_WORK_GROUP_SIZE = $91BF;
+ GL_COMPUTE_WORK_GROUP_SIZE = $8267;
+ GL_DISPATCH_INDIRECT_BUFFER = $90EE;
+ GL_DISPATCH_INDIRECT_BUFFER_BINDING = $90EF;
+ GL_COMPUTE_SHADER_BIT = $00000020;
+ GL_DRAW_INDIRECT_BUFFER = $8F3F;
+ GL_DRAW_INDIRECT_BUFFER_BINDING = $8F43;
+ GL_MAX_UNIFORM_LOCATIONS = $826E;
+ GL_FRAMEBUFFER_DEFAULT_WIDTH = $9310;
+ GL_FRAMEBUFFER_DEFAULT_HEIGHT = $9311;
+ GL_FRAMEBUFFER_DEFAULT_SAMPLES = $9313;
+ GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = $9314;
+ GL_MAX_FRAMEBUFFER_WIDTH = $9315;
+ GL_MAX_FRAMEBUFFER_HEIGHT = $9316;
+ GL_MAX_FRAMEBUFFER_SAMPLES = $9318;
+ GL_UNIFORM = $92E1;
+ GL_UNIFORM_BLOCK = $92E2;
+ GL_PROGRAM_INPUT = $92E3;
+ GL_PROGRAM_OUTPUT = $92E4;
+ GL_BUFFER_VARIABLE = $92E5;
+ GL_SHADER_STORAGE_BLOCK = $92E6;
+ GL_ATOMIC_COUNTER_BUFFER = $92C0;
+ GL_TRANSFORM_FEEDBACK_VARYING = $92F4;
+ GL_ACTIVE_RESOURCES = $92F5;
+ GL_MAX_NAME_LENGTH = $92F6;
+ GL_MAX_NUM_ACTIVE_VARIABLES = $92F7;
+ GL_NAME_LENGTH = $92F9;
+ GL_TYPE = $92FA;
+ GL_ARRAY_SIZE = $92FB;
+ GL_OFFSET = $92FC;
+ GL_BLOCK_INDEX = $92FD;
+ GL_ARRAY_STRIDE = $92FE;
+ GL_MATRIX_STRIDE = $92FF;
+ GL_IS_ROW_MAJOR = $9300;
+ GL_ATOMIC_COUNTER_BUFFER_INDEX = $9301;
+ GL_BUFFER_BINDING = $9302;
+ GL_BUFFER_DATA_SIZE = $9303;
+ GL_NUM_ACTIVE_VARIABLES = $9304;
+ GL_ACTIVE_VARIABLES = $9305;
+ GL_REFERENCED_BY_VERTEX_SHADER = $9306;
+ GL_REFERENCED_BY_FRAGMENT_SHADER = $930A;
+ GL_REFERENCED_BY_COMPUTE_SHADER = $930B;
+ GL_TOP_LEVEL_ARRAY_SIZE = $930C;
+ GL_TOP_LEVEL_ARRAY_STRIDE = $930D;
+ GL_LOCATION = $930E;
+ GL_VERTEX_SHADER_BIT = $00000001;
+ GL_FRAGMENT_SHADER_BIT = $00000002;
+ GL_ALL_SHADER_BITS = $FFFFFFFF;
+ GL_PROGRAM_SEPARABLE = $8258;
+ GL_ACTIVE_PROGRAM = $8259;
+ GL_PROGRAM_PIPELINE_BINDING = $825A;
+ GL_ATOMIC_COUNTER_BUFFER_BINDING = $92C1;
+ GL_ATOMIC_COUNTER_BUFFER_START = $92C2;
+ GL_ATOMIC_COUNTER_BUFFER_SIZE = $92C3;
+ GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = $92CC;
+ GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = $92D0;
+ GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = $92D1;
+ GL_MAX_VERTEX_ATOMIC_COUNTERS = $92D2;
+ GL_MAX_FRAGMENT_ATOMIC_COUNTERS = $92D6;
+ GL_MAX_COMBINED_ATOMIC_COUNTERS = $92D7;
+ GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE = $92D8;
+ GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = $92DC;
+ GL_ACTIVE_ATOMIC_COUNTER_BUFFERS = $92D9;
+ GL_UNSIGNED_INT_ATOMIC_COUNTER = $92DB;
+ GL_MAX_IMAGE_UNITS = $8F38;
+ GL_MAX_VERTEX_IMAGE_UNIFORMS = $90CA;
+ GL_MAX_FRAGMENT_IMAGE_UNIFORMS = $90CE;
+ GL_MAX_COMBINED_IMAGE_UNIFORMS = $90CF;
+ GL_IMAGE_BINDING_NAME = $8F3A;
+ GL_IMAGE_BINDING_LEVEL = $8F3B;
+ GL_IMAGE_BINDING_LAYERED = $8F3C;
+ GL_IMAGE_BINDING_LAYER = $8F3D;
+ GL_IMAGE_BINDING_ACCESS = $8F3E;
+ GL_IMAGE_BINDING_FORMAT = $906E;
+ GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = $00000001;
+ GL_ELEMENT_ARRAY_BARRIER_BIT = $00000002;
+ GL_UNIFORM_BARRIER_BIT = $00000004;
+ GL_TEXTURE_FETCH_BARRIER_BIT = $00000008;
+ GL_SHADER_IMAGE_ACCESS_BARRIER_BIT = $00000020;
+ GL_COMMAND_BARRIER_BIT = $00000040;
+ GL_PIXEL_BUFFER_BARRIER_BIT = $00000080;
+ GL_TEXTURE_UPDATE_BARRIER_BIT = $00000100;
+ GL_BUFFER_UPDATE_BARRIER_BIT = $00000200;
+ GL_FRAMEBUFFER_BARRIER_BIT = $00000400;
+ GL_TRANSFORM_FEEDBACK_BARRIER_BIT = $00000800;
+ GL_ATOMIC_COUNTER_BARRIER_BIT = $00001000;
+ GL_ALL_BARRIER_BITS = $FFFFFFFF;
+ GL_IMAGE_2D = $904D;
+ GL_IMAGE_3D = $904E;
+ GL_IMAGE_CUBE = $9050;
+ GL_IMAGE_2D_ARRAY = $9053;
+ GL_INT_IMAGE_2D = $9058;
+ GL_INT_IMAGE_3D = $9059;
+ GL_INT_IMAGE_CUBE = $905B;
+ GL_INT_IMAGE_2D_ARRAY = $905E;
+ GL_UNSIGNED_INT_IMAGE_2D = $9063;
+ GL_UNSIGNED_INT_IMAGE_3D = $9064;
+ GL_UNSIGNED_INT_IMAGE_CUBE = $9066;
+ GL_UNSIGNED_INT_IMAGE_2D_ARRAY = $9069;
+ GL_IMAGE_FORMAT_COMPATIBILITY_TYPE = $90C7;
+ GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = $90C8;
+ GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = $90C9;
+ GL_READ_ONLY = $88B8;
+ GL_WRITE_ONLY = $88B9;
+ GL_READ_WRITE = $88BA;
+ GL_SHADER_STORAGE_BUFFER = $90D2;
+ GL_SHADER_STORAGE_BUFFER_BINDING = $90D3;
+ GL_SHADER_STORAGE_BUFFER_START = $90D4;
+ GL_SHADER_STORAGE_BUFFER_SIZE = $90D5;
+ GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS = $90D6;
+ GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = $90DA;
+ GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = $90DB;
+ GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS = $90DC;
+ GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS = $90DD;
+ GL_MAX_SHADER_STORAGE_BLOCK_SIZE = $90DE;
+ GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = $90DF;
+ GL_SHADER_STORAGE_BARRIER_BIT = $00002000;
+ GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = $8F39;
+ GL_DEPTH_STENCIL_TEXTURE_MODE = $90EA;
+ GL_STENCIL_INDEX = $1901;
+ GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5E;
+ GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = $8E5F;
+ GL_SAMPLE_POSITION = $8E50;
+ GL_SAMPLE_MASK = $8E51;
+ GL_SAMPLE_MASK_VALUE = $8E52;
+ GL_TEXTURE_2D_MULTISAMPLE = $9100;
+ GL_MAX_SAMPLE_MASK_WORDS = $8E59;
+ GL_MAX_COLOR_TEXTURE_SAMPLES = $910E;
+ GL_MAX_DEPTH_TEXTURE_SAMPLES = $910F;
+ GL_MAX_INTEGER_SAMPLES = $9110;
+ GL_TEXTURE_BINDING_2D_MULTISAMPLE = $9104;
+ GL_TEXTURE_SAMPLES = $9106;
+ GL_TEXTURE_FIXED_SAMPLE_LOCATIONS = $9107;
+ GL_TEXTURE_WIDTH = $1000;
+ GL_TEXTURE_HEIGHT = $1001;
+ GL_TEXTURE_DEPTH = $8071;
+ GL_TEXTURE_INTERNAL_FORMAT = $1003;
+ GL_TEXTURE_RED_SIZE = $805C;
+ GL_TEXTURE_GREEN_SIZE = $805D;
+ GL_TEXTURE_BLUE_SIZE = $805E;
+ GL_TEXTURE_ALPHA_SIZE = $805F;
+ GL_TEXTURE_DEPTH_SIZE = $884A;
+ GL_TEXTURE_STENCIL_SIZE = $88F1;
+ GL_TEXTURE_SHARED_SIZE = $8C3F;
+ GL_TEXTURE_RED_TYPE = $8C10;
+ GL_TEXTURE_GREEN_TYPE = $8C11;
+ GL_TEXTURE_BLUE_TYPE = $8C12;
+ GL_TEXTURE_ALPHA_TYPE = $8C13;
+ GL_TEXTURE_DEPTH_TYPE = $8C16;
+ GL_TEXTURE_COMPRESSED = $86A1;
+ GL_SAMPLER_2D_MULTISAMPLE = $9108;
+ GL_INT_SAMPLER_2D_MULTISAMPLE = $9109;
+ GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = $910A;
+ GL_VERTEX_ATTRIB_BINDING = $82D4;
+ GL_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D5;
+ GL_VERTEX_BINDING_DIVISOR = $82D6;
+ GL_VERTEX_BINDING_OFFSET = $82D7;
+ GL_VERTEX_BINDING_STRIDE = $82D8;
+ GL_VERTEX_BINDING_BUFFER = $8F4F;
+ GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = $82D9;
+ GL_MAX_VERTEX_ATTRIB_BINDINGS = $82DA;
+ GL_MAX_VERTEX_ATTRIB_STRIDE = $82E5;
+
+
+type
+ { OpenGL Es 2.0 }
+ TglActiveTexture = procedure(aTexture: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglAttachShader = procedure(aProgram: GLuint; aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindAttribLocation = procedure(aProgram: GLuint; aIndex: GLuint; const aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindBuffer = procedure(aTarget: GLenum; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindFramebuffer = procedure(aTarget: GLenum; aFramebuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindRenderbuffer = procedure(aTarget: GLenum; aRenderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindTexture = procedure(aTarget: GLenum; aTexture: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendColor = procedure(aRed: GLfloat; aGreen: GLfloat; aBlue: GLfloat; aAlpha: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendEquation = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendEquationSeparate = procedure(aModeRGB: GLenum; aModeAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendFunc = procedure(aSFactor: GLenum; aDFactor: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlendFuncSeparate = procedure(aSFactorRGB: GLenum; aDFactorRGB: GLenum; aSFactorAlpha: GLenum; aDFactorAlpha: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBufferData = procedure(aTarget: GLenum; aSize: PGLsizei; const aData: PGLvoid; aUsage: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBufferSubData = procedure(aTarget: GLenum; aOffset: PGLint; aSize: PGLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCheckFramebufferStatus = function(aTarget: GLenum): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClear = procedure(aMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClearColor = procedure(aRed: GLfloat; aGreen: GLfloat; aBlue: GLfloat; aAlpha: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClearDepthf = procedure(d: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClearStencil = procedure(s: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglColorMask = procedure(aRed: GLboolean; aGreen: GLboolean; aBlue: GLboolean; aAlpha: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCompileShader = procedure(aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCompressedTexImage2D = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aBorder: GLint; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCompressedTexSubImage2D = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCopyTexImage2D = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei; aBorder: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCopyTexSubImage2D = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCreateProgram = function: GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCreateShader = function(aType: GLenum): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCullFace = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteBuffers = procedure(n: GLsizei; const aBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteFramebuffers = procedure(n: GLsizei; const aFrameBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteProgram = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteRenderbuffers = procedure(n: GLsizei; const aRenderBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteShader = procedure(aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteTextures = procedure(n: GLsizei; const aTextures: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDepthFunc = procedure(aFunc: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDepthMask = procedure(aFlag: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDepthRangef = procedure(n: GLfloat; aF: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDetachShader = procedure(aProgram: GLuint; aShader: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDisable = procedure(aCap: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDisableVertexAttribArray = procedure(aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawArrays = procedure(aMode: GLenum; aFirst: GLint; aCount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElements = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEnable = procedure(aCap: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEnableVertexAttribArray = procedure(aIndex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFinish = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFlush = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFramebufferRenderbuffer = procedure(aTarget: GLenum; aAttachment: GLenum; aRenderbuffertarget: GLenum; aRenderbuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFramebufferTexture2D = procedure(aTarget: GLenum; aAttachment: GLenum; aTextarget: GLenum; aTexture: GLuint; aLevel: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFrontFace = procedure(aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenBuffers = procedure(n: GLsizei; aBuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenerateMipmap = procedure(aTarget: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenFramebuffers = procedure(n: GLsizei; aFramebuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenRenderbuffers = procedure(n: GLsizei; aRenderbuffers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenTextures = procedure(n: GLsizei; aTextures: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetActiveAttrib = procedure(aProgram: GLuint; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSize: PGLint; aType: PGLenum; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetActiveUniform = procedure(aProgram: GLuint; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSize: PGLint; aType: PGLenum; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetAttachedShaders = procedure(aProgram: GLuint; aMaxCount: GLsizei; aCount: PGLsizei; aShaders: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetAttribLocation = function(aProgram: GLuint; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetBooleanv = procedure(aPname: GLenum; aData: PGLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetBufferParameteriv = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetError = function: GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetFloatv = procedure(aPname: GLenum; aData: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetFramebufferAttachmentParameteriv = procedure(aTarget: GLenum; aAttachment: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetIntegerv = procedure(aPname: GLenum; aData: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramiv = procedure(aProgram: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramInfoLog = procedure(aProgram: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aInfoLog: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetRenderbufferParameteriv = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetShaderiv = procedure(aShader: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetShaderInfoLog = procedure(aShader: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aInfoLog: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetShaderPrecisionFormat = procedure(aShadertype: GLenum; aPrecisiontype: GLenum; aRange: PGLint; aPrecision: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetShaderSource = procedure(aShader: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSource: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetString = function(aName: GLenum): PAnsiChar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTexParameterfv = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTexParameteriv = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetUniformfv = procedure(aProgram: GLuint; aLocation: GLint; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetUniformiv = procedure(aProgram: GLuint; aLocation: GLint; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetUniformLocation = function(aProgram: GLuint; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetVertexAttribfv = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetVertexAttribiv = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetVertexAttribPointerv = procedure(aIndex: GLuint; aPname: GLenum; aPointer: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglHint = procedure(aTarget: GLenum; aMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsBuffer = function(aBuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsEnabled = function(aCap: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsFramebuffer = function(aFramebuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsProgram = function(aProgram: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsRenderbuffer = function(aRenderbuffer: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsShader = function(aShader: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsTexture = function(aTexture: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglLineWidth = procedure(aWidth: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglLinkProgram = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPixelStorei = procedure(aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPolygonOffset = procedure(aFactor: GLfloat; aUnits: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglReadPixels = procedure(aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aType: GLenum; aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglReleaseShaderCompiler = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglRenderbufferStorage = procedure(aTarget: GLenum; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSampleCoverage = procedure(aValue: GLfloat; aInvert: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglScissor = procedure(aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglShaderBinary = procedure(aCount: GLsizei; const aShaders: PGLuint; aBinaryformat: GLenum; const aBinary: PGLvoid; aLength: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglShaderSource = procedure(aShader: GLuint; aCount: GLsizei; const aString: PPGLchar; const aLength: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilFunc = procedure(aFunc: GLenum; aRef: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilFuncSeparate = procedure(aFace: GLenum; aFunc: GLenum; aRef: GLint; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilMask = procedure(aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilMaskSeparate = procedure(aFace: GLenum; aMask: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilOp = procedure(aFail: GLenum; aZfail: GLenum; aZpass: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglStencilOpSeparate = procedure(aFace: GLenum; aSfail: GLenum; aDpfail: GLenum; aDppass: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexImage2D = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLint; aWidth: GLsizei; aHeight: GLsizei; aBorder: GLint; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexParameterf = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexParameterfv = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexParameteri = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexParameteriv = procedure(aTarget: GLenum; aPname: GLenum; const aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexSubImage2D = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1f = procedure(aLocation: GLint; aV0: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1fv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1i = procedure(aLocation: GLint; aV0: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1iv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2f = procedure(aLocation: GLint; aV0: GLfloat; aV1: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2fv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2i = procedure(aLocation: GLint; aV0: GLint; aV1: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2iv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3f = procedure(aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3fv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3i = procedure(aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3iv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4f = procedure(aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat; aV3: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4fv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4i = procedure(aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint; aV3: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4iv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix2fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix3fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix4fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUseProgram = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglValidateProgram = procedure(aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib1f = procedure(aIndex: GLuint; aX: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib1fv = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib2f = procedure(aIndex: GLuint; aX: GLfloat; aY: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib2fv = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib3f = procedure(aIndex: GLuint; aX: GLfloat; aY: GLfloat; aZ: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib3fv = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib4f = procedure(aIndex: GLuint; aX: GLfloat; aY: GLfloat; aZ: GLfloat; aW: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttrib4fv = procedure(aIndex: GLuint; const v: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribPointer = procedure(aIndex: GLuint; aSize: GLint; aType: GLenum; aNormalized: GLboolean; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglViewport = procedure(aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ { OpenGL ES 3.0 }
+ TglReadBuffer = procedure(aSrc: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawRangeElements = procedure(aMode: GLenum; aStart: GLuint; aEnd: GLuint; aCount: GLsizei; aType: GLenum; const aIndices: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexImage3D = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aBorder: GLint; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexSubImage3D = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFormat: GLenum; aType: GLenum; const aPixels: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCopyTexSubImage3D = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCompressedTexImage3D = procedure(aTarget: GLenum; aLevel: GLint; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aBorder: GLint; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCompressedTexSubImage3D = procedure(aTarget: GLenum; aLevel: GLint; aXoffset: GLint; aYoffset: GLint; aZoffset: GLint; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei; aFormat: GLenum; aImageSize: GLsizei; const aData: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenQueries = procedure(n: GLsizei; aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteQueries = procedure(n: GLsizei; const aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsQuery = function(aId: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBeginQuery = procedure(aTarget: GLenum; aId: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEndQuery = procedure(aTarget: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetQueryiv = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetQueryObjectuiv = procedure(aId: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUnmapBuffer = function(aTarget: GLenum): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetBufferPointerv = procedure(aTarget: GLenum; aPname: GLenum; aParams: PPGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawBuffers = procedure(n: GLsizei; const aBufs: PGLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix2x3fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix3x2fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix2x4fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix4x2fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix3x4fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformMatrix4x3fv = procedure(aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBlitFramebuffer = procedure(aSrcX0: GLint; aSrcY0: GLint; aSrcX1: GLint; aSrcY1: GLint; aDstX0: GLint; aDstY0: GLint; aDstX1: GLint; aDstY1: GLint; aMask: GLbitfield; aFilter: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglRenderbufferStorageMultisample = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFramebufferTextureLayer = procedure(aTarget: GLenum; aAttachment: GLenum; aTexture: GLuint; aLevel: GLint; aLayer: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMapBufferRange = function(aTarget: GLenum; aOffset: PGLint; aLength: PGLsizei; aAccess: GLbitfield): PGLvoid; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFlushMappedBufferRange = procedure(aTarget: GLenum; aOffset: PGLint; aLength: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindVertexArray = procedure(aArray: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteVertexArrays = procedure(n: GLsizei; const aArrays: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenVertexArrays = procedure(n: GLsizei; aArrays: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsVertexArray = function(aArray: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetIntegeri_v = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBeginTransformFeedback = procedure(aPrimitiveMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglEndTransformFeedback = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindBufferRange = procedure(aTarget: GLenum; aIndex: GLuint; aBuffer: GLuint; aOffset: PGLint; aSize: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindBufferBase = procedure(aTarget: GLenum; aIndex: GLuint; aBuffer: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTransformFeedbackVaryings = procedure(aProgram: GLuint; aCount: GLsizei; const aVaryings: PPGLchar; aBufferMode: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTransformFeedbackVarying = procedure(aProgram: GLuint; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aSize: PGLsizei; aType: PGLenum; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribIPointer = procedure(aIndex: GLuint; aSize: GLint; aType: GLenum; aStride: GLsizei; const aPointer: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetVertexAttribIiv = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetVertexAttribIuiv = procedure(aIndex: GLuint; aPname: GLenum; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribI4i = procedure(aIndex: GLuint; aX: GLint; aY: GLint; aZ: GLint; aW: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribI4ui = procedure(aIndex: GLuint; aX: GLuint; aY: GLuint; aZ: GLuint; aW: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribI4iv = procedure(aIndex: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribI4uiv = procedure(aIndex: GLuint; const v: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetUniformuiv = procedure(aProgram: GLuint; aLocation: GLint; aParams: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetFragDataLocation = function(aProgram: GLuint; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1ui = procedure(aLocation: GLint; aV0: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2ui = procedure(aLocation: GLint; aV0: GLuint; aV1: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3ui = procedure(aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4ui = procedure(aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint; aV3: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform1uiv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform2uiv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform3uiv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniform4uiv = procedure(aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClearBufferiv = procedure(aBuffer: GLenum; aDrawbuffer: GLint; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClearBufferuiv = procedure(aBuffer: GLenum; aDrawbuffer: GLint; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClearBufferfv = procedure(aBuffer: GLenum; aDrawbuffer: GLint; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClearBufferfi = procedure(aBuffer: GLenum; aDrawbuffer: GLint; aDepth: GLfloat; aStencil: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetStringi = function(aName: GLenum; aIndex: GLuint): PGLchar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCopyBufferSubData = procedure(aReadTarget: GLenum; aWriteTarget: GLenum; aReadOffset: PGLint; aWriteOffset: PGLint; aSize: PGLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetUniformIndices = procedure(aProgram: GLuint; aUniformCount: GLsizei; const aUniformNames: PPGLchar; aUniformIndices: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetActiveUniformsiv = procedure(aProgram: GLuint; aUniformCount: GLsizei; const aUniformIndices: PGLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetUniformBlockIndex = function(aProgram: GLuint; const aUniformBlockName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetActiveUniformBlockiv = procedure(aProgram: GLuint; aUniformBlockIndex: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetActiveUniformBlockName = procedure(aProgram: GLuint; aUniformBlockIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aUniformBlockName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUniformBlockBinding = procedure(aProgram: GLuint; aUniformBlockIndex: GLuint; aUniformBlockBinding: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawArraysInstanced = procedure(aMode: GLenum; aFirst: GLint; aCount: GLsizei; aInstancecount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsInstanced = procedure(aMode: GLenum; aCount: GLsizei; aType: GLenum; const aIndices: PGLvoid; aInstanceCount: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFenceSync = function(aCondition: GLenum; aFlags: GLbitfield): GLsync; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsSync = function(aSync: GLsync): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteSync = procedure(aSync: GLsync); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglClientWaitSync = function(aSync: GLsync; aFlags: GLbitfield; aTimeout: GLuint64): GLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglWaitSync = procedure(aSync: GLsync; aFlags: GLbitfield; aTimeout: GLuint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetInteger64v = procedure(aPname: GLenum; aData: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetSynciv = procedure(aSync: GLsync; aPname: GLenum; aBufSize: GLsizei; aLength: PGLsizei; aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetInteger64i_v = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetBufferParameteri64v = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint64); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenSamplers = procedure(aCount: GLsizei; aSamplers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteSamplers = procedure(aCount: GLsizei; const aSamplers: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsSampler = function(aSampler: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindSampler = procedure(aUnit: GLuint; aSampler: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSamplerParameteri = procedure(aSampler: GLuint; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSamplerParameteriv = procedure(aSampler: GLuint; aPname: GLenum; const aParam: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSamplerParameterf = procedure(aSampler: GLuint; aPname: GLenum; aParam: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSamplerParameterfv = procedure(aSampler: GLuint; aPname: GLenum; const aParam: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetSamplerParameteriv = procedure(aSampler: GLuint; aPname: GLenum; const aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetSamplerParameterfv = procedure(aSampler: GLuint; aPname: GLenum; const aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribDivisor = procedure(aIndex: GLuint; aDivisor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindTransformFeedback = procedure(aTarget: GLenum; aId: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteTransformFeedbacks = procedure(n: GLsizei; const aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenTransformFeedbacks = procedure(n: GLsizei; const aIDs: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsTransformFeedback = function(aId: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglPauseTransformFeedback = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglResumeTransformFeedback = procedure; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramBinary = procedure(aProgram: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aBinaryFormat: PGLenum; aBinary: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramBinary = procedure(aProgram: GLuint; aBinaryFormat: GLenum; const aBinary: PGLvoid; aLength: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramParameteri = procedure(aProgram: GLuint; aPname: GLenum; aValue: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglInvalidateFramebuffer = procedure(aTarget: GLenum; aNumAttachments: GLsizei; const aAttachments: PGLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglInvalidateSubFramebuffer = procedure(aTarget: GLenum; aNumAttachments: GLsizei; const aAttachments: PGLenum; aX: GLint; aY: GLint; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexStorage2D = procedure(aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexStorage3D = procedure(aTarget: GLenum; aLevels: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aDepth: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetInternalformativ = procedure(aTarget: GLenum; aInternalformat: GLenum; aPname: GLenum; aBufSize: GLsizei; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ { OpenGL ES 3.1 }
+ TglDispatchCompute = procedure(aNumGroupsX: GLuint; aNumGroupsY: GLuint; aNumGroupsZ: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDispatchComputeIndirect = procedure(aIndirect: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawArraysIndirect = procedure(aMode: GLenum; const aIndirect: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDrawElementsIndirect = procedure(aMode: GLenum; aType: GLenum; const aIndirect: PGLvoid); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglFramebufferParameteri = procedure(aTarget: GLenum; aPname: GLenum; aParam: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetFramebufferParameteriv = procedure(aTarget: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramInterfaceiv = procedure(aProgram: GLuint; aProgramInterface: GLenum; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramResourceIndex = function (aProgram: GLuint; aProgramInterface: GLenum; const aName: PGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramResourceName = procedure(aProgram: GLuint; aProgramInterface: GLenum; aIndex: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aName: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramResourceiv = procedure(aProgram: GLuint; aProgramInterface: GLenum; aIndex: GLuint; aPropCount: GLsizei; const aProps: PGLenum; aBufSize: GLsizei; aLength: PGLsizei; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramResourceLocation = function (aProgram: GLuint; aProgramInterface: GLenum; const aName: PGLchar): GLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglUseProgramStages = procedure(aPipeline: GLuint; aStages: GLbitfield; aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglActiveShaderProgram = procedure(aPipeline: GLuint; aProgram: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglCreateShaderProgramv = function (aType: GLenum; aCount: GLsizei; const aStrings: PPGLchar): GLuint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindProgramPipeline = procedure(aPipeline: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglDeleteProgramPipelines = procedure(aN: GLsizei; const aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGenProgramPipelines = procedure(aN: GLsizei; aPipelines: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglIsProgramPipeline = function (aPipeline: GLuint): GLboolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramPipelineiv = procedure(aPipeline: GLuint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1i = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2i = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3i = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4i = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLint; aV1: GLint; aV2: GLint; aV3: GLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1ui = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2ui = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3ui = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4ui = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLuint; aV1: GLuint; aV2: GLuint; aV3: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1f = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2f = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3f = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4f = procedure(aProgram: GLuint; aLocation: GLint; aV0: GLfloat; aV1: GLfloat; aV2: GLfloat; aV3: GLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1iv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2iv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3iv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4iv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1uiv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2uiv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3uiv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4uiv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform1fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform2fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform3fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniform4fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix2fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix3fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix4fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix2x3fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix3x2fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix2x4fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix4x2fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix3x4fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglProgramUniformMatrix4x3fv = procedure(aProgram: GLuint; aLocation: GLint; aCount: GLsizei; aTranspose: GLboolean; const aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglValidateProgramPipeline = procedure(aPipeline: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetProgramPipelineInfoLog = procedure(aPipeline: GLuint; aBufSize: GLsizei; aLength: PGLsizei; aInfoLog: PGLchar); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindImageTexture = procedure(aUnit: GLuint; aTexture: GLuint; aLevel: GLint; aLayered: GLboolean; aLayer: GLint; aAccess: GLenum; aFormat: GLenum); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetBooleaniV = procedure(aTarget: GLenum; aIndex: GLuint; aData: PGLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMemoryBarrier = procedure(aBarriers: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglMemoryBarrierByRegion = procedure(aBarriers: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglTexStorage2DMultisample = procedure(aTarget: GLenum; aSamples: GLsizei; aInternalformat: GLenum; aWidth: GLsizei; aHeight: GLsizei; aFixedsamplelocations: GLboolean); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetMultisamplefv = procedure(aPname: GLenum; aIndex: GLuint; aValue: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglSampleMaski = procedure(aMaskNumber: GLuint; aMask: GLbitfield); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTexLevelParameteriv = procedure(aTarget: GLenum; aLevel: GLint; aPname: GLenum; aParams: PGLint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglGetTexLevelParameterfv = procedure(aTarget: GLenum; aLevel: GLint; aPname: GLenum; aParams: PGLfloat); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglBindVertexBuffer = procedure(aBindingindex: GLuint; aBuffer: GLuint; aOffset: PGLint; aStride: GLsizei); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribFormat = procedure(aAttribindex: GLuint; aSize: GLint; aType: GLenum; aNormalized: GLboolean; aRelativeoffset: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribIFormat = procedure(aAttribindex: GLuint; aSize: GLint; aType: GLenum; aRelativeoffset: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexAttribBinding = procedure(aAttribindex: GLuint; aBindingindex: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TglVertexBindingDivisor = procedure(aBindingindex: GLuint; aDivisor: GLuint); {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+
+var
+ { *** PROCEDURES *** }
+ { OpenGL ES 2.0 }
+ glActiveTexture: TglActiveTexture;
+ glAttachShader: TglAttachShader;
+ glBindAttribLocation: TglBindAttribLocation;
+ glBindBuffer: TglBindBuffer;
+ glBindFramebuffer: TglBindFramebuffer;
+ glBindRenderbuffer: TglBindRenderbuffer;
+ glBindTexture: TglBindTexture;
+ glBlendColor: TglBlendColor;
+ glBlendEquation: TglBlendEquation;
+ glBlendEquationSeparate: TglBlendEquationSeparate;
+ glBlendFunc: TglBlendFunc;
+ glBlendFuncSeparate: TglBlendFuncSeparate;
+ glBufferData: TglBufferData;
+ glBufferSubData: TglBufferSubData;
+ glCheckFramebufferStatus: TglCheckFramebufferStatus;
+ glClear: TglClear;
+ glClearColor: TglClearColor;
+ glClearDepthf: TglClearDepthf;
+ glClearStencil: TglClearStencil;
+ glColorMask: TglColorMask;
+ glCompileShader: TglCompileShader;
+ glCompressedTexImage2D: TglCompressedTexImage2D;
+ glCompressedTexSubImage2D: TglCompressedTexSubImage2D;
+ glCopyTexImage2D: TglCopyTexImage2D;
+ glCopyTexSubImage2D: TglCopyTexSubImage2D;
+ glCreateProgram: TglCreateProgram;
+ glCreateShader: TglCreateShader;
+ glCullFace: TglCullFace;
+ glDeleteBuffers: TglDeleteBuffers;
+ glDeleteFramebuffers: TglDeleteFramebuffers;
+ glDeleteProgram: TglDeleteProgram;
+ glDeleteRenderbuffers: TglDeleteRenderbuffers;
+ glDeleteShader: TglDeleteShader;
+ glDeleteTextures: TglDeleteTextures;
+ glDepthFunc: TglDepthFunc;
+ glDepthMask: TglDepthMask;
+ glDepthRangef: TglDepthRangef;
+ glDetachShader: TglDetachShader;
+ glDisable: TglDisable;
+ glDisableVertexAttribArray: TglDisableVertexAttribArray;
+ glDrawArrays: TglDrawArrays;
+ glDrawElements: TglDrawElements;
+ glEnable: TglEnable;
+ glEnableVertexAttribArray: TglEnableVertexAttribArray;
+ glFinish: TglFinish;
+ glFlush: TglFlush;
+ glFramebufferRenderbuffer: TglFramebufferRenderbuffer;
+ glFramebufferTexture2D: TglFramebufferTexture2D;
+ glFrontFace: TglFrontFace;
+ glGenBuffers: TglGenBuffers;
+ glGenerateMipmap: TglGenerateMipmap;
+ glGenFramebuffers: TglGenFramebuffers;
+ glGenRenderbuffers: TglGenRenderbuffers;
+ glGenTextures: TglGenTextures;
+ glGetActiveAttrib: TglGetActiveAttrib;
+ glGetActiveUniform: TglGetActiveUniform;
+ glGetAttachedShaders: TglGetAttachedShaders;
+ glGetAttribLocation: TglGetAttribLocation;
+ glGetBooleanv: TglGetBooleanv;
+ glGetBufferParameteriv: TglGetBufferParameteriv;
+ glGetError: TglGetError;
+ glGetFloatv: TglGetFloatv;
+ glGetFramebufferAttachmentParameteriv: TglGetFramebufferAttachmentParameteriv;
+ glGetIntegerv: TglGetIntegerv;
+ glGetProgramiv: TglGetProgramiv;
+ glGetProgramInfoLog: TglGetProgramInfoLog;
+ glGetRenderbufferParameteriv: TglGetRenderbufferParameteriv;
+ glGetShaderiv: TglGetShaderiv;
+ glGetShaderInfoLog: TglGetShaderInfoLog;
+ glGetShaderPrecisionFormat: TglGetShaderPrecisionFormat;
+ glGetShaderSource: TglGetShaderSource;
+ glGetString: TglGetString;
+ glGetTexParameterfv: TglGetTexParameterfv;
+ glGetTexParameteriv: TglGetTexParameteriv;
+ glGetUniformfv: TglGetUniformfv;
+ glGetUniformiv: TglGetUniformiv;
+ glGetUniformLocation: TglGetUniformLocation;
+ glGetVertexAttribfv: TglGetVertexAttribfv;
+ glGetVertexAttribiv: TglGetVertexAttribiv;
+ glGetVertexAttribPointerv: TglGetVertexAttribPointerv;
+ glHint: TglHint;
+ glIsBuffer: TglIsBuffer;
+ glIsEnabled: TglIsEnabled;
+ glIsFramebuffer: TglIsFramebuffer;
+ glIsProgram: TglIsProgram;
+ glIsRenderbuffer: TglIsRenderbuffer;
+ glIsShader: TglIsShader;
+ glIsTexture: TglIsTexture;
+ glLineWidth: TglLineWidth;
+ glLinkProgram: TglLinkProgram;
+ glPixelStorei: TglPixelStorei;
+ glPolygonOffset: TglPolygonOffset;
+ glReadPixels: TglReadPixels;
+ glReleaseShaderCompiler: TglReleaseShaderCompiler;
+ glRenderbufferStorage: TglRenderbufferStorage;
+ glSampleCoverage: TglSampleCoverage;
+ glScissor: TglScissor;
+ glShaderBinary: TglShaderBinary;
+ glShaderSource: TglShaderSource;
+ glStencilFunc: TglStencilFunc;
+ glStencilFuncSeparate: TglStencilFuncSeparate;
+ glStencilMask: TglStencilMask;
+ glStencilMaskSeparate: TglStencilMaskSeparate;
+ glStencilOp: TglStencilOp;
+ glStencilOpSeparate: TglStencilOpSeparate;
+ glTexImage2D: TglTexImage2D;
+ glTexParameterf: TglTexParameterf;
+ glTexParameterfv: TglTexParameterfv;
+ glTexParameteri: TglTexParameteri;
+ glTexParameteriv: TglTexParameteriv;
+ glTexSubImage2D: TglTexSubImage2D;
+ glUniform1f: TglUniform1f;
+ glUniform1fv: TglUniform1fv;
+ glUniform1i: TglUniform1i;
+ glUniform1iv: TglUniform1iv;
+ glUniform2f: TglUniform2f;
+ glUniform2fv: TglUniform2fv;
+ glUniform2i: TglUniform2i;
+ glUniform2iv: TglUniform2iv;
+ glUniform3f: TglUniform3f;
+ glUniform3fv: TglUniform3fv;
+ glUniform3i: TglUniform3i;
+ glUniform3iv: TglUniform3iv;
+ glUniform4f: TglUniform4f;
+ glUniform4fv: TglUniform4fv;
+ glUniform4i: TglUniform4i;
+ glUniform4iv: TglUniform4iv;
+ glUniformMatrix2fv: TglUniformMatrix2fv;
+ glUniformMatrix3fv: TglUniformMatrix3fv;
+ glUniformMatrix4fv: TglUniformMatrix4fv;
+ glUseProgram: TglUseProgram;
+ glValidateProgram: TglValidateProgram;
+ glVertexAttrib1f: TglVertexAttrib1f;
+ glVertexAttrib1fv: TglVertexAttrib1fv;
+ glVertexAttrib2f: TglVertexAttrib2f;
+ glVertexAttrib2fv: TglVertexAttrib2fv;
+ glVertexAttrib3f: TglVertexAttrib3f;
+ glVertexAttrib3fv: TglVertexAttrib3fv;
+ glVertexAttrib4f: TglVertexAttrib4f;
+ glVertexAttrib4fv: TglVertexAttrib4fv;
+ glVertexAttribPointer: TglVertexAttribPointer;
+ glViewport: TglViewport;
+
+ { OpenGL ES 3.0 }
+ glReadBuffer: TglReadBuffer;
+ glDrawRangeElements: TglDrawRangeElements;
+ glTexImage3D: TglTexImage3D;
+ glTexSubImage3D: TglTexSubImage3D;
+ glCopyTexSubImage3D: TglCopyTexSubImage3D;
+ glCompressedTexImage3D: TglCompressedTexImage3D;
+ glCompressedTexSubImage3D: TglCompressedTexSubImage3D;
+ glGenQueries: TglGenQueries;
+ glDeleteQueries: TglDeleteQueries;
+ glIsQuery: TglIsQuery;
+ glBeginQuery: TglBeginQuery;
+ glEndQuery: TglEndQuery;
+ glGetQueryiv: TglGetQueryiv;
+ glGetQueryObjectuiv: TglGetQueryObjectuiv;
+ glUnmapBuffer: TglUnmapBuffer;
+ glGetBufferPointerv: TglGetBufferPointerv;
+ glDrawBuffers: TglDrawBuffers;
+ glUniformMatrix2x3fv: TglUniformMatrix2x3fv;
+ glUniformMatrix3x2fv: TglUniformMatrix3x2fv;
+ glUniformMatrix2x4fv: TglUniformMatrix2x4fv;
+ glUniformMatrix4x2fv: TglUniformMatrix4x2fv;
+ glUniformMatrix3x4fv: TglUniformMatrix3x4fv;
+ glUniformMatrix4x3fv: TglUniformMatrix4x3fv;
+ glBlitFramebuffer: TglBlitFramebuffer;
+ glRenderbufferStorageMultisample: TglRenderbufferStorageMultisample;
+ glFramebufferTextureLayer: TglFramebufferTextureLayer;
+ glMapBufferRange: TglMapBufferRange;
+ glFlushMappedBufferRange: TglFlushMappedBufferRange;
+ glBindVertexArray: TglBindVertexArray;
+ glDeleteVertexArrays: TglDeleteVertexArrays;
+ glGenVertexArrays: TglGenVertexArrays;
+ glIsVertexArray: TglIsVertexArray;
+ glGetIntegeri_v: TglGetIntegeri_v;
+ glBeginTransformFeedback: TglBeginTransformFeedback;
+ glEndTransformFeedback: TglEndTransformFeedback;
+ glBindBufferRange: TglBindBufferRange;
+ glBindBufferBase: TglBindBufferBase;
+ glTransformFeedbackVaryings: TglTransformFeedbackVaryings;
+ glGetTransformFeedbackVarying: TglGetTransformFeedbackVarying;
+ glVertexAttribIPointer: TglVertexAttribIPointer;
+ glGetVertexAttribIiv: TglGetVertexAttribIiv;
+ glGetVertexAttribIuiv: TglGetVertexAttribIuiv;
+ glVertexAttribI4i: TglVertexAttribI4i;
+ glVertexAttribI4ui: TglVertexAttribI4ui;
+ glVertexAttribI4iv: TglVertexAttribI4iv;
+ glVertexAttribI4uiv: TglVertexAttribI4uiv;
+ glGetUniformuiv: TglGetUniformuiv;
+ glGetFragDataLocation: TglGetFragDataLocation;
+ glUniform1ui: TglUniform1ui;
+ glUniform2ui: TglUniform2ui;
+ glUniform3ui: TglUniform3ui;
+ glUniform4ui: TglUniform4ui;
+ glUniform1uiv: TglUniform1uiv;
+ glUniform2uiv: TglUniform2uiv;
+ glUniform3uiv: TglUniform3uiv;
+ glUniform4uiv: TglUniform4uiv;
+ glClearBufferiv: TglClearBufferiv;
+ glClearBufferuiv: TglClearBufferuiv;
+ glClearBufferfv: TglClearBufferfv;
+ glClearBufferfi: TglClearBufferfi;
+ glGetStringi: TglGetStringi;
+ glCopyBufferSubData: TglCopyBufferSubData;
+ glGetUniformIndices: TglGetUniformIndices;
+ glGetActiveUniformsiv: TglGetActiveUniformsiv;
+ glGetUniformBlockIndex: TglGetUniformBlockIndex;
+ glGetActiveUniformBlockiv: TglGetActiveUniformBlockiv;
+ glGetActiveUniformBlockName: TglGetActiveUniformBlockName;
+ glUniformBlockBinding: TglUniformBlockBinding;
+ glDrawArraysInstanced: TglDrawArraysInstanced;
+ glDrawElementsInstanced: TglDrawElementsInstanced;
+ glFenceSync: TglFenceSync;
+ glIsSync: TglIsSync;
+ glDeleteSync: TglDeleteSync;
+ glClientWaitSync: TglClientWaitSync;
+ glWaitSync: TglWaitSync;
+ glGetInteger64v: TglGetInteger64v;
+ glGetSynciv: TglGetSynciv;
+ glGetInteger64i_v: TglGetInteger64i_v;
+ glGetBufferParameteri64v: TglGetBufferParameteri64v;
+ glGenSamplers: TglGenSamplers;
+ glDeleteSamplers: TglDeleteSamplers;
+ glIsSampler: TglIsSampler;
+ glBindSampler: TglBindSampler;
+ glSamplerParameteri: TglSamplerParameteri;
+ glSamplerParameteriv: TglSamplerParameteriv;
+ glSamplerParameterf: TglSamplerParameterf;
+ glSamplerParameterfv: TglSamplerParameterfv;
+ glGetSamplerParameteriv: TglGetSamplerParameteriv;
+ glGetSamplerParameterfv: TglGetSamplerParameterfv;
+ glVertexAttribDivisor: TglVertexAttribDivisor;
+ glBindTransformFeedback: TglBindTransformFeedback;
+ glDeleteTransformFeedbacks: TglDeleteTransformFeedbacks;
+ glGenTransformFeedbacks: TglGenTransformFeedbacks;
+ glIsTransformFeedback: TglIsTransformFeedback;
+ glPauseTransformFeedback: TglPauseTransformFeedback;
+ glResumeTransformFeedback: TglResumeTransformFeedback;
+ glGetProgramBinary: TglGetProgramBinary;
+ glProgramBinary: TglProgramBinary;
+ glProgramParameteri: TglProgramParameteri;
+ glInvalidateFramebuffer: TglInvalidateFramebuffer;
+ glInvalidateSubFramebuffer: TglInvalidateSubFramebuffer;
+ glTexStorage2D: TglTexStorage2D;
+ glTexStorage3D: TglTexStorage3D;
+ glGetInternalformativ: TglGetInternalformativ;
+
+ { OpenGL ES 3.1 }
+ glDispatchCompute: TglDispatchCompute;
+ glDispatchComputeIndirect: TglDispatchComputeIndirect;
+ glDrawArraysIndirect: TglDrawArraysIndirect;
+ glDrawElementsIndirect: TglDrawElementsIndirect;
+ glFramebufferParameteri: TglFramebufferParameteri;
+ glGetFramebufferParameteriv: TglGetFramebufferParameteriv;
+ glGetProgramInterfaceiv: TglGetProgramInterfaceiv;
+ glGetProgramResourceIndex: TglGetProgramResourceIndex;
+ glGetProgramResourceName: TglGetProgramResourceName;
+ glGetProgramResourceiv: TglGetProgramResourceiv;
+ glGetProgramResourceLocation: TglGetProgramResourceLocation;
+ glUseProgramStages: TglUseProgramStages;
+ glActiveShaderProgram: TglActiveShaderProgram;
+ glCreateShaderProgramv: TglCreateShaderProgramv;
+ glBindProgramPipeline: TglBindProgramPipeline;
+ glDeleteProgramPipelines: TglDeleteProgramPipelines;
+ glGenProgramPipelines: TglGenProgramPipelines;
+ glIsProgramPipeline: TglIsProgramPipeline;
+ glGetProgramPipelineiv: TglGetProgramPipelineiv;
+ glProgramUniform1i: TglProgramUniform1i;
+ glProgramUniform2i: TglProgramUniform2i;
+ glProgramUniform3i: TglProgramUniform3i;
+ glProgramUniform4i: TglProgramUniform4i;
+ glProgramUniform1ui: TglProgramUniform1ui;
+ glProgramUniform2ui: TglProgramUniform2ui;
+ glProgramUniform3ui: TglProgramUniform3ui;
+ glProgramUniform4ui: TglProgramUniform4ui;
+ glProgramUniform1f: TglProgramUniform1f;
+ glProgramUniform2f: TglProgramUniform2f;
+ glProgramUniform3f: TglProgramUniform3f;
+ glProgramUniform4f: TglProgramUniform4f;
+ glProgramUniform1iv: TglProgramUniform1iv;
+ glProgramUniform2iv: TglProgramUniform2iv;
+ glProgramUniform3iv: TglProgramUniform3iv;
+ glProgramUniform4iv: TglProgramUniform4iv;
+ glProgramUniform1uiv: TglProgramUniform1uiv;
+ glProgramUniform2uiv: TglProgramUniform2uiv;
+ glProgramUniform3uiv: TglProgramUniform3uiv;
+ glProgramUniform4uiv: TglProgramUniform4uiv;
+ glProgramUniform1fv: TglProgramUniform1fv;
+ glProgramUniform2fv: TglProgramUniform2fv;
+ glProgramUniform3fv: TglProgramUniform3fv;
+ glProgramUniform4fv: TglProgramUniform4fv;
+ glProgramUniformMatrix2fv: TglProgramUniformMatrix2fv;
+ glProgramUniformMatrix3fv: TglProgramUniformMatrix3fv;
+ glProgramUniformMatrix4fv: TglProgramUniformMatrix4fv;
+ glProgramUniformMatrix2x3fv: TglProgramUniformMatrix2x3fv;
+ glProgramUniformMatrix3x2fv: TglProgramUniformMatrix3x2fv;
+ glProgramUniformMatrix2x4fv: TglProgramUniformMatrix2x4fv;
+ glProgramUniformMatrix4x2fv: TglProgramUniformMatrix4x2fv;
+ glProgramUniformMatrix3x4fv: TglProgramUniformMatrix3x4fv;
+ glProgramUniformMatrix4x3fv: TglProgramUniformMatrix4x3fv;
+ glValidateProgramPipeline: TglValidateProgramPipeline;
+ glGetProgramPipelineInfoLog: TglGetProgramPipelineInfoLog;
+ glBindImageTexture: TglBindImageTexture;
+ glGetBooleaniV: TglGetBooleaniV;
+ glMemoryBarrier: TglMemoryBarrier;
+ glMemoryBarrierByRegion: TglMemoryBarrierByRegion;
+ glTexStorage2DMultisample: TglTexStorage2DMultisample;
+ glGetMultisamplefv: TglGetMultisamplefv;
+ glSampleMaski: TglSampleMaski;
+ glGetTexLevelParameteriv: TglGetTexLevelParameteriv;
+ glGetTexLevelParameterfv: TglGetTexLevelParameterfv;
+ glBindVertexBuffer: TglBindVertexBuffer;
+ glVertexAttribFormat: TglVertexAttribFormat;
+ glVertexAttribIFormat: TglVertexAttribIFormat;
+ glVertexAttribBinding: TglVertexAttribBinding;
+ glVertexBindingDivisor: TglVertexBindingDivisor;
+
+
+{ ===================================================== EGL ========================================================== }
+type
+ EGLint = Integer;
+ EGLboolean = Cardinal;
+ EGLenum = Cardinal;
+ EGLConfig = Pointer;
+ EGLContext = Pointer;
+ EGLDisplay = Pointer;
+ EGLSurface = Pointer;
+ EGLClientBuffer = Pointer;
+ EGLNativeDisplayType = Pointer;
+ EGLNativePixmapType = Pointer;
+ EGLNativeWindowType = packed record
+ element: Cardinal { DispManXElementHandle };
+ width: Integer;
+ height: Integer;
+ end;
+
+ PEGLint = ^EGLint;
+ PEGLboolean = ^EGLboolean;
+ PEGLenum = ^EGLenum;
+ PEGLConfig = ^EGLConfig;
+ PEGLContext = ^EGLContext;
+ PEGLDisplay = ^EGLDisplay;
+ PEGLSurface = ^EGLSurface;
+ PEGLClientBuffer = ^EGLClientBuffer;
+ PEGLNativeDisplayType = ^EGLNativeDisplayType;
+ PEGLNativePixmapType = ^EGLNativePixmapType;
+ PEGLNativeWindowType = ^EGLNativeWindowType;
+
+const
+ EGL_FALSE: EGLboolean = 0;
+ EGL_TRUE: EGLboolean = 1;
+
+ EGL_DEFAULT_DISPLAY: EGLNativeDisplayType = nil;
+ EGL_NO_CONTEXT: EGLContext = nil;
+ EGL_NO_DISPLAY: EGLDisplay = nil;
+ EGL_NO_SURFACE: EGLSurface = nil;
+
+ EGL_DONT_CARE: EGLint = -1;
+
+ EGL_SUCCESS = $3000;
+ EGL_NOT_INITIALIZED = $3001;
+ EGL_BAD_ACCESS = $3002;
+ EGL_BAD_ALLOC = $3003;
+ EGL_BAD_ATTRIBUTE = $3004;
+ EGL_BAD_CONFIG = $3005;
+ EGL_BAD_CONTEXT = $3006;
+ EGL_BAD_CURRENT_SURFACE = $3007;
+ EGL_BAD_DISPLAY = $3008;
+ EGL_BAD_MATCH = $3009;
+ EGL_BAD_NATIVE_PIXMAP = $300A;
+ EGL_BAD_NATIVE_WINDOW = $300B;
+ EGL_BAD_PARAMETER = $300C;
+ EGL_BAD_SURFACE = $300D;
+ EGL_CONTEXT_LOST = $300E;
+
+ EGL_BUFFER_SIZE = $3020;
+ EGL_ALPHA_SIZE = $3021;
+ EGL_BLUE_SIZE = $3022;
+ EGL_GREEN_SIZE = $3023;
+ EGL_RED_SIZE = $3024;
+ EGL_DEPTH_SIZE = $3025;
+ EGL_STENCIL_SIZE = $3026;
+ EGL_CONFIG_CAVEAT = $3027;
+ EGL_CONFIG_ID = $3028;
+ EGL_LEVEL = $3029;
+ EGL_MAX_PBUFFER_HEIGHT = $302A;
+ EGL_MAX_PBUFFER_PIXELS = $302B;
+ EGL_MAX_PBUFFER_WIDTH = $302C;
+ EGL_NATIVE_RENDERABLE = $302D;
+ EGL_NATIVE_VISUAL_ID = $302E;
+ EGL_NATIVE_VISUAL_TYPE = $302F;
+ EGL_SAMPLES = $3031;
+ EGL_SAMPLE_BUFFERS = $3032;
+ EGL_SURFACE_TYPE = $3033;
+ EGL_TRANSPARENT_TYPE = $3034;
+ EGL_TRANSPARENT_BLUE_VALUE = $3035;
+ EGL_TRANSPARENT_GREEN_VALUE = $3036;
+ EGL_TRANSPARENT_RED_VALUE = $3037;
+ EGL_NONE = $3038;
+ EGL_BIND_TO_TEXTURE_RGB = $3039;
+ EGL_BIND_TO_TEXTURE_RGBA = $303A;
+ EGL_MIN_SWAP_INTERVAL = $303B;
+ EGL_MAX_SWAP_INTERVAL = $303C;
+ EGL_LUMINANCE_SIZE = $303D;
+ EGL_ALPHA_MASK_SIZE = $303E;
+ EGL_COLOR_BUFFER_TYPE = $303F;
+ EGL_RENDERABLE_TYPE = $3040;
+ EGL_MATCH_NATIVE_PIXMAP = $3041;
+ EGL_CONFORMANT = $3042;
+
+ EGL_SLOW_CONFIG = $3050;
+ EGL_NON_CONFORMANT_CONFIG = $3051;
+ EGL_TRANSPARENT_RGB = $3052;
+ EGL_RGB_BUFFER = $308E;
+ EGL_LUMINANCE_BUFFER = $308F;
+
+ EGL_NO_TEXTURE = $305C;
+ EGL_TEXTURE_RGB = $305D;
+ EGL_TEXTURE_RGBA = $305E;
+ EGL_TEXTURE_2D = $305F;
+
+ EGL_PBUFFER_BIT = $0001;
+ EGL_PIXMAP_BIT = $0002;
+ EGL_WINDOW_BIT = $0004;
+ EGL_VG_COLORSPACE_LINEAR_BIT = $0020;
+ EGL_VG_ALPHA_FORMAT_PRE_BIT = $0040;
+ EGL_MULTISAMPLE_RESOLVE_BOX_BIT = $0200;
+ EGL_SWAP_BEHAVIOR_PRESERVED_BIT = $0400;
+
+ EGL_OPENGL_ES_BIT = $0001;
+ EGL_OPENVG_BIT = $0002;
+ EGL_OPENGL_ES2_BIT = $0004;
+ EGL_OPENGL_BIT = $0008;
+
+ EGL_VENDOR = $3053;
+ EGL_VERSION = $3054;
+ EGL_EXTENSIONS = $3055;
+ EGL_CLIENT_APIS = $308D;
+
+ EGL_HEIGHT = $3056;
+ EGL_WIDTH = $3057;
+ EGL_LARGEST_PBUFFER = $3058;
+ EGL_TEXTURE_FORMAT = $3080;
+ EGL_TEXTURE_TARGET = $3081;
+ EGL_MIPMAP_TEXTURE = $3082;
+ EGL_MIPMAP_LEVEL = $3083;
+ EGL_RENDER_BUFFER = $3086;
+ EGL_VG_COLORSPACE = $3087;
+ EGL_VG_ALPHA_FORMAT = $3088;
+ EGL_HORIZONTAL_RESOLUTION = $3090;
+ EGL_VERTICAL_RESOLUTION = $3091;
+ EGL_PIXEL_ASPECT_RATIO = $3092;
+ EGL_SWAP_BEHAVIOR = $3093;
+ EGL_MULTISAMPLE_RESOLVE = $3099;
+
+ EGL_BACK_BUFFER = $3084;
+ EGL_SINGLE_BUFFER = $3085;
+
+ EGL_VG_COLORSPACE_sRGB = $3089;
+ EGL_VG_COLORSPACE_LINEAR = $308A;
+
+ EGL_VG_ALPHA_FORMAT_NONPRE = $308B;
+ EGL_VG_ALPHA_FORMAT_PRE = $308C;
+
+ EGL_DISPLAY_SCALING = 10000;
+
+ EGL_UNKNOWN: EGLint = -1;
+
+ EGL_BUFFER_PRESERVED = $3094;
+ EGL_BUFFER_DESTROYED = $3095;
+
+ EGL_OPENVG_IMAGE = $3096;
+
+ EGL_CONTEXT_CLIENT_TYPE = $3097;
+
+ EGL_CONTEXT_CLIENT_VERSION = $3098;
+
+ EGL_MULTISAMPLE_RESOLVE_DEFAULT = $309A;
+ EGL_MULTISAMPLE_RESOLVE_BOX = $309B;
+
+ EGL_OPENGL_ES_API = $30A0;
+ EGL_OPENVG_API = $30A1;
+ EGL_OPENGL_API = $30A2;
+
+ EGL_DRAW = $3059;
+ EGL_READ = $305A;
+
+ EGL_CORE_NATIVE_ENGINE = $305B;
+
+ EGL_COLORSPACE = EGL_VG_COLORSPACE;
+ EGL_ALPHA_FORMAT = EGL_VG_ALPHA_FORMAT;
+ EGL_COLORSPACE_sRGB = EGL_VG_COLORSPACE_sRGB;
+ EGL_COLORSPACE_LINEAR = EGL_VG_COLORSPACE_LINEAR;
+ EGL_ALPHA_FORMAT_NONPRE = EGL_VG_ALPHA_FORMAT_NONPRE;
+ EGL_ALPHA_FORMAT_PRE = EGL_VG_ALPHA_FORMAT_PRE;
+
+type
+ TeglGetError = function: EGLint; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetDisplay = function(aDisplayID: EGLNativeDisplayType): EGLDisplay; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglInitialize = function(aDisplay: EGLDisplay; aMajor, aMinor: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglTerminate = function(aDisplay: EGLDisplay): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglQueryString = function(aDisplay: EGLDisplay; aName: EGLint): PAnsiChar; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetConfigs = function(aDisplay: EGLDisplay; aConfigs: PEGLConfig; aConfigSize: EGLint; aNumConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglChooseConfig = function(aDisplay: EGLDisplay; const aAttribList: PEGLint; aConfigs: PEGLConfig; aConfigSize: EGLint; aNumConfig: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglGetConfigAttrib = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aAttribute: EGLint; aValue : PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglCreateWindowSurface = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aWinType: PEGLNativeWindowType; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglCreatePbufferSurface = function(aDisplay: EGLDisplay; aConfig: EGLConfig; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglCreatePixmapSurface = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aPixmap: EGLNativePixmapType; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglDestroySurface = function(aDisplay: EGLDisplay; aSurface: EGLSurface): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglQuerySurface = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aAttribute: EGLint; aValue: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglBindAPI = function(aApi: EGLenum): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglQueryAPI = function: EGLenum; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglWaitClient = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglReleaseThread = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglCreatePbufferFromClientBuffer = function(aDisplay: EGLDisplay; aBufType: EGLenum; aBuffer: EGLClientBuffer; aConfig: EGLConfig; const aAttribList: PEGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglSurfaceAttrib = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aAttribute: EGLint; aValue: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglBindTexImage = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aBuffer: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglReleaseTexImage = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aBuffer: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglSwapInterval = function(aDisplay: EGLDisplay; aInterval: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglCreateContext = function(aDisplay: EGLDisplay; aConfig: EGLConfig; aShareContext: EGLContext; const aAttribList: PEGLint): EGLContext; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglDestroyContext = function(aDisplay: EGLDisplay; aContext: EGLContext): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglMakeCurrent = function(aDisplay: EGLDisplay; aDraw: EGLSurface; aRead: EGLSurface; aContext: EGLContext): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetCurrentContext = function: EGLContext; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglGetCurrentSurface = function(aReadDraw: EGLint): EGLSurface; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglGetCurrentDisplay = function: EGLDisplay; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglQueryContext = function(aDisplay: EGLDisplay; aContext: EGLContext; aAttribute: EGLint; aValue: PEGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglWaitGL = function: EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglWaitNative = function(aEngine: EGLint): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglSwapBuffers = function(aDisplay: EGLDisplay; aSurface: EGLSurface): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+ TeglCopyBuffers = function(aDisplay: EGLDisplay; aSurface: EGLSurface; aTarget: EGLNativePixmapType): EGLBoolean; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+ TeglGetProcAddress = function(const aProcName: PAnsiChar): Pointer; {$IFDEF DGL_WIN}stdcall;{$ELSE}cdecl;{$ENDIF}
+
+
+var
+ eglGetError: TeglGetError;
+
+ eglGetDisplay: TeglGetDisplay;
+ eglInitialize: TeglInitialize;
+ eglTerminate: TeglTerminate;
+
+ eglQueryString: TeglQueryString;
+
+ eglGetConfigs: TeglGetConfigs;
+ eglChooseConfig: TeglChooseConfig;
+ eglGetConfigAttrib: TeglGetConfigAttrib;
+
+ eglCreateWindowSurface: TeglCreateWindowSurface;
+ eglCreatePbufferSurface: TeglCreatePbufferSurface;
+ eglCreatePixmapSurface: TeglCreatePixmapSurface;
+ eglDestroySurface: TeglDestroySurface;
+ eglQuerySurface: TeglQuerySurface;
+
+ eglBindAPI: TeglBindAPI;
+ eglQueryAPI: TeglQueryAPI;
+
+ eglWaitClient: TeglWaitClient;
+
+ eglReleaseThread: TeglReleaseThread;
+
+ eglCreatePbufferFromClientBuffer: TeglCreatePbufferFromClientBuffer;
+
+ eglSurfaceAttrib: TeglSurfaceAttrib;
+ eglBindTexImage: TeglBindTexImage;
+ eglReleaseTexImage: TeglReleaseTexImage;
+
+ eglSwapInterval: TeglSwapInterval;
+
+ eglCreateContext: TeglCreateContext;
+ eglDestroyContext: TeglDestroyContext;
+ eglMakeCurrent: TeglMakeCurrent;
+
+ eglGetCurrentContext: TeglGetCurrentContext;
+ eglGetCurrentSurface: TeglGetCurrentSurface;
+ eglGetCurrentDisplay: TeglGetCurrentDisplay;
+ eglQueryContext: TeglQueryContext;
+
+ eglWaitGL: TeglWaitGL;
+ eglWaitNative: TeglWaitNative;
+ eglSwapBuffers: TeglSwapBuffers;
+ eglCopyBuffers: TeglCopyBuffers;
+
+ eglGetProcAddress: TeglGetProcAddress;
+
+function InitOpenGLES(const aOpenGLESLibName: String = LIBNAME_OPENGLES; aEGLLibName: String = LIBNAME_EGL): Boolean;
+procedure ReadExtensions;
+
+implementation
+
+var
+ LibHandleOpenGLES: Pointer = nil;
+ LibHandleEGL: Pointer = nil;
+
+function dglLoadLibrary(const aName: PChar): Pointer;
+begin
+ {$IFDEF DGL_LINUX}
+ result := dlopen(aName, RTLD_LAZY);
+ {$ENDIF}
+end;
+
+function dglGetProcAddress(const aProcName: PAnsiChar): Pointer;
+begin
+ result := nil;
+
+ if Assigned(LibHandleOpenGLES) then
+ result := dlsym(LibHandleOpenGLES, aProcName);
+
+ if not Assigned(result) and Assigned(eglGetProcAddress) then
+ result := eglGetProcAddress(aProcName);
+
+ if not Assigned(result) and Assigned(LibHandleEGL) then
+ result := dlsym(LibHandleEGL, aProcName);
+end;
+
+function dglFreeAndNilLibrary(var aLibHandle: Pointer): Boolean;
+begin
+ if Assigned(aLibHandle) then begin
+ {$IFDEF DGL_LINUX}
+ result := (dlclose(aLibHandle) = 0);
+ aLibHandle := nil;
+ {$ENDIF}
+ end else
+ result := false;
+end;
+
+procedure ReadOpenGLCore;
+begin
+
+end;
+
+function InitOpenGLES(const aOpenGLESLibName: String; aEGLLibName: String): Boolean;
+begin
+ result := true;
+
+ if Assigned(LibHandleOpenGLES) then
+ dglFreeAndNilLibrary(LibHandleOpenGLES);
+
+ if Assigned(LibHandleEGL) then
+ dglFreeAndNilLibrary(LibHandleEGL);
+
+ LibHandleOpenGLES := dglLoadLibrary(PChar(aOpenGLESLibName));
+ LibHandleEGL := dglLoadLibrary(PChar(aEGLLibName));
+
+ // load EGL procedures
+ if Assigned(LibHandleEGL) then begin
+ eglGetProcAddress := dglGetProcAddress('eglGetProcAddress');
+ eglGetError := dglGetProcAddress('eglGetError');
+ eglGetDisplay := dglGetProcAddress('eglGetDisplay');
+ eglInitialize := dglGetProcAddress('eglInitialize');
+ eglTerminate := dglGetProcAddress('eglTerminate');
+ eglQueryString := dglGetProcAddress('eglQueryString');
+ eglGetConfigs := dglGetProcAddress('eglGetConfigs');
+ eglChooseConfig := dglGetProcAddress('eglChooseConfig');
+ eglGetConfigAttrib := dglGetProcAddress('eglGetConfigAttrib');
+ eglCreateWindowSurface := dglGetProcAddress('eglCreateWindowSurface');
+ eglCreatePbufferSurface := dglGetProcAddress('eglCreatePbufferSurface');
+ eglCreatePixmapSurface := dglGetProcAddress('eglCreatePixmapSurface');
+ eglDestroySurface := dglGetProcAddress('eglDestroySurface');
+ eglQuerySurface := dglGetProcAddress('eglQuerySurface');
+ eglBindAPI := dglGetProcAddress('eglBindAPI');
+ eglQueryAPI := dglGetProcAddress('eglQueryAPI');
+ eglWaitClient := dglGetProcAddress('eglWaitClient');
+ eglReleaseThread := dglGetProcAddress('eglReleaseThread');
+ eglCreatePbufferFromClientBuffer := dglGetProcAddress('eglCreatePbufferFromClientBuffer');
+ eglSurfaceAttrib := dglGetProcAddress('eglSurfaceAttrib');
+ eglBindTexImage := dglGetProcAddress('eglBindTexImage');
+ eglReleaseTexImage := dglGetProcAddress('eglReleaseTexImage');
+ eglSwapInterval := dglGetProcAddress('eglSwapInterval');
+ eglCreateContext := dglGetProcAddress('eglCreateContext');
+ eglDestroyContext := dglGetProcAddress('eglDestroyContext');
+ eglMakeCurrent := dglGetProcAddress('eglMakeCurrent');
+ eglGetCurrentContext := dglGetProcAddress('eglGetCurrentContext');
+ eglGetCurrentSurface := dglGetProcAddress('eglGetCurrentSurface');
+ eglGetCurrentDisplay := dglGetProcAddress('eglGetCurrentDisplay');
+ eglQueryContext := dglGetProcAddress('eglQueryContext');
+ eglWaitGL := dglGetProcAddress('eglWaitGL');
+ eglWaitNative := dglGetProcAddress('eglWaitNative');
+ eglSwapBuffers := dglGetProcAddress('eglSwapBuffers');
+ eglCopyBuffers := dglGetProcAddress('eglCopyBuffers');
+ end else
+ result := false;
+end;
+
+procedure ReadExtensions;
+begin
+ glActiveTexture := dglGetProcAddress('glActiveTexture');
+ glAttachShader := dglGetProcAddress('glAttachShader');
+ glBindAttribLocation := dglGetProcAddress('glBindAttribLocation');
+ glBindBuffer := dglGetProcAddress('glBindBuffer');
+ glBindFramebuffer := dglGetProcAddress('glBindFramebuffer');
+ glBindRenderbuffer := dglGetProcAddress('glBindRenderbuffer');
+ glBindTexture := dglGetProcAddress('glBindTexture');
+ glBlendColor := dglGetProcAddress('glBlendColor');
+ glBlendEquation := dglGetProcAddress('glBlendEquation');
+ glBlendEquationSeparate := dglGetProcAddress('glBlendEquationSeparate');
+ glBlendFunc := dglGetProcAddress('glBlendFunc');
+ glBlendFuncSeparate := dglGetProcAddress('glBlendFuncSeparate');
+ glBufferData := dglGetProcAddress('glBufferData');
+ glBufferSubData := dglGetProcAddress('glBufferSubData');
+ glCheckFramebufferStatus := dglGetProcAddress('glCheckFramebufferStatus');
+ glClear := dglGetProcAddress('glClear');
+ glClearColor := dglGetProcAddress('glClearColor');
+ glClearDepthf := dglGetProcAddress('glClearDepthf');
+ glClearStencil := dglGetProcAddress('glClearStencil');
+ glColorMask := dglGetProcAddress('glColorMask');
+ glCompileShader := dglGetProcAddress('glCompileShader');
+ glCompressedTexImage2D := dglGetProcAddress('glCompressedTexImage2D');
+ glCompressedTexSubImage2D := dglGetProcAddress('glCompressedTexSubImage2D');
+ glCopyTexImage2D := dglGetProcAddress('glCopyTexImage2D');
+ glCopyTexSubImage2D := dglGetProcAddress('glCopyTexSubImage2D');
+ glCreateProgram := dglGetProcAddress('glCreateProgram');
+ glCreateShader := dglGetProcAddress('glCreateShader');
+ glCullFace := dglGetProcAddress('glCullFace');
+ glDeleteBuffers := dglGetProcAddress('glDeleteBuffers');
+ glDeleteFramebuffers := dglGetProcAddress('glDeleteFramebuffers');
+ glDeleteProgram := dglGetProcAddress('glDeleteProgram');
+ glDeleteRenderbuffers := dglGetProcAddress('glDeleteRenderbuffers');
+ glDeleteShader := dglGetProcAddress('glDeleteShader');
+ glDeleteTextures := dglGetProcAddress('glDeleteTextures');
+ glDepthFunc := dglGetProcAddress('glDepthFunc');
+ glDepthMask := dglGetProcAddress('glDepthMask');
+ glDepthRangef := dglGetProcAddress('glDepthRangef');
+ glDetachShader := dglGetProcAddress('glDetachShader');
+ glDisable := dglGetProcAddress('glDisable');
+ glDisableVertexAttribArray := dglGetProcAddress('glDisableVertexAttribArray');
+ glDrawArrays := dglGetProcAddress('glDrawArrays');
+ glDrawElements := dglGetProcAddress('glDrawElements');
+ glEnable := dglGetProcAddress('glEnable');
+ glEnableVertexAttribArray := dglGetProcAddress('glEnableVertexAttribArray');
+ glFinish := dglGetProcAddress('glFinish');
+ glFlush := dglGetProcAddress('glFlush');
+ glFramebufferRenderbuffer := dglGetProcAddress('glFramebufferRenderbuffer');
+ glFramebufferTexture2D := dglGetProcAddress('glFramebufferTexture2D');
+ glFrontFace := dglGetProcAddress('glFrontFace');
+ glGenBuffers := dglGetProcAddress('glGenBuffers');
+ glGenerateMipmap := dglGetProcAddress('glGenerateMipmap');
+ glGenFramebuffers := dglGetProcAddress('glGenFramebuffers');
+ glGenRenderbuffers := dglGetProcAddress('glGenRenderbuffers');
+ glGenTextures := dglGetProcAddress('glGenTextures');
+ glGetActiveAttrib := dglGetProcAddress('glGetActiveAttrib');
+ glGetActiveUniform := dglGetProcAddress('glGetActiveUniform');
+ glGetAttachedShaders := dglGetProcAddress('glGetAttachedShaders');
+ glGetAttribLocation := dglGetProcAddress('glGetAttribLocation');
+ glGetBooleanv := dglGetProcAddress('glGetBooleanv');
+ glGetBufferParameteriv := dglGetProcAddress('glGetBufferParameteriv');
+ glGetError := dglGetProcAddress('glGetError');
+ glGetFloatv := dglGetProcAddress('glGetFloatv');
+ glGetFramebufferAttachmentParameteriv := dglGetProcAddress('glGetFramebufferAttachmentParameteriv');
+ glGetIntegerv := dglGetProcAddress('glGetIntegerv');
+ glGetProgramiv := dglGetProcAddress('glGetProgramiv');
+ glGetProgramInfoLog := dglGetProcAddress('glGetProgramInfoLog');
+ glGetRenderbufferParameteriv := dglGetProcAddress('glGetRenderbufferParameteriv');
+ glGetShaderiv := dglGetProcAddress('glGetShaderiv');
+ glGetShaderInfoLog := dglGetProcAddress('glGetShaderInfoLog');
+ glGetShaderPrecisionFormat := dglGetProcAddress('glGetShaderPrecisionFormat');
+ glGetShaderSource := dglGetProcAddress('glGetShaderSource');
+ glGetString := dglGetProcAddress('glGetString');
+ glGetTexParameterfv := dglGetProcAddress('glGetTexParameterfv');
+ glGetTexParameteriv := dglGetProcAddress('glGetTexParameteriv');
+ glGetUniformfv := dglGetProcAddress('glGetUniformfv');
+ glGetUniformiv := dglGetProcAddress('glGetUniformiv');
+ glGetUniformLocation := dglGetProcAddress('glGetUniformLocation');
+ glGetVertexAttribfv := dglGetProcAddress('glGetVertexAttribfv');
+ glGetVertexAttribiv := dglGetProcAddress('glGetVertexAttribiv');
+ glGetVertexAttribPointerv := dglGetProcAddress('glGetVertexAttribPointerv');
+ glHint := dglGetProcAddress('glHint');
+ glIsBuffer := dglGetProcAddress('glIsBuffer');
+ glIsEnabled := dglGetProcAddress('glIsEnabled');
+ glIsFramebuffer := dglGetProcAddress('glIsFramebuffer');
+ glIsProgram := dglGetProcAddress('glIsProgram');
+ glIsRenderbuffer := dglGetProcAddress('glIsRenderbuffer');
+ glIsShader := dglGetProcAddress('glIsShader');
+ glIsTexture := dglGetProcAddress('glIsTexture');
+ glLineWidth := dglGetProcAddress('glLineWidth');
+ glLinkProgram := dglGetProcAddress('glLinkProgram');
+ glPixelStorei := dglGetProcAddress('glPixelStorei');
+ glPolygonOffset := dglGetProcAddress('glPolygonOffset');
+ glReadPixels := dglGetProcAddress('glReadPixels');
+ glReleaseShaderCompiler := dglGetProcAddress('glReleaseShaderCompiler');
+ glRenderbufferStorage := dglGetProcAddress('glRenderbufferStorage');
+ glSampleCoverage := dglGetProcAddress('glSampleCoverage');
+ glScissor := dglGetProcAddress('glScissor');
+ glShaderBinary := dglGetProcAddress('glShaderBinary');
+ glShaderSource := dglGetProcAddress('glShaderSource');
+ glStencilFunc := dglGetProcAddress('glStencilFunc');
+ glStencilFuncSeparate := dglGetProcAddress('glStencilFuncSeparate');
+ glStencilMask := dglGetProcAddress('glStencilMask');
+ glStencilMaskSeparate := dglGetProcAddress('glStencilMaskSeparate');
+ glStencilOp := dglGetProcAddress('glStencilOp');
+ glStencilOpSeparate := dglGetProcAddress('glStencilOpSeparate');
+ glTexImage2D := dglGetProcAddress('glTexImage2D');
+ glTexParameterf := dglGetProcAddress('glTexParameterf');
+ glTexParameterfv := dglGetProcAddress('glTexParameterfv');
+ glTexParameteri := dglGetProcAddress('glTexParameteri');
+ glTexParameteriv := dglGetProcAddress('glTexParameteriv');
+ glTexSubImage2D := dglGetProcAddress('glTexSubImage2D');
+ glUniform1f := dglGetProcAddress('glUniform1f');
+ glUniform1fv := dglGetProcAddress('glUniform1fv');
+ glUniform1i := dglGetProcAddress('glUniform1i');
+ glUniform1iv := dglGetProcAddress('glUniform1iv');
+ glUniform2f := dglGetProcAddress('glUniform2f');
+ glUniform2fv := dglGetProcAddress('glUniform2fv');
+ glUniform2i := dglGetProcAddress('glUniform2i');
+ glUniform2iv := dglGetProcAddress('glUniform2iv');
+ glUniform3f := dglGetProcAddress('glUniform3f');
+ glUniform3fv := dglGetProcAddress('glUniform3fv');
+ glUniform3i := dglGetProcAddress('glUniform3i');
+ glUniform3iv := dglGetProcAddress('glUniform3iv');
+ glUniform4f := dglGetProcAddress('glUniform4f');
+ glUniform4fv := dglGetProcAddress('glUniform4fv');
+ glUniform4i := dglGetProcAddress('glUniform4i');
+ glUniform4iv := dglGetProcAddress('glUniform4iv');
+ glUniformMatrix2fv := dglGetProcAddress('glUniformMatrix2fv');
+ glUniformMatrix3fv := dglGetProcAddress('glUniformMatrix3fv');
+ glUniformMatrix4fv := dglGetProcAddress('glUniformMatrix4fv');
+ glUseProgram := dglGetProcAddress('glUseProgram');
+ glValidateProgram := dglGetProcAddress('glValidateProgram');
+ glVertexAttrib1f := dglGetProcAddress('glVertexAttrib1f');
+ glVertexAttrib1fv := dglGetProcAddress('glVertexAttrib1fv');
+ glVertexAttrib2f := dglGetProcAddress('glVertexAttrib2f');
+ glVertexAttrib2fv := dglGetProcAddress('glVertexAttrib2fv');
+ glVertexAttrib3f := dglGetProcAddress('glVertexAttrib3f');
+ glVertexAttrib3fv := dglGetProcAddress('glVertexAttrib3fv');
+ glVertexAttrib4f := dglGetProcAddress('glVertexAttrib4f');
+ glVertexAttrib4fv := dglGetProcAddress('glVertexAttrib4fv');
+ glVertexAttribPointer := dglGetProcAddress('glVertexAttribPointer');
+ glViewport := dglGetProcAddress('glViewport');
+
+ { OpenGL ES 3.0 }
+ glReadBuffer := dglGetProcAddress('glReadBuffer');
+ glDrawRangeElements := dglGetProcAddress('glDrawRangeElements');
+ glTexImage3D := dglGetProcAddress('glTexImage3D');
+ glTexSubImage3D := dglGetProcAddress('glTexSubImage3D');
+ glCopyTexSubImage3D := dglGetProcAddress('glCopyTexSubImage3D');
+ glCompressedTexImage3D := dglGetProcAddress('glCompressedTexImage3D');
+ glCompressedTexSubImage3D := dglGetProcAddress('glCompressedTexSubImage3D');
+ glGenQueries := dglGetProcAddress('glGenQueries');
+ glDeleteQueries := dglGetProcAddress('glDeleteQueries');
+ glIsQuery := dglGetProcAddress('glIsQuery');
+ glBeginQuery := dglGetProcAddress('glBeginQuery');
+ glEndQuery := dglGetProcAddress('glEndQuery');
+ glGetQueryiv := dglGetProcAddress('glGetQueryiv');
+ glGetQueryObjectuiv := dglGetProcAddress('glGetQueryObjectuiv');
+ glUnmapBuffer := dglGetProcAddress('glUnmapBuffer');
+ glGetBufferPointerv := dglGetProcAddress('glGetBufferPointerv');
+ glDrawBuffers := dglGetProcAddress('glDrawBuffers');
+ glUniformMatrix2x3fv := dglGetProcAddress('glUniformMatrix2x3fv');
+ glUniformMatrix3x2fv := dglGetProcAddress('glUniformMatrix3x2fv');
+ glUniformMatrix2x4fv := dglGetProcAddress('glUniformMatrix2x4fv');
+ glUniformMatrix4x2fv := dglGetProcAddress('glUniformMatrix4x2fv');
+ glUniformMatrix3x4fv := dglGetProcAddress('glUniformMatrix3x4fv');
+ glUniformMatrix4x3fv := dglGetProcAddress('glUniformMatrix4x3fv');
+ glBlitFramebuffer := dglGetProcAddress('glBlitFramebuffer');
+ glRenderbufferStorageMultisample := dglGetProcAddress('glRenderbufferStorageMultisample');
+ glFramebufferTextureLayer := dglGetProcAddress('glFramebufferTextureLayer');
+ glMapBufferRange := dglGetProcAddress('glMapBufferRange');
+ glFlushMappedBufferRange := dglGetProcAddress('glFlushMappedBufferRange');
+ glBindVertexArray := dglGetProcAddress('glBindVertexArray');
+ glDeleteVertexArrays := dglGetProcAddress('glDeleteVertexArrays');
+ glGenVertexArrays := dglGetProcAddress('glGenVertexArrays');
+ glIsVertexArray := dglGetProcAddress('glIsVertexArray');
+ glGetIntegeri_v := dglGetProcAddress('glGetIntegeri_v');
+ glBeginTransformFeedback := dglGetProcAddress('glBeginTransformFeedback');
+ glEndTransformFeedback := dglGetProcAddress('glEndTransformFeedback');
+ glBindBufferRange := dglGetProcAddress('glBindBufferRange');
+ glBindBufferBase := dglGetProcAddress('glBindBufferBase');
+ glTransformFeedbackVaryings := dglGetProcAddress('glTransformFeedbackVaryings');
+ glGetTransformFeedbackVarying := dglGetProcAddress('glGetTransformFeedbackVarying');
+ glVertexAttribIPointer := dglGetProcAddress('glVertexAttribIPointer');
+ glGetVertexAttribIiv := dglGetProcAddress('glGetVertexAttribIiv');
+ glGetVertexAttribIuiv := dglGetProcAddress('glGetVertexAttribIuiv');
+ glVertexAttribI4i := dglGetProcAddress('glVertexAttribI4i');
+ glVertexAttribI4ui := dglGetProcAddress('glVertexAttribI4ui');
+ glVertexAttribI4iv := dglGetProcAddress('glVertexAttribI4iv');
+ glVertexAttribI4uiv := dglGetProcAddress('glVertexAttribI4uiv');
+ glGetUniformuiv := dglGetProcAddress('glGetUniformuiv');
+ glGetFragDataLocation := dglGetProcAddress('glGetFragDataLocation');
+ glUniform1ui := dglGetProcAddress('glUniform1ui');
+ glUniform2ui := dglGetProcAddress('glUniform2ui');
+ glUniform3ui := dglGetProcAddress('glUniform3ui');
+ glUniform4ui := dglGetProcAddress('glUniform4ui');
+ glUniform1uiv := dglGetProcAddress('glUniform1uiv');
+ glUniform2uiv := dglGetProcAddress('glUniform2uiv');
+ glUniform3uiv := dglGetProcAddress('glUniform3uiv');
+ glUniform4uiv := dglGetProcAddress('glUniform4uiv');
+ glClearBufferiv := dglGetProcAddress('glClearBufferiv');
+ glClearBufferuiv := dglGetProcAddress('glClearBufferuiv');
+ glClearBufferfv := dglGetProcAddress('glClearBufferfv');
+ glClearBufferfi := dglGetProcAddress('glClearBufferfi');
+ glGetStringi := dglGetProcAddress('glGetStringi');
+ glCopyBufferSubData := dglGetProcAddress('glCopyBufferSubData');
+ glGetUniformIndices := dglGetProcAddress('glGetUniformIndices');
+ glGetActiveUniformsiv := dglGetProcAddress('glGetActiveUniformsiv');
+ glGetUniformBlockIndex := dglGetProcAddress('glGetUniformBlockIndex');
+ glGetActiveUniformBlockiv := dglGetProcAddress('glGetActiveUniformBlockiv');
+ glGetActiveUniformBlockName := dglGetProcAddress('glGetActiveUniformBlockName');
+ glUniformBlockBinding := dglGetProcAddress('glUniformBlockBinding');
+ glDrawArraysInstanced := dglGetProcAddress('glDrawArraysInstanced');
+ glDrawElementsInstanced := dglGetProcAddress('glDrawElementsInstanced');
+ glFenceSync := dglGetProcAddress('glFenceSync');
+ glIsSync := dglGetProcAddress('glIsSync');
+ glDeleteSync := dglGetProcAddress('glDeleteSync');
+ glClientWaitSync := dglGetProcAddress('glClientWaitSync');
+ glWaitSync := dglGetProcAddress('glWaitSync');
+ glGetInteger64v := dglGetProcAddress('glGetInteger64v');
+ glGetSynciv := dglGetProcAddress('glGetSynciv');
+ glGetInteger64i_v := dglGetProcAddress('glGetInteger64i_v');
+ glGetBufferParameteri64v := dglGetProcAddress('glGetBufferParameteri64v');
+ glGenSamplers := dglGetProcAddress('glGenSamplers');
+ glDeleteSamplers := dglGetProcAddress('glDeleteSamplers');
+ glIsSampler := dglGetProcAddress('glIsSampler');
+ glBindSampler := dglGetProcAddress('glBindSampler');
+ glSamplerParameteri := dglGetProcAddress('glSamplerParameteri');
+ glSamplerParameteriv := dglGetProcAddress('glSamplerParameteriv');
+ glSamplerParameterf := dglGetProcAddress('glSamplerParameterf');
+ glSamplerParameterfv := dglGetProcAddress('glSamplerParameterfv');
+ glGetSamplerParameteriv := dglGetProcAddress('glGetSamplerParameteriv');
+ glGetSamplerParameterfv := dglGetProcAddress('glGetSamplerParameterfv');
+ glVertexAttribDivisor := dglGetProcAddress('glVertexAttribDivisor');
+ glBindTransformFeedback := dglGetProcAddress('glBindTransformFeedback');
+ glDeleteTransformFeedbacks := dglGetProcAddress('glDeleteTransformFeedbacks');
+ glGenTransformFeedbacks := dglGetProcAddress('glGenTransformFeedbacks');
+ glIsTransformFeedback := dglGetProcAddress('glIsTransformFeedback');
+ glPauseTransformFeedback := dglGetProcAddress('glPauseTransformFeedback');
+ glResumeTransformFeedback := dglGetProcAddress('glResumeTransformFeedback');
+ glGetProgramBinary := dglGetProcAddress('glGetProgramBinary');
+ glProgramBinary := dglGetProcAddress('glProgramBinary');
+ glProgramParameteri := dglGetProcAddress('glProgramParameteri');
+ glInvalidateFramebuffer := dglGetProcAddress('glInvalidateFramebuffer');
+ glInvalidateSubFramebuffer := dglGetProcAddress('glInvalidateSubFramebuffer');
+ glTexStorage2D := dglGetProcAddress('glTexStorage2D');
+ glTexStorage3D := dglGetProcAddress('glTexStorage3D');
+ glGetInternalformativ := dglGetProcAddress('glGetInternalformativ');
+
+ { OpenGL ES 3.1 }
+ glDispatchCompute := dglGetProcAddress('glDispatchCompute');
+ glDispatchComputeIndirect := dglGetProcAddress('glDispatchComputeIndirect');
+ glDrawArraysIndirect := dglGetProcAddress('glDrawArraysIndirect');
+ glDrawElementsIndirect := dglGetProcAddress('glDrawElementsIndirect');
+ glFramebufferParameteri := dglGetProcAddress('glFramebufferParameteri');
+ glGetFramebufferParameteriv := dglGetProcAddress('glGetFramebufferParameteriv');
+ glGetProgramInterfaceiv := dglGetProcAddress('glGetProgramInterfaceiv');
+ glGetProgramResourceIndex := dglGetProcAddress('glGetProgramResourceIndex');
+ glGetProgramResourceName := dglGetProcAddress('glGetProgramResourceName');
+ glGetProgramResourceiv := dglGetProcAddress('glGetProgramResourceiv');
+ glGetProgramResourceLocation := dglGetProcAddress('glGetProgramResourceLocation');
+ glUseProgramStages := dglGetProcAddress('glUseProgramStages');
+ glActiveShaderProgram := dglGetProcAddress('glActiveShaderProgram');
+ glCreateShaderProgramv := dglGetProcAddress('glCreateShaderProgramv');
+ glBindProgramPipeline := dglGetProcAddress('glBindProgramPipeline');
+ glDeleteProgramPipelines := dglGetProcAddress('glDeleteProgramPipelines');
+ glGenProgramPipelines := dglGetProcAddress('glGenProgramPipelines');
+ glIsProgramPipeline := dglGetProcAddress('glIsProgramPipeline');
+ glGetProgramPipelineiv := dglGetProcAddress('glGetProgramPipelineiv');
+ glProgramUniform1i := dglGetProcAddress('glProgramUniform1i');
+ glProgramUniform2i := dglGetProcAddress('glProgramUniform2i');
+ glProgramUniform3i := dglGetProcAddress('glProgramUniform3i');
+ glProgramUniform4i := dglGetProcAddress('glProgramUniform4i');
+ glProgramUniform1ui := dglGetProcAddress('glProgramUniform1ui');
+ glProgramUniform2ui := dglGetProcAddress('glProgramUniform2ui');
+ glProgramUniform3ui := dglGetProcAddress('glProgramUniform3ui');
+ glProgramUniform4ui := dglGetProcAddress('glProgramUniform4ui');
+ glProgramUniform1f := dglGetProcAddress('glProgramUniform1f');
+ glProgramUniform2f := dglGetProcAddress('glProgramUniform2f');
+ glProgramUniform3f := dglGetProcAddress('glProgramUniform3f');
+ glProgramUniform4f := dglGetProcAddress('glProgramUniform4f');
+ glProgramUniform1iv := dglGetProcAddress('glProgramUniform1iv');
+ glProgramUniform2iv := dglGetProcAddress('glProgramUniform2iv');
+ glProgramUniform3iv := dglGetProcAddress('glProgramUniform3iv');
+ glProgramUniform4iv := dglGetProcAddress('glProgramUniform4iv');
+ glProgramUniform1uiv := dglGetProcAddress('glProgramUniform1uiv');
+ glProgramUniform2uiv := dglGetProcAddress('glProgramUniform2uiv');
+ glProgramUniform3uiv := dglGetProcAddress('glProgramUniform3uiv');
+ glProgramUniform4uiv := dglGetProcAddress('glProgramUniform4uiv');
+ glProgramUniform1fv := dglGetProcAddress('glProgramUniform1fv');
+ glProgramUniform2fv := dglGetProcAddress('glProgramUniform2fv');
+ glProgramUniform3fv := dglGetProcAddress('glProgramUniform3fv');
+ glProgramUniform4fv := dglGetProcAddress('glProgramUniform4fv');
+ glProgramUniformMatrix2fv := dglGetProcAddress('glProgramUniformMatrix2fv');
+ glProgramUniformMatrix3fv := dglGetProcAddress('glProgramUniformMatrix3fv');
+ glProgramUniformMatrix4fv := dglGetProcAddress('glProgramUniformMatrix4fv');
+ glProgramUniformMatrix2x3fv := dglGetProcAddress('glProgramUniformMatrix2x3fv');
+ glProgramUniformMatrix3x2fv := dglGetProcAddress('glProgramUniformMatrix3x2fv');
+ glProgramUniformMatrix2x4fv := dglGetProcAddress('glProgramUniformMatrix2x4fv');
+ glProgramUniformMatrix4x2fv := dglGetProcAddress('glProgramUniformMatrix4x2fv');
+ glProgramUniformMatrix3x4fv := dglGetProcAddress('glProgramUniformMatrix3x4fv');
+ glProgramUniformMatrix4x3fv := dglGetProcAddress('glProgramUniformMatrix4x3fv');
+ glValidateProgramPipeline := dglGetProcAddress('glValidateProgramPipeline');
+ glGetProgramPipelineInfoLog := dglGetProcAddress('glGetProgramPipelineInfoLog');
+ glBindImageTexture := dglGetProcAddress('glBindImageTexture');
+ glGetBooleaniV := dglGetProcAddress('glGetBooleaniV');
+ glMemoryBarrier := dglGetProcAddress('glMemoryBarrier');
+ glMemoryBarrierByRegion := dglGetProcAddress('glMemoryBarrierByRegion');
+ glTexStorage2DMultisample := dglGetProcAddress('glTexStorage2DMultisample');
+ glGetMultisamplefv := dglGetProcAddress('glGetMultisamplefv');
+ glSampleMaski := dglGetProcAddress('glSampleMaski');
+ glGetTexLevelParameteriv := dglGetProcAddress('glGetTexLevelParameteriv');
+ glGetTexLevelParameterfv := dglGetProcAddress('glGetTexLevelParameterfv');
+ glBindVertexBuffer := dglGetProcAddress('glBindVertexBuffer');
+ glVertexAttribFormat := dglGetProcAddress('glVertexAttribFormat');
+ glVertexAttribIFormat := dglGetProcAddress('glVertexAttribIFormat');
+ glVertexAttribBinding := dglGetProcAddress('glVertexAttribBinding');
+ glVertexBindingDivisor := dglGetProcAddress('glVertexBindingDivisor');
+end;
+
+end.
+
projects / dglOpenGLES.git / commitdiff