From ca2ec12f29b1a3b442f6fdc2b44c30e93415f294 Mon Sep 17 00:00:00 2001 From: Bergmann89 Date: Tue, 18 Nov 2014 19:31:20 +0100 Subject: [PATCH 1/1] * initial commit --- dglOpenGLES.pas | 2241 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2241 insertions(+) create mode 100644 dglOpenGLES.pas diff --git a/dglOpenGLES.pas b/dglOpenGLES.pas new file mode 100644 index 0000000..7630ae5 --- /dev/null +++ b/dglOpenGLES.pas @@ -0,0 +1,2241 @@ +{ ============================================================================ + + 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. + -- 2.1.4